auwgent-yaml-lite 0.1.0

package/dist/index.js

@@ -0,0 +1,1153 @@
+// src/tokenizer.ts
+class Tokenizer {
+  input = "";
+  state;
+  options;
+  finishing = false;
+  constructor(options = {}) {
+    this.options = {
+      indentSize: options.indentSize ?? 2,
+      allowTabs: options.allowTabs ?? false,
+      preserveComments: options.preserveComments ?? false
+    };
+    this.state = this.createInitialState();
+  }
+  createInitialState() {
+    return {
+      pos: 0,
+      line: 1,
+      column: 1,
+      indentStack: [0],
+      currentIndent: 0,
+      pending: [],
+      atLineStart: true
+    };
+  }
+  reset() {
+    this.input = "";
+    this.state = this.createInitialState();
+  }
+  write(chunk) {
+    this.input += chunk;
+  }
+  getPosition() {
+    return {
+      line: this.state.line,
+      column: this.state.column,
+      offset: this.state.pos
+    };
+  }
+  hasMore() {
+    return this.state.pos < this.input.length || this.state.pending.length > 0;
+  }
+  next() {
+    if (this.state.pending.length > 0) {
+      return this.state.pending.shift();
+    }
+    if (this.state.pos >= this.input.length) {
+      return null;
+    }
+    if (this.state.atLineStart) {
+      return this.tokenizeLineStart();
+    }
+    return this.tokenizeContent();
+  }
+  tokenizeAll() {
+    const tokens = [];
+    let token;
+    while ((token = this.next()) !== null) {
+      tokens.push(token);
+    }
+    tokens.push(...this.finalize());
+    return tokens;
+  }
+  finalize() {
+    const tokens = [];
+    this.finishing = true;
+    let token;
+    while ((token = this.next()) !== null) {
+      tokens.push(token);
+    }
+    this.finishing = false;
+    while (this.state.indentStack.length > 1) {
+      this.state.indentStack.pop();
+      tokens.push(this.createToken("DEDENT", ""));
+    }
+    tokens.push(this.createToken("EOF", ""));
+    return tokens;
+  }
+  tokenizeLineStart() {
+    const indent = this.consumeIndent();
+    const indentLevel = Math.floor(indent / this.options.indentSize);
+    const currentLevel = this.state.indentStack[this.state.indentStack.length - 1] ?? 0;
+    this.state.atLineStart = false;
+    if (this.peekChar() === `
+` || this.peekChar() === "\r") {
+      return this.tokenizeNewline();
+    }
+    if (this.peekChar() === "#") {
+      return this.tokenizeComment();
+    }
+    if (indentLevel > currentLevel) {
+      this.state.indentStack.push(indentLevel);
+      this.state.currentIndent = indentLevel;
+      const token = this.createToken("INDENT", "  ".repeat(indentLevel - currentLevel));
+      return token;
+    } else if (indentLevel < currentLevel) {
+      this.state.currentIndent = indentLevel;
+      while (this.state.indentStack.length > 1 && (this.state.indentStack[this.state.indentStack.length - 1] ?? 0) > indentLevel) {
+        this.state.indentStack.pop();
+        this.state.pending.push(this.createToken("DEDENT", ""));
+      }
+      return this.state.pending.shift() ?? this.tokenizeContent();
+    }
+    this.state.currentIndent = indentLevel;
+    return this.tokenizeContent();
+  }
+  tokenizeContent() {
+    this.skipSpaces();
+    const char = this.peekChar();
+    if (char === "") {
+      return null;
+    }
+    if (char === `
+` || char === "\r") {
+      return this.tokenizeNewline();
+    }
+    if (char === "#") {
+      return this.tokenizeComment();
+    }
+    if (char === "-" && this.peekChar(1) === " ") {
+      this.advance();
+      return this.createToken("DASH", "-");
+    }
+    if (char === '"' || char === "'") {
+      return this.tokenizeQuotedString(char);
+    }
+    if (char === ":") {
+      this.advance();
+      return this.createToken("COLON", ":");
+    }
+    if (char === "|") {
+      return this.tokenizeMultilineString();
+    }
+    return this.tokenizeKeyOrScalar();
+  }
+  tokenizeMultilineString() {
+    const startCol = this.state.column;
+    this.advance();
+    while (this.state.pos < this.input.length) {
+      const c = this.peekChar();
+      if (c === `
+` || c === "\r")
+        break;
+      if (c !== " ")
+        break;
+      this.advance();
+    }
+    if (this.peekChar() === "\r")
+      this.advance();
+    if (this.peekChar() === `
+`) {
+      this.advance();
+      this.state.line++;
+      this.state.column = 1;
+    }
+    const baseIndent = this.measureIndent();
+    if (baseIndent === 0) {
+      return {
+        type: "SCALAR",
+        value: "",
+        line: this.state.line,
+        column: startCol,
+        indent: this.state.currentIndent
+      };
+    }
+    const lines = [];
+    while (this.state.pos < this.input.length) {
+      const lineIndent = this.measureIndent();
+      if (lineIndent < baseIndent && this.peekChar() !== `
+` && this.peekChar() !== "\r") {
+        break;
+      }
+      for (let i = 0;i < baseIndent && this.peekChar() === " "; i++) {
+        this.advance();
+      }
+      let lineContent = "";
+      while (this.state.pos < this.input.length) {
+        const c = this.peekChar();
+        if (c === `
+` || c === "\r")
+          break;
+        lineContent += c;
+        this.advance();
+      }
+      lines.push(lineContent);
+      if (this.peekChar() === "\r")
+        this.advance();
+      if (this.peekChar() === `
+`) {
+        this.advance();
+        this.state.line++;
+        this.state.column = 1;
+        this.state.atLineStart = true;
+      } else {
+        break;
+      }
+    }
+    return {
+      type: "SCALAR",
+      value: lines.join(`
+`),
+      line: this.state.line,
+      column: startCol,
+      indent: this.state.currentIndent
+    };
+  }
+  tokenizeKeyOrScalar() {
+    const startCol = this.state.column;
+    const startPos = this.state.pos;
+    const startLine = this.state.line;
+    let value = "";
+    while (this.state.pos < this.input.length) {
+      const char = this.peekChar();
+      if (char === `
+` || char === "\r" || char === "#") {
+        break;
+      }
+      if (char === ":") {
+        const next = this.peekChar(1);
+        if (next === " " || next === `
+` || next === "\r" || next === "") {
+          break;
+        }
+      }
+      value += char;
+      this.advance();
+    }
+    const reachedEOF = this.state.pos >= this.input.length;
+    if (reachedEOF && !this.finishing) {
+      this.state.pos = startPos;
+      this.state.column = startCol;
+      this.state.line = startLine;
+      return null;
+    }
+    value = value.trim();
+    if (this.peekChar() === ":") {
+      return {
+        type: "KEY",
+        value,
+        line: this.state.line,
+        column: startCol,
+        indent: this.state.currentIndent
+      };
+    }
+    return {
+      type: "SCALAR",
+      value,
+      line: this.state.line,
+      column: startCol,
+      indent: this.state.currentIndent
+    };
+  }
+  tokenizeQuotedString(quote) {
+    const startCol = this.state.column;
+    this.advance();
+    let value = "";
+    let closed = false;
+    while (this.state.pos < this.input.length) {
+      const char = this.peekChar();
+      if (char === quote) {
+        closed = true;
+        this.advance();
+        break;
+      }
+      if (char === "\\" && this.state.pos + 1 < this.input.length) {
+        this.advance();
+        const escaped = this.peekChar();
+        switch (escaped) {
+          case "n":
+            value += `
+`;
+            break;
+          case "t":
+            value += "\t";
+            break;
+          case "r":
+            value += "\r";
+            break;
+          case "\\":
+            value += "\\";
+            break;
+          case '"':
+            value += '"';
+            break;
+          case "'":
+            value += "'";
+            break;
+          default:
+            value += escaped;
+        }
+        this.advance();
+        continue;
+      }
+      if (char === `
+` || char === "\r") {
+        break;
+      }
+      value += char;
+      this.advance();
+    }
+    return {
+      type: "QUOTED",
+      value,
+      line: this.state.line,
+      column: startCol,
+      indent: this.state.currentIndent
+    };
+  }
+  tokenizeComment() {
+    const startCol = this.state.column;
+    let value = "";
+    this.advance();
+    while (this.state.pos < this.input.length) {
+      const char = this.peekChar();
+      if (char === `
+` || char === "\r") {
+        break;
+      }
+      value += char;
+      this.advance();
+    }
+    if (!this.options.preserveComments) {
+      return this.tokenizeNewline();
+    }
+    return {
+      type: "COMMENT",
+      value: value.trim(),
+      line: this.state.line,
+      column: startCol,
+      indent: this.state.currentIndent
+    };
+  }
+  tokenizeNewline() {
+    const token = this.createToken("NEWLINE", `
+`);
+    if (this.peekChar() === "\r") {
+      this.advance();
+    }
+    if (this.peekChar() === `
+`) {
+      this.advance();
+    }
+    this.state.line++;
+    this.state.column = 1;
+    this.state.atLineStart = true;
+    return token;
+  }
+  consumeIndent() {
+    let spaces = 0;
+    while (this.state.pos < this.input.length) {
+      const char = this.peekChar();
+      if (char === " ") {
+        spaces++;
+        this.advance();
+      } else if (char === "\t") {
+        if (!this.options.allowTabs) {
+          spaces += this.options.indentSize;
+        } else {
+          spaces += this.options.indentSize;
+        }
+        this.advance();
+      } else {
+        break;
+      }
+    }
+    return spaces;
+  }
+  measureIndent() {
+    let spaces = 0;
+    let offset = 0;
+    while (true) {
+      const char = this.input[this.state.pos + offset];
+      if (char === " ") {
+        spaces++;
+        offset++;
+      } else if (char === "\t" && this.options.allowTabs) {
+        spaces += this.options.indentSize;
+        offset++;
+      } else {
+        break;
+      }
+    }
+    return spaces;
+  }
+  skipSpaces() {
+    while (this.peekChar() === " ") {
+      this.advance();
+    }
+  }
+  peekChar(offset = 0) {
+    return this.input[this.state.pos + offset] ?? "";
+  }
+  advance() {
+    if (this.state.pos < this.input.length) {
+      this.state.pos++;
+      this.state.column++;
+    }
+  }
+  createToken(type, value) {
+    return {
+      type,
+      value,
+      line: this.state.line,
+      column: this.state.column,
+      indent: this.state.currentIndent
+    };
+  }
+}
+function tokenize(input, options) {
+  const tokenizer = new Tokenizer(options);
+  tokenizer.write(input);
+  return tokenizer.tokenizeAll();
+}
+// src/parser.ts
+class Parser {
+  tokenizer;
+  tokens = [];
+  pos = 0;
+  state;
+  options;
+  constructor(options = {}) {
+    this.options = options;
+    this.tokenizer = new Tokenizer(options);
+    this.state = this.createInitialState();
+  }
+  createInitialState() {
+    return {
+      stack: [],
+      errors: [],
+      listeners: new Map
+    };
+  }
+  reset() {
+    this.tokenizer.reset();
+    this.tokens = [];
+    this.pos = 0;
+    this.state = this.createInitialState();
+  }
+  on(event, handler) {
+    if (!this.state.listeners.has(event)) {
+      this.state.listeners.set(event, new Set);
+    }
+    this.state.listeners.get(event).add(handler);
+  }
+  off(event, handler) {
+    this.state.listeners.get(event)?.delete(handler);
+  }
+  emit(type, data, position) {
+    const event = { type, data, position };
+    this.state.listeners.get(type)?.forEach((handler) => handler(data));
+    this.options.middleware?.forEach((mw) => mw(event));
+  }
+  write(chunk) {
+    this.tokenizer.write(chunk);
+  }
+  peek() {
+    let token;
+    while ((token = this.tokenizer.next()) !== null) {
+      this.tokens.push(token);
+    }
+    return this.parseTokens(false);
+  }
+  end() {
+    let token;
+    while ((token = this.tokenizer.next()) !== null) {
+      this.tokens.push(token);
+    }
+    this.tokens.push(...this.tokenizer.finalize());
+    return this.parseTokens(true);
+  }
+  parseTokens(complete) {
+    if (this.state.stack.length === 0) {
+      const firstNonCommentToken = this.tokens.find((t) => t && t.type !== "COMMENT" && t.type !== "NEWLINE");
+      const isRootSequence = firstNonCommentToken?.type === "DASH";
+      if (isRootSequence) {
+        this.pushFrame("sequence", 0);
+      } else {
+        this.pushFrame("root", 0);
+      }
+    }
+    while (this.pos < this.tokens.length) {
+      const token = this.tokens[this.pos];
+      if (token) {
+        this.processToken(token);
+      }
+      this.pos++;
+    }
+    const rootFrame = this.state.stack[0];
+    const ast = rootFrame ? this.frameToNode(rootFrame) : null;
+    return {
+      ast,
+      errors: [...this.state.errors],
+      complete
+    };
+  }
+  processToken(token) {
+    const pos = {
+      line: token.line,
+      column: token.column,
+      offset: 0
+    };
+    switch (token.type) {
+      case "KEY":
+        this.handleKey(token, pos);
+        break;
+      case "COLON":
+        break;
+      case "SCALAR":
+      case "QUOTED":
+        this.handleValue(token, pos);
+        break;
+      case "DASH":
+        this.handleDash(token, pos);
+        break;
+      case "INDENT":
+        this.handleIndent(token, pos);
+        break;
+      case "DEDENT":
+        this.handleDedent(token, pos);
+        break;
+      case "NEWLINE":
+        this.handleNewline(token, pos);
+        break;
+      case "EOF":
+        this.handleEOF(pos);
+        break;
+      case "COMMENT":
+        this.emit("line", { comment: token.value }, pos);
+        break;
+    }
+  }
+  handleKey(token, pos) {
+    this.emit("key", { key: token.value }, pos);
+    const frame = this.currentFrame();
+    if (frame.type !== "mapping" && frame.type !== "root") {
+      this.pushFrame("mapping", token.indent);
+    }
+    const mappingFrame = this.currentFrame();
+    if (mappingFrame.type === "mapping" || mappingFrame.type === "root") {
+      if (mappingFrame.pendingKey && mappingFrame.pendingKeyPos) {
+        const emptyNode = {
+          kind: "empty",
+          hint: "mapping",
+          line: mappingFrame.pendingKeyPos.line,
+          column: mappingFrame.pendingKeyPos.column
+        };
+        this.addMappingEntry(mappingFrame, mappingFrame.pendingKey, emptyNode, mappingFrame.pendingKeyPos);
+      }
+      mappingFrame.pendingKey = token.value;
+      mappingFrame.pendingKeyPos = { line: token.line, column: token.column };
+    }
+  }
+  handleValue(token, pos) {
+    const value = token.value;
+    const quoted = token.type === "QUOTED";
+    this.emit("value", { value, quoted }, pos);
+    const frame = this.currentFrame();
+    if (frame.type === "mapping" || frame.type === "root") {
+      if (frame.pendingKey) {
+        const scalarNode = {
+          kind: "scalar",
+          value,
+          quoted,
+          line: token.line,
+          column: token.column
+        };
+        this.addMappingEntry(frame, frame.pendingKey, scalarNode, frame.pendingKeyPos);
+        frame.pendingKey = undefined;
+        frame.pendingKeyPos = undefined;
+      }
+    } else if (frame.type === "sequence") {
+      const scalarNode = {
+        kind: "scalar",
+        value,
+        quoted,
+        line: token.line,
+        column: token.column
+      };
+      frame.node.items.push(scalarNode);
+    }
+  }
+  handleDash(token, pos) {
+    this.emit("block_start", { type: "sequence_item" }, pos);
+    while (this.state.stack.length > 1) {
+      const topFrame = this.currentFrame();
+      if (topFrame.indent <= token.indent) {
+        break;
+      }
+      this.popFrame(pos);
+    }
+    const frame = this.currentFrame();
+    const nextToken = this.tokens[this.pos + 1];
+    const isScalarItem = nextToken && (nextToken.type === "SCALAR" || nextToken.type === "QUOTED");
+    const isKeyItem = nextToken && nextToken.type === "KEY";
+    const isDashItem = nextToken && nextToken.type === "DASH";
+    if ((frame.type === "mapping" || frame.type === "root") && frame.pendingKey) {
+      const seqNode = {
+        kind: "sequence",
+        items: [],
+        line: token.line,
+        column: token.column
+      };
+      this.addMappingEntry(frame, frame.pendingKey, seqNode, frame.pendingKeyPos);
+      frame.pendingKey = undefined;
+      frame.pendingKeyPos = undefined;
+      this.state.stack.push({
+        type: "sequence",
+        node: seqNode,
+        indent: token.indent
+      });
+      if (isKeyItem) {
+        const itemMapping = {
+          kind: "mapping",
+          entries: [],
+          line: token.line,
+          column: token.column
+        };
+        seqNode.items.push(itemMapping);
+        this.state.stack.push({
+          type: "mapping",
+          node: itemMapping,
+          indent: token.indent + 1
+        });
+      } else if (isDashItem) {
+        const innerSeq = {
+          kind: "sequence",
+          items: [],
+          line: token.line,
+          column: token.column
+        };
+        seqNode.items.push(innerSeq);
+        this.state.stack.push({
+          type: "sequence",
+          node: innerSeq,
+          indent: token.indent + 1
+        });
+      }
+    } else if (frame.type === "sequence") {
+      if (isKeyItem) {
+        const itemMapping = {
+          kind: "mapping",
+          entries: [],
+          line: token.line,
+          column: token.column
+        };
+        frame.node.items.push(itemMapping);
+        this.state.stack.push({
+          type: "mapping",
+          node: itemMapping,
+          indent: token.indent + 1
+        });
+      } else if (isDashItem) {
+        const innerSeq = {
+          kind: "sequence",
+          items: [],
+          line: token.line,
+          column: token.column
+        };
+        frame.node.items.push(innerSeq);
+        this.state.stack.push({
+          type: "sequence",
+          node: innerSeq,
+          indent: token.indent + 1
+        });
+      }
+    } else {
+      if (frame.type === "root") {
+        const seqNode = {
+          kind: "sequence",
+          items: [],
+          line: token.line,
+          column: token.column
+        };
+        frame.node = seqNode;
+        frame.type = "sequence";
+      }
+    }
+  }
+  handleIndent(token, pos) {
+    this.emit("indent", { level: token.indent }, pos);
+    const frame = this.currentFrame();
+    if ((frame.type === "mapping" || frame.type === "root") && frame.pendingKey) {
+      const nextToken = this.tokens[this.pos + 1];
+      if (nextToken && nextToken.type === "DASH") {
+        return;
+      }
+      const nestedMapping = {
+        kind: "mapping",
+        entries: [],
+        line: token.line,
+        column: token.column
+      };
+      this.addMappingEntry(frame, frame.pendingKey, nestedMapping, frame.pendingKeyPos);
+      frame.pendingKey = undefined;
+      frame.pendingKeyPos = undefined;
+      this.state.stack.push({
+        type: "mapping",
+        node: nestedMapping,
+        indent: token.indent
+      });
+    }
+  }
+  handleDedent(token, pos) {
+    this.emit("dedent", { level: token.indent }, pos);
+    while (this.state.stack.length > 1) {
+      const frame = this.currentFrame();
+      if (frame.indent <= token.indent) {
+        break;
+      }
+      this.popFrame(pos);
+    }
+  }
+  handleNewline(token, pos) {
+    this.emit("line", {}, pos);
+    const frame = this.currentFrame();
+    if ((frame.type === "mapping" || frame.type === "root") && frame.pendingKey) {
+      const nextToken = this.tokens[this.pos + 1];
+      if (nextToken && (nextToken.type === "DEDENT" || nextToken.type === "EOF")) {
+        const emptyNode = {
+          kind: "empty",
+          hint: "mapping",
+          line: token.line,
+          column: token.column
+        };
+        this.addMappingEntry(frame, frame.pendingKey, emptyNode, frame.pendingKeyPos);
+        frame.pendingKey = undefined;
+        frame.pendingKeyPos = undefined;
+      }
+    }
+  }
+  handleEOF(pos) {
+    while (this.state.stack.length > 1) {
+      this.popFrame(pos);
+    }
+    const rootFrame = this.state.stack[0];
+    if (rootFrame && rootFrame.pendingKey) {
+      const emptyNode = {
+        kind: "empty",
+        hint: "mapping",
+        line: pos.line,
+        column: pos.column
+      };
+      this.addMappingEntry(rootFrame, rootFrame.pendingKey, emptyNode, rootFrame.pendingKeyPos);
+      rootFrame.pendingKey = undefined;
+    }
+    this.checkIntentReady(pos);
+  }
+  pushFrame(type, indent) {
+    const node = type === "sequence" ? { kind: "sequence", items: [], line: 0, column: 0 } : { kind: "mapping", entries: [], line: 0, column: 0 };
+    this.state.stack.push({
+      type: type === "root" ? "mapping" : type,
+      node,
+      indent
+    });
+  }
+  popFrame(pos) {
+    const frame = this.state.stack.pop();
+    if (frame) {
+      this.emit("block_end", { type: frame.type }, pos);
+    }
+  }
+  currentFrame() {
+    return this.state.stack[this.state.stack.length - 1];
+  }
+  addMappingEntry(frame, key, value, keyPos) {
+    const mapping = frame.node;
+    if (key === "ref" && value.kind === "scalar") {
+      const refNode = {
+        kind: "ref",
+        target: value.value,
+        line: value.line,
+        column: value.column
+      };
+      mapping.entries.push({
+        key,
+        value: refNode,
+        line: keyPos.line,
+        column: keyPos.column
+      });
+    } else {
+      mapping.entries.push({
+        key,
+        value,
+        line: keyPos.line,
+        column: keyPos.column
+      });
+    }
+  }
+  checkIntentReady(pos) {
+    const rootFrame = this.state.stack[0];
+    if (!rootFrame || rootFrame.node.kind !== "mapping")
+      return;
+    const entries = rootFrame.node.entries;
+    const intentEntry = entries.find((e) => e.key === "intent");
+    if (intentEntry && intentEntry.value.kind === "mapping") {
+      const intentEntries = intentEntry.value.entries;
+      const typeEntry = intentEntries.find((e) => e.key === "type");
+      if (typeEntry) {
+        this.emit("intent_ready", {
+          type: typeEntry.value.kind === "scalar" ? typeEntry.value.value : null
+        }, pos);
+      }
+    }
+  }
+  frameToNode(frame) {
+    return frame.node;
+  }
+  addError(message, line, column) {
+    this.state.errors.push({
+      message,
+      severity: "error",
+      line,
+      column
+    });
+  }
+}
+function parse(input, options) {
+  const parser = new Parser(options);
+  parser.write(input);
+  return parser.end();
+}
+function createParser(options) {
+  return new Parser(options);
+}
+// src/ir-builder.ts
+function coerceValue(value, quoted) {
+  if (quoted) {
+    return value;
+  }
+  const trimmed = value.trim();
+  if (trimmed === "null" || trimmed === "Null" || trimmed === "NULL" || trimmed === "~") {
+    return null;
+  }
+  if (trimmed === "" && value === "") {
+    return "";
+  }
+  if (trimmed === "true" || trimmed === "True" || trimmed === "TRUE") {
+    return true;
+  }
+  if (trimmed === "false" || trimmed === "False" || trimmed === "FALSE") {
+    return false;
+  }
+  if (/^-?\d+$/.test(trimmed)) {
+    const num = parseInt(trimmed, 10);
+    if (Number.isSafeInteger(num)) {
+      return num;
+    }
+  }
+  if (/^-?\d+\.\d+$/.test(trimmed)) {
+    const num = parseFloat(trimmed);
+    if (Number.isFinite(num)) {
+      return num;
+    }
+  }
+  if (/^-?\d+\.?\d*[eE][+-]?\d+$/.test(trimmed)) {
+    const num = parseFloat(trimmed);
+    if (Number.isFinite(num)) {
+      return num;
+    }
+  }
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {}
+  }
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed === "object" && parsed !== null) {
+        return parsed;
+      }
+    } catch {}
+  }
+  return value;
+}
+
+class IRBuilder {
+  registry = new Map;
+  unresolvedRefs = [];
+  errors = [];
+  currentPath = [];
+  build(ast) {
+    this.registry.clear();
+    this.unresolvedRefs = [];
+    this.errors = [];
+    this.currentPath = [];
+    let value = ast ? this.transformNode(ast) : null;
+    if (value !== null) {
+      this.resolveRefs(value);
+      value = this.liftRefOnlyObjects(value);
+    }
+    return {
+      value: value ?? {},
+      registry: new Map(this.registry),
+      unresolvedRefs: [...this.unresolvedRefs],
+      errors: [...this.errors]
+    };
+  }
+  transformNode(node) {
+    switch (node.kind) {
+      case "scalar":
+        return this.transformScalar(node);
+      case "mapping":
+        return this.transformMapping(node);
+      case "sequence":
+        return this.transformSequence(node);
+      case "ref":
+        return this.transformRef(node);
+      case "empty":
+        return this.transformEmpty(node);
+      default:
+        return null;
+    }
+  }
+  transformScalar(node) {
+    return coerceValue(node.value, node.quoted);
+  }
+  transformMapping(node) {
+    const obj = {};
+    let nodeId = null;
+    for (const entry of node.entries) {
+      this.currentPath.push(entry.key);
+      const value = this.transformNode(entry.value);
+      obj[entry.key] = value;
+      if (entry.key === "id" && typeof value === "string") {
+        nodeId = value;
+      }
+      this.currentPath.pop();
+    }
+    if (nodeId !== null) {
+      this.registry.set(nodeId, obj);
+    }
+    return obj;
+  }
+  transformSequence(node) {
+    const arr = [];
+    for (let i = 0;i < node.items.length; i++) {
+      const item = node.items[i];
+      if (item) {
+        this.currentPath.push(`[${i}]`);
+        arr.push(this.transformNode(item));
+        this.currentPath.pop();
+      }
+    }
+    return arr;
+  }
+  transformRef(node) {
+    return { $ref: node.target };
+  }
+  transformEmpty(node) {
+    return node.hint === "sequence" ? [] : {};
+  }
+  resolveRefs(value, visited = new Set) {
+    if (value === null || typeof value !== "object") {
+      return;
+    }
+    if (visited.has(value)) {
+      return;
+    }
+    visited.add(value);
+    if (Array.isArray(value)) {
+      for (let i = 0;i < value.length; i++) {
+        const item = value[i];
+        if (item === undefined)
+          continue;
+        if (typeof item === "string" && this.registry.has(item)) {
+          value[i] = this.deepCopy(this.registry.get(item));
+          continue;
+        }
+        if (this.isRef(item)) {
+          const resolved = this.registry.get(item.$ref);
+          if (resolved !== undefined) {
+            value[i] = this.deepCopy(resolved);
+          } else {
+            this.unresolvedRefs.push(item.$ref);
+          }
+        } else {
+          this.resolveRefs(item, visited);
+        }
+      }
+    } else {
+      for (const key of Object.keys(value)) {
+        const child = value[key];
+        if (child === undefined)
+          continue;
+        if (this.isRef(child)) {
+          const resolved = this.registry.get(child.$ref);
+          if (resolved !== undefined) {
+            value[key] = this.deepCopy(resolved);
+          } else {
+            this.unresolvedRefs.push(child.$ref);
+          }
+        } else {
+          this.resolveRefs(child, visited);
+        }
+      }
+    }
+  }
+  deepCopy(value) {
+    if (value === null || typeof value !== "object") {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.deepCopy(item));
+    }
+    const copy = {};
+    for (const key of Object.keys(value)) {
+      const child = value[key];
+      if (child !== undefined) {
+        copy[key] = this.deepCopy(child);
+      }
+    }
+    return copy;
+  }
+  liftRefOnlyObjects(value) {
+    if (value === null || typeof value !== "object") {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.liftRefOnlyObjects(item));
+    }
+    const keys = Object.keys(value);
+    if (keys.length === 1 && keys[0] === "ref") {
+      const refValue = value["ref"];
+      return refValue !== undefined ? this.liftRefOnlyObjects(refValue) : null;
+    }
+    const result = {};
+    for (const key of keys) {
+      const child = value[key];
+      if (child !== undefined) {
+        result[key] = this.liftRefOnlyObjects(child);
+      }
+    }
+    return result;
+  }
+  isRef(value) {
+    return typeof value === "object" && value !== null && "$ref" in value && typeof value.$ref === "string";
+  }
+  addError(message) {
+    this.errors.push({
+      message,
+      severity: "error",
+      path: [...this.currentPath]
+    });
+  }
+}
+function buildIR(ast) {
+  const builder = new IRBuilder;
+  return builder.build(ast);
+}
+// src/index.ts
+function parseToJSON(input, options) {
+  const parser = new Parser(options);
+  parser.write(input);
+  const result = parser.end();
+  const irBuilder = new IRBuilder;
+  const ir = irBuilder.build(result.ast);
+  return ir.value;
+}
+function parseWithDiagnostics(input, options) {
+  const parser = new Parser(options);
+  parser.write(input);
+  const parseResult = parser.end();
+  const irBuilder = new IRBuilder;
+  const irResult = irBuilder.build(parseResult.ast);
+  return {
+    parse: parseResult,
+    ir: irResult
+  };
+}
+function createStreamingParser(options) {
+  const parser = new Parser(options);
+  const irBuilder = new IRBuilder;
+  let intentHandler = null;
+  parser.on("intent_ready", (data) => {
+    const { type } = data;
+    if (intentHandler && type) {
+      intentHandler(type);
+    }
+  });
+  return {
+    write(chunk) {
+      parser.write(chunk);
+    },
+    peek() {
+      const result = parser.peek();
+      return irBuilder.build(result.ast).value;
+    },
+    end() {
+      const result = parser.end();
+      return irBuilder.build(result.ast).value;
+    },
+    onIntentReady(handler) {
+      intentHandler = handler;
+    }
+  };
+}
+function validate(input, options) {
+  const parser = new Parser({ ...options, strict: true });
+  parser.write(input);
+  const result = parser.end();
+  if (result.errors.length === 0) {
+    return true;
+  }
+  return result.errors;
+}
+function extractYAML(input) {
+  let text = input;
+  const fenceMatch = text.match(/```(?:yaml|yml)?\s*\n([\s\S]*?)```/);
+  if (fenceMatch && fenceMatch[1]) {
+    return fenceMatch[1].trim();
+  }
+  const lines = text.split(`
+`);
+  let start = 0;
+  let end = lines.length;
+  for (let i = 0;i < lines.length; i++) {
+    const t = (lines[i] ?? "").trim();
+    if (/^[a-zA-Z_]\w*:/.test(t) || /^-\s/.test(t)) {
+      start = i;
+      break;
+    }
+  }
+  for (let i = lines.length - 1;i >= start; i--) {
+    const line = lines[i] ?? "";
+    const t = line.trim();
+    if (!t)
+      continue;
+    if (/^\s/.test(line) || /^[a-zA-Z_]\w*:/.test(t) || /^-\s/.test(t)) {
+      end = i + 1;
+      break;
+    }
+  }
+  return lines.slice(start, end).join(`
+`).trim();
+}
+export {
+  validate,
+  tokenize,
+  parseWithDiagnostics,
+  parseToJSON,
+  parse,
+  extractYAML,
+  createStreamingParser,
+  createParser,
+  buildIR,
+  Tokenizer,
+  Parser,
+  IRBuilder
+};