{"version":3,"sources":["../../src/parser/index.ts"],"sourcesContent":["import Definitions from '../core/definitions';\r\nimport Document from '../core/document';\r\nimport Header from '../core/header';\r\nimport Section from '../core/section';\r\nimport SectionCollection from '../core/section-collection';\r\nimport assertNever from '../errors/asserts/asserts';\r\nimport InternetObjectError from '../errors/io-error';\r\nimport ErrorCodes from '../errors/io-error-codes';\r\nimport compileObject from '../schema/compile-object';\r\nimport processSchema from '../schema/processor';\r\nimport Schema from '../schema/schema';\r\nimport Tokenizer from './tokenizer';\r\nimport TokenType from './tokenizer/token-types';\r\nimport ASTParser from './ast-parser';\r\nimport CollectionNode from './nodes/collections';\r\nimport DocumentNode from './nodes/document';\r\nimport MemberNode from './nodes/members';\r\nimport ObjectNode from './nodes/objects';\r\nimport TokenNode from './nodes/tokens';\r\nimport ParserOptions from './parser-options';\r\nimport Node from './nodes/nodes';\r\nimport ErrorNode from './nodes/error';\r\n\r\n\r\n/**\r\n * Parses an Internet Object document string into a Document instance.\r\n *\r\n * @param source - The IO document string to parse.\r\n * @param defs - Optional definitions to use for resolving schemas and variables.\r\n * @param errorCollector - Optional array to collect errors instead of throwing (for some error types).\r\n * @param options - Parser options configuration.\r\n * @returns The parsed IODocument.\r\n *\r\n * @example\r\n * ```typescript\r\n * // Simple parse\r\n * const doc = parse('Alice, 20');\r\n *\r\n * // Parse with definitions\r\n * const defs = parseDefinitions('~ $schema: { name: string, age: int }');\r\n * const doc = parse('Alice, 20', defs);\r\n * ```\r\n */\r\nexport default function parse(source: string, options?: ParserOptions): Document;\r\nexport default function parse(source: string, defs?: Definitions | null, options?: ParserOptions): Document;\r\nexport default function parse(source: string, defs?: Definitions | Schema | string | null, errorCollector?: Error[], options?: ParserOptions): Document;\r\nexport default function parse(\r\n  source: string,\r\n  defs?: Definitions | Schema | string | null | ParserOptions,\r\n  errorCollector?: Error[] | ParserOptions,\r\n  options?: ParserOptions\r\n): Document {\r\n  let externalDefs: Definitions | null = null;\r\n  let schema: Schema | string | null = null;\r\n  let o: ParserOptions = options || new ParserOptions();\r\n\r\n  // Argument shifting for backward compatibility\r\n  // If 2nd arg is ParserOptions (legacy call: parse(source, options))\r\n  if (defs && !(defs instanceof Definitions) && typeof defs === 'object' && 'continueOnError' in defs) {\r\n    o = defs as ParserOptions;\r\n    externalDefs = null;\r\n  }\r\n  // If 2nd arg is Definitions (legacy call: parse(source, defs, options))\r\n  else if (defs instanceof Definitions) {\r\n    externalDefs = defs;\r\n    // If 3rd arg is ParserOptions\r\n    if (errorCollector && !Array.isArray(errorCollector) && typeof errorCollector === 'object') {\r\n      o = errorCollector as ParserOptions;\r\n      errorCollector = undefined;\r\n    }\r\n  }\r\n  // If 2nd arg is Schema or string (new call: parse(source, schema, ...))\r\n  else if (defs instanceof Schema || typeof defs === 'string') {\r\n    schema = defs;\r\n  }\r\n\r\n  // If 3rd arg is ParserOptions (legacy call: parse(source, defs, options))\r\n  if (errorCollector && !Array.isArray(errorCollector) && typeof errorCollector === 'object') {\r\n    o = errorCollector as ParserOptions;\r\n    errorCollector = undefined;\r\n  }\r\n\r\n  // Tokenize the source\r\n  const tokenizer = new Tokenizer(source);\r\n  const tokens = tokenizer.tokenize();\r\n\r\n  // If the source is empty, then return empty document\r\n  if (tokens.length === 0) {\r\n    return new Document(new Header(), new SectionCollection());\r\n  }\r\n\r\n  // Parse the tokens into AST - optimize for simple cases\r\n  const parser = new ASTParser(tokens);\r\n  const docNode = parser.parse();\r\n\r\n  // Extract errors from docNode for transfer to Document\r\n  const errors = docNode.getErrors();\r\n\r\n  // Create document with optimized initialization\r\n  const doc = new Document(new Header(), new SectionCollection(), errors);\r\n\r\n  // If the docNode contains header, then parse it\r\n  if (docNode.header) {\r\n    if (docNode.header.child) {\r\n      // If ObjectNode, it is a default schema\r\n      //\r\n      // name, age, address  # <-- This is a schema\r\n      // ---\r\n      if (docNode.header.child instanceof ObjectNode) {\r\n        const schema = compileObject(\"schema\", docNode.header.child)\r\n        if (schema instanceof Schema) {\r\n          doc.header.definitions?.push(\"$schema\", schema, true)\r\n          doc.header.schema = schema  // Set as the default schema\r\n        } else {\r\n          assertNever(schema);\r\n        }\r\n      }\r\n\r\n      // If CollectionNode, it's always definitions (may include $schema, @variables, or regular key-values)\r\n      // Example: ~ $schema: {...}, ~ @x: 10, ~ success: T\r\n      else if (docNode.header.child instanceof CollectionNode) {\r\n        parseDefs(doc, docNode.header.child);\r\n      }\r\n\r\n      // Unexpected node\r\n      else { assertNever(docNode.header.child) }\r\n\r\n      if (externalDefs) {\r\n        doc.header.definitions.merge(externalDefs, false);\r\n      }\r\n    } else {\r\n      if (externalDefs) {\r\n        doc.header.definitions.merge(externalDefs, false);\r\n      }\r\n    }\r\n\r\n    parseDataWithSchema(docNode, doc, errorCollector);\r\n  } else {\r\n    if (externalDefs) {\r\n      doc.header.definitions.merge(externalDefs, false);\r\n    }\r\n    // If explicit schema provided, use it as default schema\r\n    if (schema) {\r\n      if (schema instanceof Schema) {\r\n        doc.header.schema = schema;\r\n      } else if (typeof schema === 'string') {\r\n        // If schema is string, it might be a reference in definitions or IO text\r\n        // Since we are in parse, we can't easily compile IO text without recursion or duplication\r\n        // But if it's a reference, we can look it up\r\n        if (doc.header.definitions) {\r\n          const resolved = doc.header.definitions.getV(schema);\r\n          if (resolved instanceof Schema) {\r\n            doc.header.schema = resolved;\r\n          }\r\n        }\r\n      }\r\n    }\r\n    parseDataWithSchema(docNode, doc, errorCollector);\r\n  }\r\n  return doc;\r\n}\r\n\r\nfunction parseData(docNode: DocumentNode, doc: Document) {\r\n  for (let i = 0; i < docNode.children.length; i++) {\r\n    const sectionNode = docNode.children[i];\r\n    doc.sections?.push(new Section(sectionNode.child?.toValue(doc.header.definitions || undefined), sectionNode.name));\r\n  }\r\n}\r\n\r\nfunction parseDataWithSchema(docNode: DocumentNode, doc: Document, errorCollector?: Error[]): void {\r\n  const sectionsLen = docNode.children.length;\r\n\r\n  // Early return if no sections\r\n  if (sectionsLen === 0) {\r\n    return;\r\n  }\r\n\r\n  for (let i = 0; i < sectionsLen; i++) {\r\n    const sectionNode = docNode.children[i];\r\n    const schemaName = sectionNode.schemaName;\r\n\r\n    // If no explicit schema name, fall back to document's default schema\r\n    const schema = schemaName\r\n      ? (schemaName === \"$schema\" ? doc.header.schema : doc.header.definitions?.getV(sectionNode.schemaNode))\r\n      : doc.header.schema;\r\n\r\n    if (!schema) {\r\n      // No schema for this section, just parse without validation\r\n      doc.sections?.push(new Section(sectionNode.child?.toValue(doc.header.definitions || undefined), sectionNode.name));\r\n      continue;\r\n    }\r\n\r\n    const result = processSchema(sectionNode.child, schema, doc.header.definitions || undefined, errorCollector);\r\n    doc.sections?.push(new Section(result, sectionNode.name, schemaName));\r\n  }\r\n}\r\n\r\nfunction parseDefs(doc: Document, cols: CollectionNode): void {\r\n  const defs = doc.header.definitions;\r\n  if (!defs) {\r\n    throw new Error(\"Document header definitions not initialized. This is an internal error - please report this issue.\");\r\n  }\r\n  const schemaDefs: Array<{ key: string; schemaDef: Node }> = []\r\n\r\n  for (let i = 0; i < cols.children.length; i++) {\r\n    const child = cols.children[i];\r\n\r\n    // If child is null or undefined then skip\r\n    if (!child) {\r\n      continue;\r\n    }\r\n\r\n    if (child instanceof ErrorNode) {\r\n      throw new InternetObjectError(ErrorCodes.invalidDefinition,\r\n        `Invalid definition: ${child.error.message}`,\r\n        child);\r\n    }\r\n\r\n    // Must be an object node\r\n    if (!(child instanceof ObjectNode)) {\r\n      assertNever(\"Invalid definition, must be object\");\r\n    }\r\n\r\n    // Type assertion after instance check - TypeScript now knows child is ObjectNode\r\n    const objectNode = child as ObjectNode;\r\n\r\n    // Must not be null\r\n    if (objectNode.children[0] === null) {\r\n      assertNever(\"Invalid definition\");\r\n    }\r\n\r\n    // Must have only one child\r\n    if (objectNode.children.length !== 1) {\r\n      // throw new InternetObjectError(ErrorCodes.invalidDefinition, objectNode.children?.[1], objectNode.children?[1])\r\n    }\r\n\r\n    const memberNode = (objectNode.children[0] as MemberNode)\r\n\r\n    // Must have a key\r\n    if (!memberNode.key) {\r\n      throw new InternetObjectError(ErrorCodes.invalidDefinition,\r\n        `Invalid definition: missing key. Each definition must have a key (e.g., '$schema: {...}' or '@variable: value').`,\r\n        memberNode.value)\r\n    }\r\n\r\n    const keyToken = memberNode.key as TokenNode\r\n\r\n    // Key must be a string\r\n    if (keyToken.type !== TokenType.STRING) {\r\n      throw new Error(\"Invalid typedef definition: key must be a string.\");\r\n    }\r\n\r\n    let key: string = keyToken.value as string\r\n\r\n    // If key starts with $, then it is a schema. Dont compile it now,\r\n    // just keep it as it is. After all the definitions are parsed, compile\r\n    // the variable schemas.\r\n    if (key.startsWith('$')) {\r\n      defs.push(key, memberNode.value, true);\r\n      schemaDefs.push({ key, schemaDef: memberNode.value });\r\n      continue;\r\n    }\r\n\r\n    // If key starts with @, then it is a variable. Keep it as it is\r\n    if (key.startsWith('@')) {\r\n      defs.push(key, memberNode.value, false, true);\r\n      continue;\r\n    }\r\n\r\n    let value: Node = (objectNode.children[0] as MemberNode).value;\r\n    defs.push(key, value.toValue(doc.header.definitions || undefined));\r\n  }\r\n\r\n  // Compile the schema definitions\r\n  for (let i = 0; i < schemaDefs.length; i++) {\r\n    const { key, schemaDef } = schemaDefs[i];\r\n    const def = compileObject(key, schemaDef, defs);\r\n\r\n    defs.set(key, def);\r\n  }\r\n}"],"mappings":"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","names":["ParserOptions","Definitions","Schema","Tokenizer","Document","Header","SectionCollection","ASTParser","ObjectNode","schema","compileObject","assertNever","CollectionNode","Section","processSchema","ErrorNode","InternetObjectError","ErrorCodes","TokenType"]}