{"version":3,"sources":["../../src/parser/ast-parser.ts"],"sourcesContent":["import assertNever      from '../errors/asserts/asserts';\r\nimport ErrorCodes       from '../errors/io-error-codes';\r\nimport SyntaxError      from '../errors/io-syntax-error';\r\nimport { tokenSpanRange } from '../errors/error-range-utils';\r\nimport Symbols          from './tokenizer/symbols';\r\nimport TokenType        from './tokenizer/token-types';\r\nimport Token            from './tokenizer/tokens';\r\nimport { isTerminator } from './tokenizer/is';\r\nimport ArrayNode        from './nodes/array';\r\nimport CollectionNode   from './nodes/collections';\r\nimport DocumentNode     from './nodes/document';\r\nimport ErrorNode        from './nodes/error';\r\nimport MemberNode       from './nodes/members';\r\nimport Node             from './nodes/nodes';\r\nimport ObjectNode       from './nodes/objects';\r\nimport SectionNode      from './nodes/section';\r\nimport TokenNode        from './nodes/tokens';\r\n\r\n/**\r\n * ASTParser transforms a token stream into an Abstract Syntax Tree (AST).\r\n *\r\n * @remarks\r\n * This is a recursive descent parser with error recovery capabilities.\r\n * It implements a three-tier error recovery strategy:\r\n *\r\n * 1. **Token-level**: Handles individual token errors (via ERROR tokens from tokenizer)\r\n * 2. **Collection-level**: `skipToNextCollectionItem()` - recovers at `~` boundaries\r\n * 3. **Section-level**: `skipToNextSyncPoint()` - recovers at structural terminators\r\n *\r\n * The parser accumulates errors in the `errors` array and continues parsing,\r\n * allowing IDEs to show all diagnostics in a single pass.\r\n *\r\n * @example\r\n * ```ts\r\n * const tokenizer = new Tokenizer(input);\r\n * const tokens = tokenizer.tokenize();\r\n * const parser = new ASTParser(tokens);\r\n * const doc = parser.parse();\r\n *\r\n * // Check for errors\r\n * const errors = doc.getErrors();\r\n * if (errors.length > 0) {\r\n *   errors.forEach(e => console.error(e.message));\r\n * }\r\n * ```\r\n */\r\nclass ASTParser {\r\n\r\n  /** Array of tokens produced by the tokenizer */\r\n  private readonly tokens: readonly Token[];\r\n\r\n  /** Tracks section names for duplicate detection */\r\n  private readonly sectionNames: { [key: string]: boolean } = {};\r\n\r\n  /** Accumulated errors during parsing for IDE diagnostics */\r\n  private readonly errors: Error[] = [];\r\n\r\n  /** Current token index in the token stream */\r\n  private current: number;\r\n\r\n  // Cached arrays for performance optimization (avoids array allocation in hot paths)\r\n  private static readonly CURLY_OPEN_ARRAY = [TokenType.CURLY_OPEN] as const;\r\n  private static readonly CURLY_CLOSE_ARRAY = [TokenType.CURLY_CLOSE] as const;\r\n  private static readonly BRACKET_OPEN_ARRAY = [TokenType.BRACKET_OPEN] as const;\r\n  private static readonly BRACKET_CLOSE_ARRAY = [TokenType.BRACKET_CLOSE] as const;\r\n  private static readonly COLLECTION_START_ARRAY = [TokenType.COLLECTION_START] as const;\r\n  private static readonly SECTION_SEP_ARRAY = [TokenType.SECTION_SEP] as const;\r\n  private static readonly COMMA_ARRAY = [TokenType.COMMA] as const;\r\n  private static readonly COLON_ARRAY = [TokenType.COLON] as const;\r\n  private static readonly COLLECTION_OR_SECTION_ARRAY = [TokenType.COLLECTION_START, TokenType.SECTION_SEP] as const;\r\n  private static readonly VALID_KEY_TYPES = [\r\n    TokenType.STRING,\r\n    TokenType.NUMBER,\r\n    TokenType.BOOLEAN,\r\n    TokenType.NULL,\r\n  ] as const;\r\n\r\n  /**\r\n   * Creates a new ASTParser instance.\r\n   * @param tokens - Read-only array of tokens from the tokenizer\r\n   */\r\n  constructor(tokens: readonly Token[]) {\r\n    this.tokens = tokens;\r\n    this.current = 0;\r\n  }\r\n\r\n  /**\r\n   * Parses the token stream and produces a DocumentNode AST.\r\n   *\r\n   * @returns DocumentNode containing the parsed AST and accumulated errors\r\n   */\r\n  public parse(): DocumentNode {\r\n    return this.processDocument();\r\n  }\r\n\r\n  /**\r\n   * Creates a syntax error with proper range spanning the entire construct.\r\n   *\r\n   * @remarks\r\n   * Industry standard (TypeScript, Roslyn): Error should highlight from\r\n   * the opening token to the last valid token, not just a single point.\r\n   * This provides better IDE experience for unclosed constructs.\r\n   *\r\n   * @param errorCode - The error code from ErrorCodes\r\n   * @param message - Human-readable error message\r\n   * @param startToken - Opening token of the construct (e.g., '{' or '[')\r\n   * @param members - Array of parsed members/elements to find the last valid token\r\n   * @returns SyntaxError with position range spanning the entire construct\r\n   */\r\n  private createUnclosedConstructError(\r\n    errorCode: string,\r\n    message: string,\r\n    startToken: Token | null,\r\n    members: Array<Node | undefined>\r\n  ): SyntaxError {\r\n    // Find the end position by looking backwards from current, skipping boundary tokens\r\n    let errorEndToken: Token | null = null;\r\n\r\n    // Start from the token before current position\r\n    let checkIndex = this.current - 1;\r\n\r\n    // Skip backwards over any boundary tokens (~ or ---)\r\n    while (checkIndex >= 0) {\r\n      const token = this.tokens[checkIndex];\r\n      if (token &&\r\n          token.type !== TokenType.COLLECTION_START &&\r\n          token.type !== TokenType.SECTION_SEP) {\r\n        errorEndToken = token;\r\n        break;\r\n      }\r\n      checkIndex--;\r\n    }\r\n\r\n    // Create the error with proper range spanning the entire construct\r\n    if (startToken && errorEndToken) {\r\n      const range = tokenSpanRange(startToken, errorEndToken);\r\n      return new SyntaxError(errorCode, message, range, false);\r\n    } else if (startToken) {\r\n      // Fallback: use start token only\r\n      return new SyntaxError(errorCode, message, startToken, false);\r\n    } else {\r\n      // No tokens available - create error without position\r\n      return new SyntaxError(errorCode, message, undefined, true);\r\n    }\r\n  }  private processDocument(): DocumentNode {\r\n    const sections = new Array<SectionNode>();\r\n    let header: SectionNode | null = null;\r\n\r\n    let token: Token | null = this.peek();\r\n    let first = true;\r\n\r\n    while (true) {\r\n      if (first) {\r\n        // When the first token is a section separator, it means that\r\n        // header section is not present. Just skip the section separator\r\n        if (token?.type === TokenType.SECTION_SEP) {\r\n          first = false;\r\n        }\r\n      }\r\n\r\n      const section = this.processSection(first);\r\n\r\n      token = this.peek();\r\n      if (!token) {\r\n        sections.push(section);\r\n        break;\r\n      }\r\n\r\n      if (first) {\r\n        header = section;\r\n      } else {\r\n        sections.push(section);\r\n      }\r\n\r\n      if (first) first = false;\r\n\r\n      // If the next token is not a section separator, it means that\r\n      // the current section is not closed properly. Add error and stop\r\n      if (token.type !== TokenType.SECTION_SEP) {\r\n        const error = new SyntaxError(\r\n          ErrorCodes.unexpectedToken,\r\n          `Expected section separator '---' but found '${token.token}'. Each section must be properly closed before starting a new one.`,\r\n          token\r\n        );\r\n        this.errors.push(error);\r\n        break; // Stop parsing but return partial document\r\n      }\r\n\r\n      // Move to the next token and check if it is a section separator\r\n      // or the end of file\r\n      this.advance();\r\n    }\r\n\r\n    // If there are more than one sections, and the document does not start\r\n    // with --- then the first one is the header.\r\n    // section. Remove it from the sections array and return it as the header\r\n    // if (sections.length > 1 && this.tokens[0].type !== TokenType.SECTION_SEP) {\r\n    //   const header = sections.shift();\r\n    //   return new DocumentNode(header ?? null, sections);\r\n    // }\r\n\r\n    return new DocumentNode(header, sections, this.errors);\r\n  }\r\n\r\n  private processSection(first: boolean): SectionNode {\r\n    let token = this.peek();\r\n\r\n    // Consume the section separator if present\r\n    if (token?.type === TokenType.SECTION_SEP) {\r\n      this.advance();\r\n    }\r\n\r\n    // If the first token is a section separator, it means that\r\n    // the section has started without a section name. A header\r\n    // section does not have a name.\r\n    const [schemaNode, nameNode] = this.parseSectionAndSchemaNames();\r\n    let name: string = nameNode?.value != null ? String(nameNode.value)\r\n      : (schemaNode?.value != null ? String(schemaNode.value).substring(1) : 'unnamed');\r\n    const originalName = name;\r\n\r\n    // Check if the section name is already used - implement auto-rename for error recovery\r\n    if (name && this.sectionNames[name]) {\r\n      const error = new SyntaxError(\r\n        ErrorCodes.unexpectedToken,\r\n        `Duplicate section name '${name}'. Each section must have a unique name within the document.`,\r\n        void 0, false\r\n      );\r\n      this.errors.push(error); // Accumulate error\r\n\r\n      // Auto-rename: users -> users_2, users_3, etc.\r\n      let suffix = 2;\r\n      while (this.sectionNames[`${originalName}_${suffix}`]) {\r\n        suffix++;\r\n      }\r\n      name = `${originalName}_${suffix}`;\r\n\r\n      // Update the nameNode with the renamed value\r\n      if (nameNode) {\r\n        nameNode.value = name;\r\n      }\r\n    }\r\n\r\n    if (!first || (first && name !== 'unnamed' && this.peek()?.type !== TokenType.SECTION_SEP)) {\r\n      this.sectionNames[name] = true;\r\n    }\r\n\r\n    const section = this.parseSectionContent();\r\n    return new SectionNode(section, nameNode, schemaNode);\r\n  }\r\n\r\n  private parseSectionAndSchemaNames(): [TokenNode | null, TokenNode | null] {\r\n    let schemaNode:TokenNode | null = null;\r\n    let nameNode:TokenNode | null = null;\r\n\r\n    let token = this.peek();\r\n    if (token?.subType === TokenType.SECTION_NAME) {\r\n      nameNode = token as TokenNode;\r\n\r\n      // Consume the section name\r\n      this.advance();\r\n\r\n      token = this.peek();\r\n      if (token?.subType === TokenType.SECTION_SCHEMA) {\r\n        schemaNode = token as TokenNode;\r\n        // Consume the section name\r\n        this.advance();\r\n      }\r\n    } else if (token?.subType === TokenType.SECTION_SCHEMA) {\r\n      schemaNode = token as TokenNode;\r\n      // Consume the section name\r\n      this.advance();\r\n\r\n      token = this.peek();\r\n    }\r\n\r\n    return [schemaNode, nameNode]\r\n  }\r\n\r\n  public parseSectionContent():\r\n    ObjectNode | CollectionNode | null {\r\n    const token = this.peek();\r\n    if (!token) return null;\r\n\r\n    if (token.type === TokenType.SECTION_SEP) {\r\n      return null;\r\n    }\r\n\r\n    // Parse the collection ~\r\n    if (token.type === TokenType.COLLECTION_START) {\r\n      return this.processCollection();\r\n    }\r\n\r\n    // Parse the single object {}\r\n    return this.processObject(false);\r\n  }\r\n\r\n  private processCollection(): CollectionNode {\r\n    const objects: Node[] = [];\r\n\r\n    while (this.match(ASTParser.COLLECTION_START_ARRAY)) {\r\n      // Consume the COLLECTION_START token\r\n      this.advance();\r\n\r\n      // Remember the position before parsing the item (for fallback)\r\n      const itemStartPos = this.current;\r\n\r\n      // Check if the first token of this collection item is an ERROR token\r\n      // If so, treat the entire item as an ErrorNode\r\n      const firstToken = this.peek();\r\n      if (firstToken && firstToken.type === TokenType.ERROR) {\r\n        const errorValue = firstToken.value as { __error: true; message: string; originalError: Error };\r\n        const errorNode = new ErrorNode(errorValue.originalError, firstToken);\r\n        this.errors.push(errorValue.originalError);\r\n        objects.push(errorNode);\r\n        this.advance(); // Consume the error token\r\n        this.skipToNextCollectionItem();\r\n        continue;\r\n      }\r\n\r\n      try {\r\n        // Parse the object and add to the collection\r\n        objects.push(this.processObject(true));\r\n      } catch (error) {\r\n        // Accumulate error for Phase 2\r\n        this.errors.push(error as Error);\r\n\r\n        // Create error node with actual error position\r\n        let position = { pos: -1, row: -1, col: -1 };\r\n        let endPosition = undefined;\r\n\r\n        // Extract position from IOError if available\r\n        if (error && typeof error === 'object' && 'positionRange' in error) {\r\n          const posRange = (error as any).positionRange;\r\n          if (posRange && posRange.getStartPos) {\r\n            position = posRange.getStartPos();\r\n            endPosition = posRange.getEndPos ? posRange.getEndPos() : undefined;\r\n          }\r\n        }\r\n\r\n        // Fallback: if no position in error, use the last valid token position\r\n        if (position.pos === -1 && this.current > 0 && this.current <= this.tokens.length) {\r\n          const lastToken = this.tokens[this.current - 1];\r\n          if (lastToken) {\r\n            position = lastToken.getEndPos(); // Use end position of last token\r\n            endPosition = position; // Point to same location\r\n          }\r\n        }\r\n\r\n        objects.push(new ErrorNode(error as Error, position, endPosition));\r\n        this.skipToNextCollectionItem();\r\n      }\r\n      // No explicit delimiter check is required since the `~`\r\n      // itself acts as both a delimiter and an indicator for\r\n      // the next object.\r\n    }\r\n\r\n    return new CollectionNode(objects);\r\n  }\r\n\r\n  /**\r\n   * Skips tokens until the next collection item boundary.\r\n   *\r\n   * @remarks\r\n   * This is a **collection-level error recovery** mechanism.\r\n   * When an error occurs while parsing a collection item, this method\r\n   * advances the token stream to the next `~` (COLLECTION_START) or\r\n   * section separator (`---`), allowing parsing to continue with the\r\n   * next collection item.\r\n   *\r\n   * Recovery pattern:\r\n   * ```\r\n   * ~ valid, item           ← parsed successfully\r\n   * ~ { unclosed object     ← error here, skipToNextCollectionItem called\r\n   * ~ another, valid        ← parsing resumes here\r\n   * ```\r\n   */\r\n  private skipToNextCollectionItem(): void {\r\n    // Skip tokens until we find next `~` (COLLECTION_START) or section end\r\n    while (this.peek() &&\r\n           !this.match(ASTParser.COLLECTION_OR_SECTION_ARRAY)) {\r\n      this.advance();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Skips tokens to the next synchronization point after a parsing error.\r\n   *\r\n   * @remarks\r\n   * This is a **section-level error recovery** mechanism.\r\n   * Synchronization points are structural terminator tokens (comma, colon,\r\n   * brackets, etc.) that serve as safe resumption points after an error.\r\n   *\r\n   * This method is more aggressive than `skipToNextCollectionItem()` and\r\n   * is used when errors occur in non-collection contexts or when finer-grained\r\n   * recovery is needed.\r\n   *\r\n   * The method uses `isTerminator()` to check for token types that represent\r\n   * structural boundaries in the Internet Object format.\r\n   */\r\n  private skipToNextSyncPoint(): void {\r\n    while (this.peek()) {\r\n      const token = this.peek();\r\n      if (!token) break;\r\n\r\n      // Check if we've reached a terminator token (structural boundary at token level)\r\n      // Note: We check token.type (e.g., \"COMMA\", \"COLON\") not raw characters\r\n      // because we're in the parser working with tokens, not the tokenizer working with chars.\r\n      // Use isTerminator() for token types, not isCharTerminator() for characters.\r\n      if (isTerminator(token.type)) {\r\n        break; // Found a synchronization point, stop here\r\n      }\r\n\r\n      this.advance();\r\n    }\r\n  }\r\n\r\n  private processObject(isCollectionContext: boolean): ObjectNode {\r\n    const obj = this.parseObject(true);\r\n\r\n    // Even after parsing the object, if there is still a token\r\n    // left, it means that the object is not closed properly.\r\n    const token = this.peek();\r\n    this.checkForPendingTokens(token, isCollectionContext);\r\n\r\n    // If there is only one member in the object, and it has no key,\r\n    // then the object is not an open object. In this case, we need\r\n    // unwrap the object\r\n    // For example. { {} } should be unwrapped to {}\r\n\r\n    // {} should be unwrapped to []\r\n    // 'a' should be unwrapped to [a]\r\n    // 'a', 'b', 'c' should be unwrapped to [a, b, c]\r\n    // {}, 'b', 'c' should be unwrapped to [{}, b, c]\r\n    // {{}} should be unwrapped to [{}]\r\n    if (obj.children.length === 1) {\r\n      const firstMember = obj.children[0] as MemberNode;\r\n      if (firstMember && !firstMember.key && firstMember.value) {\r\n        if (firstMember.value instanceof ObjectNode) {\r\n          return firstMember.value as ObjectNode;\r\n        }\r\n      }\r\n    }\r\n\r\n    return obj;\r\n  }\r\n\r\n  private checkForPendingTokens(token: Token | null, isCollectionContext: boolean) {\r\n    if (!token) return;\r\n\r\n    if (token.type === TokenType.SECTION_SEP) return;\r\n\r\n    if (isCollectionContext && token.type === TokenType.COLLECTION_START) return;\r\n\r\n    throw new SyntaxError(\r\n      ErrorCodes.unexpectedToken,\r\n      `Unexpected token '${token.value}'. Expected end of section or start of new collection item '~'.`,\r\n      token, false\r\n    );\r\n  }\r\n\r\n  private parseObject(isOpenObject: boolean): ObjectNode {\r\n    const members: Array<MemberNode> = [];\r\n    let openBracket: Token | null = this.peek();\r\n    if (isOpenObject) {\r\n      openBracket = null;\r\n    }\r\n\r\n    if (!isOpenObject && !this.advanceIfMatch(ASTParser.CURLY_OPEN_ARRAY)) {\r\n      assertNever(\"The caller must ensure that this function is called \" +\r\n        \"only when the next token is {\");\r\n    }\r\n\r\n    let index = 0;\r\n    let done = false;\r\n    let expectingValueAfterComma = true;  // After '{', we're expecting the first value (or empty position)\r\n\r\n    while (!done) {\r\n      const nextToken = this.peek();\r\n\r\n      // DEBUG\r\n      const DEBUG_PARSE_OBJECT = false; // Set to true to debug\r\n      if (DEBUG_PARSE_OBJECT && members.length < 3) {\r\n        const prevToken = this.tokens[this.current - 1];\r\n        console.log(`  loop: current=${this.current}, next=${nextToken?.type}, prev=${prevToken?.type}, expecting=${expectingValueAfterComma}, members=${members.length}`);\r\n      }\r\n\r\n      if (!nextToken || this.match([TokenType.CURLY_CLOSE, TokenType.COLLECTION_START, TokenType.SECTION_SEP])) {\r\n        // If we were expecting a value after a comma but hit end/close, that position is empty\r\n        if (expectingValueAfterComma) {\r\n          const prevToken = this.tokens[this.current - 1];\r\n          if (prevToken && prevToken.type === TokenType.COMMA) {\r\n            this.pushUndefinedMember(members, prevToken);\r\n          }\r\n        }\r\n        done = true;\r\n        break;\r\n      } else if (nextToken.type === TokenType.COMMA) {\r\n        // If we're expecting a value but got a comma, the current position is empty\r\n        if (expectingValueAfterComma) {\r\n          // Use the comma token itself for position tracking\r\n          this.pushUndefinedMember(members, nextToken);\r\n        }\r\n        // Consume the comma and mark that we're now expecting a value\r\n        this.advance();\r\n        expectingValueAfterComma = true;\r\n        continue;\r\n      } else {\r\n        // We found a value\r\n        // The member must be preceded by a comma, open bracket, or\r\n        // the beginning of the object. Otherwise it is invalid\r\n        // For example, { a: 1, b: 2 } is valid, but { a: 1 b: 2 } is not\r\n        if (index > 0) {\r\n          if (!this.matchPrev([TokenType.COMMA, TokenType.CURLY_OPEN])) {\r\n            throw new SyntaxError(\r\n              ErrorCodes.unexpectedToken,\r\n              `Missing comma before '${nextToken.value}'. Object members must be separated by commas.`,\r\n              nextToken, false\r\n            );\r\n          }\r\n        }\r\n        const member = this.parseMember();\r\n        members.push(member);\r\n        index++;\r\n        expectingValueAfterComma = false;  // We got the value\r\n      }\r\n    }\r\n\r\n    // Now, expect a closing bracket if not open object\r\n    if (!isOpenObject) {\r\n      if (!this.match(ASTParser.CURLY_CLOSE_ARRAY)) {\r\n        throw this.createUnclosedConstructError(\r\n          ErrorCodes.expectingBracket,\r\n          `Missing closing brace '}'. Object must be properly closed.`,\r\n          openBracket,\r\n          members\r\n        );\r\n      }\r\n      let closeBracket: Token | null = this.peek();\r\n      this.advance();\r\n      return new ObjectNode(members, openBracket!, closeBracket!);\r\n    } else {\r\n      return new ObjectNode(members);\r\n    }\r\n  }\r\n\r\n  private parseMember(): MemberNode {\r\n    const leftToken = this.peek();\r\n\r\n    if (!leftToken) {\r\n      assertNever(\"The caller must ensure that this function is called \" +\r\n        \"only when the member has at least one token\");\r\n    }\r\n\r\n    if (this.matchNext(ASTParser.COLON_ARRAY)) {\r\n      const isValidKey = (ASTParser.VALID_KEY_TYPES as readonly TokenType[]).includes(leftToken.type as TokenType);\r\n\r\n      if (isValidKey) {\r\n        // Consume the key and colon\r\n        this.advance(2);\r\n\r\n        // Parse the value and return the key-value pair\r\n        const value = this.parseValue();\r\n        return new MemberNode(value, leftToken as TokenNode);\r\n      } else {\r\n        throw new SyntaxError(ErrorCodes.invalidKey,\r\n          `Invalid key '${leftToken.token}'. Object keys must be strings, numbers, booleans, or null.`,\r\n          leftToken, false);\r\n      }\r\n    }\r\n\r\n    // If the next token is not a colon, that means it is\r\n    // a value without a key. In this case the key is\r\n    // the index of the value\r\n    return new MemberNode(this.parseValue());\r\n  }\r\n\r\n  private parseArray(): ArrayNode  {\r\n    const arr: Array<Node | undefined> = [];\r\n    const openBracket = this.peek();\r\n    if (!openBracket || openBracket.type !== TokenType.BRACKET_OPEN) {\r\n      throw new SyntaxError(\r\n        ErrorCodes.expectingBracket,\r\n        `Expected opening bracket '[' to start array but found '${openBracket?.token || 'end of input'}'.`,\r\n        openBracket === null ? void 0 : openBracket,\r\n        openBracket === null\r\n      );\r\n    }\r\n    // Consume the opening bracket\r\n    this.advance();\r\n\r\n    while (true) {\r\n      const currentToken = this.peek();\r\n      if (!currentToken) {\r\n        // Unexpected end of input\r\n        throw this.createUnclosedConstructError(\r\n          ErrorCodes.expectingBracket,\r\n          `Unexpected end of input while parsing array. Expected closing bracket ']'.`,\r\n          openBracket,\r\n          arr\r\n        );\r\n      }\r\n      if (currentToken.type === TokenType.BRACKET_CLOSE) {\r\n        break;\r\n      } else if (currentToken.type === TokenType.COLLECTION_START ||\r\n                 currentToken.type === TokenType.SECTION_SEP) {\r\n        // Reached a synchronization boundary without closing the array\r\n        throw this.createUnclosedConstructError(\r\n          ErrorCodes.expectingBracket,\r\n          `Missing closing bracket ']'. Array must be properly closed.`,\r\n          openBracket,\r\n          arr\r\n        );\r\n      } else if (currentToken.type === TokenType.COMMA) {\r\n        // If the next token is a comma or a closing bracket, it implies an undefined\r\n        // element in the array, which is not allowed. Throw an error.\r\n        if (this.matchNext([TokenType.COMMA, TokenType.BRACKET_CLOSE])) {\r\n          const nextToken = this.tokens[this.current + 1];\r\n          throw new SyntaxError(\r\n            ErrorCodes.unexpectedToken,\r\n            `Unexpected comma. Array elements cannot be empty - remove the extra comma or add a value.`,\r\n            nextToken, false\r\n          );\r\n        }\r\n        // consume the current comma\r\n        this.advance();\r\n        continue;\r\n      }\r\n\r\n      const member = this.parseMember();\r\n      if (member.key) {\r\n        arr.push(new ObjectNode([member]));\r\n      } else {\r\n        arr.push(member.value);\r\n      }\r\n    }\r\n\r\n    // Now, expect a closing bracket\r\n    if (!this.match(ASTParser.BRACKET_CLOSE_ARRAY)) {\r\n      throw this.createUnclosedConstructError(\r\n        ErrorCodes.expectingBracket,\r\n        `Missing closing bracket ']'. Array must be properly closed.`,\r\n        openBracket,\r\n        arr\r\n      );\r\n    }\r\n    const closeBracket = this.peek();\r\n    this.advance();\r\n    // Both openBracket and closeBracket are guaranteed to be Token (not null) here\r\n    return new ArrayNode(arr, openBracket, closeBracket!);\r\n  }\r\n\r\n  private parseValue(): Node {\r\n    const token = this.peek();\r\n    if (!token) {\r\n      throw new SyntaxError(ErrorCodes.valueRequired,\r\n        `Unexpected end of input. Expected a value (string, number, boolean, null, array, or object).`,\r\n        void 0, true);\r\n    }\r\n\r\n    switch (token.type) {\r\n      case TokenType.STRING:\r\n      case TokenType.NUMBER:\r\n      case TokenType.BIGINT:\r\n      case TokenType.DECIMAL:\r\n      case TokenType.BOOLEAN:\r\n      case TokenType.NULL:\r\n      case TokenType.DATETIME: {\r\n        const node = new TokenNode(token);\r\n        this.advance();\r\n        return node;\r\n      }\r\n      case TokenType.BRACKET_OPEN:\r\n        return this.parseArray();\r\n      case TokenType.CURLY_OPEN:\r\n        return this.parseObject(false);\r\n      case TokenType.ERROR: {\r\n        // Handle error tokens from tokenizer (e.g., unterminated strings)\r\n        // The current node becomes invalid, so we create an ErrorNode and skip to next sync point\r\n        const errorValue = token.value as { __error: true; message: string; originalError: Error };\r\n        const errorNode = new ErrorNode(errorValue.originalError, token);\r\n        this.errors.push(errorValue.originalError); // Add to error collection\r\n        this.advance(); // Move past the error token\r\n\r\n        // Skip to next synchronization boundary (collection/section delimiter or comma)\r\n        // This helps recover from the error and continue parsing the next valid item\r\n        this.skipToNextSyncPoint();\r\n\r\n        return errorNode;\r\n      }\r\n      default:\r\n        throw new SyntaxError(\r\n          ErrorCodes.unexpectedToken,\r\n          `Unexpected token '${token.value}'. Expected a valid value (string, number, boolean, null, array, or object).`,\r\n          token, token === null\r\n        );\r\n    }\r\n  }\r\n\r\n  private pushUndefinedMember(members: MemberNode[], curerntCommaToken:Token) {\r\n    const valueNode = curerntCommaToken.clone();\r\n    valueNode.type = TokenType.UNDEFINED;\r\n    valueNode.value = void 0;\r\n    const member = new MemberNode(new TokenNode(valueNode));\r\n\r\n    members.push(member);\r\n  }\r\n\r\n  /**\r\n   * Type guard to check if a token is valid (not null)\r\n   */\r\n  private isValidToken(token: Token | null): token is Token {\r\n    return token !== null;\r\n  }\r\n\r\n  /**\r\n   * Returns the current token without advancing the current index\r\n   * @returns {Token} the current token or null if eof is reached\r\n   */\r\n  private peek(): Token | null {\r\n    return this.current < this.tokens.length ? this.tokens[this.current] : null;\r\n  }\r\n\r\n  /**\r\n   * Advances the current token index by the given number of steps\r\n   */\r\n  private advance(steps: number = 1): void {\r\n    this.current += steps;\r\n  }\r\n\r\n  /**\r\n   * Checks if the current token matches any of the given types.\r\n   * If a current token is not available, returns false.\r\n   * @param types - Array of token types to match against\r\n   * @returns true if current token matches any of the given types\r\n   */\r\n  private match(types: readonly TokenType[]): boolean {\r\n    const currentToken = this.peek();\r\n    if (this.isValidToken(currentToken) && types.includes(currentToken.type as TokenType)) {\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  private matchPrev(types: readonly TokenType[]): boolean {\r\n    const prevToken = this.tokens[this.current - 1];\r\n    if (this.isValidToken(prevToken) && types.includes(prevToken.type as TokenType)) {\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /**\r\n   * Match the next token in the stream without advancing the current index.\r\n   * If the next token matches any of the given types, returns true, otherwise returns false.\r\n   * If the next token is not available, returns false.\r\n   * @param types - Array of token types to match against\r\n   * @returns true if next token matches any of the given types\r\n   */\r\n  private matchNext(types: readonly TokenType[]): boolean {\r\n    if (this.current + 1 >= this.tokens.length) {\r\n      return false;\r\n    }\r\n    const nextToken = this.tokens[this.current + 1];\r\n    if (this.isValidToken(nextToken) && types.includes(nextToken.type as TokenType)) {\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  private advanceIfMatch(types: readonly TokenType[]): boolean {\r\n    if (this.match(types)) {\r\n      this.advance();\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n}\r\n\r\nexport default ASTParser;\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAA6B;AAC7B,4BAA6B;AAC7B,6BAA6B;AAC7B,+BAA+B;AAE/B,yBAA6B;AAE7B,gBAA6B;AAC7B,mBAA6B;AAC7B,yBAA6B;AAC7B,sBAA6B;AAC7B,mBAA6B;AAC7B,qBAA6B;AAE7B,qBAA6B;AAC7B,qBAA6B;AAC7B,IAAAA,iBAA6B;AA8B7B,MAAM,UAAU;AAAA;AAAA,EAGG;AAAA;AAAA,EAGA,eAA2C,CAAC;AAAA;AAAA,EAG5C,SAAkB,CAAC;AAAA;AAAA,EAG5B;AAAA;AAAA,EAGR,OAAwB,mBAAmB,CAAC,mBAAAC,QAAU,UAAU;AAAA,EAChE,OAAwB,oBAAoB,CAAC,mBAAAA,QAAU,WAAW;AAAA,EAClE,OAAwB,qBAAqB,CAAC,mBAAAA,QAAU,YAAY;AAAA,EACpE,OAAwB,sBAAsB,CAAC,mBAAAA,QAAU,aAAa;AAAA,EACtE,OAAwB,yBAAyB,CAAC,mBAAAA,QAAU,gBAAgB;AAAA,EAC5E,OAAwB,oBAAoB,CAAC,mBAAAA,QAAU,WAAW;AAAA,EAClE,OAAwB,cAAc,CAAC,mBAAAA,QAAU,KAAK;AAAA,EACtD,OAAwB,cAAc,CAAC,mBAAAA,QAAU,KAAK;AAAA,EACtD,OAAwB,8BAA8B,CAAC,mBAAAA,QAAU,kBAAkB,mBAAAA,QAAU,WAAW;AAAA,EACxG,OAAwB,kBAAkB;AAAA,IACxC,mBAAAA,QAAU;AAAA,IACV,mBAAAA,QAAU;AAAA,IACV,mBAAAA,QAAU;AAAA,IACV,mBAAAA,QAAU;AAAA,EACZ;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,YAAY,QAA0B;AACpC,SAAK,SAAS;AACd,SAAK,UAAU;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,QAAsB;AAC3B,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBQ,6BACN,WACA,SACA,YACA,SACa;AAEb,QAAI,gBAA8B;AAGlC,QAAI,aAAa,KAAK,UAAU;AAGhC,WAAO,cAAc,GAAG;AACtB,YAAM,QAAQ,KAAK,OAAO,UAAU;AACpC,UAAI,SACA,MAAM,SAAS,mBAAAA,QAAU,oBACzB,MAAM,SAAS,mBAAAA,QAAU,aAAa;AACxC,wBAAgB;AAChB;AAAA,MACF;AACA;AAAA,IACF;AAGA,QAAI,cAAc,eAAe;AAC/B,YAAM,YAAQ,yCAAe,YAAY,aAAa;AACtD,aAAO,IAAI,uBAAAC,QAAY,WAAW,SAAS,OAAO,KAAK;AAAA,IACzD,WAAW,YAAY;AAErB,aAAO,IAAI,uBAAAA,QAAY,WAAW,SAAS,YAAY,KAAK;AAAA,IAC9D,OAAO;AAEL,aAAO,IAAI,uBAAAA,QAAY,WAAW,SAAS,QAAW,IAAI;AAAA,IAC5D;AAAA,EACF;AAAA,EAAW,kBAAgC;AACzC,UAAM,WAAW,IAAI,MAAmB;AACxC,QAAI,SAA6B;AAEjC,QAAI,QAAsB,KAAK,KAAK;AACpC,QAAI,QAAQ;AAEZ,WAAO,MAAM;AACX,UAAI,OAAO;AAGT,YAAI,OAAO,SAAS,mBAAAD,QAAU,aAAa;AACzC,kBAAQ;AAAA,QACV;AAAA,MACF;AAEA,YAAM,UAAU,KAAK,eAAe,KAAK;AAEzC,cAAQ,KAAK,KAAK;AAClB,UAAI,CAAC,OAAO;AACV,iBAAS,KAAK,OAAO;AACrB;AAAA,MACF;AAEA,UAAI,OAAO;AACT,iBAAS;AAAA,MACX,OAAO;AACL,iBAAS,KAAK,OAAO;AAAA,MACvB;AAEA,UAAI,MAAO,SAAQ;AAInB,UAAI,MAAM,SAAS,mBAAAA,QAAU,aAAa;AACxC,cAAM,QAAQ,IAAI,uBAAAC;AAAA,UAChB,sBAAAC,QAAW;AAAA,UACX,+CAA+C,MAAM,KAAK;AAAA,UAC1D;AAAA,QACF;AACA,aAAK,OAAO,KAAK,KAAK;AACtB;AAAA,MACF;AAIA,WAAK,QAAQ;AAAA,IACf;AAUA,WAAO,IAAI,gBAAAC,QAAa,QAAQ,UAAU,KAAK,MAAM;AAAA,EACvD;AAAA,EAEQ,eAAe,OAA6B;AAClD,QAAI,QAAQ,KAAK,KAAK;AAGtB,QAAI,OAAO,SAAS,mBAAAH,QAAU,aAAa;AACzC,WAAK,QAAQ;AAAA,IACf;AAKA,UAAM,CAAC,YAAY,QAAQ,IAAI,KAAK,2BAA2B;AAC/D,QAAI,OAAe,UAAU,SAAS,OAAO,OAAO,SAAS,KAAK,IAC7D,YAAY,SAAS,OAAO,OAAO,WAAW,KAAK,EAAE,UAAU,CAAC,IAAI;AACzE,UAAM,eAAe;AAGrB,QAAI,QAAQ,KAAK,aAAa,IAAI,GAAG;AACnC,YAAM,QAAQ,IAAI,uBAAAC;AAAA,QAChB,sBAAAC,QAAW;AAAA,QACX,2BAA2B,IAAI;AAAA,QAC/B;AAAA,QAAQ;AAAA,MACV;AACA,WAAK,OAAO,KAAK,KAAK;AAGtB,UAAI,SAAS;AACb,aAAO,KAAK,aAAa,GAAG,YAAY,IAAI,MAAM,EAAE,GAAG;AACrD;AAAA,MACF;AACA,aAAO,GAAG,YAAY,IAAI,MAAM;AAGhC,UAAI,UAAU;AACZ,iBAAS,QAAQ;AAAA,MACnB;AAAA,IACF;AAEA,QAAI,CAAC,SAAU,SAAS,SAAS,aAAa,KAAK,KAAK,GAAG,SAAS,mBAAAF,QAAU,aAAc;AAC1F,WAAK,aAAa,IAAI,IAAI;AAAA,IAC5B;AAEA,UAAM,UAAU,KAAK,oBAAoB;AACzC,WAAO,IAAI,eAAAI,QAAY,SAAS,UAAU,UAAU;AAAA,EACtD;AAAA,EAEQ,6BAAmE;AACzE,QAAI,aAA8B;AAClC,QAAI,WAA4B;AAEhC,QAAI,QAAQ,KAAK,KAAK;AACtB,QAAI,OAAO,YAAY,mBAAAJ,QAAU,cAAc;AAC7C,iBAAW;AAGX,WAAK,QAAQ;AAEb,cAAQ,KAAK,KAAK;AAClB,UAAI,OAAO,YAAY,mBAAAA,QAAU,gBAAgB;AAC/C,qBAAa;AAEb,aAAK,QAAQ;AAAA,MACf;AAAA,IACF,WAAW,OAAO,YAAY,mBAAAA,QAAU,gBAAgB;AACtD,mBAAa;AAEb,WAAK,QAAQ;AAEb,cAAQ,KAAK,KAAK;AAAA,IACpB;AAEA,WAAO,CAAC,YAAY,QAAQ;AAAA,EAC9B;AAAA,EAEO,sBAC8B;AACnC,UAAM,QAAQ,KAAK,KAAK;AACxB,QAAI,CAAC,MAAO,QAAO;AAEnB,QAAI,MAAM,SAAS,mBAAAA,QAAU,aAAa;AACxC,aAAO;AAAA,IACT;AAGA,QAAI,MAAM,SAAS,mBAAAA,QAAU,kBAAkB;AAC7C,aAAO,KAAK,kBAAkB;AAAA,IAChC;AAGA,WAAO,KAAK,cAAc,KAAK;AAAA,EACjC;AAAA,EAEQ,oBAAoC;AAC1C,UAAM,UAAkB,CAAC;AAEzB,WAAO,KAAK,MAAM,UAAU,sBAAsB,GAAG;AAEnD,WAAK,QAAQ;AAGb,YAAM,eAAe,KAAK;AAI1B,YAAM,aAAa,KAAK,KAAK;AAC7B,UAAI,cAAc,WAAW,SAAS,mBAAAA,QAAU,OAAO;AACrD,cAAM,aAAa,WAAW;AAC9B,cAAM,YAAY,IAAI,aAAAK,QAAU,WAAW,eAAe,UAAU;AACpE,aAAK,OAAO,KAAK,WAAW,aAAa;AACzC,gBAAQ,KAAK,SAAS;AACtB,aAAK,QAAQ;AACb,aAAK,yBAAyB;AAC9B;AAAA,MACF;AAEA,UAAI;AAEF,gBAAQ,KAAK,KAAK,cAAc,IAAI,CAAC;AAAA,MACvC,SAAS,OAAO;AAEd,aAAK,OAAO,KAAK,KAAc;AAG/B,YAAI,WAAW,EAAE,KAAK,IAAI,KAAK,IAAI,KAAK,GAAG;AAC3C,YAAI,cAAc;AAGlB,YAAI,SAAS,OAAO,UAAU,YAAY,mBAAmB,OAAO;AAClE,gBAAM,WAAY,MAAc;AAChC,cAAI,YAAY,SAAS,aAAa;AACpC,uBAAW,SAAS,YAAY;AAChC,0BAAc,SAAS,YAAY,SAAS,UAAU,IAAI;AAAA,UAC5D;AAAA,QACF;AAGA,YAAI,SAAS,QAAQ,MAAM,KAAK,UAAU,KAAK,KAAK,WAAW,KAAK,OAAO,QAAQ;AACjF,gBAAM,YAAY,KAAK,OAAO,KAAK,UAAU,CAAC;AAC9C,cAAI,WAAW;AACb,uBAAW,UAAU,UAAU;AAC/B,0BAAc;AAAA,UAChB;AAAA,QACF;AAEA,gBAAQ,KAAK,IAAI,aAAAA,QAAU,OAAgB,UAAU,WAAW,CAAC;AACjE,aAAK,yBAAyB;AAAA,MAChC;AAAA,IAIF;AAEA,WAAO,IAAI,mBAAAC,QAAe,OAAO;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBQ,2BAAiC;AAEvC,WAAO,KAAK,KAAK,KACV,CAAC,KAAK,MAAM,UAAU,2BAA2B,GAAG;AACzD,WAAK,QAAQ;AAAA,IACf;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBQ,sBAA4B;AAClC,WAAO,KAAK,KAAK,GAAG;AAClB,YAAM,QAAQ,KAAK,KAAK;AACxB,UAAI,CAAC,MAAO;AAMZ,cAAI,wBAAa,MAAM,IAAI,GAAG;AAC5B;AAAA,MACF;AAEA,WAAK,QAAQ;AAAA,IACf;AAAA,EACF;AAAA,EAEQ,cAAc,qBAA0C;AAC9D,UAAM,MAAM,KAAK,YAAY,IAAI;AAIjC,UAAM,QAAQ,KAAK,KAAK;AACxB,SAAK,sBAAsB,OAAO,mBAAmB;AAYrD,QAAI,IAAI,SAAS,WAAW,GAAG;AAC7B,YAAM,cAAc,IAAI,SAAS,CAAC;AAClC,UAAI,eAAe,CAAC,YAAY,OAAO,YAAY,OAAO;AACxD,YAAI,YAAY,iBAAiB,eAAAC,SAAY;AAC3C,iBAAO,YAAY;AAAA,QACrB;AAAA,MACF;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA,EAEQ,sBAAsB,OAAqB,qBAA8B;AAC/E,QAAI,CAAC,MAAO;AAEZ,QAAI,MAAM,SAAS,mBAAAP,QAAU,YAAa;AAE1C,QAAI,uBAAuB,MAAM,SAAS,mBAAAA,QAAU,iBAAkB;AAEtE,UAAM,IAAI,uBAAAC;AAAA,MACR,sBAAAC,QAAW;AAAA,MACX,qBAAqB,MAAM,KAAK;AAAA,MAChC;AAAA,MAAO;AAAA,IACT;AAAA,EACF;AAAA,EAEQ,YAAY,cAAmC;AACrD,UAAM,UAA6B,CAAC;AACpC,QAAI,cAA4B,KAAK,KAAK;AAC1C,QAAI,cAAc;AAChB,oBAAc;AAAA,IAChB;AAEA,QAAI,CAAC,gBAAgB,CAAC,KAAK,eAAe,UAAU,gBAAgB,GAAG;AACrE,yBAAAM,SAAY,mFACqB;AAAA,IACnC;AAEA,QAAI,QAAQ;AACZ,QAAI,OAAO;AACX,QAAI,2BAA2B;AAE/B,WAAO,CAAC,MAAM;AACZ,YAAM,YAAY,KAAK,KAAK;AAG5B,YAAM,qBAAqB;AAC3B,UAAI,sBAAsB,QAAQ,SAAS,GAAG;AAC5C,cAAM,YAAY,KAAK,OAAO,KAAK,UAAU,CAAC;AAC9C,gCAAQ,IAAI,mBAAmB,KAAK,OAAO,UAAU,WAAW,IAAI,UAAU,WAAW,IAAI,eAAe,wBAAwB,aAAa,QAAQ,MAAM,EAAE;AAAA,MACnK;AAEA,UAAI,CAAC,aAAa,KAAK,MAAM,CAAC,mBAAAR,QAAU,aAAa,mBAAAA,QAAU,kBAAkB,mBAAAA,QAAU,WAAW,CAAC,GAAG;AAExG,YAAI,0BAA0B;AAC5B,gBAAM,YAAY,KAAK,OAAO,KAAK,UAAU,CAAC;AAC9C,cAAI,aAAa,UAAU,SAAS,mBAAAA,QAAU,OAAO;AACnD,iBAAK,oBAAoB,SAAS,SAAS;AAAA,UAC7C;AAAA,QACF;AACA,eAAO;AACP;AAAA,MACF,WAAW,UAAU,SAAS,mBAAAA,QAAU,OAAO;AAE7C,YAAI,0BAA0B;AAE5B,eAAK,oBAAoB,SAAS,SAAS;AAAA,QAC7C;AAEA,aAAK,QAAQ;AACb,mCAA2B;AAC3B;AAAA,MACF,OAAO;AAKL,YAAI,QAAQ,GAAG;AACb,cAAI,CAAC,KAAK,UAAU,CAAC,mBAAAA,QAAU,OAAO,mBAAAA,QAAU,UAAU,CAAC,GAAG;AAC5D,kBAAM,IAAI,uBAAAC;AAAA,cACR,sBAAAC,QAAW;AAAA,cACX,yBAAyB,UAAU,KAAK;AAAA,cACxC;AAAA,cAAW;AAAA,YACb;AAAA,UACF;AAAA,QACF;AACA,cAAM,SAAS,KAAK,YAAY;AAChC,gBAAQ,KAAK,MAAM;AACnB;AACA,mCAA2B;AAAA,MAC7B;AAAA,IACF;AAGA,QAAI,CAAC,cAAc;AACjB,UAAI,CAAC,KAAK,MAAM,UAAU,iBAAiB,GAAG;AAC5C,cAAM,KAAK;AAAA,UACT,sBAAAA,QAAW;AAAA,UACX;AAAA,UACA;AAAA,UACA;AAAA,QACF;AAAA,MACF;AACA,UAAI,eAA6B,KAAK,KAAK;AAC3C,WAAK,QAAQ;AACb,aAAO,IAAI,eAAAK,QAAW,SAAS,aAAc,YAAa;AAAA,IAC5D,OAAO;AACL,aAAO,IAAI,eAAAA,QAAW,OAAO;AAAA,IAC/B;AAAA,EACF;AAAA,EAEQ,cAA0B;AAChC,UAAM,YAAY,KAAK,KAAK;AAE5B,QAAI,CAAC,WAAW;AACd,yBAAAC,SAAY,iGACmC;AAAA,IACjD;AAEA,QAAI,KAAK,UAAU,UAAU,WAAW,GAAG;AACzC,YAAM,aAAc,UAAU,gBAAyC,SAAS,UAAU,IAAiB;AAE3G,UAAI,YAAY;AAEd,aAAK,QAAQ,CAAC;AAGd,cAAM,QAAQ,KAAK,WAAW;AAC9B,eAAO,IAAI,eAAAC,QAAW,OAAO,SAAsB;AAAA,MACrD,OAAO;AACL,cAAM,IAAI,uBAAAR;AAAA,UAAY,sBAAAC,QAAW;AAAA,UAC/B,gBAAgB,UAAU,KAAK;AAAA,UAC/B;AAAA,UAAW;AAAA,QAAK;AAAA,MACpB;AAAA,IACF;AAKA,WAAO,IAAI,eAAAO,QAAW,KAAK,WAAW,CAAC;AAAA,EACzC;AAAA,EAEQ,aAAyB;AAC/B,UAAM,MAA+B,CAAC;AACtC,UAAM,cAAc,KAAK,KAAK;AAC9B,QAAI,CAAC,eAAe,YAAY,SAAS,mBAAAT,QAAU,cAAc;AAC/D,YAAM,IAAI,uBAAAC;AAAA,QACR,sBAAAC,QAAW;AAAA,QACX,0DAA0D,aAAa,SAAS,cAAc;AAAA,QAC9F,gBAAgB,OAAO,SAAS;AAAA,QAChC,gBAAgB;AAAA,MAClB;AAAA,IACF;AAEA,SAAK,QAAQ;AAEb,WAAO,MAAM;AACX,YAAM,eAAe,KAAK,KAAK;AAC/B,UAAI,CAAC,cAAc;AAEjB,cAAM,KAAK;AAAA,UACT,sBAAAA,QAAW;AAAA,UACX;AAAA,UACA;AAAA,UACA;AAAA,QACF;AAAA,MACF;AACA,UAAI,aAAa,SAAS,mBAAAF,QAAU,eAAe;AACjD;AAAA,MACF,WAAW,aAAa,SAAS,mBAAAA,QAAU,oBAChC,aAAa,SAAS,mBAAAA,QAAU,aAAa;AAEtD,cAAM,KAAK;AAAA,UACT,sBAAAE,QAAW;AAAA,UACX;AAAA,UACA;AAAA,UACA;AAAA,QACF;AAAA,MACF,WAAW,aAAa,SAAS,mBAAAF,QAAU,OAAO;AAGhD,YAAI,KAAK,UAAU,CAAC,mBAAAA,QAAU,OAAO,mBAAAA,QAAU,aAAa,CAAC,GAAG;AAC9D,gBAAM,YAAY,KAAK,OAAO,KAAK,UAAU,CAAC;AAC9C,gBAAM,IAAI,uBAAAC;AAAA,YACR,sBAAAC,QAAW;AAAA,YACX;AAAA,YACA;AAAA,YAAW;AAAA,UACb;AAAA,QACF;AAEA,aAAK,QAAQ;AACb;AAAA,MACF;AAEA,YAAM,SAAS,KAAK,YAAY;AAChC,UAAI,OAAO,KAAK;AACd,YAAI,KAAK,IAAI,eAAAK,QAAW,CAAC,MAAM,CAAC,CAAC;AAAA,MACnC,OAAO;AACL,YAAI,KAAK,OAAO,KAAK;AAAA,MACvB;AAAA,IACF;AAGA,QAAI,CAAC,KAAK,MAAM,UAAU,mBAAmB,GAAG;AAC9C,YAAM,KAAK;AAAA,QACT,sBAAAL,QAAW;AAAA,QACX;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF;AACA,UAAM,eAAe,KAAK,KAAK;AAC/B,SAAK,QAAQ;AAEb,WAAO,IAAI,aAAAQ,QAAU,KAAK,aAAa,YAAa;AAAA,EACtD;AAAA,EAEQ,aAAmB;AACzB,UAAM,QAAQ,KAAK,KAAK;AACxB,QAAI,CAAC,OAAO;AACV,YAAM,IAAI,uBAAAT;AAAA,QAAY,sBAAAC,QAAW;AAAA,QAC/B;AAAA,QACA;AAAA,QAAQ;AAAA,MAAI;AAAA,IAChB;AAEA,YAAQ,MAAM,MAAM;AAAA,MAClB,KAAK,mBAAAF,QAAU;AAAA,MACf,KAAK,mBAAAA,QAAU;AAAA,MACf,KAAK,mBAAAA,QAAU;AAAA,MACf,KAAK,mBAAAA,QAAU;AAAA,MACf,KAAK,mBAAAA,QAAU;AAAA,MACf,KAAK,mBAAAA,QAAU;AAAA,MACf,KAAK,mBAAAA,QAAU,UAAU;AACvB,cAAM,OAAO,IAAI,eAAAW,QAAU,KAAK;AAChC,aAAK,QAAQ;AACb,eAAO;AAAA,MACT;AAAA,MACA,KAAK,mBAAAX,QAAU;AACb,eAAO,KAAK,WAAW;AAAA,MACzB,KAAK,mBAAAA,QAAU;AACb,eAAO,KAAK,YAAY,KAAK;AAAA,MAC/B,KAAK,mBAAAA,QAAU,OAAO;AAGpB,cAAM,aAAa,MAAM;AACzB,cAAM,YAAY,IAAI,aAAAK,QAAU,WAAW,eAAe,KAAK;AAC/D,aAAK,OAAO,KAAK,WAAW,aAAa;AACzC,aAAK,QAAQ;AAIb,aAAK,oBAAoB;AAEzB,eAAO;AAAA,MACT;AAAA,MACA;AACE,cAAM,IAAI,uBAAAJ;AAAA,UACR,sBAAAC,QAAW;AAAA,UACX,qBAAqB,MAAM,KAAK;AAAA,UAChC;AAAA,UAAO,UAAU;AAAA,QACnB;AAAA,IACJ;AAAA,EACF;AAAA,EAEQ,oBAAoB,SAAuB,mBAAyB;AAC1E,UAAM,YAAY,kBAAkB,MAAM;AAC1C,cAAU,OAAO,mBAAAF,QAAU;AAC3B,cAAU,QAAQ;AAClB,UAAM,SAAS,IAAI,eAAAS,QAAW,IAAI,eAAAE,QAAU,SAAS,CAAC;AAEtD,YAAQ,KAAK,MAAM;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA,EAKQ,aAAa,OAAqC;AACxD,WAAO,UAAU;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMQ,OAAqB;AAC3B,WAAO,KAAK,UAAU,KAAK,OAAO,SAAS,KAAK,OAAO,KAAK,OAAO,IAAI;AAAA,EACzE;AAAA;AAAA;AAAA;AAAA,EAKQ,QAAQ,QAAgB,GAAS;AACvC,SAAK,WAAW;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQQ,MAAM,OAAsC;AAClD,UAAM,eAAe,KAAK,KAAK;AAC/B,QAAI,KAAK,aAAa,YAAY,KAAK,MAAM,SAAS,aAAa,IAAiB,GAAG;AACrF,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAAA,EAEQ,UAAU,OAAsC;AACtD,UAAM,YAAY,KAAK,OAAO,KAAK,UAAU,CAAC;AAC9C,QAAI,KAAK,aAAa,SAAS,KAAK,MAAM,SAAS,UAAU,IAAiB,GAAG;AAC/E,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASQ,UAAU,OAAsC;AACtD,QAAI,KAAK,UAAU,KAAK,KAAK,OAAO,QAAQ;AAC1C,aAAO;AAAA,IACT;AACA,UAAM,YAAY,KAAK,OAAO,KAAK,UAAU,CAAC;AAC9C,QAAI,KAAK,aAAa,SAAS,KAAK,MAAM,SAAS,UAAU,IAAiB,GAAG;AAC/E,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAAA,EAEQ,eAAe,OAAsC;AAC3D,QAAI,KAAK,MAAM,KAAK,GAAG;AACrB,WAAK,QAAQ;AACb,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AACF;AAEA,IAAO,qBAAQ;","names":["import_tokens","TokenType","SyntaxError","ErrorCodes","DocumentNode","SectionNode","ErrorNode","CollectionNode","ObjectNode","assertNever","MemberNode","ArrayNode","TokenNode"]}