@bendyline/squisq-formats 2.8.7 → 2.8.9

package/README.md

@@ -141,6 +141,27 @@ const page = markdownDocToPlainHtml(markdownDoc, { themeId: 'warm-earth' });
 const imported = await htmlToMarkdownDoc(htmlString);
 ```
 
+To place a document inside your own page — a site header, navigation, footer, and stylesheet — write the page as an HTML template with standard `<slot>` elements and fill it:
+
+```ts
+import { applyHtmlPageTemplate, markdownDocToPlainHtmlParts } from '@bendyline/squisq-formats/html';
+
+// template: <title><slot name="title">Post</slot> · My Blog</title> … <h1><slot name="title"></slot></h1> <slot></slot>
+const parts = markdownDocToPlainHtmlParts(markdownDoc);
+const page = applyHtmlPageTemplate(
+  template,
+  {
+    bodyHtml: parts.bodyHtml,
+    headHtml: parts.featureHeadHtml,
+    title: 'Hello',
+    values: { date: '2026-10-28' },
+  },
+  { templatePath: '_templates/post.html', outputPath: 'posts/hello.html' },
+);
+```
+
+The unnamed `<slot>` receives the body (between `<!-- squisq:content -->` markers, which `htmlToMarkdownDoc` honors on re-import), named slots receive text values or keep their fallback children, relative URLs are rebased from the template's folder to the page's, and everything else in the template is copied byte for byte.
+
 The subpath also exports `markdownDocsToPlainHtmlBundle` / `markdownDocsToHtmlBundle` (recursive multi-doc ZIP bundles with `.md` links rewritten to `.html`), `htmlToMarkdownDocSync` / `htmlToMarkdown`, and helpers (`collectImagePaths`, `collectLinkRefs`, `inferMimeType`).
 
 ### EPUB

package/dist/chunk-4LIFEQKX.js

@@ -0,0 +1,358 @@
+// src/diagrams/index.ts
+import {
+  extractPlainText,
+  isSvgIslandLang,
+  parseSvgIsland,
+  stringifyMarkdown
+} from "@bendyline/squisq/markdown";
+import {
+  TABLE_FED_TEMPLATES,
+  buildChartData,
+  detectAsciiDiagram,
+  detectAsciiTimeline,
+  detectTree,
+  isContainerTemplate,
+  isEligibleAsciiFenceLang,
+  isEligibleAsciiTimelineFenceLang,
+  isEligibleTreeFenceLang,
+  isExplicitDiagramLang,
+  isExplicitTimelineLang,
+  isExplicitTreeLang,
+  resolveTemplateName
+} from "@bendyline/squisq/doc";
+var DEFAULT_KINDS = [
+  "mermaid",
+  "diagram",
+  "timeline",
+  "tree",
+  "container",
+  "chart"
+];
+var EXPORT_DIAGRAM_KINDS = [...DEFAULT_KINDS, "svg"];
+var KIND_NAMES = {
+  mermaid: "Diagram",
+  diagram: "Diagram",
+  timeline: "Timeline",
+  tree: "Tree",
+  container: "Diagram",
+  svg: "Illustration",
+  chart: "Chart"
+};
+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 tableText(table) {
+  const [header, ...body] = table.children.map(
+    (row) => row.children.map((cell) => extractPlainText(cell).trim())
+  );
+  return { headers: header ?? [], rows: body };
+}
+function listParam(value) {
+  const entries = value?.split(",").map((entry) => entry.trim()).filter(Boolean);
+  return entries && entries.length > 0 ? entries : void 0;
+}
+var NON_CHART_PARAMS = /* @__PURE__ */ new Set([
+  "showTable",
+  "src",
+  "sheet",
+  "anchor",
+  "headerRow",
+  "titleAnchor",
+  "previewRows",
+  "sort",
+  "filter"
+]);
+function isTruthyParam(value) {
+  return value !== void 0 && value !== "false" && value !== "0";
+}
+function findChart(children, index) {
+  const heading = children[index];
+  const requested = heading.templateAnnotation?.template;
+  const template = requested ? resolveTemplateName(requested) : "";
+  if (!TABLE_FED_TEMPLATES.has(template) || template === "dataTable") return null;
+  let tableIndex = -1;
+  for (let at = index + 1; at < children.length; at++) {
+    const node = children[at];
+    if (node.type === "heading") break;
+    if (node.type === "table") {
+      tableIndex = at;
+      break;
+    }
+  }
+  if (tableIndex < 0) return null;
+  const table = children[tableIndex];
+  const params = heading.templateAnnotation?.params ?? {};
+  const data = buildChartData(tableText(table), {
+    labelColumn: params.labelColumn,
+    valueColumns: listParam(params.valueColumns)
+  });
+  if (!data) return null;
+  const { showTable } = params;
+  const chartParams = Object.fromEntries(
+    Object.entries(params).filter(([key]) => !NON_CHART_PARAMS.has(key))
+  );
+  const chartHeading = {
+    ...heading,
+    templateAnnotation: { template, params: chartParams }
+  };
+  const title = extractPlainText(heading).trim();
+  const plotted = data.series.map((series) => series.name).join(", ");
+  const what = `${template.replace(/Chart$/, "")} chart of ${plotted}${data.labelHeader ? ` by ${data.labelHeader}` : ""}`;
+  return {
+    chart: { headingIndex: index, tableIndex, keepTable: isTruthyParam(showTable) },
+    diagram: {
+      kind: "chart",
+      markdown: stringifyMarkdown({ type: "document", children: [chartHeading, table] }).trim(),
+      source: "",
+      template,
+      alt: title ? `${title}: ${what}` : what.charAt(0).toUpperCase() + what.slice(1)
+    }
+  };
+}
+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) {
+      const chart = node.type === "heading" ? findChart(children, index) : null;
+      if (chart) found.push(chart);
+      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 withoutTemplate(heading) {
+  const { templateAnnotation: _template, ...plain } = heading;
+  return plain;
+}
+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;
+}
+function cachingDiagramRasterizer(render, limit = 64) {
+  const drawn = /* @__PURE__ */ new Map();
+  return (diagram) => {
+    const key = `${diagram.kind}\0${diagram.markdown}\0${diagram.source}`;
+    let picture = drawn.get(key);
+    if (picture) {
+      drawn.delete(key);
+    } else {
+      picture = render(diagram);
+      picture.catch(() => drawn.delete(key));
+    }
+    drawn.set(key, picture);
+    if (drawn.size > limit) drawn.delete(drawn.keys().next().value);
+    return picture;
+  };
+}
+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 blockReplacements = [];
+  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) {
+      blockReplacements.push({
+        start: entry.containerIndex,
+        end: entry.containerEnd,
+        nodes: [withoutTemplate(doc.children[entry.containerIndex]), paragraph]
+      });
+    } else if (entry.chart) {
+      const { headingIndex, tableIndex, keepTable } = entry.chart;
+      const table = doc.children[tableIndex];
+      blockReplacements.push(
+        {
+          start: headingIndex,
+          end: headingIndex + 1,
+          nodes: [withoutTemplate(doc.children[headingIndex])]
+        },
+        {
+          start: tableIndex,
+          end: tableIndex + 1,
+          nodes: keepTable ? [paragraph, table] : [paragraph]
+        }
+      );
+    }
+  }
+  let children = doc.children;
+  if (blockReplacements.length > 0) {
+    const rebuilt = [];
+    let cursor = 0;
+    for (const replacement of blockReplacements) {
+      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 {
+  EXPORT_DIAGRAM_KINDS,
+  fenceDiagramKind,
+  findDiagrams,
+  cachingDiagramRasterizer,
+  rasterizeDiagrams
+};

package/dist/{chunk-UXEANVBI.js → chunk-5HUHSLGA.js}

@@ -8,9 +8,6 @@ import {
   parseCsv
 } from "./chunk-Q77KNJIN.js";
 
-// src/data/materialize.ts
-import { isDataFilePath } from "@bendyline/squisq/doc";
-
 // src/data/readers.ts
 import { applyTableViewState, parseTableViewState } from "@bendyline/squisq/table";
 function applyViewParams(headers, body, opts) {
@@ -152,89 +149,9 @@ function defaultDataReaders() {
   return [csvDataReader, xlsxDataReader, parquetDataReader];
 }
 
-// src/data/materialize.ts
-function tableRow(cells) {
-  return {
-    type: "tableRow",
-    children: cells.map((value) => ({
-      type: "tableCell",
-      children: value ? [{ type: "text", value }] : []
-    }))
-  };
-}
-function extensionOf(path) {
-  const base = path.split("/").pop() ?? path;
-  const dot = base.lastIndexOf(".");
-  return dot > 0 ? base.slice(dot + 1).toLowerCase() : "";
-}
-async function materializeDataReferences(markdownDoc, container, onWarning) {
-  const readers = defaultDataReaders();
-  const children = [];
-  let changed = false;
-  for (const node of markdownDoc.children) {
-    children.push(node);
-    if (node.type !== "heading") continue;
-    const params = node.templateAnnotation?.params;
-    const src = params?.src;
-    if (!src || !isDataFilePath(src)) 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;
-    }
-    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;
-    }
-    try {
-      const table = await reader.read(bytes, {
-        maxRows: Number.POSITIVE_INFINITY,
-        ...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 mdTable = {
-        type: "table",
-        children: [tableRow(table.headers), ...table.rows.map(tableRow)]
-      };
-      children.push(mdTable);
-      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 {
   csvDataReader,
   xlsxDataReader,
   parquetDataReader,
-  defaultDataReaders,
-  materializeDataReferences
+  defaultDataReaders
 };

package/dist/{chunk-IYNDHW2C.js → chunk-6HUQFEP3.js}

@@ -1,14 +1,15 @@
 import {
   convert,
   defaultRegistry
-} from "./chunk-ALDCFHZT.js";
+} from "./chunk-WVDAFJFS.js";
 import {
   ConversionError
 } from "./chunk-KXOZMWBS.js";
 import {
   OUTSIDE_IN_FORMAT_IDS,
+  OUTSIDE_IN_OUTPUT_TEMPLATE_KEY,
   resolveOutsideInLayout
-} from "./chunk-C23JYVPG.js";
+} from "./chunk-WJTC5OD6.js";
 
 // src/outside-in/index.ts
 import {
@@ -63,6 +64,17 @@ function isOutsideInMarkdownEditingEnabled(source) {
   const frontmatter = yaml === null ? null : parseFrontmatter(yaml);
   return frontmatter?.[OUTSIDE_IN_UPDATE_FROM_MARKDOWN_KEY] === true;
 }
+function readOutsideInOutputTemplate(source) {
+  const frontmatter = typeof source === "string" ? (() => {
+    const yaml = rawFrontmatter(source);
+    return yaml === null ? null : parseFrontmatter(yaml);
+  })() : source.frontmatter;
+  const value = frontmatter?.[OUTSIDE_IN_OUTPUT_TEMPLATE_KEY];
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  return trimmed.toLowerCase() === "none" ? "none" : trimmed;
+}
 function withOutsideInMarkdownEditing(source, layout, enabled = true) {
   return setFrontmatterValues(withOutsideInMetadata(source, layout), {
     [OUTSIDE_IN_UPDATE_FROM_MARKDOWN_KEY]: enabled
@@ -176,7 +188,9 @@ async function renderOutsideInDocument(source, options = {}) {
       { format: "html" }
     );
   }
-  const formatOptions = { ...options.formatOptions ?? {} };
+  const formatOptions = {
+    ...options.formatOptions ?? {}
+  };
   if (layout.format === "html" && options.html) {
     formatOptions.html = {
       ...formatOptions.html ?? {},
@@ -184,10 +198,19 @@ async function renderOutsideInDocument(source, options = {}) {
       basePath: options.html.basePath ?? layout.companionName
     };
   }
-  return convert(
+  const warnings = [];
+  const markdown = await prepareOutsideInMarkdown(
+    source.markdown,
+    layout.format,
+    source.container,
+    options,
+    formatOptions,
+    warnings
+  );
+  const result = await convert(
     {
       kind: "markdown",
-      markdown: source.markdown,
+      markdown,
       container: source.container,
       baseName: layout.stem
     },
@@ -198,6 +221,52 @@ async function renderOutsideInDocument(source, options = {}) {
       formatOptions
     }
   );
+  return warnings.length > 0 ? { ...result, warnings: [...warnings, ...result.warnings] } : result;
+}
+async function prepareOutsideInMarkdown(markdown, format, container, options, formatOptions, warnings) {
+  const render = options.renderDiagram;
+  if (!render || format !== "docx" && format !== "pdf" && format !== "pptx") return markdown;
+  const onWarning = (message) => {
+    warnings.push(message);
+  };
+  let doc = typeof markdown === "string" ? parseMarkdown(markdown) : markdown;
+  const { rasterizeDiagrams, EXPORT_DIAGRAM_KINDS } = await import("./diagrams/index.js");
+  const signal = options.signal;
+  if (format === "pptx") {
+    const { mermaid, svg } = await rasterizeDiagrams(doc, render, {
+      kinds: ["mermaid", "svg"],
+      signal,
+      onWarning
+    });
+    formatOptions.pptx = {
+      ...formatOptions.pptx,
+      diagramImages: new Map([...mermaid, ...svg, ...formatOptions.pptx?.diagramImages ?? []])
+    };
+    return doc;
+  }
+  const { materializeDataReferences, DATA_PREVIEW_ROWS } = await import("./materialize-ICXNO4S4.js");
+  doc = await materializeDataReferences(doc, container, onWarning, {
+    maxRows: DATA_PREVIEW_ROWS
+  });
+  const pictured = await rasterizeDiagrams(doc, render, {
+    kinds: format === "pdf" ? EXPORT_DIAGRAM_KINDS : void 0,
+    signal,
+    onWarning
+  });
+  if (format === "docx") {
+    const { svg } = await rasterizeDiagrams(doc, render, { kinds: ["svg"], signal, onWarning });
+    formatOptions.docx = {
+      ...formatOptions.docx,
+      images: new Map([...formatOptions.docx?.images ?? [], ...pictured.images]),
+      svgIslandFallbacks: new Map([...svg, ...formatOptions.docx?.svgIslandFallbacks ?? []])
+    };
+  } else {
+    formatOptions.pdf = {
+      ...formatOptions.pdf,
+      images: new Map([...formatOptions.pdf?.images ?? [], ...pictured.images])
+    };
+  }
+  return pictured.markdownDoc;
 }
 
 export {
@@ -205,6 +274,7 @@ export {
   readOutsideInMetadata,
   withOutsideInMetadata,
   isOutsideInMarkdownEditingEnabled,
+  readOutsideInOutputTemplate,
   withOutsideInMarkdownEditing,
   importOutsideInDocument,
   renderOutsideInDocument

package/dist/{chunk-BXWNU4T5.js → chunk-DTJQK7U7.js}

@@ -1,3 +1,45 @@
+// src/shared/blockTags.ts
+import {
+  detectPromotableBodyAnnotation,
+  hasTemplate,
+  isMediaAnnotationName,
+  parseStandaloneAnnotation
+} from "@bendyline/squisq/doc";
+function withoutBlockTags(doc, options = {}) {
+  const children = withoutPromotedTags(doc.children);
+  const kept = children.filter((node) => !isRemovedTag(node, options));
+  return kept.length === doc.children.length && children === doc.children ? doc : { ...doc, children: kept };
+}
+function isRemovedTag(node, options) {
+  const tag = parseStandaloneAnnotation(node)?.template;
+  if (!tag) return false;
+  if (isMediaAnnotationName(tag)) return !options.keepMedia;
+  return hasTemplate(tag);
+}
+function withoutPromotedTags(children) {
+  const out = [];
+  let changed = false;
+  let index = 0;
+  while (index < children.length) {
+    const node = children[index++];
+    out.push(node);
+    if (node.type !== "heading" || node.templateAnnotation?.template) continue;
+    let end = index;
+    while (end < children.length && children[end].type !== "heading") end++;
+    const body = children.slice(index, end);
+    const found = detectPromotableBodyAnnotation(body);
+    const tag = found?.data.template;
+    if (found && tag && !isMediaAnnotationName(tag) && hasTemplate(tag)) {
+      out.push(...found.strippedContents);
+      changed = true;
+    } else {
+      out.push(...body);
+    }
+    index = end;
+  }
+  return changed ? out : children;
+}
+
 // src/shared/footnotes.ts
 var FootnoteIndex = class {
   constructor(doc) {
@@ -102,6 +144,7 @@ function renumberFootnotes(doc) {
 }
 
 export {
+  withoutBlockTags,
   FootnoteIndex,
   footnoteIds,
   renumberFootnotes

package/dist/{chunk-QU4EVC62.js → chunk-GFHUJ7L4.js}

@@ -60,7 +60,7 @@ import {
   fontAwesomeFace,
   fontAwesomeFaces,
   fontAwesomeGlyph
-} from "./chunk-LBXBRFBZ.js";
+} from "./chunk-DDMPZZJF.js";
 import {
   extToMime,
   readImageDimensions