@openuji/speculator 0.3.0 → 0.3.2

package/dist/chunk-ONLMOJIJ.js

@@ -0,0 +1,1649 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/utils/file-loader/node.ts
+var nodeFileLoader = async (path) => {
+  const fs = await import("fs/promises");
+  const { fileURLToPath } = await import("url");
+  const urlPath = fileURLToPath(path);
+  try {
+    return await fs.readFile(urlPath, "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to load file: ${path}. ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+};
+
+// src/utils/file-loader/browser.ts
+var browserFileLoader = async (path) => {
+  try {
+    const response = await fetch(path);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    return await response.text();
+  } catch (error) {
+    throw new Error(`Failed to fetch file: ${path}. ${error instanceof Error ? error.message : "Network error"}`);
+  }
+};
+
+// src/utils/file-loader/index.ts
+function createFallbackFileLoader(loaders) {
+  return async (path) => {
+    let lastError;
+    for (const loader of loaders) {
+      try {
+        return await loader(path);
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        continue;
+      }
+    }
+    throw lastError || new Error(`All file loaders failed for: ${path}`);
+  };
+}
+function getDefaultFileLoader() {
+  if (typeof window !== "undefined" && typeof fetch !== "undefined") {
+    return browserFileLoader;
+  } else if (typeof process !== "undefined" && process.versions?.node) {
+    return nodeFileLoader;
+  } else {
+    throw new Error("Unable to detect environment for file loading. Please provide a custom fileLoader.");
+  }
+}
+
+// src/types.ts
+var SpeculatorError = class extends Error {
+  constructor(message, element, path) {
+    super(message);
+    this.element = element;
+    this.path = path;
+    this.name = "SpeculatorError";
+  }
+};
+function fromRespecConfig(respec) {
+  return { ...respec };
+}
+
+// src/utils/stats-tracker.ts
+var StatsTracker = class {
+  constructor() {
+    this._stats = {
+      elementsProcessed: 0,
+      filesIncluded: 0,
+      markdownBlocks: 0,
+      processingTime: 0
+    };
+    this.startTime = null;
+  }
+  start() {
+    this.startTime = performance.now();
+  }
+  stop() {
+    if (this.startTime !== null) {
+      this._stats.processingTime += performance.now() - this.startTime;
+      this.startTime = null;
+    }
+  }
+  incrementElements(count = 1) {
+    this._stats.elementsProcessed += count;
+  }
+  incrementFiles(count = 1) {
+    this._stats.filesIncluded += count;
+  }
+  incrementMarkdownBlocks(count = 1) {
+    this._stats.markdownBlocks += count;
+  }
+  toJSON() {
+    return { ...this._stats };
+  }
+};
+
+// src/utils/logger.ts
+var logger = {
+  debug: (...args) => {
+    if (process.env.NODE_ENV !== "production") {
+      console.debug(...args);
+    }
+  }
+};
+
+// src/processors/include-processor.ts
+var IncludeProcessor = class {
+  constructor(baseUrl, fileLoader, formatRegistry) {
+    this.baseUrl = baseUrl;
+    this.fileLoader = fileLoader;
+    this.formatRegistry = formatRegistry;
+  }
+  matches(element) {
+    return element.hasAttribute("data-include");
+  }
+  async process(element, tracker, warnings) {
+    const includePath = element.getAttribute("data-include");
+    const includeFormat = element.getAttribute("data-include-format") || "text";
+    if (!includePath) {
+      warnings.push("data-include attribute is empty");
+      element.removeAttribute("data-include");
+      element.removeAttribute("data-include-format");
+      return { content: null };
+    }
+    try {
+      const fullPath = this.resolveFilePath(includePath);
+      const content = await this.fileLoader(fullPath);
+      const processedContent = this.formatRegistry.processContent(content, includeFormat);
+      tracker.incrementFiles();
+      if (includeFormat === "markdown") {
+        tracker.incrementMarkdownBlocks();
+      }
+      element.removeAttribute("data-include");
+      element.removeAttribute("data-include-format");
+      return { content: processedContent };
+    } catch (error) {
+      const errorMsg = `Failed to load: ${includePath}`;
+      element.removeAttribute("data-include");
+      element.removeAttribute("data-include-format");
+      return { content: null, error: errorMsg };
+    }
+  }
+  resolveFilePath(path) {
+    const filePath = new URL(path, this.baseUrl || "file:///").toString();
+    logger.debug(`Resolved file path: ${filePath}`);
+    return filePath;
+  }
+};
+
+// src/markdown/index.ts
+import MarkdownIt from "markdown-it";
+
+// src/markdown/plugins/concept.ts
+function respecConceptPlugin(md) {
+  const NAME = "respec-concept";
+  function tokenize(state, silent) {
+    const pos = state.pos;
+    const src = state.src;
+    if (src.charCodeAt(pos) !== 91 || src.charCodeAt(pos + 1) !== 61) return false;
+    const end = src.indexOf("=]", pos + 2);
+    if (end < 0) return false;
+    if (!silent) {
+      const content = src.slice(pos + 2, end).trim();
+      const tokenOpen = state.push("respec_concept_open", "a", 1);
+      tokenOpen.attrSet("data-xref", content);
+      const text = state.push("text", "", 0);
+      text.content = content;
+      state.push("respec_concept_close", "a", -1);
+    }
+    state.pos = end + 2;
+    return true;
+  }
+  md.inline.ruler.before("link", NAME, tokenize);
+  md.renderer.rules.respec_concept_open = (tokens, idx) => `<a data-xref="${md.utils.escapeHtml(tokens[idx].attrGet("data-xref") || "")}">`;
+  md.renderer.rules.respec_concept_close = () => `</a>`;
+}
+
+// src/markdown/plugins/idl.ts
+function respecIdlPlugin(md) {
+  const NAME = "respec-idl";
+  function tokenize(state, silent) {
+    const pos = state.pos;
+    const src = state.src;
+    if (src.charCodeAt(pos) !== 123 || src.charCodeAt(pos + 1) !== 123) return false;
+    const end = src.indexOf("}}", pos + 2);
+    if (end < 0) return false;
+    if (!silent) {
+      const content = src.slice(pos + 2, end).trim();
+      const open = state.push("link_open", "a", 1);
+      open.attrSet("data-idl", content);
+      const text = state.push("text", "", 0);
+      text.content = content;
+      state.push("link_close", "a", -1);
+    }
+    state.pos = end + 2;
+    return true;
+  }
+  md.inline.ruler.before("emphasis", NAME, tokenize);
+}
+
+// src/markdown/plugins/cite.ts
+function respecCitePlugin(md) {
+  const NAME = "respec-cite";
+  function tokenize(state, silent) {
+    const pos = state.pos;
+    const src = state.src;
+    if (src.charCodeAt(pos) !== 91 || src.charCodeAt(pos + 1) !== 91) return false;
+    const end = src.indexOf("]]", pos + 2);
+    if (end < 0) return false;
+    if (!silent) {
+      const raw = src.slice(pos + 2, end).trim();
+      const normative = raw.startsWith("!");
+      const id = normative ? raw.slice(1) : raw;
+      const env = state.env;
+      const col = env.__citations || (env.__citations = []);
+      col.push({ id, normative });
+      const open = state.push("link_open", "a", 1);
+      open.attrSet("data-spec", id);
+      open.attrSet("data-normative", String(normative));
+      const text = state.push("text", "", 0);
+      text.content = `[${id}]`;
+      state.push("link_close", "a", -1);
+    }
+    state.pos = end + 2;
+    return true;
+  }
+  md.inline.ruler.before("link", NAME, tokenize);
+}
+
+// src/markdown/plugins/mermaid.ts
+function ensureDom() {
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    return;
+  }
+  if (typeof __require !== "function") {
+    return;
+  }
+  const { DOMParser: DOMParser2 } = __require("linkedom");
+  const { document: doc } = new DOMParser2().parseFromString("<html></html>", "text/html");
+  globalThis.window = doc.defaultView;
+  globalThis.document = doc;
+}
+function getMermaidAPI() {
+  const globalMermaid = globalThis.mermaid;
+  if (globalMermaid?.mermaidAPI) {
+    return globalMermaid.mermaidAPI;
+  }
+  if (globalThis.mermaidAPI) {
+    return globalThis.mermaidAPI;
+  }
+  if (typeof __require === "function") {
+    try {
+      return __require("mermaid").mermaidAPI;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function respecMermaidPlugin(md, config = {}) {
+  const defaultFence = md.renderer.rules.fence ?? ((tokens, idx) => `<pre><code>${md.utils.escapeHtml(tokens[idx].content)}</code></pre>
+`);
+  md.renderer.rules.fence = (tokens, idx, options, env, self) => {
+    const token = tokens[idx];
+    if (token.info.trim() !== "mermaid") {
+      return defaultFence(tokens, idx, options, env, self);
+    }
+    const mermaidAPI = getMermaidAPI();
+    if (!mermaidAPI) {
+      const code = md.utils.escapeHtml(token.content);
+      return `<pre><code>${code}</code></pre>
+`;
+    }
+    try {
+      ensureDom();
+      mermaidAPI.initialize(config);
+      const id = `mermaid-${idx}`;
+      const svg = mermaidAPI.render(id, token.content);
+      return `<div class="mermaid">${svg}</div>`;
+    } catch {
+      const code = md.utils.escapeHtml(token.content);
+      return `<pre><code>${code}</code></pre>
+`;
+    }
+  };
+}
+
+// src/utils/render.ts
+function insertContent(element, content) {
+  element.innerHTML = content;
+}
+function renderError(message) {
+  return `<p class="error">${message}</p>`;
+}
+
+// src/markdown/index.ts
+function createMarkdownRenderer(options = {}) {
+  const md = new MarkdownIt({
+    html: false,
+    linkify: options.gfm ?? true,
+    breaks: options.breaks ?? true,
+    typographer: options.smartypants ?? true,
+    xhtmlOut: false
+  });
+  const headerIds = options.headerIds ?? true;
+  md.renderer.rules.heading_open = (tokens, idx, _opts, env, self) => {
+    void env;
+    const open = tokens[idx];
+    const inline = tokens[idx + 1];
+    const close = tokens[idx + 2];
+    if (open.tag === "h1") {
+      open.tag = "h2";
+      if (close && close.type === "heading_close") close.tag = "h2";
+    }
+    if (headerIds && inline && inline.type === "inline") {
+      const id = slugify(inline.content);
+      open.attrSet("id", id);
+    }
+    return self.renderToken(tokens, idx, _opts);
+  };
+  md.renderer.rules.fence = (tokens, idx) => {
+    const token = tokens[idx];
+    const info = (token.info || "").trim();
+    const lang = info ? info.split(/\s+/)[0] : "";
+    const classAttr = lang ? ` class="${md.utils.escapeHtml(lang)}"` : "";
+    const code = md.utils.escapeHtml(token.content);
+    return `<pre${classAttr}><code>${code}</code></pre>
+`;
+  };
+  md.use(respecConceptPlugin);
+  md.use(respecIdlPlugin);
+  md.use(respecCitePlugin);
+  if (options.mermaid) {
+    const config = options.mermaid === true ? {} : options.mermaid;
+    md.use(respecMermaidPlugin, config);
+  }
+  for (const extension of options.extensions ?? []) {
+    if (Array.isArray(extension)) {
+      const [plugin, pluginOptions] = extension;
+      md.use(plugin, pluginOptions);
+    } else {
+      md.use(extension);
+    }
+  }
+  return md;
+}
+function parseMarkdown(markdown, options = {}, env) {
+  try {
+    const md = createMarkdownRenderer(options);
+    return md.render(markdown, env);
+  } catch (error) {
+    console.error("Markdown parsing error:", error);
+    return renderError(
+      `Error parsing markdown: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+function slugify(content) {
+  return content.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-");
+}
+
+// src/format-registry.ts
+var MarkdownStrategy = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  convert(content) {
+    return parseMarkdown(content, this.options);
+  }
+};
+var PassthroughStrategy = class {
+  convert(content) {
+    return content;
+  }
+};
+var FormatRegistry = class {
+  constructor(markdownOptions = {}, customStrategies = {}) {
+    const markdown = new MarkdownStrategy(markdownOptions);
+    const passthrough = new PassthroughStrategy();
+    this.strategies = /* @__PURE__ */ new Map([
+      ["markdown", markdown],
+      ["text", passthrough],
+      ["html", passthrough]
+    ]);
+    for (const [format, strategy] of Object.entries(customStrategies)) {
+      this.strategies.set(format, strategy);
+    }
+  }
+  /**
+   * Register a new strategy for a given format.
+   */
+  register(format, strategy) {
+    this.strategies.set(format, strategy);
+  }
+  /**
+   * Convert content based on the specified format.
+   */
+  processContent(content, format) {
+    const strategy = this.strategies.get(format);
+    if (!strategy) {
+      throw new Error(`Unsupported format: ${format}`);
+    }
+    return strategy.convert(content);
+  }
+};
+
+// src/utils/strip-ident.ts
+function stripIndent(content) {
+  const lines = content.replace(/\r\n?/g, "\n").split("\n");
+  const indents = lines.filter((line) => line.trim().length > 0).map((line) => line.match(/^\s*/)?.[0].length || 0);
+  const minIndent = indents.length > 0 ? Math.min(...indents) : 0;
+  return lines.map((line) => line.slice(minIndent)).join("\n");
+}
+
+// src/processors/format-processor.ts
+var FormatProcessor = class {
+  constructor(registry = new FormatRegistry()) {
+    this.registry = registry;
+  }
+  matches(element) {
+    return element.hasAttribute("data-format");
+  }
+  process(element, tracker, _warnings) {
+    const format = element.getAttribute("data-format");
+    let result = {};
+    if (format === "markdown" && element.innerHTML.trim()) {
+      try {
+        const markdownContent = stripIndent(element.innerHTML).trim();
+        result.content = this.registry.processContent(markdownContent, format);
+        tracker.incrementMarkdownBlocks();
+      } catch (error) {
+        result.error = `Failed to process markdown: ${error instanceof Error ? error.message : "Unknown error"}`;
+      }
+    } else {
+      try {
+        result.content = this.registry.processContent(element.innerHTML, format);
+      } catch (error) {
+        result.error = error instanceof Error ? error.message : String(error);
+      }
+    }
+    element.removeAttribute("data-format");
+    return result;
+  }
+};
+
+// src/html-renderer.ts
+var DOMHtmlRenderer = class {
+  parse(html) {
+    if (typeof DOMParser === "undefined") {
+      throw new SpeculatorError("DOMParser not available. This method requires a browser environment or jsdom.");
+    }
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(`<div>${html}</div>`, "text/html");
+    return doc.body.firstElementChild;
+  }
+  serialize(element) {
+    return element.innerHTML;
+  }
+};
+
+// src/utils/output-areas.ts
+var CONFIG_TO_OUTPUT_MAP = [
+  {
+    fields: ["sections"],
+    outputs: ["idl", "xref", "references", "boilerplate", "toc", "diagnostics", "assertions"]
+  },
+  {
+    fields: ["header", "sotd", "pubrules", "legal"],
+    outputs: ["boilerplate"]
+  },
+  {
+    fields: ["lint"],
+    outputs: ["diagnostics"]
+  },
+  {
+    fields: ["xref", "mdn"],
+    outputs: ["xref"]
+  }
+];
+function fieldChanged(oldVal, newVal) {
+  if (Array.isArray(oldVal) && Array.isArray(newVal)) {
+    if (oldVal === newVal) return false;
+    if (oldVal.length !== newVal.length) return true;
+    for (let i = 0; i < oldVal.length; i++) {
+      if (oldVal[i] !== newVal[i]) return true;
+    }
+    return false;
+  }
+  return oldVal !== newVal;
+}
+function getChangedOutputAreas(oldConfig, newConfig) {
+  if (!oldConfig) {
+    const all = /* @__PURE__ */ new Set();
+    for (const mapping of CONFIG_TO_OUTPUT_MAP) {
+      for (const out of mapping.outputs) all.add(out);
+    }
+    return Array.from(all);
+  }
+  const areas = /* @__PURE__ */ new Set();
+  for (const { fields, outputs } of CONFIG_TO_OUTPUT_MAP) {
+    if (fields.some((f) => fieldChanged(oldConfig[f], newConfig[f]))) {
+      outputs.forEach((o) => areas.add(o));
+    }
+  }
+  return Array.from(areas);
+}
+
+// src/renderers/sections-renderer.ts
+var SectionsRenderer = class {
+  constructor(speculator) {
+    this.speculator = speculator;
+  }
+  async render(sections = [], tracker = new StatsTracker()) {
+    const warnings = [];
+    const processed = [];
+    for (const section of sections) {
+      try {
+        if (section.hasAttribute("data-include") || section.hasAttribute("data-format") || section.querySelector("[data-include],[data-format]")) {
+          const res = await this.speculator.processElement(section, tracker);
+          processed.push(res.element);
+          warnings.push(...res.warnings);
+        } else {
+          processed.push(section);
+        }
+      } catch (e) {
+        warnings.push(
+          `Failed to process element: ${e instanceof Error ? e.message : "Unknown error"}`
+        );
+        processed.push(section);
+      }
+    }
+    return { sections: processed, warnings, stats: tracker.toJSON() };
+  }
+};
+
+// src/renderers/header-renderer.ts
+var HeaderRenderer = class {
+  render(header) {
+    const result = {};
+    if (header) result.header = header;
+    return result;
+  }
+};
+
+// src/renderers/sotd-renderer.ts
+var SotdRenderer = class {
+  render(sotd) {
+    const result = {};
+    if (sotd) result.sotd = sotd;
+    return result;
+  }
+};
+
+// src/document-builder.ts
+var DocumentBuilder = class {
+  constructor(speculator, htmlRenderer) {
+    this.htmlRenderer = htmlRenderer;
+    this.headerRenderer = new HeaderRenderer();
+    this.sotdRenderer = new SotdRenderer();
+    this.sectionsRenderer = new SectionsRenderer(speculator);
+  }
+  async build(config) {
+    const tracker = new StatsTracker();
+    const sections = config.sections || [];
+    const header = config.header;
+    const sotd = config.sotd;
+    const baseDoc = (header || sotd || sections[0])?.ownerDocument;
+    const preContainer = baseDoc ? baseDoc.createElement("div") : this.htmlRenderer.parse("");
+    if (header) preContainer.appendChild(header);
+    if (sotd) preContainer.appendChild(sotd);
+    for (const section of sections) preContainer.appendChild(section);
+    const hooks = config.preProcess;
+    if (hooks) {
+      for (const hook of hooks) {
+        await hook(preContainer);
+      }
+    }
+    const children = Array.from(preContainer.children);
+    const updatedSections = [];
+    for (const child of children) {
+      if (child === header || child === sotd) continue;
+      updatedSections.push(child);
+    }
+    const { sections: processedSections, warnings, stats } = await this.sectionsRenderer.render(updatedSections, tracker);
+    const { header: renderedHeader } = this.headerRenderer.render(
+      header?.cloneNode(true)
+    );
+    const { sotd: renderedSotd } = this.sotdRenderer.render(
+      sotd?.cloneNode(true)
+    );
+    const finalBaseDoc = (renderedHeader || renderedSotd || processedSections[0])?.ownerDocument;
+    const container = finalBaseDoc ? finalBaseDoc.createElement("div") : this.htmlRenderer.parse("");
+    if (renderedHeader) container.appendChild(renderedHeader);
+    if (renderedSotd) container.appendChild(renderedSotd);
+    for (const section of processedSections) container.appendChild(section);
+    const result = { container, stats, warnings };
+    if (renderedHeader) result.header = renderedHeader;
+    if (renderedSotd) result.sotd = renderedSotd;
+    return result;
+  }
+};
+
+// src/pipeline/postprocess.ts
+var Postprocessor = class {
+  constructor(passes) {
+    this.passes = passes;
+  }
+  /**
+   * Run the configured passes.
+   * @param areas Optional list of output areas to run. If omitted, all passes
+   *              are executed.
+   * @param options Configuration options for the passes.
+   */
+  async run(config, areas) {
+    const ctx = { outputs: {}, warnings: [], config };
+    const active = areas ? this.passes.filter((p) => areas.includes(p.area)) : this.passes;
+    const composed = compose(active);
+    await composed(ctx);
+    return { outputs: ctx.outputs, warnings: ctx.warnings };
+  }
+};
+function compose(passes) {
+  return function run(ctx) {
+    let index = -1;
+    async function dispatch(i) {
+      if (i <= index) return;
+      index = i;
+      const pass = passes[i];
+      if (!pass) return;
+      await pass.run(ctx, () => dispatch(i + 1));
+    }
+    return dispatch(0);
+  };
+}
+
+// src/pipeline/pipeline-runner.ts
+var PipelineRunner = class {
+  constructor(passFactory) {
+    this.passFactory = passFactory;
+  }
+  run(container, config, areas) {
+    const passes = this.passFactory(container);
+    const processor = new Postprocessor(passes);
+    return processor.run(config, areas);
+  }
+};
+
+// src/pipeline/passes/idl.ts
+import * as WebIDL2 from "webidl2";
+function norm(s) {
+  return s.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function slug(s) {
+  return s.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function uniqueId(doc, base) {
+  let id = base;
+  let i = 2;
+  while (doc.getElementById(id)) {
+    id = `${base}-${i++}`;
+  }
+  return id;
+}
+function collectTargetsFromAst(ast) {
+  const defs = [];
+  const addTop = (name) => {
+    const key = norm(name);
+    defs.push({ id: `idl-${slug(name)}`, key, text: name });
+  };
+  const addMember = (ifc, mem) => {
+    const key = `${norm(ifc)}.${norm(mem)}`;
+    defs.push({ id: `idl-${slug(ifc)}-${slug(mem)}`, key, text: `${ifc}.${mem}` });
+  };
+  for (const d of ast) {
+    switch (d.type) {
+      case "interface":
+      case "interface mixin":
+      case "namespace":
+      case "dictionary":
+      case "callback interface":
+      case "callback":
+      case "typedef":
+      case "enum": {
+        if (!("name" in d) || !d.name) break;
+        addTop(d.name);
+        if ("members" in d && Array.isArray(d.members)) {
+          for (const m of d.members) {
+            if (m.type === "attribute" && m.name) addMember(d.name, m.name);
+            else if (m.type === "operation" && m.name) addMember(d.name, m.name);
+            else if (m.type === "const" && m.name) addMember(d.name, m.name);
+            else if (m.type === "field" && m.name) addMember(d.name, m.name);
+          }
+        }
+        break;
+      }
+    }
+  }
+  return { defs };
+}
+function insertAnchorsBefore(pre, targets) {
+  if (!targets.length) return;
+  const doc = pre.ownerDocument;
+  const wrapper = doc.createElement("div");
+  wrapper.className = "idl-anchors";
+  wrapper.hidden = true;
+  for (const t of targets) {
+    const a = doc.createElement("a");
+    a.id = uniqueId(doc, t.id);
+    a.textContent = t.text;
+    wrapper.appendChild(a);
+  }
+  pre.parentNode?.insertBefore(wrapper, pre);
+}
+function parseIdlToTargets(idl) {
+  const ast = WebIDL2.parse(idl);
+  return collectTargetsFromAst(ast).defs;
+}
+function findIdlBlocks(root) {
+  const blocks = [];
+  const pres = root.querySelectorAll("pre");
+  pres.forEach((pre) => {
+    const cls = (pre.getAttribute("class") || "").toLowerCase();
+    const looksIdlClass = /\b(idl|language-idl)\b/.test(cls);
+    const code = pre.querySelector("code");
+    const text = (code ? code.textContent : pre.textContent) || "";
+    const maybeIdl = looksIdlClass || /^\s*(interface|dictionary|enum|namespace|callback|typedef)\b/.test(text);
+    if (maybeIdl && text.trim()) blocks.push(pre);
+  });
+  return blocks;
+}
+function buildIdlIndex(root, warnings) {
+  const map = /* @__PURE__ */ new Map();
+  const blocks = findIdlBlocks(root);
+  for (const pre of blocks) {
+    const code = pre.querySelector("code");
+    const idl = (code ? code.textContent : pre.textContent) || "";
+    try {
+      const targets = parseIdlToTargets(idl);
+      insertAnchorsBefore(pre, targets);
+      for (const t of targets) {
+        const href = `#${t.id}`;
+        if (!map.has(t.key)) map.set(t.key, href);
+      }
+    } catch (e) {
+      const msg = e && e.message ? e.message : String(e);
+      warnings.push(`IDL parse error: ${msg}`);
+    }
+  }
+  return map;
+}
+function resolveIdlLinks(root, index, warnings, suppressClass) {
+  const anchors = root.querySelectorAll("a[data-idl]");
+  Array.from(anchors).forEach((a) => {
+    if (a.closest(`.${suppressClass}`)) return;
+    const raw = a.getAttribute("data-idl") || "";
+    const term = raw.trim();
+    const hasMember = term.includes(".");
+    let key = "";
+    if (hasMember) {
+      const [iface, member] = term.split(".", 2);
+      key = `${norm(iface)}.${norm(member)}`;
+    } else {
+      key = norm(term);
+    }
+    const href = index.get(key);
+    if (href) {
+      a.setAttribute("href", href);
+    } else {
+      warnings.push(`Unresolved IDL link: "${term}"`);
+    }
+  });
+}
+var IdlPass = class {
+  constructor(root) {
+    this.root = root;
+    this.area = "idl";
+  }
+  async execute(_data, config) {
+    const warnings = [];
+    const suppressClass = config.postprocess?.diagnostics?.suppressClass ?? "no-link-warnings";
+    const index = buildIdlIndex(this.root, warnings);
+    resolveIdlLinks(this.root, index, warnings, suppressClass);
+    return { warnings };
+  }
+  async run(ctx, next) {
+    const current = ctx.outputs[this.area];
+    const { warnings } = await this.execute(current, ctx.config);
+    if (warnings && warnings.length) ctx.warnings.push(...warnings);
+    await next();
+  }
+};
+
+// src/xref/local-map.ts
+function uniqueId2(doc, base) {
+  let id = base;
+  let i = 2;
+  while (doc.getElementById(id)) id = `${base}-${i++}`;
+  return id;
+}
+function norm2(term) {
+  return term.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function slugify2(text) {
+  return text.trim().toLowerCase().replace(/[^\w]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function buildLocalMap(root) {
+  const map = /* @__PURE__ */ new Map();
+  const doc = root.ownerDocument;
+  const dfns = root.querySelectorAll("dfn");
+  dfns.forEach((dfn) => {
+    const text = (dfn.getAttribute("data-lt") || dfn.textContent || "").trim();
+    if (!text) return;
+    if (!dfn.id) {
+      const first = (text.split(/[|,]/)[0] || dfn.textContent || "").trim();
+      dfn.id = slugify2(first);
+    }
+    const href = `#${dfn.id}`;
+    const variants = text.split(/[|,]/).map((s) => s.trim()).filter(Boolean);
+    for (const v of variants) {
+      const key = norm2(v);
+      if (!map.has(key)) {
+        map.set(key, { href, text: v, source: "dfn" });
+      }
+    }
+  });
+  const headings = root.querySelectorAll("h2, h3, h4, h5, h6");
+  headings.forEach((h) => {
+    const label = (h.textContent || "").trim();
+    if (!label) return;
+    const parentSection = h.closest("section[id]");
+    let targetId = null;
+    if (parentSection) {
+      targetId = parentSection.id;
+    } else if (h.id) {
+      targetId = h.id;
+    } else {
+      const slug2 = slugify2(label);
+      const uid = uniqueId2(doc, slug2);
+      h.id = uid;
+      targetId = uid;
+    }
+    if (!targetId) return;
+    const key = norm2(label);
+    if (!map.has(key)) {
+      map.set(key, { href: `#${targetId}`, text: label, source: "heading" });
+    }
+  });
+  return map;
+}
+
+// src/xref/resolve.ts
+async function resolveQueries(resolverConfigs, unresolved) {
+  const warnings = [];
+  for (const cfg of resolverConfigs) {
+    const queries = [];
+    const idMap = /* @__PURE__ */ new Map();
+    for (const [key, entry] of unresolved.entries()) {
+      let specs;
+      if (entry.specsOverride) {
+        const allowed = cfg.specs ? entry.specsOverride.filter((s) => cfg.specs.includes(s)) : entry.specsOverride;
+        specs = allowed;
+      } else {
+        specs = cfg.specs;
+      }
+      if (specs && specs.length === 0) continue;
+      const id = `${key}|${queries.length}`;
+      const q = { id, term: entry.term };
+      if (specs && specs.length) q.specs = specs;
+      queries.push(q);
+      idMap.set(id, entry);
+    }
+    if (!queries.length) continue;
+    try {
+      const resMap = await cfg.resolver.resolveBatch(queries);
+      for (const [id, hits] of resMap.entries()) {
+        const entry = idMap.get(id);
+        if (entry) entry.results.push(...hits);
+      }
+    } catch (err) {
+      warnings.push(
+        `Xref resolver failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return { unresolved, warnings };
+}
+
+// src/pipeline/passes/xref.ts
+function isSuppressed(node, suppressClass) {
+  return !!node.closest(`.${suppressClass}`);
+}
+function getCiteSpecs(node) {
+  let el = node;
+  while (el) {
+    const cite = el.getAttribute("data-cite");
+    if (cite) {
+      return cite.split(/[\s,]+/).map((s) => s.trim()).filter(Boolean);
+    }
+    el = el.parentElement;
+  }
+  return void 0;
+}
+var XrefPass = class {
+  constructor(root) {
+    this.root = root;
+    this.area = "xref";
+  }
+  async execute(_data, config) {
+    const suppressClass = config.postprocess?.diagnostics?.suppressClass ?? "no-link-warnings";
+    const localMap = buildLocalMap(this.root);
+    const xrefAnchors = Array.from(this.root.querySelectorAll("a[data-xref]"));
+    const resolverConfigs = Array.isArray(config.postprocess?.xref) ? config.postprocess.xref : config.postprocess?.xref ? [config.postprocess.xref] : [];
+    const unresolved = collectUnresolvedAnchors(xrefAnchors, localMap, suppressClass);
+    const { unresolved: resolvedEntries, warnings: resolveWarnings } = await resolveQueries(
+      resolverConfigs,
+      unresolved
+    );
+    const defaultPriority = resolverConfigs.flatMap((cfg) => cfg.specs || []);
+    const applyWarnings = applyXrefResults(resolvedEntries, defaultPriority);
+    return { warnings: [...resolveWarnings, ...applyWarnings] };
+  }
+  async run(ctx, next) {
+    const current = ctx.outputs[this.area];
+    const { warnings } = await this.execute(current, ctx.config);
+    if (warnings && warnings.length) ctx.warnings.push(...warnings);
+    await next();
+  }
+};
+function collectUnresolvedAnchors(anchors, localMap, suppressClass) {
+  const unresolved = /* @__PURE__ */ new Map();
+  for (const a of anchors) {
+    if (isSuppressed(a, suppressClass)) continue;
+    const term = a.getAttribute("data-xref") || "";
+    const key = norm2(term);
+    const hit = localMap.get(key);
+    if (hit) {
+      a.setAttribute("href", hit.href);
+      continue;
+    }
+    const specsOverride = getCiteSpecs(a);
+    const mapKey = `${key}|${(specsOverride || []).join(",")}`;
+    let entry = unresolved.get(mapKey);
+    if (!entry) {
+      entry = { term, anchors: [], results: [] };
+      if (specsOverride) entry.specsOverride = specsOverride;
+      unresolved.set(mapKey, entry);
+    }
+    entry.anchors.push(a);
+  }
+  return unresolved;
+}
+function applyXrefResults(unresolved, defaultPriority) {
+  const warnings = [];
+  for (const entry of unresolved.values()) {
+    const hits = entry.results;
+    let chosen;
+    let ambiguous = false;
+    const preferred = entry.specsOverride && entry.specsOverride.length ? entry.specsOverride : defaultPriority;
+    if (hits.length > 0) {
+      if (preferred && preferred.length) {
+        const remaining = new Set(hits);
+        for (const spec of preferred) {
+          const matches = hits.filter((h) => h.cite === spec);
+          matches.forEach((m) => remaining.delete(m));
+          if (matches.length === 1) {
+            chosen = matches[0];
+            break;
+          }
+          if (matches.length > 1) {
+            ambiguous = true;
+            break;
+          }
+        }
+        if (!chosen && !ambiguous) {
+          const leftovers = Array.from(remaining);
+          if (leftovers.length === 1) {
+            chosen = leftovers[0];
+          } else if (leftovers.length > 1) {
+            ambiguous = true;
+          }
+        }
+      } else if (hits.length === 1) {
+        chosen = hits[0];
+      } else {
+        ambiguous = true;
+      }
+    }
+    if (chosen) {
+      for (const a of entry.anchors) {
+        a.setAttribute("href", chosen.href);
+        if (chosen.cite) a.setAttribute("data-cite", chosen.cite);
+      }
+    } else if (ambiguous) {
+      warnings.push(`Ambiguous xref: "${entry.term}"`);
+    } else {
+      warnings.push(`No matching xref: "${entry.term}"`);
+    }
+  }
+  return warnings;
+}
+
+// src/renderers/references-renderer.ts
+function formatEntry(id, e) {
+  const parts = [];
+  parts.push(`<span class="ref-id">[${id}]</span>`);
+  if (e.href) parts.push(`<a href="${e.href}">${e.title || id}</a>`);
+  else parts.push(`<span class="ref-title">${e.title || id}</span>`);
+  const meta = [];
+  if (e.publisher) meta.push(e.publisher);
+  if (e.status) meta.push(e.status);
+  if (e.date) meta.push(e.date);
+  if (meta.length) parts.push(`<span class="ref-meta"> \u2014 ${meta.join(", ")}</span>`);
+  return parts.join(" ");
+}
+function idForRef(id) {
+  return `bib-${id.toLowerCase()}`;
+}
+var ReferencesRenderer = class {
+  constructor(doc) {
+    this.doc = doc;
+  }
+  render(data) {
+    const section = this.doc.createElement("section");
+    section.id = "references";
+    const normSec = this.doc.createElement("section");
+    normSec.id = "normative-references";
+    normSec.innerHTML = "<h3>Normative references</h3><ul></ul>";
+    const infoSec = this.doc.createElement("section");
+    infoSec.id = "informative-references";
+    infoSec.innerHTML = "<h3>Informative references</h3><ul></ul>";
+    section.innerHTML = "<h2>References</h2>";
+    section.appendChild(normSec);
+    section.appendChild(infoSec);
+    const renderList = (sec, items) => {
+      const ul = sec.querySelector("ul");
+      ul.innerHTML = "";
+      items.sort((a, b) => a.id.localeCompare(b.id)).forEach(({ id, entry }) => {
+        const li = this.doc.createElement("li");
+        li.id = idForRef(id);
+        if (entry) {
+          li.innerHTML = formatEntry(id, entry);
+        } else {
+          li.setAttribute("data-spec", id);
+          li.innerHTML = `<span class="ref-id">[${id}]</span> <span class="ref-missing">\u2014 unresolved reference</span>`;
+        }
+        ul.appendChild(li);
+      });
+    };
+    renderList(normSec, data.normative);
+    renderList(infoSec, data.informative);
+    return section.outerHTML;
+  }
+};
+
+// src/pipeline/passes/references.ts
+var ReferencesPass = class {
+  constructor(root) {
+    this.root = root;
+    this.area = "references";
+  }
+  async execute(_data, config) {
+    const warnings = [];
+    const biblio = config.postprocess?.biblio?.entries ?? {};
+    const cites = Array.from(this.root.querySelectorAll("a[data-spec]"));
+    if (!cites.length) return { data: { html: "", citeUpdates: [] }, warnings };
+    const normativeIds = /* @__PURE__ */ new Set();
+    const informativeIds = /* @__PURE__ */ new Set();
+    for (const a of cites) {
+      const id = (a.getAttribute("data-spec") || "").trim();
+      const norm3 = (a.getAttribute("data-normative") || "false") === "true";
+      (norm3 ? normativeIds : informativeIds).add(id);
+    }
+    for (const id of normativeIds) informativeIds.delete(id);
+    const normative = [];
+    const informative = [];
+    Array.from(normativeIds).sort((a, b) => a.localeCompare(b)).forEach((id) => {
+      const entry = biblio[id];
+      if (!entry) warnings.push(`Unresolved reference: "${id}"`);
+      normative.push({ id, entry });
+    });
+    Array.from(informativeIds).sort((a, b) => a.localeCompare(b)).forEach((id) => {
+      const entry = biblio[id];
+      if (!entry) warnings.push(`Unresolved reference: "${id}"`);
+      informative.push({ id, entry });
+    });
+    const renderer = new ReferencesRenderer(this.root.ownerDocument);
+    const html = renderer.render({ normative, informative });
+    const citeUpdates = [];
+    for (const a of cites) {
+      const id = (a.getAttribute("data-spec") || "").trim();
+      const targetId = idForRef(id);
+      citeUpdates.push({ element: a, href: `#${targetId}` });
+    }
+    return { data: { html, citeUpdates }, warnings };
+  }
+  async run(ctx, next) {
+    const current = ctx.outputs[this.area];
+    const { data, warnings } = await this.execute(current, ctx.config);
+    if (data !== void 0) ctx.outputs[this.area] = data;
+    if (warnings && warnings.length) ctx.warnings.push(...warnings);
+    await next();
+  }
+};
+
+// src/pipeline/passes/boilerplate.ts
+var BoilerplatePass = class {
+  constructor(root) {
+    this.root = root;
+    this.area = "boilerplate";
+  }
+  async execute(_data, config) {
+    const bp = config.postprocess?.boilerplate;
+    if (!bp) return { data: { sections: [], ref: null }, warnings: [] };
+    const mountMode = bp.mount || "end";
+    let ref = null;
+    if (mountMode === "before-references") {
+      ref = this.root.querySelector("#references");
+    } else if (mountMode === "after-toc") {
+      const toc = this.root.querySelector("#toc");
+      ref = toc ? toc.nextSibling : null;
+    }
+    const sections = [];
+    const defs = [
+      { key: "conformance", title: "Conformance" },
+      { key: "security", title: "Security" },
+      { key: "privacy", title: "Privacy" }
+    ];
+    for (const { key, title: defaultTitle } of defs) {
+      const opt = bp[key];
+      if (!opt) continue;
+      const cfg = typeof opt === "object" ? opt : {};
+      const id = cfg.id || key;
+      if (this.root.querySelector(`#${id}`)) continue;
+      const title = cfg.title || defaultTitle;
+      const content = cfg.content;
+      const descriptor = { id, title };
+      if (content !== void 0) descriptor.content = content;
+      sections.push(descriptor);
+    }
+    return { data: { sections, ref }, warnings: [] };
+  }
+  async run(ctx, next) {
+    const current = ctx.outputs[this.area];
+    const { data, warnings } = await this.execute(current, ctx.config);
+    if (data !== void 0) ctx.outputs[this.area] = data;
+    if (warnings && warnings.length) ctx.warnings.push(...warnings);
+    await next();
+  }
+};
+
+// src/renderers/boilerplate-renderer.ts
+function createSection(doc, id, title, content) {
+  const sec = doc.createElement("section");
+  sec.id = id;
+  const h2 = doc.createElement("h2");
+  h2.textContent = title;
+  sec.appendChild(h2);
+  if (content) {
+    const p = doc.createElement("p");
+    p.textContent = content;
+    sec.appendChild(p);
+  }
+  return sec;
+}
+var BoilerplateRenderer = class {
+  constructor(doc) {
+    this.doc = doc;
+  }
+  render(descriptors) {
+    return descriptors.map((d) => createSection(this.doc, d.id, d.title, d.content));
+  }
+};
+
+// src/renderers/toc-renderer.ts
+var TocRenderer = class {
+  constructor(doc) {
+    this.doc = doc;
+  }
+  render(items = []) {
+    if (!items.length) return { toc: "" };
+    const minDepth = Math.min(...items.map((i) => i.depth));
+    const rootOl = this.doc.createElement("ol");
+    rootOl.setAttribute("role", "list");
+    const olStack = [rootOl];
+    let currentDepth = 1;
+    for (const item of items) {
+      const targetDepth = item.depth - minDepth + 1;
+      while (targetDepth > currentDepth) {
+        const newOl = this.doc.createElement("ol");
+        newOl.setAttribute("role", "list");
+        const parentOl = olStack[olStack.length - 1];
+        let parentLi = parentOl.lastElementChild;
+        if (!parentLi) {
+          parentLi = this.doc.createElement("li");
+          parentOl.appendChild(parentLi);
+        }
+        parentLi.appendChild(newOl);
+        olStack.push(newOl);
+        currentDepth++;
+      }
+      while (targetDepth < currentDepth) {
+        olStack.pop();
+        currentDepth--;
+      }
+      const currentOl = olStack[olStack.length - 1];
+      const li = this.doc.createElement("li");
+      li.setAttribute("data-depth", String(item.depth));
+      const a = this.doc.createElement("a");
+      a.href = `#${item.id}`;
+      a.textContent = item.text;
+      li.appendChild(a);
+      currentOl.appendChild(li);
+    }
+    return { toc: rootOl.outerHTML };
+  }
+};
+
+// src/pipeline/passes/toc.ts
+function collectTocItems(root) {
+  const headings = Array.from(root.querySelectorAll("h2, h3, h4"));
+  const items = [];
+  for (const h of headings) {
+    if (!h.id) continue;
+    const depth = h.tagName.toLowerCase() === "h3" ? 2 : h.tagName.toLowerCase() === "h4" ? 3 : 1;
+    items.push({ id: h.id, text: h.textContent || "", depth });
+  }
+  return items;
+}
+var TocPass = class {
+  constructor(root) {
+    this.root = root;
+    this.area = "toc";
+  }
+  async execute(_data, config) {
+    const { toc } = config.postprocess || {};
+    console.log("TOC items:", toc);
+    const items = collectTocItems(this.root);
+    if (!items.length) return { data: "", warnings: [] };
+    if (toc && toc.render === false) {
+      return { data: items, warnings: [] };
+    }
+    const renderer = new TocRenderer(this.root.ownerDocument);
+    const { toc: tocHtml } = renderer.render(items);
+    return { data: tocHtml, warnings: [] };
+  }
+  async run(ctx, next) {
+    const current = ctx.outputs[this.area];
+    const { data, warnings } = await this.execute(current, ctx.config);
+    if (data !== void 0) ctx.outputs[this.area] = data;
+    if (warnings && warnings.length) ctx.warnings.push(...warnings);
+    await next();
+  }
+};
+
+// src/pipeline/passes/diagnostics.ts
+var DiagnosticsPass = class {
+  constructor(root) {
+    this.root = root;
+    this.area = "diagnostics";
+  }
+  async execute(_data, config) {
+    const warnings = [];
+    const suppressClass = config.postprocess?.diagnostics?.suppressClass ?? "no-link-warnings";
+    const idsAndLinks = config.postprocess?.diagnostics?.idsAndLinks ?? true;
+    if (idsAndLinks) {
+      const seen = /* @__PURE__ */ new Map();
+      this.root.querySelectorAll("[id]").forEach((el) => {
+        const id = el.id;
+        if (!id) return;
+        if (seen.has(id)) {
+          if (!el.closest(`.${suppressClass}`)) {
+            warnings.push(`Duplicate id: "${id}"`);
+          }
+        } else {
+          seen.set(id, el);
+        }
+      });
+      const anchors = this.root.querySelectorAll("a");
+      anchors.forEach((a) => {
+        if (a.closest(`.${suppressClass}`)) return;
+        const hasHref = a.hasAttribute("href") && a.getAttribute("href") !== "";
+        const isPlaceholder = a.hasAttribute("data-xref") || a.hasAttribute("data-idl") || a.hasAttribute("data-spec");
+        if (!hasHref && isPlaceholder) {
+          const label = a.getAttribute("data-xref") || a.getAttribute("data-idl") || a.getAttribute("data-spec") || a.textContent || "";
+          warnings.push(`Unresolved link placeholder: "${label.trim()}"`);
+        }
+      });
+    }
+    return { warnings };
+  }
+  async run(ctx, next) {
+    const current = ctx.outputs[this.area];
+    const { warnings } = await this.execute(current, ctx.config);
+    if (warnings && warnings.length) ctx.warnings.push(...warnings);
+    await next();
+  }
+};
+
+// src/pipeline/passes/assertions.ts
+function getSpecAndVersionFromBaseUrl(baseUrl) {
+  if (!baseUrl) return {};
+  try {
+    const url = new URL(baseUrl);
+    const parts = url.pathname.replace(/\/+$/, "").split("/").filter(Boolean);
+    const n = parts.length;
+    if (n >= 2) {
+      const version = parts[n - 1];
+      const spec = parts[n - 2];
+      return { spec, version };
+    }
+  } catch {
+  }
+  return {};
+}
+function toStandardId(prefix, major, seq) {
+  const n = String(seq).padStart(3, "0");
+  return `${prefix}-${major}-${n}`;
+}
+function closestBlock(el) {
+  return el.closest("p, li, dd, dt, td, th, blockquote") || null;
+}
+function normText(el) {
+  const text = (el.textContent || "").replace(/\s+/g, " ").trim();
+  return text.length > 200 ? `${text.slice(0, 197)}...` : text;
+}
+function ensureUniqueId(root, desired) {
+  let id = desired;
+  let i = 1;
+  const doc = root.ownerDocument;
+  while (doc && typeof doc.getElementById === "function" && doc.getElementById(id)) {
+    id = `${desired}-${i++}`;
+  }
+  return id;
+}
+var AssertionsPass = class {
+  constructor(root) {
+    this.root = root;
+    this.area = "assertions";
+  }
+  async execute(_data, config) {
+    const warnings = [];
+    const { spec: specOpt, version: versionOpt } = config.postprocess?.assertions || {};
+    const { spec: specFromPath, version: versionFromPath } = getSpecAndVersionFromBaseUrl(config.baseUrl);
+    const spec = (specOpt || specFromPath || "SPEC").toUpperCase();
+    const version = (versionOpt || versionFromPath || "0").toString();
+    const majorMatch = version.match(/^(\d+)/);
+    const major = majorMatch ? majorMatch[1] : "0";
+    const map = /* @__PURE__ */ new Map();
+    const markers = Array.from(this.root.querySelectorAll("em.rfc2119"));
+    for (const em of markers) {
+      const block = closestBlock(em);
+      if (!block) continue;
+      const text = (em.textContent || "").trim().toUpperCase();
+      let type = void 0;
+      if (text === "MUST NOT") type = "MUST NOT";
+      else if (text === "MUST") type = "MUST";
+      else if (text === "SHOULD") type = "SHOULD";
+      else if (text === "MAY") type = "MAY";
+      if (!type) continue;
+      const entry = map.get(block) || { keywords: [], markers: [] };
+      entry.keywords.push(type);
+      entry.markers.push(em);
+      map.set(block, entry);
+    }
+    if (!map.size) return { data: [], warnings };
+    const selectors = "p, li, dd, dt, td, th, blockquote";
+    const blocksInOrder = Array.from(this.root.querySelectorAll(selectors)).filter((el) => map.has(el));
+    const items = [];
+    let seq = 1;
+    for (const block of blocksInOrder) {
+      const { keywords } = map.get(block);
+      if (keywords.length > 1) {
+        warnings.push(
+          `Multiple normative keywords (${keywords.join(", ")}) in block: "${normText(block)}"`
+        );
+      }
+      const type = keywords[0];
+      const standardId = toStandardId(spec, major, seq++);
+      let anchorId = block.id;
+      if (!anchorId) {
+        anchorId = ensureUniqueId(this.root, standardId);
+        block.id = anchorId;
+      }
+      block.setAttribute("data-assertion-id", standardId);
+      items.push({ id: standardId, anchorId, type, snippet: normText(block) });
+    }
+    return { data: items, warnings };
+  }
+  async run(ctx, next) {
+    const current = ctx.outputs[this.area];
+    const { data, warnings } = await this.execute(current, ctx.config);
+    if (data !== void 0) ctx.outputs[this.area] = data;
+    if (warnings && warnings.length) ctx.warnings.push(...warnings);
+    await next();
+  }
+};
+
+// src/speculator.ts
+var Speculator = class {
+  constructor(options = {}) {
+    const baseUrl = options.baseUrl;
+    const fileLoader = options.fileLoader || getDefaultFileLoader();
+    const markdownOptions = options.markdownOptions || {};
+    this.baseConfig = { postprocess: options.postprocess || {} };
+    this.formatRegistry = options.formatRegistry || new FormatRegistry(markdownOptions);
+    this.formatProcessor = options.formatProcessor || new FormatProcessor(this.formatRegistry);
+    this.includeProcessor = options.includeProcessor || new IncludeProcessor(baseUrl, fileLoader, this.formatRegistry);
+    this.htmlRenderer = options.htmlRenderer || new DOMHtmlRenderer();
+    this.documentBuilder = new DocumentBuilder(this, this.htmlRenderer);
+    this.processors = [this.includeProcessor, this.formatProcessor];
+    const passes = options.passes;
+    if (Array.isArray(passes)) {
+      this.passFactory = () => passes;
+    } else if (typeof passes === "function") {
+      this.passFactory = passes;
+    } else {
+      this.passFactory = (container) => {
+        return [
+          new IdlPass(container),
+          new XrefPass(container),
+          new ReferencesPass(container),
+          new BoilerplatePass(container),
+          new TocPass(container),
+          new AssertionsPass(container),
+          new DiagnosticsPass(container)
+        ];
+      };
+    }
+    this.pipelineRunner = new PipelineRunner(this.passFactory);
+  }
+  /**
+   * Process a single DOM element
+   */
+  async processElement(element, tracker = new StatsTracker()) {
+    tracker.start();
+    const warnings = [];
+    const clonedElement = element.cloneNode(true);
+    try {
+      await this.processNode(clonedElement, tracker, warnings);
+      tracker.stop();
+      return { element: clonedElement, warnings, stats: tracker.toJSON() };
+    } catch (error) {
+      throw new SpeculatorError(
+        `Failed to process element: ${error instanceof Error ? error.message : "Unknown error"}`,
+        element
+      );
+    }
+  }
+  async processNode(node, tracker, warnings) {
+    let matched = false;
+    for (const processor of this.processors) {
+      if (!processor.matches(node)) continue;
+      matched = true;
+      const { content, error } = await processor.process(node, tracker, warnings);
+      if (error) {
+        warnings.push(error);
+        insertContent(node, renderError(error));
+        continue;
+      }
+      if (content !== void 0 && content !== null) {
+        let renderedContent = content;
+        if (processor instanceof FormatProcessor) {
+          const rendered = this.htmlRenderer.parse(content);
+          renderedContent = this.htmlRenderer.serialize(rendered);
+        }
+        insertContent(node, renderedContent);
+      }
+    }
+    if (matched) tracker.incrementElements();
+    const children = Array.from(node.children);
+    for (const child of children) {
+      await this.processNode(child, tracker, warnings);
+    }
+  }
+  /**
+   * Process an entire document described by a SpeculatorConfig
+   */
+  async renderDocument(spec, outputs = []) {
+    const startTime = performance.now();
+    const config = {
+      ...this.baseConfig,
+      ...spec,
+      postprocess: { ...this.baseConfig.postprocess || {}, ...spec.postprocess || {} }
+    };
+    const { container, header, sotd, stats, warnings: sectionWarnings } = await this.documentBuilder.build(config);
+    const allWarnings = [...sectionWarnings];
+    let areas = getChangedOutputAreas(this.prevConfig, config);
+    this.prevConfig = config;
+    if (Array.isArray(outputs) && outputs.length > 0) {
+      areas = areas.filter((a) => outputs.includes(a));
+    }
+    let toc;
+    let boilerplate;
+    let references;
+    let pipelineOutputs = {};
+    try {
+      if (areas.length) {
+        const result = await this.pipelineRunner.run(container, config, areas);
+        pipelineOutputs = result.outputs;
+        allWarnings.push(...result.warnings);
+        if (result.outputs.toc) {
+          toc = result.outputs.toc;
+        }
+        const bpOut = result.outputs.boilerplate;
+        if (bpOut && bpOut.sections.length) {
+          const renderer = new BoilerplateRenderer(container.ownerDocument);
+          const nodes = renderer.render(bpOut.sections);
+          boilerplate = nodes.map((el) => el.outerHTML);
+        }
+        const refOut = result.outputs.references;
+        if (refOut && refOut.html) {
+          refOut.citeUpdates.forEach(
+            ({ element, href }) => element.setAttribute("href", href)
+          );
+          references = refOut.html;
+        }
+      }
+      const hooks = config.postProcess ? Array.isArray(config.postProcess) ? config.postProcess : [config.postProcess] : [];
+      for (const hook of hooks) {
+        await hook(container, pipelineOutputs);
+      }
+    } catch (e) {
+      allWarnings.push(
+        `Postprocess failed: ${e instanceof Error ? e.message : "Unknown error"}`
+      );
+    }
+    stats.processingTime = performance.now() - startTime;
+    const finalSections = Array.from(container.children).filter(
+      (el) => el !== header && el !== sotd
+    );
+    return {
+      sections: finalSections,
+      warnings: allWarnings,
+      toc,
+      stats,
+      ...header ? { header } : {},
+      ...sotd ? { sotd } : {},
+      ...boilerplate ? { boilerplate } : {},
+      ...references ? { references } : {}
+    };
+  }
+  async renderSections(inputHtml) {
+    const container = this.htmlRenderer.parse(inputHtml);
+    const sections = Array.from(container.children);
+    return this.renderDocument({ sections });
+  }
+  /**
+   * Process HTML string and return processed HTML
+   */
+  async renderHTML(inputHtml) {
+    const result = await this.renderSections(inputHtml);
+    const container = this.htmlRenderer.parse("<div></div>");
+    const doc = container.ownerDocument;
+    const root = doc.createElement("div");
+    for (const section of result.sections) {
+      root.appendChild(section);
+    }
+    const htmlSections = this.htmlRenderer.serialize(root);
+    return {
+      sections: htmlSections,
+      toc: result.toc,
+      warnings: result.warnings,
+      stats: result.stats,
+      ...result.header ? { header: this.htmlRenderer.serialize(result.header) } : {},
+      ...result.sotd ? { sotd: this.htmlRenderer.serialize(result.sotd) } : {},
+      ...result.boilerplate ? { boilerplate: result.boilerplate } : {},
+      ...result.references ? { references: result.references } : {}
+    };
+  }
+};
+
+// src/utils/respec-xref-resolver.ts
+function groupQueriesBySpec(queries) {
+  const bySpec = /* @__PURE__ */ new Map();
+  for (const q of queries) {
+    const key = (q.specs || []).slice().sort().join(",");
+    const arr = bySpec.get(key) || [];
+    arr.push(q);
+    bySpec.set(key, arr);
+  }
+  return bySpec;
+}
+function buildXrefURL(endpoint, specKey, qs) {
+  const params = new URLSearchParams();
+  for (const q of qs) {
+    params.append("terms", q.term);
+  }
+  if (specKey) params.set("cite", specKey);
+  return `${endpoint}?${params.toString()}`;
+}
+function mapXrefResults(data, q) {
+  const list = data[q.term.toLowerCase()] || [];
+  return list.map((item) => ({
+    href: item.uri || item.url || item.href,
+    text: item.title || item.term || item.text,
+    cite: item.spec || item.shortname
+  })).filter((r) => !!r.href);
+}
+var RespecXrefResolver = class {
+  constructor(fetchFn = fetch, endpoint = "https://respec.org/xref") {
+    this.fetchFn = fetchFn;
+    this.endpoint = endpoint;
+  }
+  async resolveBatch(queries) {
+    const results = /* @__PURE__ */ new Map();
+    for (const [specKey, qs] of groupQueriesBySpec(queries)) {
+      const url = buildXrefURL(this.endpoint, specKey, qs);
+      try {
+        const resp = await this.fetchFn(url);
+        const data = await resp.json();
+        for (const q of qs) {
+          results.set(q.id || q.term, mapXrefResults(data, q));
+        }
+      } catch {
+        for (const q of qs) {
+          results.set(q.id || q.term, []);
+        }
+      }
+    }
+    return results;
+  }
+};
+
+export {
+  nodeFileLoader,
+  browserFileLoader,
+  createFallbackFileLoader,
+  getDefaultFileLoader,
+  SpeculatorError,
+  fromRespecConfig,
+  StatsTracker,
+  IncludeProcessor,
+  createMarkdownRenderer,
+  parseMarkdown,
+  FormatRegistry,
+  FormatProcessor,
+  DOMHtmlRenderer,
+  getChangedOutputAreas,
+  Speculator,
+  RespecXrefResolver
+};