@openuji/speculator 0.1.0 → 0.2.0

package/dist/node.cjs

@@ -0,0 +1,930 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node.ts
+var node_exports = {};
+__export(node_exports, {
+  DOMHtmlRenderer: () => DOMHtmlRenderer,
+  FormatProcessor: () => FormatProcessor,
+  IncludeProcessor: () => IncludeProcessor,
+  LinkedomHtmlRenderer: () => LinkedomHtmlRenderer,
+  Speculator: () => Speculator2,
+  SpeculatorError: () => SpeculatorError,
+  browserFileLoader: () => browserFileLoader,
+  createFallbackFileLoader: () => createFallbackFileLoader,
+  createMarkdownRenderer: () => createMarkdownRenderer,
+  getDefaultFileLoader: () => getDefaultFileLoader,
+  nodeFileLoader: () => nodeFileLoader,
+  parseMarkdown: () => parseMarkdown
+});
+module.exports = __toCommonJS(node_exports);
+
+// src/utils/file-loader.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"}`);
+  }
+};
+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"}`);
+  }
+};
+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";
+  }
+};
+
+// src/pipeline/postprocess.ts
+async function postprocess(root, passes, options = {}) {
+  const warnings = [];
+  for (const pass of passes) {
+    const result = await pass.run(root, options);
+    if (result && result.length) {
+      warnings.push(...result);
+    }
+  }
+  return { warnings };
+}
+
+// src/processors/include-processor.ts
+var IncludeProcessor = class {
+  constructor(baseUrl, fileLoader, formatProcessor) {
+    this.baseUrl = baseUrl;
+    this.fileLoader = fileLoader;
+    this.formatProcessor = formatProcessor;
+  }
+  async process(element, stats, warnings) {
+    const includePath = element.getAttribute("data-include");
+    const includeFormat = element.getAttribute("data-include-format") || "text";
+    if (!includePath) {
+      warnings.push("data-include attribute is empty");
+      return;
+    }
+    try {
+      const fullPath = this.resolveFilePath(includePath);
+      const content = await this.fileLoader(fullPath);
+      const processedContent = this.formatProcessor.processContent(content, includeFormat);
+      element.innerHTML = processedContent;
+      stats.filesIncluded++;
+      if (includeFormat === "markdown") {
+        stats.markdownBlocks++;
+      }
+    } catch (error) {
+      const errorMsg = `Failed to load: ${includePath}`;
+      warnings.push(errorMsg);
+      element.innerHTML = `<p class="error">${errorMsg}</p>`;
+      throw new SpeculatorError(errorMsg, element, includePath);
+    }
+    element.removeAttribute("data-include");
+    element.removeAttribute("data-include-format");
+  }
+  resolveFilePath(path) {
+    const filePath = new URL(path, this.baseUrl || "file:///").toString();
+    console.log(`Resolved file path: ${filePath}`);
+    return filePath;
+  }
+};
+
+// src/markdown/index.ts
+var import_markdown_it = __toESM(require("markdown-it"), 1);
+
+// 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/index.ts
+function createMarkdownRenderer(options = {}) {
+  const md = new import_markdown_it.default({
+    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);
+  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 `<p class="error">Error parsing markdown: ${error instanceof Error ? error.message : "Unknown error"}</p>`;
+  }
+}
+function slugify(content) {
+  return content.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-");
+}
+
+// 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(markdownOptions = {}) {
+    this.markdownOptions = markdownOptions;
+  }
+  /**
+   * Convert content based on the specified format.
+   */
+  processContent(content, format) {
+    switch (format) {
+      case "markdown":
+        return parseMarkdown(content, this.markdownOptions);
+      case "text":
+      case "html":
+      default:
+        return content;
+    }
+  }
+  /**
+   * Process an element with a data-format attribute.
+   */
+  process(element, stats, warnings) {
+    const format = element.getAttribute("data-format");
+    if (format === "markdown" && element.innerHTML.trim()) {
+      try {
+        const markdownContent = stripIndent(element.innerHTML).trim();
+        element.innerHTML = this.processContent(markdownContent, format);
+        stats.markdownBlocks++;
+      } catch (error) {
+        const errorMsg = `Failed to process markdown: ${error instanceof Error ? error.message : "Unknown error"}`;
+        warnings.push(errorMsg);
+        element.innerHTML = `<p class="error">${errorMsg}</p>`;
+      }
+    }
+    element.removeAttribute("data-format");
+  }
+};
+
+// 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/pipeline/passes/idl.ts
+var WebIDL2 = __toESM(require("webidl2"), 1);
+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 = {
+  async run(root, options) {
+    const warnings = [];
+    const suppressClass = options.diagnostics?.suppressClass ?? "no-link-warnings";
+    const index = buildIdlIndex(root, warnings);
+    resolveIdlLinks(root, index, warnings, suppressClass);
+    return warnings;
+  }
+};
+
+// src/pipeline/passes/xref.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 isSuppressed(node, suppressClass) {
+  return !!node.closest(`.${suppressClass}`);
+}
+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;
+}
+var xrefPass = {
+  async run(root, options) {
+    const suppressClass = options.diagnostics?.suppressClass ?? "no-link-warnings";
+    const warnings = [];
+    const localMap = buildLocalMap(root);
+    const xrefAnchors = Array.from(root.querySelectorAll("a[data-xref]"));
+    const unresolved = /* @__PURE__ */ new Map();
+    for (const a of xrefAnchors) {
+      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);
+      } else {
+        const bucket = unresolved.get(key) || [];
+        bucket.push(a);
+        unresolved.set(key, bucket);
+      }
+    }
+    const resolver = options.xref?.resolver;
+    if (resolver && unresolved.size) {
+      const queries = Array.from(unresolved.keys()).map((term) => ({ term }));
+      resolver.resolveBatch(queries, options.xref?.specs).then((results) => {
+        for (const [key, anchors] of unresolved.entries()) {
+          const res = results.get(key);
+          if (!res) continue;
+          for (const a of anchors) {
+            a.setAttribute("href", res.href);
+            if (res.cite) a.setAttribute("data-cite", res.cite);
+          }
+          unresolved.delete(key);
+        }
+      }).catch((err) => {
+        warnings.push(`Xref resolver failed: ${err instanceof Error ? err.message : String(err)}`);
+      });
+    }
+    for (const [key, anchors] of unresolved.entries()) {
+      const original = anchors[0].getAttribute("data-xref") || key;
+      warnings.push(`Unresolved xref: "${original}"`);
+    }
+    return warnings;
+  }
+};
+
+// src/pipeline/passes/references.ts
+function ensureSection(root, id, title) {
+  let section = root.querySelector(`#${id}`);
+  if (!section) {
+    section = root.ownerDocument.createElement("section");
+    section.id = id;
+    section.innerHTML = `<h2>${title}</h2>`;
+    root.appendChild(section);
+  }
+  return section;
+}
+function ensureSubsection(parent, id, title) {
+  let sec = parent.querySelector(`#${id}`);
+  if (!sec) {
+    sec = parent.ownerDocument.createElement("section");
+    sec.id = id;
+    sec.innerHTML = `<h3>${title}</h3><ul></ul>`;
+    parent.appendChild(sec);
+  }
+  return sec;
+}
+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 referencesPass = {
+  async run(root, options) {
+    const warnings = [];
+    const biblio = options.biblio?.entries ?? {};
+    const cites = Array.from(root.querySelectorAll("a[data-spec]"));
+    if (!cites.length) return warnings;
+    const normative = /* @__PURE__ */ new Set();
+    const informative = /* @__PURE__ */ new Set();
+    for (const a of cites) {
+      const id = (a.getAttribute("data-spec") || "").trim();
+      const norm3 = (a.getAttribute("data-normative") || "false") === "true";
+      (norm3 ? normative : informative).add(id);
+    }
+    for (const id of normative) informative.delete(id);
+    const refs = ensureSection(root, "references", "References");
+    const normSec = ensureSubsection(refs, "normative-references", "Normative references");
+    const infoSec = ensureSubsection(refs, "informative-references", "Informative references");
+    const renderList = (sec, ids) => {
+      const ul = sec.querySelector("ul");
+      ul.innerHTML = "";
+      Array.from(ids).sort((a, b) => a.localeCompare(b)).forEach((id) => {
+        const li = root.ownerDocument.createElement("li");
+        li.id = idForRef(id);
+        const entry = biblio[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>`;
+          warnings.push(`Unresolved reference: "${id}"`);
+        }
+        ul.appendChild(li);
+      });
+    };
+    renderList(normSec, normative);
+    renderList(infoSec, informative);
+    for (const a of cites) {
+      const id = (a.getAttribute("data-spec") || "").trim();
+      const targetId = idForRef(id);
+      a.setAttribute("href", `#${targetId}`);
+      a.setAttribute("data-cite-ref", targetId);
+    }
+    return warnings;
+  }
+};
+
+// src/pipeline/passes/boilerplate.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 boilerplatePass = {
+  async run(root, options) {
+    const bp = options.boilerplate;
+    if (!bp) return [];
+    const doc = root.ownerDocument;
+    const mountMode = bp.mount || "end";
+    let ref = null;
+    if (mountMode === "before-references") {
+      ref = root.querySelector("#references");
+    } else if (mountMode === "after-toc") {
+      const toc = root.querySelector("#toc");
+      ref = toc ? toc.nextSibling : null;
+    }
+    const insert = (section) => {
+      if (ref) {
+        root.insertBefore(section, ref);
+      } else {
+        root.appendChild(section);
+      }
+    };
+    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 (root.querySelector(`#${id}`)) continue;
+      const title = cfg.title || defaultTitle;
+      const content = cfg.content;
+      const sec = createSection(doc, id, title, content);
+      insert(sec);
+    }
+    return [];
+  }
+};
+
+// src/pipeline/passes/toc.ts
+var tocPass = {
+  async run(root, options) {
+    const { toc } = options;
+    if (toc?.enabled === false) return [];
+    const selector = toc?.selector ?? "#toc";
+    const mount = root.querySelector(selector);
+    if (!mount) return [];
+    const headings = Array.from(root.querySelectorAll("h2, h3"));
+    if (!headings.length) return [];
+    const doc = root.ownerDocument;
+    const ol = doc.createElement("ol");
+    ol.setAttribute("role", "list");
+    for (const h of headings) {
+      if (!h.id) continue;
+      const li = doc.createElement("li");
+      const depth = h.tagName.toLowerCase() === "h3" ? 2 : 1;
+      li.setAttribute("data-depth", String(depth));
+      li.innerHTML = `<a href="#${h.id}">${h.textContent || ""}</a>`;
+      ol.appendChild(li);
+    }
+    mount.innerHTML = "";
+    mount.appendChild(ol);
+    return [];
+  }
+};
+
+// src/pipeline/passes/diagnostics.ts
+var diagnosticsPass = {
+  async run(root, options) {
+    const warnings = [];
+    const suppressClass = options.diagnostics?.suppressClass ?? "no-link-warnings";
+    const idsAndLinks = options.diagnostics?.idsAndLinks ?? true;
+    if (idsAndLinks) {
+      const seen = /* @__PURE__ */ new Map();
+      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 = 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;
+  }
+};
+
+// src/speculator.ts
+var Speculator = class {
+  constructor(options = {}) {
+    const baseUrl = options.baseUrl;
+    const fileLoader = options.fileLoader || getDefaultFileLoader();
+    const markdownOptions = options.markdownOptions || {};
+    this.postprocessOptions = options.postprocess || {};
+    this.formatProcessor = options.formatProcessor || new FormatProcessor(markdownOptions);
+    this.includeProcessor = options.includeProcessor || new IncludeProcessor(baseUrl, fileLoader, this.formatProcessor);
+    this.htmlRenderer = options.htmlRenderer || new DOMHtmlRenderer();
+  }
+  /**
+   * Process a single DOM element
+   */
+  async processElement(element) {
+    const startTime = performance.now();
+    const stats = {
+      elementsProcessed: 0,
+      filesIncluded: 0,
+      markdownBlocks: 0,
+      processingTime: 0
+    };
+    const warnings = [];
+    const clonedElement = element.cloneNode(true);
+    try {
+      if (clonedElement.hasAttribute("data-include")) {
+        await this.includeProcessor.process(clonedElement, stats, warnings);
+      }
+      if (clonedElement.hasAttribute("data-format")) {
+        this.formatProcessor.process(clonedElement, stats, warnings);
+      }
+      stats.elementsProcessed = 1;
+      stats.processingTime = performance.now() - startTime;
+      return { element: clonedElement, warnings, stats };
+    } catch (error) {
+      throw new SpeculatorError(
+        `Failed to process element: ${error instanceof Error ? error.message : "Unknown error"}`,
+        element
+      );
+    }
+  }
+  /**
+   * Process an entire document
+   */
+  async renderDocument(container) {
+    const startTime = performance.now();
+    const sections = container.querySelectorAll(
+      "section[data-include], section[data-format], *[data-include], *[data-format]"
+    );
+    const allStats = {
+      elementsProcessed: 0,
+      filesIncluded: 0,
+      markdownBlocks: 0,
+      processingTime: 0
+    };
+    const allWarnings = [];
+    const processedElements = [];
+    for (const section of Array.from(sections)) {
+      try {
+        const result = await this.processElement(section);
+        processedElements.push(result.element);
+        allStats.elementsProcessed += result.stats.elementsProcessed;
+        allStats.filesIncluded += result.stats.filesIncluded;
+        allStats.markdownBlocks += result.stats.markdownBlocks;
+        allWarnings.push(...result.warnings);
+      } catch (error) {
+        allWarnings.push(
+          `Failed to process element: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+        processedElements.push(section);
+      }
+    }
+    sections.forEach((section, index) => {
+      if (processedElements[index] && section.parentNode) {
+        section.parentNode.replaceChild(processedElements[index], section);
+      }
+    });
+    const passes = [
+      idlPass,
+      xrefPass,
+      referencesPass,
+      boilerplatePass,
+      tocPass,
+      diagnosticsPass
+    ];
+    try {
+      const { warnings } = await postprocess(container, passes, this.postprocessOptions || {});
+      allWarnings.push(...warnings);
+    } catch (e) {
+      allWarnings.push(`Postprocess failed: ${e instanceof Error ? e.message : "Unknown error"}`);
+    }
+    allStats.processingTime = performance.now() - startTime;
+    return { element: container, warnings: allWarnings, stats: allStats };
+  }
+  /**
+   * Process HTML string and return processed HTML
+   */
+  async renderHTML(html) {
+    const container = this.htmlRenderer.parse(html);
+    await this.renderDocument(container);
+    return this.htmlRenderer.serialize(container);
+  }
+};
+
+// src/linkedom-html-renderer.ts
+var import_linkedom = require("linkedom");
+var LinkedomHtmlRenderer = class {
+  parse(html) {
+    const parser = new import_linkedom.DOMParser();
+    const doc = parser.parseFromString(`<div>${html}</div>`, "text/html");
+    return doc.querySelector("div");
+  }
+  serialize(element) {
+    return element.innerHTML;
+  }
+};
+
+// src/node.ts
+var Speculator2 = class extends Speculator {
+  constructor(options = {}) {
+    super({ ...options, htmlRenderer: options.htmlRenderer || new LinkedomHtmlRenderer() });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DOMHtmlRenderer,
+  FormatProcessor,
+  IncludeProcessor,
+  LinkedomHtmlRenderer,
+  Speculator,
+  SpeculatorError,
+  browserFileLoader,
+  createFallbackFileLoader,
+  createMarkdownRenderer,
+  getDefaultFileLoader,
+  nodeFileLoader,
+  parseMarkdown
+});