{"version":3,"sources":["../../../src/parser/tokenizer/index.ts"],"sourcesContent":["import Decimal from '../../core/decimal/decimal';\r\nimport PositionRange from '../../core/positions';\r\nimport assertNever from '../../errors/asserts/asserts';\r\nimport ErrorCodes from '../../errors/io-error-codes';\r\nimport SyntaxError from '../../errors/io-syntax-error';\r\nimport { unclosedConstructRange, createPosition } from '../../errors/error-range-utils';\r\nimport * as dtParser from '../../utils/datetime';\r\nimport * as is from './is';\r\nimport { CHAR_CODES, isDigitCode, isWhitespaceCode } from './is';\r\nimport Literals from './literals';\r\nimport Symbols from './symbols';\r\nimport TokenType from './token-types';\r\nimport Token, { TokenErrorValue, isIOError } from './tokens';\r\n\r\n// Cached regex patterns for performance optimization\r\nconst REGEX_CACHE = {\r\n hex4: /^[0-9a-fA-F]{4}$/,\r\n hex2: /^[0-9a-fA-F]{2}$/,\r\n floatDigit: /^[0-9.]+$/,\r\n intDigit: /^[0-9]+$/,\r\n hex: /^[0-9a-fA-F]+$/,\r\n octal: /^[0-7]+$/,\r\n binary: /^[01]+$/,\r\n sectionSchemaName: /^(?:(?:(?[\\p{L}\\p{M}\\p{N}\\-_]+)(?[ \\t]*:[ \\t]*)?)(?\\$[\\p{L}\\p{M}\\p{N}\\-_]+)?|(?\\$[\\p{L}\\p{M}\\p{N}\\-_]+))/u,\r\n annotatedStrStart: /^(?[a-zA-Z]{1,4})(?['\"])/,\r\n base64: /^[A-Za-z0-9+/]*={0,2}$/\r\n} as const;\r\n\r\n// Fast hex digit checking using character codes (only used in tokenizer)\r\nconst isHexDigitCode = (charCode: number): boolean =>\r\n isDigitCode(charCode) ||\r\n (charCode >= CHAR_CODES.A_UPPER && charCode <= CHAR_CODES.F_UPPER) ||\r\n (charCode >= CHAR_CODES.A_LOWER && charCode <= CHAR_CODES.F_LOWER);\r\n\r\nconst regexHex4 = REGEX_CACHE.hex4;\r\nconst regexHex2 = REGEX_CACHE.hex2;\r\nconst reFloatDigit = REGEX_CACHE.floatDigit;\r\nconst reIntDigit = REGEX_CACHE.intDigit;\r\nconst reHex = REGEX_CACHE.hex;\r\nconst reOctal = REGEX_CACHE.octal;\r\nconst reBinary = REGEX_CACHE.binary;\r\n\r\n// https://regex101.com/r/HOVtCj/1\r\n// const reSectionSchemaName = /^(?\\$[\\p{L}\\p{M}\\p{N}\\-_]+)(?:[ \\t]*:[ \\t]*(?[\\p{L}\\p{M}\\p{N}\\-_]+))?/u;\r\n\r\n// https://regex101.com/r/jaWr0V/2\r\n// Cached constants for performance\r\nconst NON_DECIMAL_PREFIXES = [\"x\", \"X\", \"o\", \"O\", \"b\", \"B\"] as const;\r\n\r\nconst reSectionSchemaName = REGEX_CACHE.sectionSchemaName;\r\nconst nonDecimalPrefixes = NON_DECIMAL_PREFIXES;\r\nconst reAnotatedStrStart = REGEX_CACHE.annotatedStrStart;\r\n\r\n/**\r\n * Tokenizer for IO format.\r\n */\r\nclass Tokenizer {\r\n private pos: number = 0; // Current position within the input string\r\n private input: string = \"\"; // Input string to tokenize\r\n private row: number = 1; // Current row within the input string\r\n private col: number = 1; // Current column within the input string\r\n private reachedEnd: boolean = false; // True if the end of the input string has been reached, else false\r\n private inputLength: number = 0; // Cache input length for performance\r\n\r\n /**\r\n * Initialize the tokenizer with an input string.\r\n * @param input - String to be tokenized.\r\n */\r\n constructor(input: string) {\r\n this.input = input;\r\n this.inputLength = input.length; // Cache length for performance\r\n }\r\n\r\n /**\r\n * Fast character checking for special symbols using character codes\r\n */\r\n private isSpecialSymbolFast(charCode: number): boolean {\r\n return charCode === CHAR_CODES.CURLY_OPEN || charCode === CHAR_CODES.CURLY_CLOSE ||\r\n charCode === CHAR_CODES.BRACKET_OPEN || charCode === CHAR_CODES.BRACKET_CLOSE ||\r\n charCode === CHAR_CODES.COMMA || charCode === CHAR_CODES.COLON ||\r\n charCode === CHAR_CODES.TILDE;\r\n }\r\n\r\n /**\r\n * Fast token type lookup for special symbols using character codes\r\n */\r\n private getSymbolTokenTypeFast(charCode: number): string {\r\n switch (charCode) {\r\n case CHAR_CODES.CURLY_OPEN: return TokenType.CURLY_OPEN;\r\n case CHAR_CODES.CURLY_CLOSE: return TokenType.CURLY_CLOSE;\r\n case CHAR_CODES.BRACKET_OPEN: return TokenType.BRACKET_OPEN;\r\n case CHAR_CODES.BRACKET_CLOSE: return TokenType.BRACKET_CLOSE;\r\n case CHAR_CODES.COMMA: return TokenType.COMMA;\r\n case CHAR_CODES.COLON: return TokenType.COLON;\r\n case CHAR_CODES.TILDE: return TokenType.COLLECTION_START;\r\n default: return TokenType.UNKNOWN;\r\n }\r\n }\r\n\r\n /**\r\n * Create an error token for invalid input and continue tokenizing.\r\n * @param error - The error that occurred\r\n * @param startPos - Starting position of the invalid token\r\n * @param startRow - Starting row of the invalid token\r\n * @param startCol - Starting column of the invalid token\r\n * @param tokenText - The invalid token text\r\n */\r\n private createErrorToken(error: Error, startPos: number, startRow: number, startCol: number, tokenText: string): Token {\r\n const errorValue: TokenErrorValue = {\r\n __error: true,\r\n message: error.message,\r\n originalError: error\r\n };\r\n\r\n // Extract errorCode from IOError instances for typed error handling\r\n if (isIOError(error)) {\r\n errorValue.errorCode = error.errorCode;\r\n }\r\n\r\n return Token.init(\r\n startPos,\r\n startRow,\r\n startCol,\r\n tokenText,\r\n errorValue,\r\n TokenType.ERROR\r\n );\r\n }\r\n\r\n /**\r\n * Skip to the next valid token boundary after an error.\r\n * This helps recover from parsing errors by advancing to a safe position.\r\n */\r\n private skipToNextTokenBoundary(): void {\r\n // Skip characters until we find a delimiter, whitespace, or special symbol\r\n while (!this.reachedEnd &&\r\n !is.isWhitespace(this.input[this.pos]) &&\r\n !is.isSpecialSymbol(this.input[this.pos]) &&\r\n this.input[this.pos] !== ',' &&\r\n this.input[this.pos] !== '\\n') {\r\n this.advance();\r\n }\r\n }\r\n\r\n /**\r\n * Advance the current position and update the row and column accordingly.\r\n */\r\n private advance(step: number = 1): void {\r\n if (this.reachedEnd) {\r\n return;\r\n }\r\n\r\n // Optimize for single step (most common case)\r\n if (step === 1) {\r\n if (this.input.charCodeAt(this.pos) === CHAR_CODES.NEWLINE) {\r\n this.row++;\r\n this.col = 1;\r\n } else {\r\n this.col++;\r\n }\r\n this.pos++;\r\n if (this.pos >= this.inputLength) {\r\n this.reachedEnd = true;\r\n }\r\n return;\r\n }\r\n\r\n // Handle multiple steps\r\n for (let i = 0; i < step; i++) {\r\n if (this.input.charCodeAt(this.pos) === CHAR_CODES.NEWLINE) {\r\n this.row++;\r\n this.col = 1;\r\n } else {\r\n this.col++;\r\n }\r\n this.pos++;\r\n\r\n if (this.pos >= this.inputLength) {\r\n this.reachedEnd = true;\r\n break;\r\n }\r\n }\r\n }\r\n\r\n private parseSingleLineComment(): void {\r\n while (!this.reachedEnd && this.input[this.pos] !== \"\\n\") {\r\n this.advance();\r\n }\r\n }\r\n\r\n private parseRegularString(encloser: string): Token {\r\n const start = this.pos;\r\n const startRow = this.row;\r\n const startCol = this.col;\r\n\r\n this.advance(); // Move past the opening quotation mark\r\n let value = \"\";\r\n let needToNormalize = false;\r\n\r\n while (!this.reachedEnd && this.input[this.pos] !== encloser) {\r\n if (is.isWhitespace(this.input[this.pos])) {\r\n value += this.skipWhitespaces();\r\n continue;\r\n }\r\n\r\n // Check if current character is a backslash (escape character)\r\n if (this.input[this.pos] === Symbols.BACKSLASH) {\r\n try {\r\n ({ value, needToNormalize } = this.escapeString(\r\n value,\r\n needToNormalize\r\n ));\r\n // escapeString has already advanced the position, so continue to next iteration\r\n } catch (error) {\r\n // For invalid escape sequences, treat them as literal characters without the backslash\r\n // Note: escapeString has already advanced past the backslash, so pos is at the escape char\r\n if (!this.reachedEnd) {\r\n const escapeChar = this.input[this.pos];\r\n value += escapeChar; // Add the escape character (u, x, etc.) without backslash\r\n\r\n // For \\u and \\x sequences, we need to add the invalid hex digits too\r\n if (escapeChar === 'u') {\r\n // Add the next 4 characters (or until end of input)\r\n this.advance();\r\n for (let i = 0; i < 4 && !this.reachedEnd; i++) {\r\n value += this.input[this.pos];\r\n this.advance();\r\n }\r\n continue;\r\n } else if (escapeChar === 'x') {\r\n // Add the next 2 characters (or until end of input)\r\n this.advance();\r\n for (let i = 0; i < 2 && !this.reachedEnd; i++) {\r\n value += this.input[this.pos];\r\n this.advance();\r\n }\r\n continue;\r\n } else {\r\n this.advance();\r\n }\r\n }\r\n continue;\r\n }\r\n } else {\r\n value += this.input[this.pos];\r\n this.advance();\r\n }\r\n }\r\n\r\n // If we reached the end without finding the closing quote,\r\n // create an error token for the unclosed string\r\n if (this.reachedEnd) {\r\n const tokenText = this.input.substring(start, this.pos);\r\n\r\n // Create a temporary token for the opening quote to get proper range\r\n const openingToken = Token.init(start, startRow, startCol, '\"', '\"', \"STRING\");\r\n const currentPos = createPosition(this.pos, this.row, this.col);\r\n\r\n const error = new SyntaxError(\r\n ErrorCodes.stringNotClosed,\r\n `Unterminated string literal. Expected closing quote '\"' before end of input.`,\r\n unclosedConstructRange(openingToken, currentPos),\r\n true\r\n );\r\n\r\n return this.createErrorToken(error, start, startRow, startCol, tokenText);\r\n }\r\n\r\n this.advance(); // Move past the closing quotation mark\r\n\r\n const tokenText = this.input.substring(start, this.pos);\r\n\r\n // After building the 'value' string, normalize it:\r\n if (needToNormalize) {\r\n value = value.normalize(\"NFC\");\r\n }\r\n\r\n return Token.init(\r\n start,\r\n startRow,\r\n startCol,\r\n tokenText,\r\n value,\r\n \"STRING\",\r\n \"REGULAR_STRING\"\r\n );\r\n }\r\n\r\n private escapeString(value: string, needToNormalize: boolean) {\r\n this.advance(); // Move past the backslash\r\n if (this.reachedEnd) {\r\n throw new SyntaxError(\r\n ErrorCodes.invalidEscapeSequence,\r\n `Invalid escape sequence at end of input. Expected escape character after backslash.`,\r\n this.currentPosition, true\r\n )\r\n }\r\n\r\n switch (this.input[this.pos]) {\r\n case \"b\":\r\n value += \"\\b\";\r\n break;\r\n case \"f\":\r\n value += \"\\f\";\r\n break;\r\n case \"n\":\r\n value += \"\\n\";\r\n break;\r\n case \"r\":\r\n value += \"\\r\";\r\n break;\r\n case \"t\":\r\n value += \"\\t\";\r\n break;\r\n case \"u\":\r\n const hex = this.input.substring(this.pos + 1, this.pos + 5);\r\n if (regexHex4.test(hex)) {\r\n // /^[0-9a-fA-F]{4}$/\r\n value += String.fromCharCode(parseInt(hex, 16));\r\n this.advance(4); // Move past the 4 hex digits\r\n needToNormalize = true;\r\n } else {\r\n throw new SyntaxError(\r\n ErrorCodes.invalidEscapeSequence,\r\n `Invalid Unicode escape sequence '\\\\u${hex}'. Expected 4 hexadecimal digits (0-9, A-F).`,\r\n this.currentPosition);\r\n }\r\n break;\r\n case \"x\":\r\n const hexByte = this.input.substring(this.pos + 1, this.pos + 3);\r\n if (regexHex2.test(hexByte)) {\r\n // /^[0-9a-fA-F]{2}$/\r\n value += String.fromCharCode(parseInt(hexByte, 16));\r\n this.advance(2); // Move past the 2 hex digits\r\n needToNormalize = true;\r\n } else {\r\n throw new SyntaxError(\r\n ErrorCodes.invalidEscapeSequence,\r\n `Invalid hexadecimal escape sequence '\\\\x${hexByte}'. Expected 2 hexadecimal digits (0-9, A-F).`,\r\n this.currentPosition);\r\n }\r\n break;\r\n default:\r\n value += this.input[this.pos]; // Treat unrecognized escape sequences as literal characters without backslash\r\n this.advance(); // Move past the escape character\r\n break;\r\n }\r\n return { value, needToNormalize };\r\n }\r\n\r\n private get currentPosition(): PositionRange {\r\n const getPos = () => {\r\n return {\r\n pos: this.pos,\r\n row: this.row,\r\n col: this.col\r\n }\r\n }\r\n\r\n return {\r\n getStartPos: getPos,\r\n getEndPos: getPos\r\n };\r\n }\r\n\r\n\r\n private checkIfAnotatedString(): Annotation | null {\r\n // Annotated strings starts with a letter and can have a maximum of 4 letters\r\n // followed by a quotation mark (single or double).\r\n const match = reAnotatedStrStart.exec(this.input.substring(this.pos, this.pos + 5));\r\n if (!match) {\r\n return null;\r\n }\r\n\r\n return match.groups as Annotation;\r\n }\r\n\r\n private parseAnotatedString(annotation: Annotation): Token {\r\n const start = this.pos;\r\n const startRow = this.row;\r\n const startCol = this.col;\r\n\r\n // Skip over the annotation characters\r\n for (let i = 0; i < annotation.name.length; i++) {\r\n this.advance();\r\n }\r\n\r\n if (this.reachedEnd) {\r\n const tokenText = this.input.substring(start, this.pos);\r\n\r\n // Create a temporary token for the opening annotation to get proper range\r\n const openingToken = Token.init(start, startRow, startCol, annotation.name + annotation.quote, annotation.name, \"STRING\");\r\n const currentPos = createPosition(this.pos, this.row, this.col);\r\n\r\n const error = new SyntaxError(\r\n ErrorCodes.stringNotClosed,\r\n `Unterminated annotated string literal. Expected closing quote '${annotation.quote}' before end of input.`,\r\n unclosedConstructRange(openingToken, currentPos),\r\n true\r\n );\r\n\r\n return this.createErrorToken(error, start, startRow, startCol, tokenText);\r\n }\r\n\r\n this.advance(); // Move past the opening quotation mark\r\n while (!this.reachedEnd && this.input[this.pos] !== annotation.quote) {\r\n this.advance();\r\n }\r\n\r\n // If we reached the end without finding the closing quote,\r\n // treat it as an annotated string that goes to EOF\r\n const tokenText = this.input.substring(start, this.pos);\r\n let value: string;\r\n\r\n if (this.reachedEnd) {\r\n // Extract value from unclosed string (from after opening quote to EOF)\r\n value = tokenText.substring(annotation.name.length + 1);\r\n } else {\r\n this.advance(); // Move past the closing quotation mark\r\n const fullTokenText = this.input.substring(start, this.pos);\r\n value = fullTokenText.substring(annotation.name.length + 1, fullTokenText.length - 1);\r\n }\r\n\r\n // Prepare the token\r\n const token = new Token();\r\n token.pos = start;\r\n token.row = startRow;\r\n token.col = startCol;\r\n token.token = this.reachedEnd ? tokenText : this.input.substring(start, this.pos);\r\n token.value = value;\r\n\r\n return token;\r\n }\r\n\r\n private parseRawString(annotation: Annotation): Token {\r\n const token = this.parseAnotatedString(annotation);\r\n\r\n // If the annotated string parsing already returned an error token, return it as-is\r\n if (token.type === TokenType.ERROR) {\r\n return token;\r\n }\r\n\r\n token.type = TokenType.STRING;\r\n token.subType = \"RAW_STRING\";\r\n return token;\r\n }\r\n\r\n private parseByteString(annotation: Annotation): Token {\r\n const token = this.parseAnotatedString(annotation);\r\n\r\n // If the annotated string parsing already returned an error token, return it as-is\r\n if (token.type === TokenType.ERROR) {\r\n return token;\r\n }\r\n\r\n // Validate base64 format using cached regex\r\n const valueStr = token.value as string;\r\n if (!REGEX_CACHE.base64.test(valueStr)) {\r\n const error = new SyntaxError(\r\n ErrorCodes.invalidBase64,\r\n `Invalid base64 format '${valueStr.length > 20 ? valueStr.substring(0, 20) + '...' : valueStr}'. Expected valid base64 characters (A-Z, a-z, 0-9, +, /) with optional '=' padding.`,\r\n token\r\n );\r\n return this.createErrorToken(error, token.pos, token.row, token.col, token.token);\r\n }\r\n\r\n token.type = TokenType.BINARY;\r\n token.subType = \"BINARY_STRING\";\r\n\r\n // Convert the base64 string to a byte array\r\n token.value = Buffer.from(valueStr, \"base64\");\r\n return token;\r\n }\r\n\r\n private parseDateTime(annotation: Annotation): Token {\r\n const token = this.parseAnotatedString(annotation);\r\n\r\n // If the annotated string parsing already returned an error token, return it as-is\r\n if (token.type === TokenType.ERROR) {\r\n return token;\r\n }\r\n\r\n try {\r\n let fn = (value: string): Date | null => null\r\n\r\n switch (annotation.name) {\r\n case \"dt\":\r\n fn = dtParser.parseDateTime;\r\n token.subType = TokenType.DATETIME\r\n break;\r\n case \"d\":\r\n fn = dtParser.parseDate;\r\n token.subType = TokenType.DATE\r\n break;\r\n case \"t\":\r\n fn = dtParser.parseTime;\r\n token.subType = TokenType.TIME\r\n break;\r\n default:\r\n assertNever(annotation);\r\n }\r\n\r\n const dt = typeof token.value === 'string' ? fn(token.value) : null;\r\n if (!dt) {\r\n const error = new SyntaxError(ErrorCodes.invalidDateTime,\r\n `Invalid ${annotation.name === 'dt' ? 'datetime' : annotation.name === 'd' ? 'date' : 'time'} format '${token.value}'. Expected valid ISO 8601 format.`,\r\n token);\r\n return this.createErrorToken(error, token.pos, token.row, token.col, token.token);\r\n }\r\n\r\n token.value = dt;\r\n token.type = TokenType.DATETIME;\r\n return token;\r\n } catch (error) {\r\n return this.createErrorToken(error as Error, token.pos, token.row, token.col, token.token);\r\n }\r\n }\r\n\r\n private parseNumber(): Token | null {\r\n const start = this.pos;\r\n const startRow = this.row;\r\n const startCol = this.col;\r\n let rawValue = \"\";\r\n let base = 10; // default is decimal\r\n let hasDecimal = false;\r\n let hasExponent = false;\r\n let prefix = \"\";\r\n let subType: string | undefined;\r\n\r\n // Check if current position points to a plus or minus sign.\r\n if (this.input[this.pos] === \"+\" || this.input[this.pos] === \"-\") {\r\n const sign = this.input[this.pos];\r\n // If sign is followed by \"Inf\", handle infinite literal.\r\n if (this.input.startsWith(\"Inf\", this.pos + 1)) {\r\n const infLiteral = sign + \"Inf\";\r\n this.advance(4); // sign + \"Inf\"\r\n return Token.init(\r\n start,\r\n startRow,\r\n startCol,\r\n infLiteral,\r\n sign === \"+\" ? Infinity : -Infinity,\r\n TokenType.NUMBER\r\n );\r\n }\r\n // Otherwise, allow sign only if immediately followed by a digit or dot.\r\n if (is.isDigit(this.input[this.pos + 1]) || this.input[this.pos + 1] === \".\") {\r\n rawValue += sign;\r\n this.advance();\r\n } else {\r\n return null;\r\n }\r\n }\r\n // Also support an Inf literal without a sign.\r\n else if (this.input.startsWith(\"Inf\", this.pos)) {\r\n const infLiteral = \"Inf\";\r\n this.advance(3);\r\n return Token.init(\r\n start,\r\n startRow,\r\n startCol,\r\n infLiteral,\r\n Infinity,\r\n TokenType.NUMBER\r\n );\r\n }\r\n\r\n if (this.input[this.pos] === \".\") {\r\n // If there is a dot, ensure it is followed by a digit.\r\n if (!reFloatDigit.test(this.input[this.pos + 1])) {\r\n return null;\r\n }\r\n }\r\n\r\n // Determine the number format\r\n if (this.input[this.pos] === \"0\" && nonDecimalPrefixes.includes(this.input[this.pos + 1] as any)) {\r\n switch (this.input[this.pos + 1]) {\r\n case \"X\":\r\n case \"x\":\r\n base = 16;\r\n subType = \"HEX\";\r\n prefix = this.input[this.pos] + this.input[this.pos + 1];\r\n this.advance(2);\r\n while (reHex.test(this.input[this.pos])) {\r\n rawValue += this.input[this.pos];\r\n this.advance();\r\n }\r\n break;\r\n\r\n case \"O\":\r\n case \"o\":\r\n base = 8;\r\n subType = \"OCTAL\";\r\n prefix = this.input[this.pos] + this.input[this.pos + 1];\r\n this.advance(2);\r\n while (reOctal.test(this.input[this.pos])) {\r\n rawValue += this.input[this.pos];\r\n this.advance();\r\n }\r\n break;\r\n\r\n case \"B\":\r\n case \"b\":\r\n base = 2;\r\n subType = \"BINARY\";\r\n prefix = this.input[this.pos] + this.input[this.pos + 1];\r\n this.advance(2);\r\n while (reBinary.test(this.input[this.pos])) {\r\n rawValue += this.input[this.pos];\r\n this.advance();\r\n }\r\n break;\r\n default:\r\n assertNever(this.input[this.pos + 1]);\r\n }\r\n } else {\r\n // Parse whole part\r\n while (reIntDigit.test(this.input[this.pos])) {\r\n rawValue += this.input[this.pos];\r\n this.advance();\r\n }\r\n\r\n // Parse decimal point and fractional part\r\n if (this.input[this.pos] === \".\") {\r\n hasDecimal = true;\r\n rawValue += \".\";\r\n this.advance();\r\n while (reIntDigit.test(this.input[this.pos])) {\r\n rawValue += this.input[this.pos];\r\n this.advance();\r\n }\r\n }\r\n\r\n // Parse scientific notation (e.g., e10 or E10)\r\n if (this.input[this.pos] === \"e\" || this.input[this.pos] === \"E\") {\r\n hasExponent = true;\r\n rawValue += this.input[this.pos];\r\n this.advance();\r\n if (this.input[this.pos] === \"+\" || this.input[this.pos] === \"-\") {\r\n rawValue += this.input[this.pos];\r\n this.advance();\r\n }\r\n while (reIntDigit.test(this.input[this.pos])) {\r\n rawValue += this.input[this.pos];\r\n this.advance();\r\n }\r\n }\r\n }\r\n\r\n let tokenType = TokenType.NUMBER;\r\n let numberValue: number | bigint | Decimal;\r\n\r\n // if the next char is 'n', then it is a BigInt literal\r\n if (this.input[this.pos] === \"n\") {\r\n tokenType = TokenType.BIGINT;\r\n numberValue = BigInt(prefix + rawValue);\r\n rawValue += \"n\";\r\n this.advance();\r\n } else if (this.input[this.pos] === \"m\") {\r\n // Decimal literal\r\n tokenType = TokenType.DECIMAL;\r\n numberValue = new Decimal(rawValue);\r\n rawValue += \"f\";\r\n this.advance();\r\n } else {\r\n if (base === 10 && (hasDecimal || hasExponent)) {\r\n numberValue = parseFloat(rawValue);\r\n } else {\r\n numberValue = parseInt(rawValue, base);\r\n if (isNaN(numberValue as number)) {\r\n assertNever(\"Expected a number but got NaN\", this.currentPosition.getStartPos());\r\n }\r\n }\r\n }\r\n\r\n return Token.init(\r\n start,\r\n startRow,\r\n startCol,\r\n prefix + rawValue,\r\n numberValue,\r\n tokenType,\r\n subType\r\n );\r\n }\r\n\r\n private parseLiteralOrOpenString(): Token | null {\r\n const start = this.pos;\r\n const startRow = this.row;\r\n const startCol = this.col;\r\n\r\n let value = \"\";\r\n let normalizeString = false;\r\n\r\n while (!this.reachedEnd && is.isValidOpenStringChar(this.input[this.pos])) {\r\n let char = this.input[this.pos];\r\n\r\n if (is.isWhitespace(char)) {\r\n value += this.skipWhitespaces();\r\n continue;\r\n }\r\n\r\n if (char === Symbols.MINUS) {\r\n // if the next two chars are -- that means it is a\r\n // section seperator.\r\n if (this.input.substring(this.pos, this.pos + 3) === \"---\") {\r\n break;\r\n }\r\n }\r\n\r\n if (char === Symbols.BACKSLASH) {\r\n try {\r\n ({ value, needToNormalize: normalizeString } = this.escapeString(\r\n value,\r\n normalizeString\r\n ));\r\n // escapeString has already advanced the position, so continue to next iteration\r\n continue;\r\n } catch (error) {\r\n // For open strings, preserve the backslash and the escape character\r\n // Note: escapeString has already advanced past the backslash, so pos is at the escape char\r\n value += \"\\\\\";\r\n if (!this.reachedEnd) {\r\n const escapeChar = this.input[this.pos];\r\n value += escapeChar; // Add the escape character (u, x, etc.)\r\n\r\n // For \\u and \\x sequences, we need to add the invalid hex digits too\r\n if (escapeChar === 'u') {\r\n // Add the next 4 characters (or until end of input)\r\n this.advance();\r\n for (let i = 0; i < 4 && !this.reachedEnd; i++) {\r\n value += this.input[this.pos];\r\n this.advance();\r\n }\r\n continue;\r\n } else if (escapeChar === 'x') {\r\n // Add the next 2 characters (or until end of input)\r\n this.advance();\r\n for (let i = 0; i < 2 && !this.reachedEnd; i++) {\r\n value += this.input[this.pos];\r\n this.advance();\r\n }\r\n continue;\r\n } else {\r\n this.advance();\r\n }\r\n }\r\n continue;\r\n }\r\n } else {\r\n value += char;\r\n this.advance();\r\n }\r\n }\r\n\r\n value = value.trimEnd();\r\n\r\n if (normalizeString) {\r\n value = value.normalize(\"NFC\");\r\n }\r\n\r\n if (value === \"\") {\r\n return null\r\n // assertNever(this.input[this.pos])\r\n }\r\n\r\n switch (value) {\r\n case Literals.TRUE:\r\n case Literals.T:\r\n return Token.init(\r\n start,\r\n startRow,\r\n startCol,\r\n value,\r\n true,\r\n TokenType.BOOLEAN\r\n );\r\n\r\n case Literals.FALSE:\r\n case Literals.F:\r\n return Token.init(\r\n start,\r\n startRow,\r\n startCol,\r\n value,\r\n false,\r\n TokenType.BOOLEAN\r\n );\r\n\r\n case Literals.NULL:\r\n case Literals.N:\r\n return Token.init(\r\n start,\r\n startRow,\r\n startCol,\r\n value,\r\n null,\r\n TokenType.NULL\r\n );\r\n case Literals.Inf:\r\n case Literals.NaN:\r\n return Token.init(\r\n start,\r\n startRow,\r\n startCol,\r\n value,\r\n value === Literals.Inf ? Infinity : NaN,\r\n TokenType.NUMBER\r\n );\r\n\r\n default:\r\n return Token.init(\r\n start,\r\n startRow,\r\n startCol,\r\n value,\r\n value,\r\n TokenType.STRING,\r\n \"OPEN_STRING\"\r\n );\r\n }\r\n }\r\n\r\n /**\r\n * Merges the two tokens into one token. This is used to merge the\r\n * tokens detected by various tokenizer functions.\r\n */\r\n private mergeTokens(\r\n first: Token, second: Token): Token {\r\n const token = new Token();\r\n token.pos = first.pos;\r\n token.row = first.row;\r\n token.col = first.col;\r\n token.token = first.token + second.token;\r\n token.value = first.token + (second.value?.toString() ?? '');\r\n token.type = second.type;\r\n token.subType = second.subType;\r\n return token;\r\n }\r\n\r\n /**\r\n * Skip over any whitespaces and return them as a string.\r\n * @returns {string} The skipped whitespaces.\r\n */\r\n private skipWhitespaces(hspacesOnly: boolean = false): string {\r\n const startPos = this.pos;\r\n while (!this.reachedEnd && is.isWhitespace(this.input[this.pos], hspacesOnly)) {\r\n const space = this.input[this.pos];\r\n // replace \\r\\n or \\r with \\n. This behavior is configurable\r\n // with the normalizeNewline option\r\n if (space === '\\r') {\r\n if (this.input[this.pos + 1] === '\\n') {\r\n this.advance();\r\n }\r\n this.advance();\r\n } else {\r\n this.advance();\r\n }\r\n }\r\n\r\n // Optimize: use substring instead of character-by-character concatenation\r\n if (startPos === this.pos) {\r\n return '';\r\n }\r\n\r\n let spaces = this.input.substring(startPos, this.pos);\r\n // Only normalize if we found \\r characters\r\n if (spaces.includes('\\r')) {\r\n spaces = spaces.replace(/\\r\\n/g, '\\n').replace(/\\r/g, '\\n');\r\n }\r\n\r\n return spaces;\r\n }\r\n\r\n /**\r\n * Tokenize the input string.\r\n * @returns {Token[]} Array of parsed tokens.\r\n */\r\n public tokenize(): readonly Token[] {\r\n // Pre-allocate array with estimated size for better performance\r\n const estimatedTokens = Math.max(10, Math.floor(this.inputLength / 8));\r\n const tokens: Token[] = new Array(estimatedTokens);\r\n let tokenIndex = 0;\r\n\r\n while (this.pos < this.inputLength) {\r\n const charCode = this.input.charCodeAt(this.pos);\r\n\r\n // Whitespaces - use fast character code checking\r\n if (isWhitespaceCode(charCode)) {\r\n // Skip over the whitespace\r\n this.advance();\r\n continue;\r\n }\r\n\r\n // Single-line comments\r\n else if (charCode === CHAR_CODES.HASH) {\r\n this.parseSingleLineComment();\r\n }\r\n\r\n // Regular strings\r\n else if (charCode === CHAR_CODES.DOUBLE_QUOTE || charCode === CHAR_CODES.SINGLE_QUOTE) {\r\n tokens[tokenIndex++] = this.parseRegularString(this.input[this.pos]);\r\n }\r\n\r\n // Special symbols (e.g., curly braces, brackets, etc.) - use fast character code checking\r\n else if (this.isSpecialSymbolFast(charCode)) {\r\n const startRow = this.row;\r\n const startCol = this.col;\r\n const ch = this.input[this.pos];\r\n tokens[tokenIndex++] = Token.init(\r\n this.pos,\r\n startRow,\r\n startCol,\r\n ch,\r\n ch,\r\n this.getSymbolTokenTypeFast(charCode)\r\n );\r\n this.advance();\r\n }\r\n\r\n // Numbers\r\n else if (charCode === CHAR_CODES.PLUS || charCode === CHAR_CODES.MINUS || charCode === CHAR_CODES.DOT || isDigitCode(charCode)) {\r\n // Check if it is a SECTION_SEP ---\r\n if (charCode === CHAR_CODES.MINUS) {\r\n // If the next two chars are -- that means it is a\r\n // data seperator.\r\n if (this.input.substring(this.pos, this.pos + 3) === \"---\") {\r\n tokenIndex = this.parseSectionSeparator(tokens, tokenIndex);\r\n continue;\r\n }\r\n }\r\n\r\n const token = this.parseNumber();\r\n\r\n if (token) {\r\n const spaces = this.skipWhitespaces();\r\n if (!this.reachedEnd) {\r\n // If the next character (2abc) is not a symbol or whitespace, then\r\n // it must be a literal or open string. Parse it and merge it\r\n // with the number token.\r\n if (\r\n !is.isSpecialSymbol(this.input[this.pos]) &&\r\n !is.isWhitespace(this.input[this.pos])\r\n ) {\r\n const nextToken = this.parseLiteralOrOpenString();\r\n if (nextToken) {\r\n nextToken.type = TokenType.STRING;\r\n nextToken.subType = \"OPEN_STRING\";\r\n if (spaces.length > 0) {\r\n nextToken.token = spaces + nextToken.token;\r\n nextToken.value = spaces + nextToken.value;\r\n }\r\n tokens[tokenIndex++] = this.mergeTokens(token, nextToken);\r\n } else {\r\n tokens[tokenIndex++] = token;\r\n }\r\n } else {\r\n tokens[tokenIndex++] = token;\r\n }\r\n } else {\r\n tokens[tokenIndex++] = token;\r\n }\r\n } else {\r\n // It wasn't a number, so it must be a literal or open string\r\n const token = this.parseLiteralOrOpenString();\r\n if (token) {\r\n tokens[tokenIndex++] = token;\r\n }\r\n }\r\n }\r\n\r\n // Literals or open strings\r\n else {\r\n const annotation = this.checkIfAnotatedString();\r\n if (annotation) {\r\n switch (annotation.name) {\r\n case \"r\":\r\n tokens[tokenIndex++] = this.parseRawString(annotation);\r\n break;\r\n\r\n case \"b\":\r\n tokens[tokenIndex++] = this.parseByteString(annotation);\r\n break;\r\n\r\n case \"d\":\r\n case \"dt\":\r\n case \"t\":\r\n tokens[tokenIndex++] = this.parseDateTime(annotation);\r\n break;\r\n\r\n default:\r\n const error = new SyntaxError(ErrorCodes.unsupportedAnnotation,\r\n `Unsupported annotation '${annotation.name}'. Supported annotations are: 'r' (raw string), 'b' (binary), 'dt' (datetime), 'd' (date), 't' (time).`,\r\n this.currentPosition);\r\n const tokenText = this.input.substring(this.pos, this.pos + annotation.name.length + 1);\r\n tokens[tokenIndex++] = this.createErrorToken(error, this.pos, this.row, this.col, tokenText);\r\n this.skipToNextTokenBoundary();\r\n }\r\n } else {\r\n const token = this.parseLiteralOrOpenString();\r\n if (token) {\r\n tokens[tokenIndex++] = token;\r\n }\r\n }\r\n }\r\n }\r\n\r\n // Return properly sized array\r\n tokens.length = tokenIndex;\r\n return tokens;\r\n }\r\n\r\n private parseSectionSeparator(tokens: Token[], tokenIndex: number): number {\r\n tokens[tokenIndex++] = Token.init(\r\n this.pos,\r\n this.row,\r\n this.col,\r\n \"---\",\r\n \"---\",\r\n TokenType.SECTION_SEP\r\n );\r\n this.advance(3); // Advance past the \"---\"\r\n this.skipWhitespaces(true);\r\n\r\n const match = reSectionSchemaName.exec(this.input.substring(this.pos));\r\n\r\n if (match) {\r\n let schema: string | undefined;\r\n let name: string | undefined;\r\n let sep = match.groups?.sep;\r\n let schema2: string | undefined;\r\n\r\n if (match.groups) {\r\n schema = match.groups.schema;\r\n name = match.groups.name;\r\n schema2 = match.groups.schema2;\r\n }\r\n\r\n\r\n // When only a schema is provided, the schema is the name\r\n if (schema2) {\r\n tokens[tokenIndex++] = Token.init(\r\n this.pos,\r\n this.row,\r\n this.col,\r\n schema2,\r\n schema2,\r\n TokenType.STRING,\r\n TokenType.SECTION_SCHEMA\r\n );\r\n this.advance(schema2.length);\r\n this.skipWhitespaces(true);\r\n } else if (name) {\r\n tokens[tokenIndex++] = Token.init(\r\n this.pos,\r\n this.row,\r\n this.col,\r\n name,\r\n name,\r\n TokenType.STRING,\r\n TokenType.SECTION_NAME\r\n );\r\n this.advance(name.length);\r\n this.skipWhitespaces(true);\r\n\r\n if (sep) {\r\n // skip over the separator when it is present\r\n this.advance(sep.length);\r\n this.skipWhitespaces(true);\r\n\r\n // Once the sep is detected, the schema must be present\r\n if (!schema) {\r\n const error = new SyntaxError(ErrorCodes.schemaMissing,\r\n `Missing schema definition after section separator. Expected schema name starting with '$' (e.g., '$mySchema').`,\r\n this.currentPosition);\r\n tokens[tokenIndex++] = this.createErrorToken(error, this.pos, this.row, this.col, \"\");\r\n return tokenIndex;\r\n }\r\n\r\n tokens[tokenIndex++] = Token.init(\r\n this.pos,\r\n this.row,\r\n this.col,\r\n schema,\r\n schema,\r\n TokenType.STRING,\r\n TokenType.SECTION_SCHEMA\r\n );\r\n this.advance(schema.length);\r\n this.skipWhitespaces(true);\r\n }\r\n }\r\n }\r\n\r\n return tokenIndex;\r\n }\r\n}\r\n\r\ntype Annotation = {\r\n name: string;\r\n quote: string;\r\n}\r\n\r\nexport default Tokenizer;\r\n"],"mappings":"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","names":["TokenType","Token","Symbols","tokenText","SyntaxError","ErrorCodes","assertNever","Decimal","Literals","token"]}