@bendyline/squisq-formats 2.8.8 → 2.8.9

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/index.d.ts

@@ -2,6 +2,9 @@ import { Theme, ThemeRegistry, Doc } from '@bendyline/squisq/schemas';
 import { H as HtmlExportOptions } from '../import-ipP4Ghp8.js';
 export { a as HtmlImportOptions, c as collectImagePaths, g as generateExternalHtml, h as htmlToMarkdown, b as htmlToMarkdownDoc, d as htmlToMarkdownDocSync } from '../import-ipP4Ghp8.js';
 import { HtmlPolicy, MarkdownDocument } from '@bendyline/squisq/markdown';
+import { DataSourceTable } from '@bendyline/squisq/doc';
+import { ContentContainer } from '@bendyline/squisq/storage';
+import { DiagramRasterizer } from '../diagrams/index.js';
 
 /**
  * Image Utilities for HTML Export
@@ -128,6 +131,19 @@ interface PlainHtmlExportOptions {
      *   inherit the sandbox, so the player would load broken), or print.
      */
     videoEmbeds?: 'player' | 'poster';
+    /**
+     * Inline icons as SVG, keyed `family:name` (`solid:star`) — the `icons` that
+     * `prepareMarkdownDocForPlainHtml` returns. An icon found here is drawn as
+     * an inline `<svg>` in the text color and needs no Font Awesome stylesheet;
+     * any other icon keeps its Font Awesome markup (see {@link iconsCss}).
+     */
+    icons?: ReadonlyMap<string, PlainHtmlIcon>;
+}
+/** One icon's outline: an SVG path in a `0 0 width height` box whose height is 1em. */
+interface PlainHtmlIcon {
+    width: number;
+    height: number;
+    path: string;
 }
 /**
  * Render a parsed markdown document as a complete, semantic HTML page.
@@ -163,6 +179,74 @@ interface PlainHtmlParts {
  */
 declare function markdownDocToPlainHtmlParts(doc: MarkdownDocument, options?: PlainHtmlExportOptions): PlainHtmlParts;
 
+/**
+ * Preparing a document for a static HTML page.
+ *
+ * A plain HTML page (`markdownDocToPlainHtml`, or a page template filled from
+ * `markdownDocToPlainHtmlParts`) runs no script, so what the player draws at
+ * runtime has to be settled before the page is written:
+ *
+ * - `{[dataTable src=…]}` references (and charts fed by one) get the table
+ *   they point at, bounded to a preview window with a "Showing N of M rows"
+ *   note — the author's body link to the full file follows it;
+ * - Mermaid fences, ASCII diagrams and timelines, drawing / layout / diagram
+ *   blocks, and charts become pictures, drawn by a host-supplied renderer
+ *   (drawing needs a browser) and returned as `data:` URLs;
+ * - inline icons become inline SVG outlines, so the page needs no Font
+ *   Awesome stylesheet or font.
+ *
+ * File trees stay preformatted text, which a page shows as well as a picture
+ * would and keeps selectable; SVG islands the renderer already draws.
+ */
+
+interface PlainHtmlPreparationOptions {
+    /**
+     * Draws diagrams and charts as pictures. In a browser, pass
+     * `createDiagramPictureRenderer()` from
+     * `@bendyline/squisq-react/diagram-pictures`. Without one, diagrams stay as
+     * their source and charts as their table.
+     */
+    renderDiagram?: DiagramRasterizer;
+    /**
+     * The container holding the document's data sidecars. Without one, a data
+     * reference keeps only its link.
+     */
+    container?: ContentContainer | null;
+    /** Rows per data table; a block's own `previewRows` wins. Default 100. */
+    maxDataRows?: number;
+    /**
+     * A caller-owned memo of data-file reads, for a host that prepares the
+     * same document again and again (a live preview). The caller clears it
+     * when the files may have changed.
+     */
+    dataTableCache?: Map<string, Promise<DataSourceTable>>;
+    signal?: AbortSignal;
+    /** Receives a note for each table or picture that could not be produced. */
+    onWarning?: (message: string) => void;
+}
+interface PreparedPlainHtmlDocument {
+    /** The document to render, with data tables filled in and pictures in place. */
+    markdownDoc: MarkdownDocument;
+    /**
+     * The pictures as `data:` URLs, keyed by the image URL written into
+     * `markdownDoc`. Merge them into the renderer's `images` option.
+     */
+    images: Map<string, string>;
+    /** Outlines of the document's inline icons: the renderer's `icons` option. */
+    icons: Map<string, PlainHtmlIcon>;
+}
+/**
+ * Whether {@link prepareMarkdownDocForPlainHtml} would change anything for
+ * `doc` with these options — so a live preview renders a document with
+ * nothing to prepare at once, without waiting on the asynchronous step.
+ */
+declare function needsPlainHtmlPreparation(doc: MarkdownDocument, options?: Pick<PlainHtmlPreparationOptions, 'renderDiagram' | 'container'>): boolean;
+/**
+ * Settle everything in `doc` a script-free page cannot draw. Never throws for
+ * one table or picture: each degrades to its link or source with a warning.
+ */
+declare function prepareMarkdownDocForPlainHtml(doc: MarkdownDocument, options?: PlainHtmlPreparationOptions): Promise<PreparedPlainHtmlDocument>;
+
 /**
  * HTML Page Templates
  *
@@ -477,4 +561,4 @@ declare function docToHtml(doc: Doc, options: HtmlExportOptions): string;
  */
 declare function docToHtmlZip(doc: Doc, options: HtmlZipExportOptions): Promise<Blob>;
 
-export { HTML_PAGE_TEMPLATE_CONTENT_END, HTML_PAGE_TEMPLATE_CONTENT_START, type HtmlBundleOptions, HtmlExportOptions, type HtmlPageTemplateContent, HtmlPageTemplateError, type HtmlPageTemplateInspection, type HtmlPageTemplateIssue, type HtmlPageTemplateOptions, type HtmlZipExportOptions, type PlainHtmlBundleOptions, type PlainHtmlExportOptions, type PlainHtmlParts, applyHtmlPageTemplate, arrayBufferToBase64DataUrl, collectLinkRefs, docToHtml, docToHtmlZip, extractFilename, extractHtmlPageTemplateContent, inferMimeType, inspectHtmlPageTemplate, isHtmlPageTemplate, markdownDocToPlainHtml, markdownDocToPlainHtmlParts, markdownDocsToHtmlBundle, markdownDocsToPlainHtmlBundle };
+export { HTML_PAGE_TEMPLATE_CONTENT_END, HTML_PAGE_TEMPLATE_CONTENT_START, type HtmlBundleOptions, HtmlExportOptions, type HtmlPageTemplateContent, HtmlPageTemplateError, type HtmlPageTemplateInspection, type HtmlPageTemplateIssue, type HtmlPageTemplateOptions, type HtmlZipExportOptions, type PlainHtmlBundleOptions, type PlainHtmlExportOptions, type PlainHtmlIcon, type PlainHtmlParts, type PlainHtmlPreparationOptions, type PreparedPlainHtmlDocument, applyHtmlPageTemplate, arrayBufferToBase64DataUrl, collectLinkRefs, docToHtml, docToHtmlZip, extractFilename, extractHtmlPageTemplateContent, inferMimeType, inspectHtmlPageTemplate, isHtmlPageTemplate, markdownDocToPlainHtml, markdownDocToPlainHtmlParts, markdownDocsToHtmlBundle, markdownDocsToPlainHtmlBundle, needsPlainHtmlPreparation, prepareMarkdownDocForPlainHtml };

package/dist/html/index.js

@@ -17,15 +17,18 @@ import {
   markdownDocToPlainHtml,
   markdownDocToPlainHtmlParts,
   markdownDocsToHtmlBundle,
-  markdownDocsToPlainHtmlBundle
-} from "../chunk-LK4KCVN6.js";
+  markdownDocsToPlainHtmlBundle,
+  needsPlainHtmlPreparation,
+  prepareMarkdownDocForPlainHtml
+} from "../chunk-SZ3OIY6G.js";
+import "../chunk-4LIFEQKX.js";
 import {
   arrayBufferToBase64DataUrl,
   extractFilename,
   inferMimeType
 } from "../chunk-WMIDXNGR.js";
 import "../chunk-VCZUXQUL.js";
-import "../chunk-BXWNU4T5.js";
+import "../chunk-DTJQK7U7.js";
 import "../chunk-JZR32FON.js";
 export {
   HTML_PAGE_TEMPLATE_CONTENT_END,
@@ -49,5 +52,7 @@ export {
   markdownDocToPlainHtml,
   markdownDocToPlainHtmlParts,
   markdownDocsToHtmlBundle,
-  markdownDocsToPlainHtmlBundle
+  markdownDocsToPlainHtmlBundle,
+  needsPlainHtmlPreparation,
+  prepareMarkdownDocForPlainHtml
 };

package/dist/index.d.ts

@@ -19,6 +19,8 @@ import '@bendyline/squisq/markdown';
 import './reader-B_m1aKZC.js';
 import '@bendyline/squisq/storage';
 import './layouts-CTdPlB-u.js';
+import '@bendyline/squisq/doc';
+import './diagrams/index.js';
 import './themeReader-DCtwC83Q.js';
 import '@bendyline/squisq/transform';
 import './container/index.js';