@lexbuild/core 1.0.0

package/dist/index.js

@@ -0,0 +1,1600 @@
+// src/xml/parser.ts
+import { SaxesParser } from "saxes";
+
+// src/xml/namespace.ts
+var USLM_NS = "http://xml.house.gov/schemas/uslm/1.0";
+var XHTML_NS = "http://www.w3.org/1999/xhtml";
+var DC_NS = "http://purl.org/dc/elements/1.1/";
+var DCTERMS_NS = "http://purl.org/dc/terms/";
+var XSI_NS = "http://www.w3.org/2001/XMLSchema-instance";
+var NAMESPACE_PREFIXES = {
+  [XHTML_NS]: "xhtml",
+  [DC_NS]: "dc",
+  [DCTERMS_NS]: "dcterms",
+  [XSI_NS]: "xsi"
+};
+var LEVEL_ELEMENTS = /* @__PURE__ */ new Set([
+  "title",
+  "subtitle",
+  "chapter",
+  "subchapter",
+  "article",
+  "subarticle",
+  "part",
+  "subpart",
+  "division",
+  "subdivision",
+  "preliminary",
+  "section",
+  "subsection",
+  "paragraph",
+  "subparagraph",
+  "clause",
+  "subclause",
+  "item",
+  "subitem",
+  "subsubitem",
+  // Appendix-level elements
+  "appendix",
+  "compiledAct",
+  "reorganizationPlans",
+  "reorganizationPlan",
+  "courtRules",
+  "courtRule"
+]);
+var CONTENT_ELEMENTS = /* @__PURE__ */ new Set([
+  "content",
+  "chapeau",
+  "continuation",
+  "proviso"
+]);
+var INLINE_ELEMENTS = /* @__PURE__ */ new Set([
+  "b",
+  "i",
+  "sub",
+  "sup",
+  "ref",
+  "date",
+  "term",
+  "inline",
+  "shortTitle",
+  "del",
+  "ins"
+]);
+var NOTE_ELEMENTS = /* @__PURE__ */ new Set([
+  "note",
+  "notes",
+  "sourceCredit",
+  "statutoryNote",
+  "editorialNote",
+  "changeNote"
+]);
+var APPENDIX_LEVEL_ELEMENTS = /* @__PURE__ */ new Set([
+  "compiledAct",
+  "courtRules",
+  "courtRule",
+  "reorganizationPlans",
+  "reorganizationPlan"
+]);
+var META_ELEMENTS = /* @__PURE__ */ new Set([
+  "meta",
+  "docNumber",
+  "docPublicationName",
+  "docReleasePoint",
+  "property"
+]);
+var CONTAINER_ELEMENTS = /* @__PURE__ */ new Set([
+  "uscDoc",
+  "main",
+  "meta",
+  "toc",
+  "layout",
+  "header",
+  "row",
+  "column",
+  "tocItem"
+]);
+
+// src/xml/parser.ts
+var XMLParser = class {
+  saxParser;
+  defaultNs;
+  prefixMap;
+  listeners = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.defaultNs = options?.defaultNamespace ?? USLM_NS;
+    this.prefixMap = {
+      ...NAMESPACE_PREFIXES,
+      ...options?.namespacePrefixes
+    };
+    this.saxParser = new SaxesParser({ xmlns: true, position: true });
+    this.saxParser.on("opentag", (node) => {
+      const ns = node.uri;
+      const localName = node.local;
+      const normalizedName = this.normalizeName(localName, ns);
+      const attrs = this.normalizeAttributes(node.attributes);
+      this.emit("openElement", normalizedName, attrs, ns);
+    });
+    this.saxParser.on("closetag", (node) => {
+      const ns = node.uri;
+      const localName = node.local;
+      const normalizedName = this.normalizeName(localName, ns);
+      this.emit("closeElement", normalizedName, ns);
+    });
+    this.saxParser.on("text", (text) => {
+      this.emit("text", text);
+    });
+    this.saxParser.on("error", (err) => {
+      this.emit("error", err);
+    });
+    this.saxParser.on("end", () => {
+      this.emit("end");
+    });
+  }
+  /**
+   * Register an event listener.
+   */
+  on(event, handler) {
+    let handlers = this.listeners.get(event);
+    if (!handlers) {
+      handlers = [];
+      this.listeners.set(event, handlers);
+    }
+    handlers.push(handler);
+    return this;
+  }
+  /**
+   * Parse a complete XML string.
+   */
+  parseString(xml) {
+    this.saxParser.write(xml);
+    this.saxParser.close();
+  }
+  /**
+   * Parse from a readable stream (e.g., fs.createReadStream).
+   * Returns a promise that resolves when parsing is complete.
+   */
+  parseStream(stream) {
+    return new Promise((resolve2, reject) => {
+      stream.on("data", (chunk) => {
+        try {
+          this.saxParser.write(typeof chunk === "string" ? chunk : chunk.toString("utf-8"));
+        } catch (err) {
+          reject(err);
+        }
+      });
+      stream.on("end", () => {
+        try {
+          this.saxParser.close();
+          resolve2();
+        } catch (err) {
+          reject(err);
+        }
+      });
+      stream.on("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+  /**
+   * Normalize an element name based on its namespace.
+   * Default namespace elements get bare names; others get prefixed.
+   */
+  normalizeName(localName, ns) {
+    if (ns === this.defaultNs || ns === "") {
+      return localName;
+    }
+    const prefix = this.prefixMap[ns];
+    if (prefix) {
+      return `${prefix}:${localName}`;
+    }
+    return `{${ns}}${localName}`;
+  }
+  /**
+   * Normalize saxes namespace-aware attributes to a flat record.
+   * Strips namespace prefixes from attribute names for simplicity,
+   * except for xmlns declarations which are dropped entirely.
+   */
+  normalizeAttributes(saxAttrs) {
+    const attrs = {};
+    for (const [, attr] of Object.entries(saxAttrs)) {
+      if (attr.prefix === "xmlns" || attr.local === "xmlns") {
+        continue;
+      }
+      const name = attr.prefix && attr.prefix !== "" ? `${attr.prefix}:${attr.local}` : attr.local;
+      attrs[name] = attr.value;
+    }
+    return attrs;
+  }
+  /**
+   * Emit an event to all registered listeners.
+   */
+  emit(event, ...args) {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(...args);
+      }
+    }
+  }
+};
+
+// src/ast/types.ts
+var LEVEL_TYPES = [
+  // Big levels (above section)
+  "title",
+  "appendix",
+  "subtitle",
+  "chapter",
+  "subchapter",
+  "compiledAct",
+  "reorganizationPlans",
+  "reorganizationPlan",
+  "courtRules",
+  "courtRule",
+  "article",
+  "subarticle",
+  "part",
+  "subpart",
+  "division",
+  "subdivision",
+  "preliminary",
+  // Primary level
+  "section",
+  // Small levels (below section)
+  "subsection",
+  "paragraph",
+  "subparagraph",
+  "clause",
+  "subclause",
+  "item",
+  "subitem",
+  "subsubitem"
+];
+var BIG_LEVELS = /* @__PURE__ */ new Set([
+  "title",
+  "appendix",
+  "subtitle",
+  "chapter",
+  "subchapter",
+  "compiledAct",
+  "reorganizationPlans",
+  "reorganizationPlan",
+  "courtRules",
+  "courtRule",
+  "article",
+  "subarticle",
+  "part",
+  "subpart",
+  "division",
+  "subdivision",
+  "preliminary"
+]);
+var SMALL_LEVELS = /* @__PURE__ */ new Set([
+  "subsection",
+  "paragraph",
+  "subparagraph",
+  "clause",
+  "subclause",
+  "item",
+  "subitem",
+  "subsubitem"
+]);
+
+// src/ast/builder.ts
+var INLINE_TYPE_MAP = {
+  b: "bold",
+  i: "italic",
+  sub: "sub",
+  sup: "sup",
+  ref: "ref",
+  date: "date",
+  term: "term",
+  inline: "text",
+  shortTitle: "text",
+  del: "text",
+  ins: "text"
+};
+var ASTBuilder = class {
+  options;
+  stack = [];
+  ancestors = [];
+  documentMeta = {};
+  /** Whether we are currently inside the <meta> block */
+  inMeta = false;
+  /** Nesting depth inside <quotedContent> — levels inside quotes are not emitted */
+  quotedContentDepth = 0;
+  /** Active XHTML table collector (null when not inside a table) */
+  tableCollector = null;
+  /** Active USLM layout collector (null when not inside a layout) */
+  layoutCollector = null;
+  /** Nesting depth inside <toc> — elements inside toc are handled by layout collector only */
+  tocDepth = 0;
+  /** Current meta field being collected (e.g., "dc:title", "docNumber") */
+  metaField = null;
+  /** Attributes of the current meta property element */
+  metaPropertyAttrs = null;
+  constructor(options) {
+    this.options = options;
+  }
+  /** Returns the document metadata collected so far */
+  getDocumentMeta() {
+    return this.documentMeta;
+  }
+  /**
+   * Handle an openElement event from the parser.
+   */
+  onOpenElement(name, attrs) {
+    if (name === "meta") {
+      this.inMeta = true;
+      this.stack.push({ kind: "meta", node: null, elementName: name, textBuffer: "" });
+      return;
+    }
+    if (this.inMeta) {
+      this.handleMetaOpen(name, attrs);
+      return;
+    }
+    if (name === "uscDoc") {
+      if (attrs["identifier"]) {
+        this.documentMeta.identifier = attrs["identifier"];
+      }
+      return;
+    }
+    if (name === "main") {
+      return;
+    }
+    if (name === "xhtml:table") {
+      this.tableCollector = {
+        headers: [],
+        rows: [],
+        currentRow: [],
+        cellText: "",
+        inHead: false,
+        inCell: false,
+        isComplex: false,
+        cellDepth: 0
+      };
+      return;
+    }
+    if (this.tableCollector) {
+      this.handleTableOpen(name, attrs);
+      return;
+    }
+    if (name === "layout") {
+      this.layoutCollector = {
+        headers: [],
+        rows: [],
+        currentRow: [],
+        cellText: "",
+        inHead: false,
+        inCell: false,
+        isComplex: false,
+        cellDepth: 0
+      };
+      return;
+    }
+    if (this.layoutCollector) {
+      this.handleLayoutOpen(name, attrs);
+      return;
+    }
+    if (name === "toc") {
+      this.tocDepth++;
+      return;
+    }
+    if (this.tocDepth > 0) {
+      return;
+    }
+    if (LEVEL_ELEMENTS.has(name)) {
+      this.openLevel(name, attrs);
+      return;
+    }
+    if (CONTENT_ELEMENTS.has(name)) {
+      this.openContent(name, attrs);
+      return;
+    }
+    if (INLINE_ELEMENTS.has(name)) {
+      this.openInline(name, attrs);
+      return;
+    }
+    if (name === "notes") {
+      this.openNotesContainer(attrs);
+      return;
+    }
+    if (name === "note" || name === "statutoryNote" || name === "editorialNote" || name === "changeNote") {
+      this.openNote(name, attrs);
+      return;
+    }
+    if (name === "sourceCredit") {
+      this.openSourceCredit();
+      return;
+    }
+    if (name === "quotedContent") {
+      this.openQuotedContent(attrs);
+      return;
+    }
+    if (name === "num") {
+      const parentFrame = this.findParentFrame("level");
+      if (parentFrame && attrs["value"]) {
+        parentFrame.node.numValue = attrs["value"];
+      }
+      this.stack.push({ kind: "ignore", node: null, elementName: name, textBuffer: "" });
+      return;
+    }
+    if (name === "heading") {
+      this.stack.push({ kind: "ignore", node: null, elementName: name, textBuffer: "" });
+      return;
+    }
+    if (name === "p") {
+      this.stack.push({ kind: "ignore", node: null, elementName: name, textBuffer: "" });
+      return;
+    }
+    this.stack.push({ kind: "ignore", node: null, elementName: name, textBuffer: "" });
+  }
+  /**
+   * Handle a closeElement event from the parser.
+   */
+  onCloseElement(name) {
+    if (name === "meta") {
+      this.inMeta = false;
+      this.popFrame("meta");
+      return;
+    }
+    if (this.inMeta) {
+      this.handleMetaClose(name);
+      return;
+    }
+    if (name === "uscDoc" || name === "main") {
+      return;
+    }
+    if (name === "xhtml:table" && this.tableCollector) {
+      this.finishTable();
+      return;
+    }
+    if (this.tableCollector) {
+      this.handleTableClose(name);
+      return;
+    }
+    if (name === "toc") {
+      this.tocDepth = Math.max(0, this.tocDepth - 1);
+      return;
+    }
+    if (name === "layout" && this.layoutCollector) {
+      this.finishLayout();
+      return;
+    }
+    if (this.layoutCollector) {
+      this.handleLayoutClose(name);
+      return;
+    }
+    if (this.tocDepth > 0) {
+      return;
+    }
+    if (name === "num" || name === "heading") {
+      const frame2 = this.peekFrame();
+      if (frame2?.elementName === name) {
+        this.handleNumOrHeadingClose(name, frame2);
+        this.stack.pop();
+        return;
+      }
+    }
+    if (name === "p") {
+      const frame2 = this.peekFrame();
+      if (frame2?.elementName === "p") {
+        this.handlePClose(frame2);
+        this.stack.pop();
+        return;
+      }
+    }
+    if (LEVEL_ELEMENTS.has(name)) {
+      this.closeLevel(name);
+      return;
+    }
+    if (CONTENT_ELEMENTS.has(name)) {
+      this.closeContent();
+      return;
+    }
+    if (INLINE_ELEMENTS.has(name)) {
+      this.closeInline();
+      return;
+    }
+    if (name === "notes") {
+      this.closeNotesContainer();
+      return;
+    }
+    if (name === "note" || name === "statutoryNote" || name === "editorialNote" || name === "changeNote") {
+      this.closeNote();
+      return;
+    }
+    if (name === "sourceCredit") {
+      this.closeSourceCredit();
+      return;
+    }
+    if (name === "quotedContent") {
+      this.closeQuotedContent();
+      return;
+    }
+    const frame = this.peekFrame();
+    if (frame?.kind === "ignore" && frame.elementName === name) {
+      this.stack.pop();
+    }
+  }
+  /**
+   * Handle a text event from the parser.
+   */
+  onText(text) {
+    if (this.tableCollector?.inCell) {
+      this.tableCollector.cellText += text;
+      return;
+    }
+    if (this.tableCollector) {
+      return;
+    }
+    if (this.layoutCollector?.inCell) {
+      this.layoutCollector.cellText += text;
+      return;
+    }
+    if (this.layoutCollector) {
+      return;
+    }
+    if (this.tocDepth > 0) {
+      return;
+    }
+    if (this.inMeta) {
+      const frame2 = this.peekFrame();
+      if (frame2) {
+        frame2.textBuffer += text;
+      }
+      return;
+    }
+    const frame = this.peekFrame();
+    if (!frame) return;
+    if (frame.kind === "ignore") {
+      frame.textBuffer += text;
+      return;
+    }
+    if (frame.kind === "inline") {
+      const inlineNode = frame.node;
+      const textChild = { type: "inline", inlineType: "text", text };
+      if (!inlineNode.children) {
+        inlineNode.children = [];
+      }
+      inlineNode.children.push(textChild);
+      this.bubbleTextToCollector(text);
+      return;
+    }
+    if (frame.kind === "content" || frame.kind === "sourceCredit") {
+      if (!text.trim()) return;
+      const textNode = { type: "inline", inlineType: "text", text };
+      const parent = frame.node;
+      if (parent && "children" in parent && Array.isArray(parent.children)) {
+        parent.children.push(textNode);
+      }
+      return;
+    }
+    if (frame.kind === "note" || frame.kind === "quotedContent") {
+      const trimmed = text.trim();
+      if (trimmed) {
+        const textNode = { type: "inline", inlineType: "text", text };
+        const contentNode = {
+          type: "content",
+          variant: "content",
+          children: [textNode]
+        };
+        const parent = frame.node;
+        if (parent && "children" in parent && Array.isArray(parent.children)) {
+          parent.children.push(contentNode);
+        }
+      }
+      return;
+    }
+    if (frame.kind === "level") {
+      const trimmed = text.trim();
+      if (trimmed) {
+        const textNode = { type: "inline", inlineType: "text", text };
+        const contentNode = {
+          type: "content",
+          variant: "content",
+          children: [textNode]
+        };
+        frame.node.children.push(contentNode);
+      }
+      return;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Meta handling
+  // ---------------------------------------------------------------------------
+  handleMetaOpen(name, attrs) {
+    this.metaField = name;
+    this.metaPropertyAttrs = attrs;
+    this.stack.push({ kind: "ignore", node: null, elementName: name, textBuffer: "" });
+  }
+  handleMetaClose(name) {
+    const frame = this.peekFrame();
+    if (frame?.elementName !== name) return;
+    const text = frame.textBuffer.trim();
+    this.stack.pop();
+    switch (this.metaField) {
+      case "dc:title":
+        this.documentMeta.dcTitle = text;
+        break;
+      case "dc:type":
+        this.documentMeta.dcType = text;
+        break;
+      case "docNumber":
+        this.documentMeta.docNumber = text;
+        break;
+      case "docPublicationName":
+        this.documentMeta.docPublicationName = text;
+        break;
+      case "docReleasePoint":
+        this.documentMeta.releasePoint = text;
+        break;
+      case "dc:publisher":
+        this.documentMeta.publisher = text;
+        break;
+      case "dcterms:created":
+        this.documentMeta.created = text;
+        break;
+      case "dc:creator":
+        this.documentMeta.creator = text;
+        break;
+      case "property":
+        if (this.metaPropertyAttrs?.["role"] === "is-positive-law") {
+          this.documentMeta.positivelaw = text.toLowerCase() === "yes";
+        }
+        break;
+    }
+    this.metaField = null;
+    this.metaPropertyAttrs = null;
+  }
+  // ---------------------------------------------------------------------------
+  // Level handling
+  // ---------------------------------------------------------------------------
+  openLevel(levelType, attrs) {
+    const node = {
+      type: "level",
+      levelType,
+      identifier: attrs["identifier"],
+      status: attrs["status"],
+      sourceElement: levelType,
+      children: []
+    };
+    const emitIndex = LEVEL_TYPES_ARRAY.indexOf(this.options.emitAt);
+    const thisIndex = LEVEL_TYPES_ARRAY.indexOf(levelType);
+    if (thisIndex >= 0 && thisIndex < emitIndex && this.quotedContentDepth === 0) {
+      this.ancestors.push({
+        levelType,
+        identifier: attrs["identifier"]
+      });
+    }
+    this.stack.push({ kind: "level", node, elementName: levelType, textBuffer: "" });
+  }
+  closeLevel(levelType) {
+    const frame = this.popFrame("level");
+    if (!frame) return;
+    const node = frame.node;
+    if (this.quotedContentDepth > 0) {
+      this.addToParent(node);
+      return;
+    }
+    if (levelType === this.options.emitAt) {
+      const context = {
+        ancestors: [...this.ancestors],
+        documentMeta: { ...this.documentMeta }
+      };
+      this.options.onEmit(node, context);
+      return;
+    }
+    const emitIndex = LEVEL_TYPES_ARRAY.indexOf(this.options.emitAt);
+    const thisIndex = LEVEL_TYPES_ARRAY.indexOf(levelType);
+    if (thisIndex < emitIndex) {
+      this.ancestors.pop();
+      return;
+    }
+    this.addToParent(node);
+  }
+  // ---------------------------------------------------------------------------
+  // Content handling
+  // ---------------------------------------------------------------------------
+  openContent(variant, _attrs) {
+    const node = {
+      type: "content",
+      variant,
+      sourceElement: variant,
+      children: []
+    };
+    this.stack.push({ kind: "content", node, elementName: variant, textBuffer: "" });
+  }
+  closeContent() {
+    const frame = this.popFrame("content");
+    if (!frame) return;
+    if (frame.node) this.addToParent(frame.node);
+  }
+  // ---------------------------------------------------------------------------
+  // Inline handling
+  // ---------------------------------------------------------------------------
+  openInline(name, attrs) {
+    const inlineType = INLINE_TYPE_MAP[name] ?? "text";
+    const node = {
+      type: "inline",
+      inlineType,
+      sourceElement: name
+    };
+    if (name === "ref") {
+      if (attrs["href"]) {
+        node.href = attrs["href"];
+      }
+      if (attrs["class"] === "footnoteRef") {
+        node.inlineType = "footnoteRef";
+        node.idref = attrs["idref"];
+      }
+    }
+    if (name === "date" && attrs["date"]) {
+      node.href = attrs["date"];
+    }
+    this.stack.push({ kind: "inline", node, elementName: name, textBuffer: "" });
+  }
+  closeInline() {
+    const frame = this.popFrame("inline");
+    if (!frame) return;
+    const node = frame.node;
+    const firstChild = node.children?.[0];
+    if (node.children?.length === 1 && firstChild?.inlineType === "text" && !firstChild.children) {
+      node.text = firstChild.text;
+      node.children = void 0;
+    }
+    this.addInlineToParent(node);
+  }
+  // ---------------------------------------------------------------------------
+  // Note handling
+  // ---------------------------------------------------------------------------
+  openNotesContainer(attrs) {
+    const node = {
+      type: "notesContainer",
+      notesType: attrs["type"],
+      children: []
+    };
+    this.stack.push({ kind: "notesContainer", node, elementName: "notes", textBuffer: "" });
+  }
+  closeNotesContainer() {
+    const frame = this.popFrame("notesContainer");
+    if (!frame) return;
+    if (frame.node) this.addToParent(frame.node);
+  }
+  openNote(name, attrs) {
+    const node = {
+      type: "note",
+      topic: attrs["topic"],
+      role: attrs["role"],
+      sourceElement: name,
+      children: []
+    };
+    this.stack.push({ kind: "note", node, elementName: name, textBuffer: "" });
+  }
+  closeNote() {
+    const frame = this.popFrame("note");
+    if (!frame) return;
+    if (frame.node) this.addToParent(frame.node);
+  }
+  // ---------------------------------------------------------------------------
+  // SourceCredit handling
+  // ---------------------------------------------------------------------------
+  openSourceCredit() {
+    const node = {
+      type: "sourceCredit",
+      children: []
+    };
+    this.stack.push({ kind: "sourceCredit", node, elementName: "sourceCredit", textBuffer: "" });
+  }
+  closeSourceCredit() {
+    const frame = this.popFrame("sourceCredit");
+    if (!frame) return;
+    if (frame.node) this.addToParent(frame.node);
+  }
+  // ---------------------------------------------------------------------------
+  // QuotedContent handling
+  // ---------------------------------------------------------------------------
+  openQuotedContent(attrs) {
+    this.quotedContentDepth++;
+    const node = {
+      type: "quotedContent",
+      origin: attrs["origin"],
+      children: []
+    };
+    this.stack.push({ kind: "quotedContent", node, elementName: "quotedContent", textBuffer: "" });
+  }
+  closeQuotedContent() {
+    this.quotedContentDepth--;
+    const frame = this.popFrame("quotedContent");
+    if (!frame) return;
+    const parentFrame = this.peekFrame();
+    if (parentFrame && (parentFrame.kind === "content" || parentFrame.kind === "inline" || parentFrame.kind === "sourceCredit")) {
+      const qNode = {
+        type: "inline",
+        inlineType: "quoted",
+        text: this.extractText(frame.node)
+      };
+      this.addInlineToParent(qNode);
+    } else {
+      if (frame.node) this.addToParent(frame.node);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Num/Heading/P helpers
+  // ---------------------------------------------------------------------------
+  handleNumOrHeadingClose(name, frame) {
+    const text = frame.textBuffer.trim();
+    const noteFrame = this.findParentFrame("note");
+    const levelFrame = this.findParentFrame("level");
+    if (name === "heading" && noteFrame && (!levelFrame || this.stack.indexOf(noteFrame) > this.stack.indexOf(levelFrame))) {
+      noteFrame.node.heading = text;
+      return;
+    }
+    if (!levelFrame) return;
+    const levelNode = levelFrame.node;
+    if (name === "num") {
+      levelNode.num = text;
+    } else if (name === "heading") {
+      levelNode.heading = text;
+    }
+    const ancestor = this.ancestors.find(
+      (a) => a.levelType === levelNode.levelType && a.identifier === levelNode.identifier
+    );
+    if (ancestor) {
+      if (name === "num") {
+        ancestor.numValue = levelNode.numValue;
+      } else if (name === "heading") {
+        ancestor.heading = text;
+      }
+    }
+  }
+  handlePClose(frame) {
+    const text = frame.textBuffer;
+    if (!text) return;
+    const parentFrame = this.peekFrameAbove(frame);
+    if (!parentFrame) return;
+    if (parentFrame.kind === "content" || parentFrame.kind === "sourceCredit") {
+      const textNode = { type: "inline", inlineType: "text", text };
+      const parent = parentFrame.node;
+      if (parent && "children" in parent && Array.isArray(parent.children)) {
+        const children = parent.children;
+        if (children.length > 0) {
+          children.push({ type: "inline", inlineType: "text", text: "\n\n" });
+        }
+        children.push(textNode);
+      }
+    } else if (parentFrame.kind === "note" || parentFrame.kind === "level" || parentFrame.kind === "quotedContent") {
+      const textNode = { type: "inline", inlineType: "text", text };
+      const contentNode = {
+        type: "content",
+        variant: "content",
+        children: [textNode]
+      };
+      const parent = parentFrame.node;
+      if (parent && "children" in parent && Array.isArray(parent.children)) {
+        parent.children.push(contentNode);
+      }
+    }
+  }
+  /**
+   * Bubble text content up to the nearest heading/num ignore frame on the stack.
+   * This handles patterns like <heading><b>Editorial Notes</b></heading>
+   * where the text is inside an inline child but needs to be collected by the heading frame.
+   */
+  // ---------------------------------------------------------------------------
+  // XHTML table handling
+  // ---------------------------------------------------------------------------
+  handleTableOpen(name, attrs) {
+    const tc = this.tableCollector;
+    if (!tc) return;
+    switch (name) {
+      case "xhtml:thead":
+        tc.inHead = true;
+        break;
+      case "xhtml:tbody":
+        tc.inHead = false;
+        break;
+      case "xhtml:tr":
+        tc.currentRow = [];
+        break;
+      case "xhtml:th":
+      case "xhtml:td":
+        tc.inCell = true;
+        tc.cellText = "";
+        tc.cellDepth = 0;
+        if (attrs["colspan"] && attrs["colspan"] !== "1") {
+          tc.isComplex = true;
+        }
+        if (attrs["rowspan"] && attrs["rowspan"] !== "1") {
+          tc.isComplex = true;
+        }
+        break;
+      // Sub-elements inside cells (p, span, i, a, etc.) — track depth
+      default:
+        if (tc.inCell) {
+          tc.cellDepth++;
+        }
+        break;
+    }
+  }
+  handleTableClose(name) {
+    const tc = this.tableCollector;
+    if (!tc) return;
+    switch (name) {
+      case "xhtml:thead":
+        tc.inHead = false;
+        break;
+      case "xhtml:tbody":
+        break;
+      case "xhtml:tr":
+        if (tc.inHead) {
+          tc.headers.push(tc.currentRow);
+        } else {
+          tc.rows.push(tc.currentRow);
+        }
+        tc.currentRow = [];
+        break;
+      case "xhtml:th":
+      case "xhtml:td":
+        tc.currentRow.push(tc.cellText.trim());
+        tc.inCell = false;
+        tc.cellText = "";
+        break;
+      default:
+        if (tc.inCell) {
+          tc.cellDepth = Math.max(0, tc.cellDepth - 1);
+        }
+        break;
+    }
+  }
+  finishTable() {
+    const tc = this.tableCollector;
+    if (!tc) return;
+    this.tableCollector = null;
+    const node = {
+      type: "table",
+      variant: "xhtml",
+      headers: tc.headers,
+      rows: tc.rows
+    };
+    this.addToParent(node);
+  }
+  // ---------------------------------------------------------------------------
+  // USLM layout handling
+  // ---------------------------------------------------------------------------
+  handleLayoutOpen(name, _attrs) {
+    const lc = this.layoutCollector;
+    if (!lc) return;
+    switch (name) {
+      case "header":
+        lc.inHead = true;
+        lc.currentRow = [];
+        break;
+      case "tocItem":
+      case "row":
+        lc.currentRow = [];
+        break;
+      case "column":
+        lc.inCell = true;
+        lc.cellText = "";
+        break;
+      default:
+        break;
+    }
+  }
+  handleLayoutClose(name) {
+    const lc = this.layoutCollector;
+    if (!lc) return;
+    switch (name) {
+      case "header":
+        lc.headers.push(lc.currentRow);
+        lc.currentRow = [];
+        lc.inHead = false;
+        break;
+      case "tocItem":
+      case "row":
+        lc.rows.push(lc.currentRow);
+        lc.currentRow = [];
+        break;
+      case "column":
+        lc.currentRow.push(lc.cellText.trim());
+        lc.inCell = false;
+        lc.cellText = "";
+        break;
+      default:
+        break;
+    }
+  }
+  finishLayout() {
+    const lc = this.layoutCollector;
+    if (!lc) return;
+    this.layoutCollector = null;
+    if (lc.rows.length === 0 && lc.headers.length === 0) return;
+    const node = {
+      type: "table",
+      variant: "layout",
+      headers: lc.headers,
+      rows: lc.rows
+    };
+    this.addToParent(node);
+  }
+  bubbleTextToCollector(text) {
+    for (let i = this.stack.length - 2; i >= 0; i--) {
+      const f = this.stack[i];
+      if (f?.kind === "ignore" && (f.elementName === "heading" || f.elementName === "num")) {
+        f.textBuffer += text;
+        return;
+      }
+      if (f && f.kind !== "inline" && f.kind !== "ignore") {
+        return;
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Stack utilities
+  // ---------------------------------------------------------------------------
+  peekFrame() {
+    return this.stack[this.stack.length - 1];
+  }
+  peekFrameAbove(belowFrame) {
+    const idx = this.stack.lastIndexOf(belowFrame);
+    if (idx > 0) {
+      return this.stack[idx - 1];
+    }
+    return void 0;
+  }
+  popFrame(expectedKind) {
+    const frame = this.stack[this.stack.length - 1];
+    if (frame?.kind === expectedKind) {
+      this.stack.pop();
+      return frame;
+    }
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      const f = this.stack[i];
+      if (f?.kind === expectedKind) {
+        return this.stack.splice(i, 1)[0];
+      }
+    }
+    return void 0;
+  }
+  findParentFrame(kind) {
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      const f = this.stack[i];
+      if (f?.kind === kind) {
+        return f;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Add a block-level AST node to the nearest parent that accepts children.
+   */
+  addToParent(node) {
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      const frame = this.stack[i];
+      if (!frame) continue;
+      if (frame.kind === "level") {
+        frame.node.children.push(node);
+        return;
+      }
+      if (frame.kind === "note") {
+        frame.node.children.push(node);
+        return;
+      }
+      if (frame.kind === "notesContainer") {
+        frame.node.children.push(node);
+        return;
+      }
+      if (frame.kind === "quotedContent") {
+        frame.node.children.push(node);
+        return;
+      }
+    }
+  }
+  /**
+   * Add an inline AST node to the nearest parent that accepts inline children.
+   */
+  addInlineToParent(node) {
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      const frame = this.stack[i];
+      if (!frame) continue;
+      if (frame.kind === "inline") {
+        const parent = frame.node;
+        if (!parent.children) {
+          parent.children = [];
+        }
+        parent.children.push(node);
+        return;
+      }
+      if (frame.kind === "content" || frame.kind === "sourceCredit") {
+        const parent = frame.node;
+        if (parent && "children" in parent && Array.isArray(parent.children)) {
+          parent.children.push(node);
+        }
+        return;
+      }
+    }
+  }
+  /**
+   * Extract plain text from a node tree (for flattening quotedContent).
+   */
+  extractText(node) {
+    let result = "";
+    for (const child of node.children) {
+      if (child.type === "inline") {
+        result += this.extractInlineText(child);
+      } else if (child.type === "content") {
+        for (const inline of child.children) {
+          result += this.extractInlineText(inline);
+        }
+      }
+    }
+    return result;
+  }
+  extractInlineText(node) {
+    if (node.text) return node.text;
+    if (node.children) {
+      return node.children.map((c) => this.extractInlineText(c)).join("");
+    }
+    return "";
+  }
+};
+var LEVEL_TYPES_ARRAY = LEVEL_TYPES;
+
+// src/markdown/frontmatter.ts
+import { readFileSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { stringify } from "yaml";
+function readPackageVersion() {
+  try {
+    const dir = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = resolve(dir, "..", "..", "package.json");
+    const raw = readFileSync(pkgPath, "utf-8");
+    return JSON.parse(raw).version;
+  } catch {
+    return "0.0.0";
+  }
+}
+var FORMAT_VERSION = "1.0.0";
+var GENERATOR = `lexbuild@${readPackageVersion()}`;
+function generateFrontmatter(data) {
+  const fm = {
+    identifier: data.identifier,
+    title: data.title,
+    title_number: data.title_number,
+    title_name: data.title_name,
+    section_number: data.section_number,
+    section_name: data.section_name
+  };
+  if (data.chapter_number !== void 0) {
+    fm["chapter_number"] = data.chapter_number;
+  }
+  if (data.chapter_name !== void 0) {
+    fm["chapter_name"] = data.chapter_name;
+  }
+  if (data.subchapter_number !== void 0) {
+    fm["subchapter_number"] = data.subchapter_number;
+  }
+  if (data.subchapter_name !== void 0) {
+    fm["subchapter_name"] = data.subchapter_name;
+  }
+  if (data.part_number !== void 0) {
+    fm["part_number"] = data.part_number;
+  }
+  if (data.part_name !== void 0) {
+    fm["part_name"] = data.part_name;
+  }
+  fm["positive_law"] = data.positive_law;
+  fm["currency"] = data.currency;
+  fm["last_updated"] = data.last_updated;
+  fm["format_version"] = FORMAT_VERSION;
+  fm["generator"] = GENERATOR;
+  if (data.source_credit !== void 0) {
+    fm["source_credit"] = data.source_credit;
+  }
+  if (data.status !== void 0) {
+    fm["status"] = data.status;
+  }
+  const yamlStr = stringify(fm, {
+    lineWidth: 0,
+    // Don't wrap long lines
+    defaultStringType: "QUOTE_DOUBLE",
+    defaultKeyType: "PLAIN"
+  });
+  return `---
+${yamlStr}---`;
+}
+
+// src/markdown/renderer.ts
+var DEFAULT_RENDER_OPTIONS = {
+  headingOffset: 0,
+  linkStyle: "plaintext"
+};
+function renderDocument(sectionNode, frontmatter, options = DEFAULT_RENDER_OPTIONS) {
+  const fm = generateFrontmatter(frontmatter);
+  const content = renderSection(sectionNode, options);
+  return `${fm}
+
+${content}
+`;
+}
+function renderSection(node, options = DEFAULT_RENDER_OPTIONS) {
+  const parts = [];
+  const headingLevel = 1 + options.headingOffset;
+  const prefix = "#".repeat(headingLevel);
+  const numDisplay = node.num ?? "";
+  const heading = node.heading ? ` ${node.heading}` : "";
+  parts.push(`${prefix} ${numDisplay}${heading}`);
+  for (const child of node.children) {
+    const rendered = renderNode(child, options);
+    if (rendered) {
+      parts.push(rendered);
+    }
+  }
+  return parts.join("\n\n");
+}
+function renderNode(node, options = DEFAULT_RENDER_OPTIONS) {
+  switch (node.type) {
+    case "level":
+      return renderLevel(node, options);
+    case "content":
+      return renderContent(node);
+    case "inline":
+      return renderInline(node, options);
+    case "sourceCredit":
+      return renderSourceCredit(node, options);
+    case "note":
+      return renderNote(node, options);
+    case "notesContainer":
+      return renderNotesContainer(node, options);
+    case "quotedContent":
+      return renderQuotedContent(node, options);
+    case "table":
+      return renderTable(node);
+    case "toc":
+    case "tocItem":
+      return "";
+    default:
+      return "";
+  }
+}
+function renderLevel(node, options) {
+  if (SMALL_LEVELS.has(node.levelType)) {
+    return renderSmallLevel(node, options);
+  }
+  const parts = [];
+  if (node.num ?? node.heading) {
+    const numDisplay = node.num ?? "";
+    const heading = node.heading ? ` ${node.heading}` : "";
+    parts.push(`**${numDisplay}${heading}**`);
+  }
+  for (const child of node.children) {
+    const rendered = renderNode(child, options);
+    if (rendered) {
+      parts.push(rendered);
+    }
+  }
+  return parts.join("\n\n");
+}
+function renderSmallLevel(node, options) {
+  const parts = [];
+  const numDisplay = node.num ?? (node.numValue ? `(${node.numValue})` : "");
+  let prefix = numDisplay ? `**${numDisplay}**` : "";
+  if (node.heading) {
+    prefix += ` **${node.heading}**`;
+  }
+  const contentParts = [];
+  const childParts = [];
+  for (const child of node.children) {
+    if (child.type === "content") {
+      contentParts.push(renderContent(child));
+    } else if (child.type === "level") {
+      childParts.push(renderNode(child, options));
+    } else {
+      const rendered = renderNode(child, options);
+      if (rendered) {
+        childParts.push(rendered);
+      }
+    }
+  }
+  if (contentParts.length > 0) {
+    const firstContent = contentParts[0] ?? "";
+    if (prefix) {
+      parts.push(`${prefix} ${firstContent}`);
+    } else {
+      parts.push(firstContent);
+    }
+    for (let i = 1; i < contentParts.length; i++) {
+      parts.push(contentParts[i] ?? "");
+    }
+  } else if (prefix) {
+    parts.push(prefix);
+  }
+  for (const child of childParts) {
+    parts.push(child);
+  }
+  return parts.join("\n\n");
+}
+function renderContent(node) {
+  const raw = renderInlineChildren(node.children);
+  return normalizeWhitespace(raw);
+}
+function renderInlineChildren(children, options) {
+  return children.map((child) => renderInline(child, options)).join("");
+}
+function normalizeWhitespace(text) {
+  return text.trim().replace(/\n\s*\n/g, "\n\n");
+}
+function renderInline(node, options) {
+  switch (node.inlineType) {
+    case "text":
+      return node.text ?? renderInlineChildren(node.children ?? [], options);
+    case "bold":
+      return `**${getInlineText(node, options)}**`;
+    case "italic":
+      return `*${getInlineText(node, options)}*`;
+    case "ref":
+      return renderRef(node, options);
+    case "date":
+      return getInlineText(node, options);
+    case "term":
+      return `**${getInlineText(node, options)}**`;
+    case "quoted":
+      return `"${node.text ?? getInlineText(node, options)}"`;
+    case "sup":
+      return `<sup>${getInlineText(node, options)}</sup>`;
+    case "sub":
+      return `<sub>${getInlineText(node, options)}</sub>`;
+    case "footnoteRef":
+      return `[^${getInlineText(node, options)}]`;
+    default:
+      return getInlineText(node, options);
+  }
+}
+function getInlineText(node, options) {
+  if (node.text) return node.text;
+  if (node.children) return renderInlineChildren(node.children, options);
+  return "";
+}
+function renderRef(node, options) {
+  const text = getInlineText(node, options);
+  const href = node.href;
+  if (!href) {
+    return text;
+  }
+  const style = options?.linkStyle ?? "plaintext";
+  if (style === "plaintext") {
+    return text;
+  }
+  if (style === "relative" && options?.resolveLink) {
+    const resolved = options.resolveLink(href);
+    if (resolved) {
+      return `[${text}](${resolved})`;
+    }
+  }
+  if (href.startsWith("/us/usc/")) {
+    const olrcUrl = buildOlrcUrl(href);
+    return `[${text}](${olrcUrl})`;
+  }
+  return text;
+}
+function buildOlrcUrl(identifier) {
+  const match = /^\/us\/usc\/t(\d+)(?:\/s(.+?))?(?:\/|$)/.exec(identifier);
+  if (match) {
+    const titleNum = match[1];
+    const sectionNum = match[2];
+    if (sectionNum) {
+      return `https://uscode.house.gov/view.xhtml?req=granuleid:USC-prelim-title${titleNum}-section${sectionNum}`;
+    }
+    return `https://uscode.house.gov/view.xhtml?req=granuleid:USC-prelim-title${titleNum}`;
+  }
+  return `https://uscode.house.gov/view.xhtml?req=${encodeURIComponent(identifier)}`;
+}
+function renderTable(node) {
+  const allRows = [...node.headers, ...node.rows];
+  if (allRows.length === 0) return "";
+  let colCount = 0;
+  for (const row of allRows) {
+    if (row.length > colCount) colCount = row.length;
+  }
+  if (colCount === 0) return "";
+  const lines = [];
+  let headerRow;
+  for (let i = node.headers.length - 1; i >= 0; i--) {
+    const row = node.headers[i];
+    if (row && row.length === colCount) {
+      headerRow = row;
+      break;
+    }
+  }
+  if (!headerRow) {
+    headerRow = Array.from({ length: colCount }, () => "");
+  }
+  lines.push(`| ${headerRow.map((cell) => cell.replace(/\|/g, "\\|")).join(" | ")} |`);
+  lines.push(`| ${Array.from({ length: colCount }, () => "---").join(" | ")} |`);
+  for (const row of node.rows) {
+    const paddedRow = Array.from({ length: colCount }, (_, i) => row[i] ?? "");
+    lines.push(`| ${paddedRow.map((cell) => cell.replace(/\|/g, "\\|")).join(" | ")} |`);
+  }
+  return lines.join("\n");
+}
+function renderSourceCredit(node, options) {
+  const text = renderInlineChildren(node.children, options);
+  return `---
+
+**Source Credit**: ${text}`;
+}
+function renderNotesContainer(node, options) {
+  const filter = options.notesFilter;
+  if (!filter) {
+    const parts2 = [];
+    for (const child of node.children) {
+      const rendered = renderNode(child, options);
+      if (rendered) {
+        parts2.push(rendered);
+      }
+    }
+    return parts2.join("\n\n");
+  }
+  const parts = [];
+  let currentCategory = "unknown";
+  for (const child of node.children) {
+    if (child.type !== "note") {
+      const rendered = renderNode(child, options);
+      if (rendered) parts.push(rendered);
+      continue;
+    }
+    if (child.role === "crossHeading") {
+      if (child.topic === "editorialNotes") {
+        currentCategory = "editorial";
+      } else if (child.topic === "statutoryNotes") {
+        currentCategory = "statutory";
+      }
+      if (shouldIncludeCategory(currentCategory, filter)) {
+        const rendered = renderNode(child, options);
+        if (rendered) parts.push(rendered);
+      }
+      continue;
+    }
+    if (shouldIncludeNote(child, currentCategory, filter)) {
+      const rendered = renderNode(child, options);
+      if (rendered) parts.push(rendered);
+    }
+  }
+  return parts.join("\n\n");
+}
+var AMENDMENT_TOPICS = /* @__PURE__ */ new Set([
+  "amendments",
+  "effectiveDateOfAmendment",
+  "shortTitleOfAmendment"
+]);
+var EDITORIAL_TOPICS = /* @__PURE__ */ new Set(["codification", "dispositionOfSections"]);
+var STATUTORY_TOPICS = /* @__PURE__ */ new Set([
+  "changeOfName",
+  "regulations",
+  "miscellaneous",
+  "repeals",
+  "separability",
+  "crossReferences"
+]);
+function shouldIncludeCategory(category, filter) {
+  if (category === "editorial") return filter.editorial || filter.amendments;
+  if (category === "statutory") return filter.statutory || filter.amendments;
+  return filter.editorial || filter.statutory || filter.amendments;
+}
+function shouldIncludeNote(node, currentCategory, filter) {
+  const topic = node.topic ?? "";
+  if (AMENDMENT_TOPICS.has(topic)) return filter.amendments;
+  if (EDITORIAL_TOPICS.has(topic)) return filter.editorial;
+  if (STATUTORY_TOPICS.has(topic)) return filter.statutory;
+  if (currentCategory === "editorial") return filter.editorial;
+  if (currentCategory === "statutory") return filter.statutory;
+  return filter.editorial || filter.statutory || filter.amendments;
+}
+function renderNote(node, options) {
+  const parts = [];
+  if (node.role === "crossHeading" && node.heading) {
+    parts.push(`## ${node.heading}`);
+    return parts.join("\n\n");
+  }
+  if (node.heading) {
+    parts.push(`### ${node.heading}`);
+  }
+  for (const child of node.children) {
+    const rendered = renderNode(child, options);
+    if (rendered) {
+      parts.push(rendered);
+    }
+  }
+  return parts.join("\n\n");
+}
+function renderQuotedContent(node, options) {
+  const parts = [];
+  for (const child of node.children) {
+    const rendered = renderNode(child, options);
+    if (rendered) {
+      parts.push(rendered);
+    }
+  }
+  const inner = parts.join("\n\n");
+  return inner.split("\n").map((line) => `> ${line}`).join("\n");
+}
+
+// src/markdown/links.ts
+import { relative, dirname as dirname2 } from "path";
+function parseIdentifier(identifier) {
+  const match = /^\/(\w+)\/(\w+)\/t(\w+)(?:\/s([^/]+)(?:\/(.+))?)?$/.exec(identifier);
+  if (!match) return null;
+  return {
+    jurisdiction: match[1] ?? "",
+    code: match[2] ?? "",
+    titleNum: match[3],
+    sectionNum: match[4],
+    subPath: match[5]
+  };
+}
+function createLinkResolver() {
+  const registry = /* @__PURE__ */ new Map();
+  return {
+    register(identifier, filePath) {
+      registry.set(identifier, filePath);
+    },
+    resolve(identifier, fromFile) {
+      const targetPath = registry.get(identifier);
+      if (!targetPath) {
+        const parsed = parseIdentifier(identifier);
+        if (parsed?.sectionNum && parsed.titleNum) {
+          const sectionId = `/us/usc/t${parsed.titleNum}/s${parsed.sectionNum}`;
+          const sectionPath = registry.get(sectionId);
+          if (sectionPath) {
+            return relative(dirname2(fromFile), sectionPath);
+          }
+        }
+        return null;
+      }
+      return relative(dirname2(fromFile), targetPath);
+    },
+    fallbackUrl(identifier) {
+      const parsed = parseIdentifier(identifier);
+      if (!parsed || parsed.code !== "usc") return null;
+      if (parsed.sectionNum) {
+        return `https://uscode.house.gov/view.xhtml?req=granuleid:USC-prelim-title${parsed.titleNum}-section${parsed.sectionNum}`;
+      }
+      if (parsed.titleNum) {
+        return `https://uscode.house.gov/view.xhtml?req=granuleid:USC-prelim-title${parsed.titleNum}`;
+      }
+      return null;
+    }
+  };
+}
+export {
+  APPENDIX_LEVEL_ELEMENTS,
+  ASTBuilder,
+  BIG_LEVELS,
+  CONTAINER_ELEMENTS,
+  CONTENT_ELEMENTS,
+  DCTERMS_NS,
+  DC_NS,
+  FORMAT_VERSION,
+  GENERATOR,
+  INLINE_ELEMENTS,
+  LEVEL_ELEMENTS,
+  LEVEL_TYPES,
+  META_ELEMENTS,
+  NAMESPACE_PREFIXES,
+  NOTE_ELEMENTS,
+  SMALL_LEVELS,
+  USLM_NS,
+  XHTML_NS,
+  XMLParser,
+  XSI_NS,
+  createLinkResolver,
+  generateFrontmatter,
+  parseIdentifier,
+  renderDocument,
+  renderNode,
+  renderSection
+};
+//# sourceMappingURL=index.js.map