@bendyline/squisq-formats 2.8.7 → 2.8.9

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
@@ -118,7 +121,7 @@ interface PlainHtmlExportOptions {
     htmlPolicy?: HtmlPolicy;
     /**
      * How a hosted video (a paragraph that is only a link to a YouTube, Vimeo,
-     * Loom, Dailymotion or Wistia page, or that provider's `<iframe>` embed
+     * Loom or Wistia page, or that provider's `<iframe>` embed
      * code) renders:
      *
      * - `player` (default) — the provider's player iframe;
@@ -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.
@@ -138,6 +154,202 @@ interface PlainHtmlExportOptions {
  * 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;
+
+/**
+ * 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
+ *
+ * Places a rendered document inside a page of the author's own — a site
+ * header, navigation, footer, and stylesheet — instead of the fixed shell
+ * `markdownDocToPlainHtml` emits. A template is an ordinary HTML file that
+ * marks where content goes with the HTML standard's `<slot>` element:
+ *
+ * - the one unnamed `<slot>` receives the document body;
+ * - `<slot name="title">` receives the document title, and
+ *   `<slot name="KEY">` the caller's value for `KEY` (typically a
+ *   frontmatter field), inserted as text;
+ * - a slot with no value is replaced by its children — the standard fallback
+ *   content — so a template opened directly in a browser previews with its
+ *   placeholders.
+ *
+ * `<slot/>` is accepted as an empty slot (the spelling Astro and JSX authors
+ * use), although HTML itself has no self-closing `<slot>`.
+ *
+ * `<title>` cannot contain elements, so slots written inside it are matched
+ * as text; a `<title>` without one is replaced by the document title.
+ * Existing description and Open Graph / Twitter title and description
+ * `<meta>` tags receive the document's values. Relative URLs in the template
+ * are rewritten so they still resolve from the generated page's location.
+ *
+ * The template is scanned, never re-serialized: everything outside the
+ * replaced ranges is emitted byte for byte, so its formatting, comments, and
+ * scripts survive unchanged.
+ */
+/** Marks the start of the injected document body in a templated page. */
+declare const HTML_PAGE_TEMPLATE_CONTENT_START = "<!-- squisq:content -->";
+/** Marks the end of the injected document body in a templated page. */
+declare const HTML_PAGE_TEMPLATE_CONTENT_END = "<!-- /squisq:content -->";
+interface HtmlPageTemplateContent {
+    /** Rendered document body. Inserted as-is; the caller sanitizes it. */
+    bodyHtml: string;
+    /**
+     * Markup the body needs in `<head>`, such as
+     * `PlainHtmlParts.featureHeadHtml`. Inserted before the template's own
+     * stylesheets so the template's CSS cascades last.
+     */
+    headHtml?: string;
+    /** Document title, as text. */
+    title: string;
+    /**
+     * Text for named slots, keyed by slot name. `description` also fills
+     * description `<meta>` tags. `title` comes from {@link title}.
+     */
+    values?: Readonly<Record<string, string | undefined>>;
+}
+interface HtmlPageTemplateOptions {
+    /**
+     * Container-relative path of the template file: the location its relative
+     * URLs were written against.
+     */
+    templatePath?: string;
+    /**
+     * Container-relative path of the page being generated. With
+     * {@link templatePath}, relative URLs in the template are rewritten to
+     * resolve from here.
+     */
+    outputPath?: string;
+}
+interface HtmlPageTemplateIssue {
+    message: string;
+    /** 1-based line in the template. */
+    line: number;
+}
+interface HtmlPageTemplateInspection {
+    /** True when the HTML has a `<slot>` outside any `<template>`. */
+    isTemplate: boolean;
+    /** Unnamed slots outside `<template>`; a usable template has exactly one. */
+    defaultSlotCount: number;
+    /** Distinct named slots, in document order. */
+    namedSlots: string[];
+    /** Problems that make {@link applyHtmlPageTemplate} refuse the template. */
+    errors: HtmlPageTemplateIssue[];
+}
+/** Thrown by {@link applyHtmlPageTemplate} for a template it cannot use. */
+declare class HtmlPageTemplateError extends Error {
+    readonly issues: readonly HtmlPageTemplateIssue[];
+    constructor(issues: readonly HtmlPageTemplateIssue[]);
+}
+/**
+ * True when `html` is a page template: it has a `<slot>` outside any
+ * `<template>`. Outside a shadow tree a slot does nothing, so an ordinary
+ * page has no reason to carry one.
+ */
+declare function isHtmlPageTemplate(html: string): boolean;
+/** Describe a template's slots and any problems that would prevent its use. */
+declare function inspectHtmlPageTemplate(html: string): HtmlPageTemplateInspection;
+/**
+ * Generate a page by filling `template`'s slots with `content`.
+ *
+ * @throws {HtmlPageTemplateError} when the template has no single unnamed
+ *   slot, or its slots are unbalanced or nested.
+ */
+declare function applyHtmlPageTemplate(template: string, content: HtmlPageTemplateContent, options?: HtmlPageTemplateOptions): string;
+/**
+ * The document body a templated page carries between its content markers, or
+ * null when `html` has none. Lets an importer skip the template's chrome.
+ */
+declare function extractHtmlPageTemplateContent(html: string): string | null;
 
 /**
  * Recursive plain-HTML bundle export.
@@ -349,4 +561,4 @@ declare function docToHtml(doc: Doc, options: HtmlExportOptions): string;
  */
 declare function docToHtmlZip(doc: Doc, options: HtmlZipExportOptions): Promise<Blob>;
 
-export { type HtmlBundleOptions, HtmlExportOptions, type HtmlZipExportOptions, type PlainHtmlBundleOptions, type PlainHtmlExportOptions, arrayBufferToBase64DataUrl, collectLinkRefs, docToHtml, docToHtmlZip, extractFilename, inferMimeType, markdownDocToPlainHtml, 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

@@ -1,37 +1,58 @@
 import {
+  HTML_PAGE_TEMPLATE_CONTENT_END,
+  HTML_PAGE_TEMPLATE_CONTENT_START,
+  HtmlPageTemplateError,
+  applyHtmlPageTemplate,
   collectImagePaths,
   collectLinkRefs,
   docToHtml,
   docToHtmlZip,
+  extractHtmlPageTemplateContent,
   generateExternalHtml,
   htmlToMarkdown,
   htmlToMarkdownDoc,
   htmlToMarkdownDocSync,
+  inspectHtmlPageTemplate,
+  isHtmlPageTemplate,
   markdownDocToPlainHtml,
+  markdownDocToPlainHtmlParts,
   markdownDocsToHtmlBundle,
-  markdownDocsToPlainHtmlBundle
-} from "../chunk-B6UQPW75.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,
+  HTML_PAGE_TEMPLATE_CONTENT_START,
+  HtmlPageTemplateError,
+  applyHtmlPageTemplate,
   arrayBufferToBase64DataUrl,
   collectImagePaths,
   collectLinkRefs,
   docToHtml,
   docToHtmlZip,
   extractFilename,
+  extractHtmlPageTemplateContent,
   generateExternalHtml,
   htmlToMarkdown,
   htmlToMarkdownDoc,
   htmlToMarkdownDocSync,
   inferMimeType,
+  inspectHtmlPageTemplate,
+  isHtmlPageTemplate,
   markdownDocToPlainHtml,
+  markdownDocToPlainHtmlParts,
   markdownDocsToHtmlBundle,
-  markdownDocsToPlainHtmlBundle
+  markdownDocsToPlainHtmlBundle,
+  needsPlainHtmlPreparation,
+  prepareMarkdownDocForPlainHtml
 };

package/dist/index.d.ts

@@ -8,10 +8,10 @@ export { EpubExportOptions, docToEpub, markdownDocToEpub } from './epub/index.js
 export { ExtractedFileTheme, InferSourceFormat, InferThemeOptions, InferredFileTheme, compileExtractedTheme, inferThemeFromFile } from './infer/index.js';
 export { B as BUILTIN_FORMAT_IDS, a as BuiltinFormatOptions, C as ConversionLimits, b as ConversionResult, c as ConvertOptions, d as ConvertSource, D as DEFAULT_CONVERSION_LIMITS, e as DbkFormatOptions, F as FormatDefinition, f as FormatId, g as FormatRegistry, M as MarkdownFormatOptions, N as NormalizedInput, P as PreparedConversion, h as PreparedExportOptions, r as resolveConversionLimits } from './types-CVv9eldp.js';
 export { ConversionError, ConversionErrorCode, ConversionErrorOptions, convert, createRegistry, defaultFormats, defaultRegistry, prepareConversion } from './registry/index.js';
-export { ImportedOutsideInDocument, OUTSIDE_IN_UPDATE_FROM_MARKDOWN_KEY, OutsideInMetadata, RenderOutsideInOptions, importOutsideInDocument, isOutsideInMarkdownEditingEnabled, readOutsideInMetadata, renderOutsideInDocument, withOutsideInMarkdownEditing, withOutsideInMetadata } from './outside-in/index.js';
+export { ImportedOutsideInDocument, OUTSIDE_IN_UPDATE_FROM_MARKDOWN_KEY, OutsideInMetadata, RenderOutsideInOptions, importOutsideInDocument, isOutsideInMarkdownEditingEnabled, readOutsideInMetadata, readOutsideInOutputTemplate, renderOutsideInDocument, withOutsideInMarkdownEditing, withOutsideInMetadata } from './outside-in/index.js';
 export { Z as ZipSafetyError, a as ZipSafetyErrorCode, b as ZipSafetyErrorOptions, c as ZipSafetyLimits } from './zipLimits-BOKCB7qk.js';
 export { H as HtmlExportOptions, a as HtmlImportOptions, c as collectImagePaths, h as htmlToMarkdown, b as htmlToMarkdownDoc, d as htmlToMarkdownDocSync } from './import-ipP4Ghp8.js';
-export { OUTSIDE_IN_FORMAT_IDS, OutsideInFormatId, OutsideInLayout, chooseOutsideInMarkdownPath, isOutsideInTargetPath, resolveOutsideInLayout } from './outside-in/layout.js';
+export { OUTSIDE_IN_FORMAT_IDS, OUTSIDE_IN_OUTPUT_TEMPLATE_KEY, OutsideInFormatId, OutsideInLayout, chooseOutsideInMarkdownPath, isOutsideInTargetPath, resolveOutsideInLayout } from './outside-in/layout.js';
 export { P as PptxExportOptions, a as PptxImportOptions, d as docToPptx, m as markdownDocToPptx, p as pptxToMarkdownDoc } from './import-Cn_V1_7e.js';
 export { X as XlsxExportOptions, a as XlsxImportOptions, b as XlsxTable, c as XlsxTableColumn, d as XlsxTablesOptions, e as docToXlsx, g as gridToTables, m as markdownDocToXlsx, x as xlsxToMarkdownDoc, f as xlsxToTables } from './export-C4bBD3Mx.js';
 import '@bendyline/squisq/schemas';
@@ -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';