@bendyline/squisq-formats 2.8.8 → 2.8.10

package/dist/html/icons.js

@@ -0,0 +1,62 @@
+// src/html/plainHtmlIcons.ts
+var fonts = /* @__PURE__ */ new Map();
+function loadFont(family) {
+  let font = fonts.get(family);
+  if (!font) {
+    font = Promise.all([import("@pdf-lib/fontkit"), import("../fontAwesome-C6FRDYTY.js")]).then(
+      ([fontkit, { fontAwesomeFace }]) => fontkit.default.create(fontAwesomeFace(family).data)
+    );
+    font.catch(() => fonts.delete(family));
+    fonts.set(family, font);
+  }
+  return font;
+}
+function usedIcons(doc) {
+  const used = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    const n = node;
+    if (n.type === "inlineIcon" && n.family && n.name) {
+      used.set(`${n.family}:${n.name}`, [n.family, n.name]);
+    }
+    if (Array.isArray(n.children)) n.children.forEach(visit);
+  };
+  visit(doc);
+  return used;
+}
+var round = (n) => Math.round(n * 100) / 100;
+function glyphPath(font, glyph) {
+  const y = (value) => round(font.ascent - value);
+  const parts = [];
+  const sink = {
+    moveTo: (x, py) => parts.push(`M${round(x)} ${y(py)}`),
+    lineTo: (x, py) => parts.push(`L${round(x)} ${y(py)}`),
+    quadraticCurveTo: (cx, cy, x, py) => parts.push(`Q${round(cx)} ${y(cy)} ${round(x)} ${y(py)}`),
+    bezierCurveTo: (c1x, c1y, c2x, c2y, x, py) => parts.push(`C${round(c1x)} ${y(c1y)} ${round(c2x)} ${y(c2y)} ${round(x)} ${y(py)}`),
+    closePath: () => parts.push("Z")
+  };
+  glyph.path.toFunction()(sink);
+  return parts.join("");
+}
+async function plainHtmlIcons(doc) {
+  const icons = /* @__PURE__ */ new Map();
+  const used = usedIcons(doc);
+  if (used.size === 0) return icons;
+  const { fontAwesomeGlyph } = await import("../fontAwesome-C6FRDYTY.js");
+  for (const [key, [family, name]] of used) {
+    const glyph = fontAwesomeGlyph(family, name);
+    if (!glyph) continue;
+    const font = await loadFont(family);
+    const outline = font.glyphForCodePoint(glyph.codePointAt(0));
+    if (!outline || outline.advanceWidth <= 0) continue;
+    icons.set(key, {
+      width: outline.advanceWidth,
+      height: font.unitsPerEm,
+      path: glyphPath(font, outline)
+    });
+  }
+  return icons;
+}
+export {
+  plainHtmlIcons
+};

package/dist/html/index.d.ts

@@ -1,7 +1,8 @@
 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';
+export { a as PlainHtmlExportOptions, P as PlainHtmlIcon, b as PlainHtmlParts, m as markdownDocToPlainHtml, c as markdownDocToPlainHtmlParts } from '../plainHtml-B6IXcSet.js';
+import { MarkdownDocument } from '@bendyline/squisq/markdown';
 
 /**
  * Image Utilities for HTML Export
@@ -35,134 +36,6 @@ declare function arrayBufferToBase64DataUrl(buffer: ArrayBuffer, mimeType: strin
  */
 declare function extractFilename(path: string): string;
 
-/**
- * Plain HTML Export — semantic, player-free
- *
- * Renders a MarkdownDocument to a self-contained HTML string. Unlike
- * `docToHtml` (which bundles the SquisqPlayer IIFE and renders SVG block
- * cards), this output is what a reader-mode tool would produce: semantic
- * `<h1>`/`<p>`/`<ul>`/etc. with a small embedded stylesheet, no JS, no
- * runtime path-rewriting. Drives both the "Page" preview tab in the
- * editor and the plain-style branch of the export dialog so what users
- * see live matches the file they download.
- *
- * Image URLs default to the markdown's own paths. Pass `images` to
- * substitute a different value per source URL — typically pre-resolved
- * blob URLs (live preview) or data URIs (single-file export).
- */
-
-interface PlainHtmlExportOptions {
-    /** Document title — populates `<title>` and is HTML-escaped. */
-    title?: string;
-    /**
-     * Substitution map for image `src` URLs. Keys are the URL exactly as
-     * it appears in the markdown source; values are the URL to emit in
-     * the rendered `<img src>`. URLs not present in the map fall through
-     * unchanged (so external `https://…` references still work).
-     */
-    images?: Map<string, string>;
-    /**
-     * Substitution map for anchor `href` URLs. Keys are the URL exactly
-     * as it appears in the markdown source (e.g. `'resume.md'`,
-     * `'resume.md#experience'`); values are the URL to emit. URLs not in
-     * the map pass through unchanged. Used by the recursive bundle
-     * exporter to rewrite `.md` references to `.html` so a static export
-     * of a linked document tree is internally browsable.
-     */
-    links?: Map<string, string>;
-    /**
-     * Optional Squisq theme. When provided, the rendered page uses the
-     * theme's colors and typography, and any Google-hosted fonts the
-     * theme references are loaded via a `<link>` to fonts.googleapis.com
-     * so the face renders correctly without host preloads.
-     *
-     * When omitted, the function falls back (in order) to {@link themeId}
-     * and then to `doc.frontmatter.themeId` — so an authored
-     * `themeId: warm-earth` in the doc's frontmatter styles the export
-     * automatically, without the caller having to wire theme resolution
-     * themselves.
-     */
-    theme?: Theme;
-    /**
-     * Optional theme id (e.g. `'warm-earth'`, `'gezellig'`). Convenient
-     * for hosts whose export dialog tracks themes by id — they can pass
-     * the id straight through instead of resolving to a `Theme` object.
-     * When both `theme` and `themeId` are provided, `theme` wins.
-     */
-    themeId?: string;
-    /** Explicit caller-owned registry for non-document custom themes. */
-    themeRegistry?: ThemeRegistry;
-    /**
-     * Optional FontAwesome CSS text to inline into the rendered page,
-     * replacing the default cross-origin `<link>` to cdnjs. Required for
-     * sandboxed iframe previews where tracking prevention or stricter
-     * origin policies can silently drop cross-origin font fetches —
-     * inlining keeps the icons resolvable purely from same-origin
-     * resources. Hosts typically gather this string by scraping
-     * `document.styleSheets` for `@font-face` rules whose family starts
-     * with `"Font Awesome"`. A CDN `<link>` is emitted only when this option
-     * is absent and {@link externalResources} is explicitly `allow`.
-     */
-    iconsCss?: string;
-    /**
-     * Whether this exporter may add remote font/icon stylesheets. Defaults to
-     * `deny`, keeping the generated file self-contained. Authored links and
-     * images are unaffected; bundle exporters are responsible for inlining or
-     * rewriting those document resources.
-     */
-    externalResources?: 'deny' | 'allow';
-    /**
-     * Raw HTML policy. Defaults to `sanitize`, which removes unsafe tags,
-     * event handlers, and executable URL schemes before emitting HTML.
-     */
-    htmlPolicy?: HtmlPolicy;
-    /**
-     * How a hosted video (a paragraph that is only a link to a YouTube, Vimeo,
-     * Loom or Wistia page, or that provider's `<iframe>` embed
-     * code) renders:
-     *
-     * - `player` (default) — the provider's player iframe;
-     * - `poster` — a static card linking to the video's page (the provider's
-     *   thumbnail where it serves one). For contexts where a player cannot run:
-     *   a preview iframe sandboxed without `allow-scripts` (nested frames
-     *   inherit the sandbox, so the player would load broken), or print.
-     */
-    videoEmbeds?: 'player' | 'poster';
-}
-/**
- * Render a parsed markdown document as a complete, semantic HTML page.
- *
- * When `options.theme` is provided, the output adopts the theme's
- * colors and typography. Google-hosted fonts referenced by the theme
- * are loaded via a single `<link>` to fonts.googleapis.com so the page
- * renders consistently when opened standalone.
- */
-declare function markdownDocToPlainHtml(doc: MarkdownDocument, options?: PlainHtmlExportOptions): string;
-/**
- * The pieces of a plain HTML page that belong to the document itself, for a
- * host that places the document inside a page of its own (see
- * `applyHtmlPageTemplate`).
- */
-interface PlainHtmlParts {
-    /** The `title` option, unescaped. */
-    title: string;
-    /** The rendered document body, footnotes included. */
-    bodyHtml: string;
-    /**
-     * `<head>` markup for the CSS the body's own constructs need — feature
-     * sections, video embeds, SVG islands, icons — and nothing that styles the
-     * page around them: no theme typography, colors, fonts, or `body` rules.
-     */
-    featureHeadHtml: string;
-}
-/**
- * Render a document's body and the functional CSS it depends on, without the
- * page shell or theme stylesheet `markdownDocToPlainHtml` wraps around them.
- * The theme (when one resolves) still informs body rendering, such as the
- * color an SVG island's `currentColor` follows.
- */
-declare function markdownDocToPlainHtmlParts(doc: MarkdownDocument, options?: PlainHtmlExportOptions): PlainHtmlParts;
-
 /**
  * HTML Page Templates
  *
@@ -477,4 +350,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, applyHtmlPageTemplate, arrayBufferToBase64DataUrl, collectLinkRefs, docToHtml, docToHtmlZip, extractFilename, extractHtmlPageTemplateContent, inferMimeType, inspectHtmlPageTemplate, isHtmlPageTemplate, markdownDocsToHtmlBundle, markdownDocsToPlainHtmlBundle };

package/dist/html/index.js

@@ -18,14 +18,14 @@ import {
   markdownDocToPlainHtmlParts,
   markdownDocsToHtmlBundle,
   markdownDocsToPlainHtmlBundle
-} from "../chunk-LK4KCVN6.js";
+} from "../chunk-QPJHAMOW.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,

package/dist/html/prepare.d.ts

@@ -0,0 +1,97 @@
+import { MarkdownDocument } from '@bendyline/squisq/markdown';
+import { DataSourceTable } from '@bendyline/squisq/doc';
+import { ContentContainer } from '@bendyline/squisq/storage';
+import { DiagramRasterizer } from '../diagrams/index.js';
+import { P as PlainHtmlIcon } from '../plainHtml-B6IXcSet.js';
+import '@bendyline/squisq/schemas';
+
+/**
+ * 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, drawn by a host-supplied
+ *   outliner (`plainHtmlIcons` from `@bendyline/squisq-formats/html-icons`),
+ *   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.
+ *
+ * This module is its own entry, `@bendyline/squisq-formats/html-prepare`, and
+ * nothing under `/html` imports it. A bundler that writes one file inlines
+ * every dynamic import it can reach, and filling data tables reaches the XLSX
+ * reader (an XML parser and zip code, ~300 KB) that a host only rendering
+ * plain HTML — say, an editor-extension host — must not carry. Both drawing
+ * steps are the host's to pass in for the same reason: the icon outlines alone
+ * (Font Awesome's faces and their parser) are ~2.5 MB.
+ */
+
+/**
+ * Outlines the inline icons `doc` uses, keyed `family:name` — the renderer's
+ * `icons` option. `plainHtmlIcons` from `@bendyline/squisq-formats/html-icons`
+ * is one.
+ */
+type PlainHtmlIconOutliner = (doc: MarkdownDocument) => Promise<Map<string, PlainHtmlIcon>>;
+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;
+    /**
+     * Draws inline icons as SVG outlines. Pass `plainHtmlIcons` from
+     * `@bendyline/squisq-formats/html-icons`; it needs no browser. Without one,
+     * icons keep their Font Awesome markup.
+     */
+    outlineIcons?: PlainHtmlIconOutliner;
+    /**
+     * 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' | 'outlineIcons' | '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>;
+
+export { type PlainHtmlIconOutliner, type PlainHtmlPreparationOptions, type PreparedPlainHtmlDocument, needsPlainHtmlPreparation, prepareMarkdownDocForPlainHtml };

package/dist/html/prepare.js

@@ -0,0 +1,85 @@
+import {
+  findDiagrams,
+  rasterizeDiagrams
+} from "../chunk-4LIFEQKX.js";
+import {
+  arrayBufferToBase64DataUrl
+} from "../chunk-WMIDXNGR.js";
+import "../chunk-JZR32FON.js";
+
+// src/html/plainHtmlPrepare.ts
+import { isDataFilePath } from "@bendyline/squisq/doc";
+var PAGE_DIAGRAM_KINDS = [
+  "mermaid",
+  "diagram",
+  "timeline",
+  "container",
+  "chart"
+];
+function needsPlainHtmlPreparation(doc, options = {}) {
+  let icons = false;
+  let data = false;
+  const visit = (node) => {
+    if (!node || typeof node !== "object" || icons && data) return;
+    const n = node;
+    if (n.type === "inlineIcon") icons = true;
+    if (n.type === "heading") {
+      const src = n.templateAnnotation?.params?.src;
+      if (src && isDataFilePath(src)) data = true;
+    }
+    if (Array.isArray(n.children)) n.children.forEach(visit);
+  };
+  doc.children.forEach(visit);
+  if (icons && options.outlineIcons || data && options.container) return true;
+  if (!options.renderDiagram) return false;
+  return findDiagrams(doc).some((diagram) => PAGE_DIAGRAM_KINDS.includes(diagram.kind));
+}
+async function prepareMarkdownDocForPlainHtml(doc, options = {}) {
+  const { renderDiagram, outlineIcons, container, signal, onWarning } = options;
+  let markdownDoc = doc;
+  if (container) {
+    const { materializeDataReferences, DATA_PREVIEW_ROWS } = await import("../materialize-ICXNO4S4.js");
+    markdownDoc = await materializeDataReferences(markdownDoc, container, onWarning, {
+      maxRows: options.maxDataRows ?? DATA_PREVIEW_ROWS,
+      tableCache: options.dataTableCache
+    });
+  }
+  signal?.throwIfAborted();
+  const icons = outlineIcons ? await outlineIcons(markdownDoc) : /* @__PURE__ */ new Map();
+  const images = /* @__PURE__ */ new Map();
+  if (!renderDiagram) return { markdownDoc, images, icons };
+  const pictured = await rasterizeDiagrams(markdownDoc, renderDiagram, {
+    kinds: PAGE_DIAGRAM_KINDS,
+    urlPrefix: "squisq-picture",
+    signal,
+    onWarning
+  });
+  const widths = /* @__PURE__ */ new Map();
+  for (const [url, picture] of pictured.images) {
+    const bytes = picture.data;
+    const buffer = bytes.buffer.slice(
+      bytes.byteOffset,
+      bytes.byteOffset + bytes.byteLength
+    );
+    images.set(url, arrayBufferToBase64DataUrl(buffer, picture.contentType));
+    widths.set(url, Math.round(picture.width));
+  }
+  return { markdownDoc: withPictureWidths(pictured.markdownDoc, widths), images, icons };
+}
+function withPictureWidths(doc, widths) {
+  if (widths.size === 0) return doc;
+  const visit = (node) => {
+    if (node.type === "image") {
+      const width = widths.get(node.url);
+      return width === void 0 ? node : { ...node, width };
+    }
+    const children = node.children;
+    if (!Array.isArray(children)) return node;
+    return { ...node, children: children.map(visit) };
+  };
+  return { ...doc, children: doc.children.map(visit) };
+}
+export {
+  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 './plainHtml-B6IXcSet.js';
 import './themeReader-DCtwC83Q.js';
 import '@bendyline/squisq/transform';
 import './container/index.js';
+import './diagrams/index.js';

package/dist/index.js

@@ -5,11 +5,11 @@ import {
   htmlToMarkdown,
   htmlToMarkdownDoc,
   htmlToMarkdownDocSync
-} from "./chunk-LK4KCVN6.js";
+} from "./chunk-QPJHAMOW.js";
 import {
   docToEpub,
   markdownDocToEpub
-} from "./chunk-SVYTUYZM.js";
+} from "./chunk-ZJERBWTB.js";
 import {
   BUILTIN_FORMAT_IDS
 } from "./chunk-2P5HJAQL.js";
@@ -29,7 +29,14 @@ import {
   renderOutsideInDocument,
   withOutsideInMarkdownEditing,
   withOutsideInMetadata
-} from "./chunk-6ALSRHD7.js";
+} from "./chunk-NCDY3EOL.js";
+import {
+  OUTSIDE_IN_FORMAT_IDS,
+  OUTSIDE_IN_OUTPUT_TEMPLATE_KEY,
+  chooseOutsideInMarkdownPath,
+  isOutsideInTargetPath,
+  resolveOutsideInLayout
+} from "./chunk-WJTC5OD6.js";
 import {
   DEFAULT_CONVERSION_LIMITS,
   convert,
@@ -38,29 +45,22 @@ import {
   defaultRegistry,
   prepareConversion,
   resolveConversionLimits
-} from "./chunk-GDUZJ75A.js";
+} from "./chunk-MJTPWLVV.js";
 import {
   ConversionError
 } from "./chunk-KXOZMWBS.js";
-import {
-  OUTSIDE_IN_FORMAT_IDS,
-  OUTSIDE_IN_OUTPUT_TEMPLATE_KEY,
-  chooseOutsideInMarkdownPath,
-  isOutsideInTargetPath,
-  resolveOutsideInLayout
-} from "./chunk-WJTC5OD6.js";
 import {
   docToDocx,
   docxToDoc,
   docxToMarkdownDoc,
   markdownDocToDocx
-} from "./chunk-KROH7FNT.js";
+} from "./chunk-VKLJUHC2.js";
 import {
   docToPptx,
   markdownDocToPptx,
   pptxToDoc,
   pptxToMarkdownDoc
-} from "./chunk-QU4EVC62.js";
+} from "./chunk-S5VXWSRR.js";
 import "./chunk-6N2J7C2B.js";
 import "./chunk-WMIDXNGR.js";
 import "./chunk-DHAK4PII.js";
@@ -96,11 +96,11 @@ import {
   markdownDocToPdf,
   pdfToDoc,
   pdfToMarkdownDoc
-} from "./chunk-TMOXUUTG.js";
+} from "./chunk-NQNIFIDP.js";
 import "./chunk-34KECNZO.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 {
   BUILTIN_FORMAT_IDS,

package/dist/{materialize-G4WC5UG3.js → materialize-ICXNO4S4.js}

@@ -1,11 +1,14 @@
 import {
+  DATA_PREVIEW_ROWS,
   materializeDataReferences
-} from "./chunk-UXEANVBI.js";
+} from "./chunk-YRFBWYAD.js";
+import "./chunk-5HUHSLGA.js";
 import "./chunk-ATWVNF7D.js";
 import "./chunk-Q77KNJIN.js";
 import "./chunk-DXYWKZ52.js";
 import "./chunk-S5PCVMKU.js";
 import "./chunk-7AWFHP5U.js";
 export {
+  DATA_PREVIEW_ROWS,
   materializeDataReferences
 };

package/dist/outside-in/index.d.ts

@@ -1,6 +1,7 @@
 import { MarkdownDocument } from '@bendyline/squisq/markdown';
 import { ContentContainer } from '@bendyline/squisq/storage';
 import { c as ConvertOptions, b as ConversionResult } from '../types-CVv9eldp.js';
+import { DiagramRasterizer } from '../diagrams/index.js';
 import { OutsideInLayout, OutsideInFormatId } from './layout.js';
 export { OUTSIDE_IN_FORMAT_IDS, OUTSIDE_IN_OUTPUT_TEMPLATE_KEY, chooseOutsideInMarkdownPath, isOutsideInTargetPath, resolveOutsideInLayout } from './layout.js';
 import '@bendyline/squisq/schemas';
@@ -58,6 +59,17 @@ interface RenderOutsideInOptions extends ConvertOptions {
         /** URL from the rendered HTML file to its companion media folder. */
         basePath?: string;
     };
+    /**
+     * Draws diagrams as pictures for the targets that cannot draw them: Word
+     * and PDF get pictures in place of Mermaid, ASCII diagrams, timelines, file
+     * trees, drawings, and layouts (PDF also of SVG islands, which Word embeds
+     * as vector art over the picture); PowerPoint, whose own shapes draw the
+     * rest, gets pictures of Mermaid and of SVG islands. In a browser, pass
+     * `createDiagramPictureRenderer()` from
+     * `@bendyline/squisq-react/diagram-pictures`. Without one those diagrams
+     * render as their source text. HTML targets draw their own.
+     */
+    renderDiagram?: DiagramRasterizer;
 }
 /** Read outside-in metadata without interpreting the output path as authority. */
 declare function readOutsideInMetadata(source: string): OutsideInMetadata | null;

package/dist/outside-in/index.js

@@ -7,9 +7,7 @@ import {
   renderOutsideInDocument,
   withOutsideInMarkdownEditing,
   withOutsideInMetadata
-} from "../chunk-6ALSRHD7.js";
-import "../chunk-GDUZJ75A.js";
-import "../chunk-KXOZMWBS.js";
+} from "../chunk-NCDY3EOL.js";
 import {
   OUTSIDE_IN_FORMAT_IDS,
   OUTSIDE_IN_OUTPUT_TEMPLATE_KEY,
@@ -17,6 +15,8 @@ import {
   isOutsideInTargetPath,
   resolveOutsideInLayout
 } from "../chunk-WJTC5OD6.js";
+import "../chunk-MJTPWLVV.js";
+import "../chunk-KXOZMWBS.js";
 import "../chunk-7AWFHP5U.js";
 export {
   OUTSIDE_IN_FORMAT_IDS,

package/dist/pdf/index.d.ts

@@ -116,7 +116,7 @@ interface PdfExportOptions {
 /**
  * Convert a MarkdownDocument to a PDF ArrayBuffer.
  */
-declare function markdownDocToPdf(doc: MarkdownDocument, options?: PdfExportOptions): Promise<ArrayBuffer>;
+declare function markdownDocToPdf(source: MarkdownDocument, options?: PdfExportOptions): Promise<ArrayBuffer>;
 /**
  * Convert a squisq Doc to a PDF ArrayBuffer.
  *

package/dist/pdf/index.js

@@ -5,11 +5,11 @@ import {
   pdfToContainer,
   pdfToDoc,
   pdfToMarkdownDoc
-} from "../chunk-TMOXUUTG.js";
+} from "../chunk-NQNIFIDP.js";
 import "../chunk-34KECNZO.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 {
   configurePdfWorker,