@openuji/speculator 0.2.0 → 0.3.0

package/README.md

@@ -6,7 +6,7 @@ A TypeScript library for processing ReSpec-like markup and open for intgration i
 ## Installation
 
 ```bash
-pnpm install @openui/speculator
+pnpm install -D @openui/speculator linkdom
 ```
 
 

package/dist/browser.cjs

@@ -33,6 +33,7 @@ __export(browser_exports, {
   DOMHtmlRenderer: () => DOMHtmlRenderer,
   FormatProcessor: () => FormatProcessor,
   IncludeProcessor: () => IncludeProcessor,
+  RespecXrefResolver: () => RespecXrefResolver,
   Speculator: () => Speculator,
   SpeculatorError: () => SpeculatorError,
   browserFileLoader: () => browserFileLoader,
@@ -101,16 +102,35 @@ var SpeculatorError = class extends Error {
 };
 
 // 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);
+var Postprocessor = class {
+  constructor(passes) {
+    this.passes = passes;
+  }
+  /**
+   * Run the configured passes on the given root element.
+   *
+   * @param root The document root to process.
+   * @param areas Optional list of output areas to run. If omitted, all passes
+   *              are executed.
+   * @param options Configuration options for the passes.
+   */
+  async run(root, areas, options = {}) {
+    const warnings = [];
+    const outputs = {};
+    const active = areas ? this.passes.filter((p) => areas.includes(p.area)) : this.passes;
+    for (const pass of active) {
+      const current = outputs[pass.area];
+      const result = await pass.run(root, current, options);
+      if (result.data !== void 0) {
+        outputs[pass.area] = result.data;
+      }
+      if (result.warnings && result.warnings.length) {
+        warnings.push(...result.warnings);
+      }
     }
+    return { outputs, warnings };
   }
-  return { warnings };
-}
+};
 
 // src/processors/include-processor.ts
 var IncludeProcessor = class {
@@ -478,12 +498,13 @@ function resolveIdlLinks(root, index, warnings, suppressClass) {
   });
 }
 var idlPass = {
-  async run(root, options) {
+  area: "idl",
+  async run(root, _data, options) {
     const warnings = [];
     const suppressClass = options.diagnostics?.suppressClass ?? "no-link-warnings";
     const index = buildIdlIndex(root, warnings);
     resolveIdlLinks(root, index, warnings, suppressClass);
-    return warnings;
+    return { warnings };
   }
 };
 
@@ -503,6 +524,17 @@ function slugify2(text) {
 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;
+}
 function buildLocalMap(root) {
   const map = /* @__PURE__ */ new Map();
   const doc = root.ownerDocument;
@@ -548,11 +580,13 @@ function buildLocalMap(root) {
   return map;
 }
 var xrefPass = {
-  async run(root, options) {
+  area: "xref",
+  async run(root, _data, 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 resolverConfigs = Array.isArray(options.xref) ? options.xref : options.xref ? [options.xref] : [];
     const unresolved = /* @__PURE__ */ new Map();
     for (const a of xrefAnchors) {
       if (isSuppressed(a, suppressClass)) continue;
@@ -561,34 +595,96 @@ var xrefPass = {
       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);
+        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);
     }
-    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);
+    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;
         }
-      }).catch((err) => {
-        warnings.push(`Xref resolver failed: ${err instanceof Error ? err.message : String(err)}`);
-      });
+        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)}`
+        );
+      }
     }
-    for (const [key, anchors] of unresolved.entries()) {
-      const original = anchors[0].getAttribute("data-xref") || key;
-      warnings.push(`Unresolved xref: "${original}"`);
+    const defaultPriority = resolverConfigs.flatMap((cfg) => cfg.specs || []);
+    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;
+    return { warnings };
   }
 };
 
@@ -629,11 +725,12 @@ function idForRef(id) {
   return `bib-${id.toLowerCase()}`;
 }
 var referencesPass = {
-  async run(root, options) {
+  area: "references",
+  async run(root, _data, options) {
     const warnings = [];
     const biblio = options.biblio?.entries ?? {};
     const cites = Array.from(root.querySelectorAll("a[data-spec]"));
-    if (!cites.length) return warnings;
+    if (!cites.length) return { warnings };
     const normative = /* @__PURE__ */ new Set();
     const informative = /* @__PURE__ */ new Set();
     for (const a of cites) {
@@ -670,7 +767,7 @@ var referencesPass = {
       a.setAttribute("href", `#${targetId}`);
       a.setAttribute("data-cite-ref", targetId);
     }
-    return warnings;
+    return { warnings };
   }
 };
 
@@ -689,9 +786,10 @@ function createSection(doc, id, title, content) {
   return sec;
 }
 var boilerplatePass = {
-  async run(root, options) {
+  area: "boilerplate",
+  async run(root, _data, options) {
     const bp = options.boilerplate;
-    if (!bp) return [];
+    if (!bp) return { warnings: [] };
     const doc = root.ownerDocument;
     const mountMode = bp.mount || "end";
     let ref = null;
@@ -724,20 +822,21 @@ var boilerplatePass = {
       const sec = createSection(doc, id, title, content);
       insert(sec);
     }
-    return [];
+    return { warnings: [] };
   }
 };
 
 // src/pipeline/passes/toc.ts
 var tocPass = {
-  async run(root, options) {
+  area: "toc",
+  async run(root, _data, options) {
     const { toc } = options;
-    if (toc?.enabled === false) return [];
+    if (toc?.enabled === false) return { warnings: [] };
     const selector = toc?.selector ?? "#toc";
     const mount = root.querySelector(selector);
-    if (!mount) return [];
+    if (!mount) return { warnings: [] };
     const headings = Array.from(root.querySelectorAll("h2, h3"));
-    if (!headings.length) return [];
+    if (!headings.length) return { warnings: [] };
     const doc = root.ownerDocument;
     const ol = doc.createElement("ol");
     ol.setAttribute("role", "list");
@@ -751,13 +850,14 @@ var tocPass = {
     }
     mount.innerHTML = "";
     mount.appendChild(ol);
-    return [];
+    return { warnings: [] };
   }
 };
 
 // src/pipeline/passes/diagnostics.ts
 var diagnosticsPass = {
-  async run(root, options) {
+  area: "diagnostics",
+  async run(root, _data, options) {
     const warnings = [];
     const suppressClass = options.diagnostics?.suppressClass ?? "no-link-warnings";
     const idsAndLinks = options.diagnostics?.idsAndLinks ?? true;
@@ -785,7 +885,7 @@ var diagnosticsPass = {
         }
       });
     }
-    return warnings;
+    return { warnings };
   }
 };
 
@@ -799,6 +899,14 @@ var Speculator = class {
     this.formatProcessor = options.formatProcessor || new FormatProcessor(markdownOptions);
     this.includeProcessor = options.includeProcessor || new IncludeProcessor(baseUrl, fileLoader, this.formatProcessor);
     this.htmlRenderer = options.htmlRenderer || new DOMHtmlRenderer();
+    this.postprocessor = new Postprocessor([
+      idlPass,
+      xrefPass,
+      referencesPass,
+      boilerplatePass,
+      tocPass,
+      diagnosticsPass
+    ]);
   }
   /**
    * Process a single DOM element
@@ -866,16 +974,20 @@ var Speculator = class {
         section.parentNode.replaceChild(processedElements[index], section);
       }
     });
-    const passes = [
-      idlPass,
-      xrefPass,
-      referencesPass,
-      boilerplatePass,
-      tocPass,
-      diagnosticsPass
-    ];
     try {
-      const { warnings } = await postprocess(container, passes, this.postprocessOptions || {});
+      const areas = [
+        "idl",
+        "xref",
+        "references",
+        "boilerplate",
+        "toc",
+        "diagnostics"
+      ];
+      const { warnings } = await this.postprocessor.run(
+        container,
+        areas,
+        this.postprocessOptions || {}
+      );
       allWarnings.push(...warnings);
     } catch (e) {
       allWarnings.push(`Postprocess failed: ${e instanceof Error ? e.message : "Unknown error"}`);
@@ -886,10 +998,63 @@ var Speculator = class {
   /**
    * 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);
+  async renderHTML(inputHtml) {
+    const container = this.htmlRenderer.parse(inputHtml);
+    const result = await this.renderDocument(container);
+    const html = this.htmlRenderer.serialize(result.element);
+    return { html, warnings: result.warnings, stats: result.stats };
+  }
+};
+
+// 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;
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
@@ -897,6 +1062,7 @@ var Speculator = class {
   DOMHtmlRenderer,
   FormatProcessor,
   IncludeProcessor,
+  RespecXrefResolver,
   Speculator,
   SpeculatorError,
   browserFileLoader,

package/dist/browser.d.cts

@@ -88,6 +88,14 @@ interface ProcessingResult {
     /** Processing statistics */
     stats: ProcessingStats;
 }
+interface HtmlProcessingResult {
+    /** The processed HTML element */
+    html: string;
+    /** Any warnings encountered during processing */
+    warnings: string[];
+    /** Processing statistics */
+    stats: ProcessingStats;
+}
 /**
  * Processing statistics
  */
@@ -114,7 +122,13 @@ declare class SpeculatorError extends Error {
     constructor(message: string, element?: Element | undefined, path?: string | undefined);
 }
 type XrefQuery = {
+    /** Unique identifier returned with results (internal use). */
+    id?: string;
+    /** The term to resolve. */
     term: string;
+    /** Optional list of spec shortnames to constrain the search. */
+    specs?: string[];
+    /** Additional context for the lookup (unused for now). */
     context?: string;
 };
 type XrefResult = {
@@ -123,11 +137,15 @@ type XrefResult = {
     cite?: string;
 };
 interface XrefResolver {
-    resolveBatch(queries: XrefQuery[], specs?: string[]): Promise<Map<string, XrefResult>>;
+    /**
+     * Resolve a batch of xref queries. The returned map is keyed by the query's
+     * `id` if provided, otherwise by the query term.
+     */
+    resolveBatch(queries: XrefQuery[]): Promise<Map<string, XrefResult[]>>;
 }
 interface XrefOptions {
     specs?: string[];
-    resolver?: XrefResolver;
+    resolver: XrefResolver;
 }
 interface BiblioEntry {
     id: string;
@@ -149,6 +167,12 @@ interface TocOptions {
     selector?: string;
     enabled?: boolean;
 }
+interface DiagnosticsOptions {
+    /** Suppress link warnings within elements having this class. */
+    suppressClass?: string;
+    /** Enable duplicate-id and missing-href checks (default true). */
+    idsAndLinks?: boolean;
+}
 interface BoilerplateOptions {
     conformance?: boolean | {
         title?: string;
@@ -167,24 +191,8 @@ interface BoilerplateOptions {
     };
     mount?: 'end' | 'before-references' | 'after-toc';
 }
-interface DiagnosticsOptions {
-    /** Suppress link warnings within elements having this class. */
-    suppressClass?: string;
-}
-interface DiagnosticsOptions {
-    suppressClass?: string;
-    /** Enable duplicate-id and missing-href checks (default true). */
-    idsAndLinks?: boolean;
-}
 interface PostprocessOptions {
-    xref?: XrefOptions;
-    biblio?: BiblioOptions;
-    idl?: IdlOptions;
-    toc?: TocOptions;
-    diagnostics?: DiagnosticsOptions;
-}
-interface PostprocessOptions {
-    xref?: XrefOptions;
+    xref?: XrefOptions | XrefOptions[];
     biblio?: BiblioOptions;
     idl?: IdlOptions;
     toc?: TocOptions;
@@ -200,6 +208,7 @@ declare class Speculator {
     private readonly formatProcessor;
     private readonly htmlRenderer;
     private readonly postprocessOptions;
+    private readonly postprocessor;
     constructor(options?: SpeculatorOptions);
     /**
      * Process a single DOM element
@@ -212,7 +221,7 @@ declare class Speculator {
     /**
      * Process HTML string and return processed HTML
      */
-    renderHTML(html: string): Promise<string>;
+    renderHTML(inputHtml: string): Promise<HtmlProcessingResult>;
 }
 
 declare function createMarkdownRenderer(options?: MarkdownOptions): MarkdownIt;
@@ -235,4 +244,16 @@ declare function createFallbackFileLoader(loaders: FileLoader[]): FileLoader;
  */
 declare function getDefaultFileLoader(): FileLoader;
 
-export { DOMHtmlRenderer, type DataFormat, type FileLoader, FormatProcessor, type HtmlRenderer, IncludeProcessor, type MarkdownOptions, type ProcessingResult, type ProcessingStats, Speculator, SpeculatorError, type SpeculatorOptions, browserFileLoader, createFallbackFileLoader, createMarkdownRenderer, getDefaultFileLoader, nodeFileLoader, parseMarkdown };
+/**
+ * Xref resolver that queries the public ReSpec xref database.
+ *
+ * The fetch implementation is injectable to allow easy testing.
+ */
+declare class RespecXrefResolver implements XrefResolver {
+    private readonly fetchFn;
+    private readonly endpoint;
+    constructor(fetchFn?: typeof fetch, endpoint?: string);
+    resolveBatch(queries: XrefQuery[]): Promise<Map<string, XrefResult[]>>;
+}
+
+export { DOMHtmlRenderer, type DataFormat, type FileLoader, FormatProcessor, type HtmlRenderer, IncludeProcessor, type MarkdownOptions, type ProcessingResult, type ProcessingStats, RespecXrefResolver, Speculator, SpeculatorError, type SpeculatorOptions, browserFileLoader, createFallbackFileLoader, createMarkdownRenderer, getDefaultFileLoader, nodeFileLoader, parseMarkdown };

package/dist/browser.d.ts

@@ -88,6 +88,14 @@ interface ProcessingResult {
     /** Processing statistics */
     stats: ProcessingStats;
 }
+interface HtmlProcessingResult {
+    /** The processed HTML element */
+    html: string;
+    /** Any warnings encountered during processing */
+    warnings: string[];
+    /** Processing statistics */
+    stats: ProcessingStats;
+}
 /**
  * Processing statistics
  */
@@ -114,7 +122,13 @@ declare class SpeculatorError extends Error {
     constructor(message: string, element?: Element | undefined, path?: string | undefined);
 }
 type XrefQuery = {
+    /** Unique identifier returned with results (internal use). */
+    id?: string;
+    /** The term to resolve. */
     term: string;
+    /** Optional list of spec shortnames to constrain the search. */
+    specs?: string[];
+    /** Additional context for the lookup (unused for now). */
     context?: string;
 };
 type XrefResult = {
@@ -123,11 +137,15 @@ type XrefResult = {
     cite?: string;
 };
 interface XrefResolver {
-    resolveBatch(queries: XrefQuery[], specs?: string[]): Promise<Map<string, XrefResult>>;
+    /**
+     * Resolve a batch of xref queries. The returned map is keyed by the query's
+     * `id` if provided, otherwise by the query term.
+     */
+    resolveBatch(queries: XrefQuery[]): Promise<Map<string, XrefResult[]>>;
 }
 interface XrefOptions {
     specs?: string[];
-    resolver?: XrefResolver;
+    resolver: XrefResolver;
 }
 interface BiblioEntry {
     id: string;
@@ -149,6 +167,12 @@ interface TocOptions {
     selector?: string;
     enabled?: boolean;
 }
+interface DiagnosticsOptions {
+    /** Suppress link warnings within elements having this class. */
+    suppressClass?: string;
+    /** Enable duplicate-id and missing-href checks (default true). */
+    idsAndLinks?: boolean;
+}
 interface BoilerplateOptions {
     conformance?: boolean | {
         title?: string;
@@ -167,24 +191,8 @@ interface BoilerplateOptions {
     };
     mount?: 'end' | 'before-references' | 'after-toc';
 }
-interface DiagnosticsOptions {
-    /** Suppress link warnings within elements having this class. */
-    suppressClass?: string;
-}
-interface DiagnosticsOptions {
-    suppressClass?: string;
-    /** Enable duplicate-id and missing-href checks (default true). */
-    idsAndLinks?: boolean;
-}
 interface PostprocessOptions {
-    xref?: XrefOptions;
-    biblio?: BiblioOptions;
-    idl?: IdlOptions;
-    toc?: TocOptions;
-    diagnostics?: DiagnosticsOptions;
-}
-interface PostprocessOptions {
-    xref?: XrefOptions;
+    xref?: XrefOptions | XrefOptions[];
     biblio?: BiblioOptions;
     idl?: IdlOptions;
     toc?: TocOptions;
@@ -200,6 +208,7 @@ declare class Speculator {
     private readonly formatProcessor;
     private readonly htmlRenderer;
     private readonly postprocessOptions;
+    private readonly postprocessor;
     constructor(options?: SpeculatorOptions);
     /**
      * Process a single DOM element
@@ -212,7 +221,7 @@ declare class Speculator {
     /**
      * Process HTML string and return processed HTML
      */
-    renderHTML(html: string): Promise<string>;
+    renderHTML(inputHtml: string): Promise<HtmlProcessingResult>;
 }
 
 declare function createMarkdownRenderer(options?: MarkdownOptions): MarkdownIt;
@@ -235,4 +244,16 @@ declare function createFallbackFileLoader(loaders: FileLoader[]): FileLoader;
  */
 declare function getDefaultFileLoader(): FileLoader;
 
-export { DOMHtmlRenderer, type DataFormat, type FileLoader, FormatProcessor, type HtmlRenderer, IncludeProcessor, type MarkdownOptions, type ProcessingResult, type ProcessingStats, Speculator, SpeculatorError, type SpeculatorOptions, browserFileLoader, createFallbackFileLoader, createMarkdownRenderer, getDefaultFileLoader, nodeFileLoader, parseMarkdown };
+/**
+ * Xref resolver that queries the public ReSpec xref database.
+ *
+ * The fetch implementation is injectable to allow easy testing.
+ */
+declare class RespecXrefResolver implements XrefResolver {
+    private readonly fetchFn;
+    private readonly endpoint;
+    constructor(fetchFn?: typeof fetch, endpoint?: string);
+    resolveBatch(queries: XrefQuery[]): Promise<Map<string, XrefResult[]>>;
+}
+
+export { DOMHtmlRenderer, type DataFormat, type FileLoader, FormatProcessor, type HtmlRenderer, IncludeProcessor, type MarkdownOptions, type ProcessingResult, type ProcessingStats, RespecXrefResolver, Speculator, SpeculatorError, type SpeculatorOptions, browserFileLoader, createFallbackFileLoader, createMarkdownRenderer, getDefaultFileLoader, nodeFileLoader, parseMarkdown };

package/dist/browser.js

@@ -2,6 +2,7 @@ import {
   DOMHtmlRenderer,
   FormatProcessor,
   IncludeProcessor,
+  RespecXrefResolver,
   Speculator,
   SpeculatorError,
   browserFileLoader,
@@ -10,11 +11,12 @@ import {
   getDefaultFileLoader,
   nodeFileLoader,
   parseMarkdown
-} from "./chunk-JAR5PGCK.js";
+} from "./chunk-U4GQ6EOV.js";
 export {
   DOMHtmlRenderer,
   FormatProcessor,
   IncludeProcessor,
+  RespecXrefResolver,
   Speculator,
   SpeculatorError,
   browserFileLoader,