@bendyline/squisq-formats 2.8.8 → 2.8.10

package/dist/chunk-YRFBWYAD.js

@@ -0,0 +1,128 @@
+import {
+  defaultDataReaders
+} from "./chunk-5HUHSLGA.js";
+
+// src/data/materialize.ts
+import {
+  isDataFilePath
+} from "@bendyline/squisq/doc";
+function tableRow(cells) {
+  return {
+    type: "tableRow",
+    children: cells.map((value) => ({
+      type: "tableCell",
+      children: value ? [{ type: "text", value }] : []
+    }))
+  };
+}
+function count(n) {
+  return n.toLocaleString("en-US");
+}
+function extensionOf(path) {
+  const base = path.split("/").pop() ?? path;
+  const dot = base.lastIndexOf(".");
+  return dot > 0 ? base.slice(dot + 1).toLowerCase() : "";
+}
+var DATA_PREVIEW_ROWS = 100;
+async function materializeDataReferences(markdownDoc, container, onWarning, options = {}) {
+  const readers = defaultDataReaders();
+  const children = [];
+  let changed = false;
+  for (const [index, node] of markdownDoc.children.entries()) {
+    children.push(node);
+    if (node.type !== "heading") continue;
+    const params = node.templateAnnotation?.params;
+    const src = params?.src;
+    if (!src || !isDataFilePath(src)) continue;
+    if (markdownDoc.children[index + 1]?.type === "table") continue;
+    const label = params?.sheet && params?.anchor ? `${params.sheet}!${params.anchor}` : src;
+    if (!container) {
+      onWarning?.(
+        `Data reference "${src}" could not be embedded: the export has no source container to read it from.`
+      );
+      continue;
+    }
+    const ext = extensionOf(src);
+    const reader = readers.find((r) => r.extensions.includes(ext));
+    if (!reader) {
+      onWarning?.(`Data reference "${src}" could not be embedded: no reader for ".${ext}".`);
+      continue;
+    }
+    const previewRows = Number.parseInt(params?.previewRows ?? "", 10);
+    const maxRows = options.maxRows === void 0 ? Number.POSITIVE_INFINITY : previewRows > 0 ? previewRows : options.maxRows;
+    const readOptions = {
+      maxRows,
+      ...params?.sheet ? { sheet: params.sheet } : {},
+      ...params?.anchor ? { anchor: params.anchor } : {},
+      ...params?.headerRow !== void 0 ? { headerRow: params.headerRow !== "false" } : {},
+      // Exports honor the author's curated view: the sort/filter params
+      // shape the embedded full table exactly as they shape previews.
+      ...params?.sort ? { sort: params.sort } : {},
+      ...params?.filter ? { filter: params.filter } : {}
+    };
+    const cacheKey = [
+      src,
+      readOptions.sheet ?? "",
+      readOptions.anchor ?? "",
+      String(readOptions.headerRow ?? ""),
+      readOptions.sort ?? "",
+      readOptions.filter ?? "",
+      String(maxRows)
+    ].join("\0");
+    let pending = options.tableCache?.get(cacheKey);
+    if (!pending) {
+      let bytes = null;
+      try {
+        bytes = await container.readFile(src);
+      } catch {
+        bytes = null;
+      }
+      if (!bytes) {
+        onWarning?.(`Data reference "${src}" could not be embedded: file not found in container.`);
+        continue;
+      }
+      pending = reader.read(bytes, readOptions);
+      options.tableCache?.set(cacheKey, pending);
+    }
+    try {
+      const table = await pending;
+      const mdTable = {
+        type: "table",
+        children: [tableRow(table.headers), ...table.rows.map(tableRow)]
+      };
+      children.push(mdTable);
+      if (table.totalRows > table.rows.length) {
+        children.push({
+          type: "paragraph",
+          children: [
+            {
+              type: "emphasis",
+              children: [
+                {
+                  type: "text",
+                  value: `Showing ${count(table.rows.length)} of ${count(table.totalRows)} rows.`
+                }
+              ]
+            }
+          ]
+        });
+      }
+      changed = true;
+      if (ext === "xlsx") {
+        onWarning?.(
+          `Region ${label} exported as values; formulas in the sidecar workbook were not carried over.`
+        );
+      }
+    } catch (err) {
+      onWarning?.(
+        `Data reference "${src}" could not be embedded: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return changed ? { ...markdownDoc, children } : markdownDoc;
+}
+
+export {
+  DATA_PREVIEW_ROWS,
+  materializeDataReferences
+};

package/dist/{chunk-SVYTUYZM.js → chunk-ZJERBWTB.js}

@@ -14,13 +14,14 @@ import {
 } from "./chunk-JU2RHXUB.js";
 import {
   FootnoteIndex,
-  footnoteIds
-} from "./chunk-BXWNU4T5.js";
+  footnoteIds,
+  withoutBlockTags
+} from "./chunk-DTJQK7U7.js";
 import {
   collectInlineIconFamilies,
   fontAwesomeFaces,
   fontAwesomeGlyph
-} from "./chunk-LBXBRFBZ.js";
+} from "./chunk-DDMPZZJF.js";
 import {
   imageSizeAttributes
 } from "./chunk-JZR32FON.js";
@@ -30,8 +31,9 @@ import JSZip from "jszip";
 import { resolveFontFamily } from "@bendyline/squisq/schemas";
 import { resolveThemeForDoc } from "@bendyline/squisq/doc";
 import { isHtmlLineBreak, readFrontmatterThemeId, sanitizeUrl } from "@bendyline/squisq/markdown";
-async function markdownDocToEpub(sourceDoc, options = {}) {
+async function markdownDocToEpub(authoredDoc, options = {}) {
   options.signal?.throwIfAborted();
+  const sourceDoc = withoutBlockTags(authoredDoc);
   const themeId = options.themeId ?? readFrontmatterThemeId(sourceDoc.frontmatter);
   const islandColor = themeId ? resolveThemeForDoc(sourceDoc, themeId, options.themeRegistry).colors.text : void 0;
   const { doc, images: islandImages } = svgIslandsAsImages(sourceDoc, { color: islandColor });

package/dist/data/index.d.ts

@@ -1,4 +1,4 @@
-import { DataSourceReader } from '@bendyline/squisq/doc';
+import { DataSourceReader, DataSourceTable } from '@bendyline/squisq/doc';
 import { ContentContainer } from '@bendyline/squisq/storage';
 import { MarkdownDocument } from '@bendyline/squisq/markdown';
 
@@ -31,12 +31,34 @@ declare function defaultDataReaders(): DataSourceReader[];
  * (its body link simply doesn't survive a tables-only export).
  */
 
+/**
+ * Rows a data reference shows in a document or page, which cannot carry the
+ * file it points at; the reader follows the author's link for the rest.
+ */
+declare const DATA_PREVIEW_ROWS = 100;
+interface MaterializeDataReferencesOptions {
+    /**
+     * Embed at most this many data rows per reference — a block's own
+     * `previewRows` param wins — followed by a "Showing N of M rows" note when
+     * rows were left out. Default: every row.
+     */
+    maxRows?: number;
+    /**
+     * A caller-owned memo of reader results, keyed by file and read options,
+     * for a caller that materializes the same document repeatedly (a live
+     * preview). The caller clears it when the files may have changed.
+     */
+    tableCache?: Map<string, Promise<DataSourceTable>>;
+}
 /**
  * Returns a copy of `markdownDoc` where every heading annotated with a
- * resolvable data `src` is followed by the full source table. The input
- * document is returned unchanged (same object) when nothing materialized.
+ * resolvable data `src` is followed by the source table (in full unless
+ * `options.maxRows` bounds it). A reference whose heading is already followed
+ * by a table keeps it — author data wins, as in `resolveDataReferences` — so
+ * materializing twice adds nothing. The input document is returned unchanged
+ * (same object) when nothing materialized.
  */
-declare function materializeDataReferences(markdownDoc: MarkdownDocument, container: ContentContainer | null | undefined, onWarning?: (message: string) => void): Promise<MarkdownDocument>;
+declare function materializeDataReferences(markdownDoc: MarkdownDocument, container: ContentContainer | null | undefined, onWarning?: (message: string) => void, options?: MaterializeDataReferencesOptions): Promise<MarkdownDocument>;
 
 /**
  * Sidecar naming shared by the spill-capable importers (`xlsxToContainer`,
@@ -75,4 +97,4 @@ declare function sidecarReferenceDoc(plan: DataSidecarPlan): MarkdownDocument;
 /** {@link sidecarReferenceDoc} as serialized markdown source. */
 declare function sidecarReferenceMarkdown(plan: DataSidecarPlan): string;
 
-export { type DataSidecarPlan, csvDataReader, defaultDataReaders, docSlugForFileName, materializeDataReferences, parquetDataReader, planDataSidecar, sanitizeSourceFileName, sidecarReferenceDoc, sidecarReferenceMarkdown, xlsxDataReader };
+export { DATA_PREVIEW_ROWS, type DataSidecarPlan, type MaterializeDataReferencesOptions, csvDataReader, defaultDataReaders, docSlugForFileName, materializeDataReferences, parquetDataReader, planDataSidecar, sanitizeSourceFileName, sidecarReferenceDoc, sidecarReferenceMarkdown, xlsxDataReader };

package/dist/data/index.js

@@ -1,10 +1,13 @@
+import {
+  DATA_PREVIEW_ROWS,
+  materializeDataReferences
+} from "../chunk-YRFBWYAD.js";
 import {
   csvDataReader,
   defaultDataReaders,
-  materializeDataReferences,
   parquetDataReader,
   xlsxDataReader
-} from "../chunk-UXEANVBI.js";
+} from "../chunk-5HUHSLGA.js";
 import "../chunk-ATWVNF7D.js";
 import "../chunk-Q77KNJIN.js";
 import {
@@ -17,6 +20,7 @@ import {
 import "../chunk-S5PCVMKU.js";
 import "../chunk-7AWFHP5U.js";
 export {
+  DATA_PREVIEW_ROWS,
   csvDataReader,
   defaultDataReaders,
   docSlugForFileName,

package/dist/diagrams/index.d.ts

@@ -21,25 +21,28 @@ import { MarkdownDocument, MarkdownCodeBlock } from '@bendyline/squisq/markdown'
  *   and PPTX embed an island natively as vector art, so by default it is
  *   left in place. Ask for it to picture islands for PDF, or to get the
  *   `svg` map of PNG fallbacks the Office exporters place beside the vector.
+ * - chart heading blocks (`{[barChart]}`, `{[pieChart]}`, …) whose first
+ *   table is chartable: the picture replaces the table, as the player shows
+ *   the chart alone (the table stays beneath it with `showTable`).
  *
- * `docToPptx` keeps drawings, timelines and ASCII diagrams as native shapes;
- * for it, use the returned `mermaid` map as its `diagramImages` option.
+ * `docToPptx` keeps drawings, timelines, ASCII diagrams and charts as native
+ * shapes; for it, use the returned `mermaid` map as its `diagramImages` option.
  */
 
 /** What kind of diagram a picture is wanted for. */
-type ExportDiagramKind = 'mermaid' | 'diagram' | 'timeline' | 'tree' | 'container' | 'svg';
+type ExportDiagramKind = 'mermaid' | 'diagram' | 'timeline' | 'tree' | 'container' | 'svg' | 'chart';
 /** Every kind, `svg` included — for exporters with no vector picture of their own (PDF). */
 declare const EXPORT_DIAGRAM_KINDS: readonly ExportDiagramKind[];
 interface ExportDiagram {
     readonly kind: ExportDiagramKind;
     /**
-     * The diagram's own markdown: its fence, or for a container its heading
-     * and every child heading and body it owns.
+     * The diagram's own markdown: its fence, for a container its heading and
+     * every child heading and body it owns, for a chart its heading and table.
      */
     readonly markdown: string;
-    /** The fence content for fence kinds; '' for containers. */
+    /** The fence content for fence kinds; '' for containers and charts. */
     readonly source: string;
-    /** The container's template (`drawing`, `layout`, `diagram`); '' for fences. */
+    /** The container's or chart's template (`drawing`, `barChart`, …); '' for fences. */
     readonly template: string;
     /** A text alternative for the picture. */
     readonly alt: string;
@@ -87,6 +90,14 @@ interface RasterizedDiagrams {
 declare function fenceDiagramKind(node: MarkdownCodeBlock): ExportDiagramKind | null;
 /** Every diagram in `doc`, in document order. */
 declare function findDiagrams(doc: MarkdownDocument): ExportDiagram[];
+/**
+ * A renderer that remembers what it drew, for a host that renders the same
+ * document again and again — a live preview, or a file regenerated on every
+ * save — so each pass redraws only the diagrams that changed. A picture is
+ * keyed by the diagram itself; the least recently used beyond `limit` are
+ * forgotten, and a failure is never remembered.
+ */
+declare function cachingDiagramRasterizer(render: DiagramRasterizer, limit?: number): DiagramRasterizer;
 /**
  * Picture every diagram in `doc` with `render`, one at a time, and return
  * the document with each pictured diagram replaced by an image of it. A
@@ -94,4 +105,4 @@ declare function findDiagrams(doc: MarkdownDocument): ExportDiagram[];
  */
 declare function rasterizeDiagrams(doc: MarkdownDocument, render: DiagramRasterizer, options?: RasterizeDiagramsOptions): Promise<RasterizedDiagrams>;
 
-export { type DiagramPicture, type DiagramRasterizer, EXPORT_DIAGRAM_KINDS, type ExportDiagram, type ExportDiagramKind, type RasterizeDiagramsOptions, type RasterizedDiagrams, fenceDiagramKind, findDiagrams, rasterizeDiagrams };
+export { type DiagramPicture, type DiagramRasterizer, EXPORT_DIAGRAM_KINDS, type ExportDiagram, type ExportDiagramKind, type RasterizeDiagramsOptions, type RasterizedDiagrams, cachingDiagramRasterizer, fenceDiagramKind, findDiagrams, rasterizeDiagrams };

package/dist/diagrams/index.js

@@ -1,248 +1,13 @@
-// src/diagrams/index.ts
 import {
-  extractPlainText,
-  isSvgIslandLang,
-  parseSvgIsland,
-  stringifyMarkdown
-} from "@bendyline/squisq/markdown";
-import {
-  detectAsciiDiagram,
-  detectAsciiTimeline,
-  detectTree,
-  isContainerTemplate,
-  isEligibleAsciiFenceLang,
-  isEligibleAsciiTimelineFenceLang,
-  isEligibleTreeFenceLang,
-  isExplicitDiagramLang,
-  isExplicitTimelineLang,
-  isExplicitTreeLang,
-  resolveTemplateName
-} from "@bendyline/squisq/doc";
-var DEFAULT_KINDS = [
-  "mermaid",
-  "diagram",
-  "timeline",
-  "tree",
-  "container"
-];
-var EXPORT_DIAGRAM_KINDS = [...DEFAULT_KINDS, "svg"];
-var KIND_NAMES = {
-  mermaid: "Diagram",
-  diagram: "Diagram",
-  timeline: "Timeline",
-  tree: "Tree",
-  container: "Diagram",
-  svg: "Illustration"
-};
-function fenceDiagramKind(node) {
-  const lang = node.lang ?? null;
-  if ((lang ?? "").trim().toLowerCase() === "mermaid") return "mermaid";
-  if (isSvgIslandLang(lang)) return parseSvgIsland(node.value).ok ? "svg" : null;
-  if (isEligibleAsciiFenceLang(lang)) {
-    const detection = detectAsciiDiagram(node.value, { explicit: isExplicitDiagramLang(lang) });
-    if (detection.isDiagram) return "diagram";
-  }
-  if (isEligibleTreeFenceLang(lang)) {
-    if (detectTree(node.value, { explicit: isExplicitTreeLang(lang) }).isTree) return "tree";
-  }
-  if (isEligibleAsciiTimelineFenceLang(lang)) {
-    const detection = detectAsciiTimeline(node.value, { explicit: isExplicitTimelineLang(lang) });
-    if (detection.isTimeline) return "timeline";
-  }
-  return null;
-}
-function containerTemplateOf(node) {
-  if (node.type !== "heading") return null;
-  const requested = node.templateAnnotation?.template;
-  if (!requested || !isContainerTemplate(requested)) return null;
-  return resolveTemplateName(requested);
-}
-function mermaidAlt(source) {
-  const title = /^\s*accTitle\s*:\s*(.+?)\s*$/mu.exec(source)?.[1] ?? "";
-  const description = /^\s*accDescr\s*:\s*(.+?)\s*$/mu.exec(source)?.[1] ?? "";
-  return [title, description].filter(Boolean).join(". ");
-}
-function fenceAlt(kind, source) {
-  if (kind === "mermaid") return mermaidAlt(source);
-  if (kind === "svg") {
-    const result = parseSvgIsland(source);
-    return result.ok && result.island.title || "";
-  }
-  return "";
-}
-function fenceMarkdown(node) {
-  return stringifyMarkdown({ type: "document", children: [node] }).trim();
-}
-function findInDocument(doc) {
-  const found = [];
-  const children = doc.children;
-  const walk = (nodes) => {
-    for (const node of nodes) {
-      if (node.type === "code") {
-        const fence = node;
-        const kind = fenceDiagramKind(fence);
-        if (kind) {
-          found.push({
-            fence,
-            diagram: {
-              kind,
-              markdown: fenceMarkdown(fence),
-              source: fence.value,
-              template: "",
-              alt: fenceAlt(kind, fence.value) || KIND_NAMES[kind]
-            }
-          });
-        }
-        continue;
-      }
-      const nested = node.children;
-      if (Array.isArray(nested) && node.type !== "heading" && node.type !== "paragraph") {
-        walk(nested);
-      }
-    }
-  };
-  for (let index = 0; index < children.length; index++) {
-    const node = children[index];
-    const template = containerTemplateOf(node);
-    if (!template) {
-      walk([node]);
-      continue;
-    }
-    const depth = node.depth;
-    let end = index + 1;
-    while (end < children.length) {
-      const next = children[end];
-      if (next.type === "heading" && next.depth <= depth) break;
-      end++;
-    }
-    const heading = extractPlainText(node).trim();
-    found.push({
-      containerIndex: index,
-      containerEnd: end,
-      diagram: {
-        kind: "container",
-        markdown: stringifyMarkdown({
-          type: "document",
-          children: children.slice(index, end)
-        }).trim(),
-        source: "",
-        template,
-        alt: heading || KIND_NAMES.container
-      }
-    });
-    index = end - 1;
-  }
-  return found;
-}
-function imageUrls(nodes, into) {
-  for (const node of nodes) {
-    if (node.type === "image") into.add(node.url);
-    const nested = node.children;
-    if (Array.isArray(nested)) imageUrls(nested, into);
-  }
-  return into;
-}
-function findDiagrams(doc) {
-  return findInDocument(doc).map((entry) => entry.diagram);
-}
-function imageParagraph(url, alt) {
-  const image = { type: "image", url, alt, title: null };
-  return { type: "paragraph", children: [image] };
-}
-function replaceFences(nodes, replacements) {
-  let changed = false;
-  const next = nodes.map((node) => {
-    const replacement = replacements.get(node);
-    if (replacement) {
-      changed = true;
-      return replacement;
-    }
-    const nested = node.children;
-    if (Array.isArray(nested)) {
-      const replaced = replaceFences(nested, replacements);
-      if (replaced !== nested) {
-        changed = true;
-        return { ...node, children: replaced };
-      }
-    }
-    return node;
-  });
-  return changed ? next : nodes;
-}
-async function rasterizeDiagrams(doc, render, options = {}) {
-  const kinds = new Set(options.kinds ?? DEFAULT_KINDS);
-  const prefix = options.urlPrefix ?? "diagram";
-  const taken = imageUrls(doc.children, /* @__PURE__ */ new Set());
-  let counter = 0;
-  const nextUrl = () => {
-    let url;
-    do
-      url = `${prefix}-${String(++counter)}.png`;
-    while (taken.has(url));
-    taken.add(url);
-    return url;
-  };
-  const images = /* @__PURE__ */ new Map();
-  const mermaid = /* @__PURE__ */ new Map();
-  const svg = /* @__PURE__ */ new Map();
-  const fenceReplacements = /* @__PURE__ */ new Map();
-  const containerReplacements = [];
-  for (const entry of findInDocument(doc)) {
-    options.signal?.throwIfAborted();
-    if (!kinds.has(entry.diagram.kind)) continue;
-    let picture = null;
-    try {
-      picture = await render(entry.diagram);
-    } catch (error) {
-      options.onWarning?.(
-        `A ${KIND_NAMES[entry.diagram.kind].toLowerCase()} could not be drawn and was kept as text: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-    if (!picture || picture.width <= 0 || picture.height <= 0) continue;
-    const data = picture.data instanceof Uint8Array ? picture.data : new Uint8Array(picture.data);
-    const url = nextUrl();
-    images.set(url, {
-      data,
-      contentType: "image/png",
-      width: picture.width,
-      height: picture.height
-    });
-    if (entry.diagram.kind === "mermaid") mermaid.set(entry.diagram.source.trim(), picture);
-    if (entry.diagram.kind === "svg") svg.set(entry.diagram.source.trim(), picture);
-    const paragraph = imageParagraph(url, entry.diagram.alt);
-    if (entry.fence) {
-      fenceReplacements.set(entry.fence, paragraph);
-    } else if (entry.containerIndex !== void 0 && entry.containerEnd !== void 0) {
-      const heading = doc.children[entry.containerIndex];
-      const { templateAnnotation: _template, ...plainHeading } = heading;
-      containerReplacements.push({
-        start: entry.containerIndex,
-        end: entry.containerEnd,
-        nodes: [plainHeading, paragraph]
-      });
-    }
-  }
-  let children = doc.children;
-  if (containerReplacements.length > 0) {
-    const rebuilt = [];
-    let cursor = 0;
-    for (const replacement of containerReplacements) {
-      rebuilt.push(...children.slice(cursor, replacement.start), ...replacement.nodes);
-      cursor = replacement.end;
-    }
-    rebuilt.push(...children.slice(cursor));
-    children = rebuilt;
-  }
-  if (fenceReplacements.size > 0) children = replaceFences(children, fenceReplacements);
-  return {
-    markdownDoc: children === doc.children ? doc : { ...doc, children },
-    images,
-    mermaid,
-    svg
-  };
-}
+  EXPORT_DIAGRAM_KINDS,
+  cachingDiagramRasterizer,
+  fenceDiagramKind,
+  findDiagrams,
+  rasterizeDiagrams
+} from "../chunk-4LIFEQKX.js";
 export {
   EXPORT_DIAGRAM_KINDS,
+  cachingDiagramRasterizer,
   fenceDiagramKind,
   findDiagrams,
   rasterizeDiagrams

package/dist/docx/index.d.ts

@@ -84,7 +84,7 @@ interface DocxExportOptions {
  * @param options - Export options
  * @returns An ArrayBuffer containing the .docx file
  */
-declare function markdownDocToDocx(doc: MarkdownDocument, options?: DocxExportOptions): Promise<ArrayBuffer>;
+declare function markdownDocToDocx(source: MarkdownDocument, options?: DocxExportOptions): Promise<ArrayBuffer>;
 /**
  * Convert a squisq Doc to a .docx Blob.
  *

package/dist/docx/index.js

@@ -4,7 +4,7 @@ import {
   docxToDoc,
   docxToMarkdownDoc,
   markdownDocToDocx
-} from "../chunk-KROH7FNT.js";
+} from "../chunk-VKLJUHC2.js";
 import "../chunk-DHAK4PII.js";
 import "../chunk-VCZUXQUL.js";
 import "../chunk-BZ5SHMOY.js";
@@ -12,9 +12,9 @@ import "../chunk-ILCJ3WFD.js";
 import "../chunk-JU2RHXUB.js";
 import "../chunk-S5PCVMKU.js";
 import "../chunk-7AWFHP5U.js";
-import "../chunk-BXWNU4T5.js";
+import "../chunk-DTJQK7U7.js";
 import "../chunk-IIQYS2YH.js";
-import "../chunk-LBXBRFBZ.js";
+import "../chunk-DDMPZZJF.js";
 import "../chunk-JZR32FON.js";
 export {
   docToDocx,

package/dist/epub/index.d.ts

@@ -66,7 +66,7 @@ interface EpubExportOptions {
  * Chapters are split at H1/H2 heading boundaries. All referenced images
  * (provided via `options.images`) are embedded in the archive.
  */
-declare function markdownDocToEpub(sourceDoc: MarkdownDocument, options?: EpubExportOptions): Promise<ArrayBuffer>;
+declare function markdownDocToEpub(authoredDoc: MarkdownDocument, options?: EpubExportOptions): Promise<ArrayBuffer>;
 /**
  * Convert a squisq Doc to an EPUB 3 file.
  *

package/dist/epub/index.js

@@ -1,13 +1,13 @@
 import {
   docToEpub,
   markdownDocToEpub
-} from "../chunk-SVYTUYZM.js";
+} from "../chunk-ZJERBWTB.js";
 import "../chunk-WMIDXNGR.js";
 import "../chunk-VCZUXQUL.js";
 import "../chunk-BZ5SHMOY.js";
 import "../chunk-JU2RHXUB.js";
-import "../chunk-BXWNU4T5.js";
-import "../chunk-LBXBRFBZ.js";
+import "../chunk-DTJQK7U7.js";
+import "../chunk-DDMPZZJF.js";
 import "../chunk-JZR32FON.js";
 export {
   docToEpub,

package/dist/fontAwesome-C6FRDYTY.js

@@ -0,0 +1,14 @@
+import {
+  collectInlineIconFamilies,
+  fontAwesomeFace,
+  fontAwesomeFaces,
+  fontAwesomeGlyph,
+  obfuscateDocxFont
+} from "./chunk-DDMPZZJF.js";
+export {
+  collectInlineIconFamilies,
+  fontAwesomeFace,
+  fontAwesomeFaces,
+  fontAwesomeGlyph,
+  obfuscateDocxFont
+};

package/dist/html/icons.d.ts

@@ -0,0 +1,29 @@
+import { MarkdownDocument } from '@bendyline/squisq/markdown';
+import { P as PlainHtmlIcon } from '../plainHtml-B6IXcSet.js';
+import '@bendyline/squisq/schemas';
+
+/**
+ * Inline icons as SVG, for pages that should not depend on a font.
+ *
+ * A Font Awesome icon in the plain renderer is `<i class="fa-solid fa-star">`,
+ * which draws only where Font Awesome's stylesheet and fonts load — a CDN the
+ * page may not be allowed to reach, or a bundle it doesn't ship. Each icon's
+ * outline is read here from the same Font Awesome faces the DOCX, PDF and
+ * EPUB exporters embed, and drawn as a small inline `<svg>` instead: no font,
+ * no network, and it takes the text color like the glyph would.
+ *
+ * This module is its own entry, `@bendyline/squisq-formats/html-icons`, and
+ * nothing under `/html` may import it: the faces and their parser are ~2.5 MB,
+ * and a one-file bundle of `/html` would carry them even if it never drew an
+ * icon. Hosts pass `plainHtmlIcons` to `prepareMarkdownDocForPlainHtml`
+ * (`@bendyline/squisq-formats/html-prepare`) as `outlineIcons`.
+ */
+
+/**
+ * The outline of every icon `doc` uses, keyed `family:name` — the `icons`
+ * option of `markdownDocToPlainHtml`. An icon the catalog doesn't know is left
+ * out and keeps its Font Awesome markup.
+ */
+declare function plainHtmlIcons(doc: MarkdownDocument): Promise<Map<string, PlainHtmlIcon>>;
+
+export { plainHtmlIcons };