@bendyline/squisq-formats 2.8.6 → 2.8.8

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-IYNDHW2C.js → chunk-6ALSRHD7.js}

@@ -1,14 +1,15 @@
 import {
   convert,
   defaultRegistry
-} from "./chunk-ALDCFHZT.js";
+} from "./chunk-GDUZJ75A.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
@@ -205,6 +217,7 @@ export {
   readOutsideInMetadata,
   withOutsideInMetadata,
   isOutsideInMarkdownEditingEnabled,
+  readOutsideInOutputTemplate,
   withOutsideInMarkdownEditing,
   importOutsideInDocument,
   renderOutsideInDocument

package/dist/{chunk-B6UQPW75.js → chunk-LK4KCVN6.js}

@@ -306,6 +306,39 @@ import {
 import { resolveFontFamily, buildGoogleFontsUrl } from "@bendyline/squisq/schemas";
 import { resolveThemeForDoc } from "@bendyline/squisq/doc";
 function markdownDocToPlainHtml(doc, options = {}) {
+  const { title, body, fontsLink, iconsLink, themedCss, featureCss } = renderPlainHtml(
+    doc,
+    options
+  );
+  const safeCss = escapeStyleText(`${themedCss}
+${featureCss}`);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>${escapeHtml2(title)}</title>
+${fontsLink}${iconsLink}<style>
+${safeCss}
+</style>
+</head>
+<body>
+${body}
+</body>
+</html>`;
+}
+function markdownDocToPlainHtmlParts(doc, options = {}) {
+  const { title, body, iconsLink, featureCss } = renderPlainHtml(doc, options);
+  return {
+    title,
+    bodyHtml: body,
+    featureHeadHtml: `${iconsLink}<style data-squisq>
+${escapeStyleText(featureCss)}
+</style>
+`
+  };
+}
+function renderPlainHtml(doc, options) {
   const {
     title = "Document",
     images,
@@ -342,22 +375,14 @@ ${escapeStyleText(iconsCss)}
 ${VIDEO_EMBED_CSS}` : "";
   const svgCss = docUsesSvgIslands(doc) ? `
 ${SVG_ISLAND_CSS}` : "";
-  const safeCss = escapeStyleText(`${themedCss}
-${FEATURE_CSS}${videoCss}${svgCss}`);
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>${escapeHtml2(title)}</title>
-${fontsLink}${iconsLink}<style>
-${safeCss}
-</style>
-</head>
-<body>
-${body}
-</body>
-</html>`;
+  return {
+    title,
+    body,
+    fontsLink,
+    iconsLink,
+    themedCss,
+    featureCss: `${FEATURE_CSS}${videoCss}${svgCss}`
+  };
 }
 function escapeStyleText(css) {
   return css.replace(/</g, "\\3c ");
@@ -1177,6 +1202,502 @@ function titleForFilename(path, mdDoc) {
   return base.replace(/\.md$/i, "");
 }
 
+// src/html/pageTemplate.ts
+var HTML_PAGE_TEMPLATE_CONTENT_START = "<!-- squisq:content -->";
+var HTML_PAGE_TEMPLATE_CONTENT_END = "<!-- /squisq:content -->";
+var HtmlPageTemplateError = class extends Error {
+  constructor(issues) {
+    super(
+      issues.length === 1 ? `Invalid page template: ${describeIssue(issues[0])}` : `Invalid page template:
+${issues.map((issue) => `- ${describeIssue(issue)}`).join("\n")}`
+    );
+    this.name = "HtmlPageTemplateError";
+    this.issues = issues;
+  }
+};
+function isHtmlPageTemplate(html) {
+  return scanHtml(html).some(isLightSlot);
+}
+function inspectHtmlPageTemplate(html) {
+  return analyzeTemplate(html).inspection;
+}
+function analyzeTemplate(html) {
+  const tags = scanHtml(html);
+  const { slots, issues } = collectSlots(tags);
+  const lines = lineIndex(html);
+  const errors = issues.map(({ message, offset }) => ({ message, line: lines(offset) }));
+  const defaultSlots = slots.filter((slot) => slot.name === null);
+  if (defaultSlots.length === 0) {
+    errors.push({
+      message: "The template has no unnamed <slot> for the document content.",
+      line: 1
+    });
+  } else if (defaultSlots.length > 1) {
+    for (const extra of defaultSlots.slice(1)) {
+      errors.push({
+        message: "The template has more than one unnamed <slot>; the content can appear only once.",
+        line: lines(extra.start)
+      });
+    }
+  }
+  const namedSlots = [];
+  for (const slot of slots) {
+    if (slot.name !== null && !namedSlots.includes(slot.name)) namedSlots.push(slot.name);
+  }
+  return {
+    tags,
+    slots,
+    inspection: {
+      isTemplate: tags.some(isLightSlot),
+      defaultSlotCount: defaultSlots.length,
+      namedSlots,
+      errors: errors.sort((a, b) => a.line - b.line)
+    }
+  };
+}
+function isLightSlot(tag) {
+  return tag.kind === "start" && tag.name === "slot" && !tag.inert;
+}
+function applyHtmlPageTemplate(template, content, options = {}) {
+  const { tags, slots, inspection } = analyzeTemplate(template);
+  if (inspection.errors.length > 0) throw new HtmlPageTemplateError(inspection.errors);
+  const values = content.values ?? {};
+  const valueFor = (name) => name === "title" ? content.title : values[name];
+  const edits = [];
+  const replacements = /* @__PURE__ */ new Set();
+  for (const slot of slots) {
+    const value = slot.name === null ? void 0 : valueFor(slot.name);
+    if (slot.name === null || value !== void 0) {
+      const replacement = {
+        start: slot.start,
+        end: slot.end,
+        text: slot.name === null ? `${HTML_PAGE_TEMPLATE_CONTENT_START}
+${content.bodyHtml}
+${HTML_PAGE_TEMPLATE_CONTENT_END}` : escapeHtml3(value ?? "")
+      };
+      edits.push(replacement);
+      replacements.add(replacement);
+    } else {
+      edits.push({ start: slot.start, end: slot.contentStart, text: "" });
+      if (slot.end > slot.contentEnd)
+        edits.push({ start: slot.contentEnd, end: slot.end, text: "" });
+    }
+  }
+  const title = tags.find(
+    (tag) => tag.kind === "start" && tag.name === "title" && !tag.inert
+  );
+  if (title?.text) {
+    edits.push({
+      start: title.text.start,
+      end: title.text.end,
+      text: fillTitleText(template.slice(title.text.start, title.text.end), valueFor)
+    });
+  }
+  for (const tag of tags) {
+    if (tag.kind !== "start" || tag.name !== "meta" || tag.inert) continue;
+    const key = (attributeValue(tag, "name") ?? attributeValue(tag, "property"))?.toLowerCase();
+    const value = key ? metaValue(key, content.title, values.description) : void 0;
+    if (value === void 0) continue;
+    const contentAttribute = tag.attributes.find((attribute) => attribute.name === "content");
+    const text = `content="${escapeAttr2(value)}"`;
+    if (contentAttribute) {
+      edits.push({ start: contentAttribute.start, end: contentAttribute.end, text });
+    } else {
+      edits.push({ start: tag.closeStart, end: tag.closeStart, text: ` ${text}` });
+    }
+  }
+  const fromDir = options.templatePath === void 0 ? null : posixDirname2(options.templatePath);
+  const toDir = options.outputPath === void 0 ? null : posixDirname2(options.outputPath);
+  if (fromDir !== null && toDir !== null && fromDir !== toDir) {
+    for (const tag of tags) {
+      if (tag.kind !== "start") continue;
+      for (const attribute of tag.attributes) {
+        if (attribute.value === null) continue;
+        const rewrite = URL_ATTRIBUTES.has(attribute.name) ? rebaseUrl : SRCSET_ATTRIBUTES.has(attribute.name) ? rebaseSrcset : null;
+        if (!rewrite) continue;
+        const raw = template.slice(attribute.valueStart, attribute.valueEnd);
+        const rebased = rewrite(raw, fromDir, toDir);
+        if (rebased !== raw) {
+          edits.push({ start: attribute.valueStart, end: attribute.valueEnd, text: rebased });
+        }
+      }
+    }
+  }
+  const headInsert = `${content.headHtml ?? ""}${title ? "" : `<title>${escapeHtml3(content.title)}</title>
+`}`;
+  if (headInsert) {
+    const at = headInsertionPoint(tags);
+    edits.push({ start: at, end: at, text: headInsert });
+  }
+  const live = edits.filter(
+    (edit) => replacements.has(edit) || ![...replacements].some(
+      (slot) => edit.end > edit.start ? edit.start >= slot.start && edit.end <= slot.end : edit.start > slot.start && edit.start < slot.end
+    )
+  );
+  return applyEdits(template, live);
+}
+function extractHtmlPageTemplateContent(html) {
+  const start = html.indexOf(HTML_PAGE_TEMPLATE_CONTENT_START);
+  if (start < 0) return null;
+  const from = start + HTML_PAGE_TEMPLATE_CONTENT_START.length;
+  const end = html.lastIndexOf(HTML_PAGE_TEMPLATE_CONTENT_END);
+  return end < from ? null : html.slice(from, end);
+}
+var TEXT_ELEMENTS = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "title",
+  "textarea",
+  "xmp",
+  "iframe",
+  "noembed",
+  "noframes",
+  "noscript"
+]);
+function scanHtml(html) {
+  const tags = [];
+  let templateDepth = 0;
+  let foreignDepth = 0;
+  let index = 0;
+  while (index < html.length) {
+    const open = html.indexOf("<", index);
+    if (open < 0) break;
+    const next = html[open + 1];
+    if (html.startsWith("<!--", open)) {
+      const close = html.indexOf("-->", open + 4);
+      index = close < 0 ? html.length : close + 3;
+    } else if (next === "!" || next === "?") {
+      const close = html.indexOf(">", open + 2);
+      index = close < 0 ? html.length : close + 1;
+    } else if (next === "/" && isAsciiLetter(html[open + 2])) {
+      const nameEnd = scanName(html, open + 2);
+      const name = html.slice(open + 2, nameEnd).toLowerCase();
+      const close = html.indexOf(">", nameEnd);
+      const end = close < 0 ? html.length : close + 1;
+      if (name === "template" && templateDepth > 0) templateDepth--;
+      if ((name === "svg" || name === "math") && foreignDepth > 0) foreignDepth--;
+      tags.push({ kind: "end", name, start: open, end, inert: templateDepth + foreignDepth > 0 });
+      index = end;
+    } else if (isAsciiLetter(next)) {
+      const tag = scanStartTag(html, open, templateDepth + foreignDepth > 0);
+      tags.push(tag);
+      index = tag.end;
+      if (tag.name === "template") templateDepth++;
+      else if ((tag.name === "svg" || tag.name === "math") && !tag.selfClosing) foreignDepth++;
+      else if (TEXT_ELEMENTS.has(tag.name) && foreignDepth === 0) {
+        const closing = new RegExp(`</${tag.name}(?=[\\s/>])`, "gi");
+        closing.lastIndex = tag.end;
+        const match = closing.exec(html);
+        const textEnd = match ? match.index : html.length;
+        tag.text = { start: tag.end, end: textEnd };
+        index = textEnd;
+      }
+    } else {
+      index = open + 1;
+    }
+  }
+  return tags;
+}
+function scanStartTag(html, start, inert) {
+  const nameEnd = scanName(html, start + 1);
+  const name = html.slice(start + 1, nameEnd).toLowerCase();
+  const attributes = [];
+  let index = nameEnd;
+  for (; ; ) {
+    index = skipSpace(html, index);
+    if (index >= html.length) {
+      return {
+        kind: "start",
+        name,
+        start,
+        end: html.length,
+        closeStart: html.length,
+        selfClosing: false,
+        attributes,
+        inert
+      };
+    }
+    const char = html[index];
+    if (char === ">") {
+      return {
+        kind: "start",
+        name,
+        start,
+        end: index + 1,
+        closeStart: index,
+        selfClosing: false,
+        attributes,
+        inert
+      };
+    }
+    if (char === "/") {
+      if (html[index + 1] === ">") {
+        return {
+          kind: "start",
+          name,
+          start,
+          end: index + 2,
+          closeStart: index,
+          selfClosing: true,
+          attributes,
+          inert
+        };
+      }
+      index++;
+      continue;
+    }
+    const attributeStart = index;
+    index++;
+    while (index < html.length && !isSpace(html[index]) && !"/>=".includes(html[index])) index++;
+    const attributeName = html.slice(attributeStart, index).toLowerCase();
+    const afterName = index;
+    index = skipSpace(html, index);
+    if (html[index] !== "=") {
+      attributes.push({
+        name: attributeName,
+        value: null,
+        start: attributeStart,
+        end: afterName,
+        valueStart: afterName,
+        valueEnd: afterName
+      });
+      continue;
+    }
+    index = skipSpace(html, index + 1);
+    const quote = html[index];
+    let valueStart;
+    let valueEnd;
+    if (quote === '"' || quote === "'") {
+      valueStart = index + 1;
+      const close = html.indexOf(quote, valueStart);
+      valueEnd = close < 0 ? html.length : close;
+      index = close < 0 ? html.length : close + 1;
+    } else {
+      valueStart = index;
+      while (index < html.length && !isSpace(html[index]) && html[index] !== ">") index++;
+      valueEnd = index;
+    }
+    attributes.push({
+      name: attributeName,
+      value: html.slice(valueStart, valueEnd),
+      start: attributeStart,
+      end: index,
+      valueStart,
+      valueEnd
+    });
+  }
+}
+function scanName(html, from) {
+  let index = from;
+  while (index < html.length && !isSpace(html[index]) && html[index] !== "/" && html[index] !== ">") {
+    index++;
+  }
+  return index;
+}
+function skipSpace(html, from) {
+  let index = from;
+  while (index < html.length && isSpace(html[index])) index++;
+  return index;
+}
+function isSpace(char) {
+  return char === " " || char === "\n" || char === "	" || char === "\r" || char === "\f";
+}
+function isAsciiLetter(char) {
+  return char !== void 0 && /^[A-Za-z]$/.test(char);
+}
+function attributeValue(tag, name) {
+  return tag.attributes.find((attribute) => attribute.name === name)?.value ?? void 0;
+}
+function collectSlots(tags) {
+  const slots = [];
+  const issues = [];
+  let open = null;
+  for (const tag of tags) {
+    if (tag.name !== "slot" || tag.inert) continue;
+    if (tag.kind === "start") {
+      if (open) {
+        issues.push({
+          message: "A <slot> cannot be placed inside another <slot>.",
+          offset: tag.start
+        });
+        continue;
+      }
+      if (tag.selfClosing) {
+        slots.push({
+          name: slotName(tag),
+          start: tag.start,
+          end: tag.end,
+          contentStart: tag.end,
+          contentEnd: tag.end
+        });
+      } else {
+        open = tag;
+      }
+    } else if (open) {
+      slots.push({
+        name: slotName(open),
+        start: open.start,
+        end: tag.end,
+        contentStart: open.end,
+        contentEnd: tag.start
+      });
+      open = null;
+    } else {
+      issues.push({ message: "A </slot> has no matching <slot>.", offset: tag.start });
+    }
+  }
+  if (open) {
+    issues.push({
+      message: "A <slot> is never closed; write <slot></slot> or <slot/>.",
+      offset: open.start
+    });
+  }
+  return { slots, issues };
+}
+function slotName(tag) {
+  const name = attributeValue(tag, "name")?.trim();
+  return name ? name : null;
+}
+function fillTitleText(text, valueFor) {
+  const { slots } = collectSlots(scanHtml(text));
+  if (slots.length === 0) return escapeHtml3(valueFor("title") ?? "");
+  const edits = slots.map((slot) => {
+    const value = valueFor(slot.name ?? "title");
+    return {
+      start: slot.start,
+      end: slot.end,
+      text: value === void 0 ? text.slice(slot.contentStart, slot.contentEnd) : escapeHtml3(value)
+    };
+  });
+  return applyEdits(text, edits);
+}
+var TITLE_META = /* @__PURE__ */ new Set(["og:title", "twitter:title"]);
+var DESCRIPTION_META = /* @__PURE__ */ new Set(["description", "og:description", "twitter:description"]);
+function metaValue(key, title, description) {
+  if (TITLE_META.has(key)) return title;
+  if (DESCRIPTION_META.has(key)) return description;
+  return void 0;
+}
+function headInsertionPoint(tags) {
+  for (const tag of tags) {
+    if (tag.inert) continue;
+    if (tag.kind === "end" && tag.name === "head") return tag.start;
+    if (tag.kind !== "start") continue;
+    if (tag.name === "body") return tag.start;
+    if (tag.name === "style") return tag.start;
+    if (tag.name === "link" && (attributeValue(tag, "rel") ?? "").toLowerCase().split(/\s+/).includes("stylesheet")) {
+      return tag.start;
+    }
+  }
+  const container = tags.find(
+    (tag) => tag.kind === "start" && (tag.name === "head" || tag.name === "html")
+  );
+  return container?.end ?? 0;
+}
+var URL_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "href",
+  "src",
+  "poster",
+  "action",
+  "formaction",
+  "cite",
+  "data",
+  "background",
+  "xlink:href"
+]);
+var SRCSET_ATTRIBUTES = /* @__PURE__ */ new Set(["srcset", "imagesrcset"]);
+function rebaseUrl(raw, fromDir, toDir) {
+  const url = raw.trim();
+  if (!url || url.startsWith("#") || url.startsWith("?") || url.startsWith("/") || url.startsWith("\\") || /^[a-z][a-z0-9+.-]*:/i.test(url) || url.includes("{{")) {
+    return raw;
+  }
+  const cut = url.search(/[?#]/);
+  const path = cut < 0 ? url : url.slice(0, cut);
+  const suffix = cut < 0 ? "" : url.slice(cut);
+  if (path.includes("&")) return raw;
+  const target = normalizePath(fromDir ? `${fromDir}/${path}` : path);
+  if (target === null) return raw;
+  const isDirectory = path.endsWith("/") || /(?:^|\/)\.\.?$/.test(path);
+  let relative = relativeTo(toDir, target);
+  if (isDirectory) relative = relative ? `${relative}/` : "./";
+  const leading = raw.slice(0, raw.length - raw.trimStart().length);
+  const trailing = raw.slice(raw.trimEnd().length);
+  return `${leading}${relative}${suffix}${trailing}`;
+}
+function rebaseSrcset(raw, fromDir, toDir) {
+  let out = "";
+  let index = 0;
+  while (index < raw.length) {
+    const separator = /^[\s,]*/.exec(raw.slice(index))?.[0] ?? "";
+    out += separator;
+    index += separator.length;
+    if (index >= raw.length) break;
+    let urlEnd = index;
+    while (urlEnd < raw.length && !isSpace(raw[urlEnd])) urlEnd++;
+    let url = raw.slice(index, urlEnd);
+    const commas = /,+$/.exec(url)?.[0] ?? "";
+    url = url.slice(0, url.length - commas.length);
+    out += rebaseUrl(url, fromDir, toDir) + commas;
+    index = urlEnd;
+    if (commas) continue;
+    let descriptorEnd = index;
+    let depth = 0;
+    while (descriptorEnd < raw.length) {
+      const char = raw[descriptorEnd];
+      if (char === "(") depth++;
+      else if (char === ")") depth = Math.max(0, depth - 1);
+      else if (char === "," && depth === 0) break;
+      descriptorEnd++;
+    }
+    out += raw.slice(index, descriptorEnd);
+    index = descriptorEnd;
+  }
+  return out;
+}
+function relativeTo(fromDir, target) {
+  const from = fromDir ? fromDir.split("/") : [];
+  const to = target ? target.split("/") : [];
+  let shared = 0;
+  while (shared < from.length && shared < to.length && from[shared] === to[shared]) shared++;
+  return [...from.slice(shared).map(() => ".."), ...to.slice(shared)].join("/");
+}
+function posixDirname2(path) {
+  const normalized = normalizePath(path.replace(/\\/g, "/")) ?? "";
+  const slash = normalized.lastIndexOf("/");
+  return slash < 0 ? "" : normalized.slice(0, slash);
+}
+function applyEdits(source, edits) {
+  const ordered = [...edits].sort(
+    (a, b) => a.start - b.start || Number(a.end > a.start) - Number(b.end > b.start)
+  );
+  let out = "";
+  let cursor = 0;
+  for (const edit of ordered) {
+    if (edit.start < cursor) continue;
+    out += source.slice(cursor, edit.start) + edit.text;
+    cursor = edit.end;
+  }
+  return out + source.slice(cursor);
+}
+function lineIndex(source) {
+  return (offset) => {
+    let line = 1;
+    for (let index = source.indexOf("\n"); index >= 0 && index < offset; index = source.indexOf("\n", index + 1)) {
+      line++;
+    }
+    return line;
+  };
+}
+function describeIssue(issue) {
+  return `${issue.message} (line ${issue.line})`;
+}
+function escapeHtml3(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr2(s) {
+  return escapeHtml3(s).replace(/"/g, "&quot;");
+}
+
 // src/html/docsHtmlBundle.ts
 import JSZip2 from "jszip";
 import { parseMarkdown as parseMarkdown2, inferDocumentTitle as inferDocumentTitle2 } from "@bendyline/squisq/markdown";
@@ -1997,11 +2518,13 @@ function htmlToMarkdownDocSync(html, options = {}) {
   const embedded = findEmbeddedSquisqDoc(nodes);
   if (embedded) return docToMarkdown(parseEmbeddedSquisqDoc(embedded));
   const headMetadata = options.headMetadata === false ? {} : readHeadMetadata(nodes);
+  const templated = extractHtmlPageTemplateContent(html);
+  const contentNodes = templated === null ? nodes : parseHtmlToNodes(templated);
   const {
     nodes: bodyNodes,
     bodies,
     identifiers
-  } = extractFootnoteSection(dropContentlessElements(nodes));
+  } = extractFootnoteSection(dropContentlessElements(contentNodes));
   const clean = (input) => options.sanitize === false ? input : sanitizeHtmlNodes2(input);
   const children = blocksFromNodes(clean(bodyNodes));
   if (bodies.size > 0) {
@@ -2121,8 +2644,16 @@ export {
   collectImagePaths,
   generateExternalHtml,
   markdownDocToPlainHtml,
+  markdownDocToPlainHtmlParts,
   markdownDocsToPlainHtmlBundle,
   collectLinkRefs,
+  HTML_PAGE_TEMPLATE_CONTENT_START,
+  HTML_PAGE_TEMPLATE_CONTENT_END,
+  HtmlPageTemplateError,
+  isHtmlPageTemplate,
+  inspectHtmlPageTemplate,
+  applyHtmlPageTemplate,
+  extractHtmlPageTemplateContent,
   markdownDocsToHtmlBundle,
   htmlToMarkdownDocSync,
   htmlToMarkdownDoc,

package/dist/{chunk-C23JYVPG.js → chunk-WJTC5OD6.js}

@@ -1,5 +1,6 @@
 // src/outside-in/layout.ts
 var OUTSIDE_IN_FORMAT_IDS = ["html", "docx", "pdf", "pptx", "xlsx", "csv"];
+var OUTSIDE_IN_OUTPUT_TEMPLATE_KEY = "squisq-output-template";
 var OUTSIDE_IN_FORMAT_SET = new Set(OUTSIDE_IN_FORMAT_IDS);
 function normalizePath(path) {
   const slash = path.replace(/\\/g, "/");
@@ -83,6 +84,7 @@ function chooseOutsideInMarkdownPath(layout, paths) {
 
 export {
   OUTSIDE_IN_FORMAT_IDS,
+  OUTSIDE_IN_OUTPUT_TEMPLATE_KEY,
   resolveOutsideInLayout,
   isOutsideInTargetPath,
   chooseOutsideInMarkdownPath

package/dist/html/index.d.ts

@@ -118,7 +118,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;
@@ -138,6 +138,134 @@ 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;
+
+/**
+ * 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 +477,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 PlainHtmlParts, applyHtmlPageTemplate, arrayBufferToBase64DataUrl, collectLinkRefs, docToHtml, docToHtmlZip, extractFilename, extractHtmlPageTemplateContent, inferMimeType, inspectHtmlPageTemplate, isHtmlPageTemplate, markdownDocToPlainHtml, markdownDocToPlainHtmlParts, markdownDocsToHtmlBundle, markdownDocsToPlainHtmlBundle };

package/dist/html/index.js

@@ -1,16 +1,24 @@
 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";
+} from "../chunk-LK4KCVN6.js";
 import {
   arrayBufferToBase64DataUrl,
   extractFilename,
@@ -20,18 +28,26 @@ import "../chunk-VCZUXQUL.js";
 import "../chunk-BXWNU4T5.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
 };

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';

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   htmlToMarkdown,
   htmlToMarkdownDoc,
   htmlToMarkdownDocSync
-} from "./chunk-B6UQPW75.js";
+} from "./chunk-LK4KCVN6.js";
 import {
   docToEpub,
   markdownDocToEpub
@@ -25,10 +25,11 @@ import {
   importOutsideInDocument,
   isOutsideInMarkdownEditingEnabled,
   readOutsideInMetadata,
+  readOutsideInOutputTemplate,
   renderOutsideInDocument,
   withOutsideInMarkdownEditing,
   withOutsideInMetadata
-} from "./chunk-IYNDHW2C.js";
+} from "./chunk-6ALSRHD7.js";
 import {
   DEFAULT_CONVERSION_LIMITS,
   convert,
@@ -37,16 +38,17 @@ import {
   defaultRegistry,
   prepareConversion,
   resolveConversionLimits
-} from "./chunk-ALDCFHZT.js";
+} from "./chunk-GDUZJ75A.js";
 import {
   ConversionError
 } from "./chunk-KXOZMWBS.js";
 import {
   OUTSIDE_IN_FORMAT_IDS,
+  OUTSIDE_IN_OUTPUT_TEMPLATE_KEY,
   chooseOutsideInMarkdownPath,
   isOutsideInTargetPath,
   resolveOutsideInLayout
-} from "./chunk-C23JYVPG.js";
+} from "./chunk-WJTC5OD6.js";
 import {
   docToDocx,
   docxToDoc,
@@ -105,6 +107,7 @@ export {
   ConversionError,
   DEFAULT_CONVERSION_LIMITS,
   OUTSIDE_IN_FORMAT_IDS,
+  OUTSIDE_IN_OUTPUT_TEMPLATE_KEY,
   OUTSIDE_IN_UPDATE_FROM_MARKDOWN_KEY,
   ZipSafetyError,
   chooseOutsideInMarkdownPath,
@@ -147,6 +150,7 @@ export {
   pptxToMarkdownDoc,
   prepareConversion,
   readOutsideInMetadata,
+  readOutsideInOutputTemplate,
   renderOutsideInDocument,
   resolveConversionLimits,
   resolveOutsideInLayout,

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

@@ -2,7 +2,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 { OutsideInLayout, OutsideInFormatId } from './layout.js';
-export { OUTSIDE_IN_FORMAT_IDS, chooseOutsideInMarkdownPath, isOutsideInTargetPath, resolveOutsideInLayout } from './layout.js';
+export { OUTSIDE_IN_FORMAT_IDS, OUTSIDE_IN_OUTPUT_TEMPLATE_KEY, chooseOutsideInMarkdownPath, isOutsideInTargetPath, resolveOutsideInLayout } from './layout.js';
 import '@bendyline/squisq/schemas';
 import '@bendyline/squisq/transform';
 import '../docx/index.js';
@@ -65,6 +65,13 @@ declare function readOutsideInMetadata(source: string): OutsideInMetadata | null
 declare function withOutsideInMetadata(source: string, layout: OutsideInLayout): string;
 /** True only when the companion explicitly opts into rendered-file updates. */
 declare function isOutsideInMarkdownEditingEnabled(source: string | MarkdownDocument): boolean;
+/**
+ * The companion's page template choice: the authored path, `'none'` when it
+ * opts out of any host default, or null when it names none. Resolving the
+ * path against the companion is the host's job, since only the host knows
+ * where the container root is.
+ */
+declare function readOutsideInOutputTemplate(source: string | MarkdownDocument): string | null;
 /**
  * Opt a companion into or out of Markdown-driven regeneration while keeping
  * the portable target relationship current.
@@ -82,4 +89,4 @@ declare function renderOutsideInDocument(source: {
     container?: ContentContainer;
 }, options?: RenderOutsideInOptions): Promise<ConversionResult>;
 
-export { type ImportedOutsideInDocument, OUTSIDE_IN_UPDATE_FROM_MARKDOWN_KEY, OutsideInFormatId, OutsideInLayout, type OutsideInMetadata, type RenderOutsideInOptions, importOutsideInDocument, isOutsideInMarkdownEditingEnabled, readOutsideInMetadata, renderOutsideInDocument, withOutsideInMarkdownEditing, withOutsideInMetadata };
+export { type ImportedOutsideInDocument, OUTSIDE_IN_UPDATE_FROM_MARKDOWN_KEY, OutsideInFormatId, OutsideInLayout, type OutsideInMetadata, type RenderOutsideInOptions, importOutsideInDocument, isOutsideInMarkdownEditingEnabled, readOutsideInMetadata, readOutsideInOutputTemplate, renderOutsideInDocument, withOutsideInMarkdownEditing, withOutsideInMetadata };

package/dist/outside-in/index.js

@@ -3,27 +3,31 @@ import {
   importOutsideInDocument,
   isOutsideInMarkdownEditingEnabled,
   readOutsideInMetadata,
+  readOutsideInOutputTemplate,
   renderOutsideInDocument,
   withOutsideInMarkdownEditing,
   withOutsideInMetadata
-} from "../chunk-IYNDHW2C.js";
-import "../chunk-ALDCFHZT.js";
+} from "../chunk-6ALSRHD7.js";
+import "../chunk-GDUZJ75A.js";
 import "../chunk-KXOZMWBS.js";
 import {
   OUTSIDE_IN_FORMAT_IDS,
+  OUTSIDE_IN_OUTPUT_TEMPLATE_KEY,
   chooseOutsideInMarkdownPath,
   isOutsideInTargetPath,
   resolveOutsideInLayout
-} from "../chunk-C23JYVPG.js";
+} from "../chunk-WJTC5OD6.js";
 import "../chunk-7AWFHP5U.js";
 export {
   OUTSIDE_IN_FORMAT_IDS,
+  OUTSIDE_IN_OUTPUT_TEMPLATE_KEY,
   OUTSIDE_IN_UPDATE_FROM_MARKDOWN_KEY,
   chooseOutsideInMarkdownPath,
   importOutsideInDocument,
   isOutsideInMarkdownEditingEnabled,
   isOutsideInTargetPath,
   readOutsideInMetadata,
+  readOutsideInOutputTemplate,
   renderOutsideInDocument,
   resolveOutsideInLayout,
   withOutsideInMarkdownEditing,

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

@@ -19,6 +19,12 @@
  */
 declare const OUTSIDE_IN_FORMAT_IDS: readonly ["html", "docx", "pdf", "pptx", "xlsx", "csv"];
 type OutsideInFormatId = (typeof OUTSIDE_IN_FORMAT_IDS)[number];
+/**
+ * Frontmatter naming the page template a rendered output is generated
+ * through: a path relative to the companion Markdown, a `/`-prefixed path
+ * from the container root, or `none` to opt out of a host default.
+ */
+declare const OUTSIDE_IN_OUTPUT_TEMPLATE_KEY = "squisq-output-template";
 interface OutsideInLayout {
     /** User-facing rendered file, relative to the host's workspace root. */
     targetPath: string;
@@ -55,4 +61,4 @@ declare function isOutsideInTargetPath(path: string): boolean;
  */
 declare function chooseOutsideInMarkdownPath(layout: OutsideInLayout, paths: readonly string[]): string | null;
 
-export { OUTSIDE_IN_FORMAT_IDS, type OutsideInFormatId, type OutsideInLayout, chooseOutsideInMarkdownPath, isOutsideInTargetPath, resolveOutsideInLayout };
+export { OUTSIDE_IN_FORMAT_IDS, OUTSIDE_IN_OUTPUT_TEMPLATE_KEY, type OutsideInFormatId, type OutsideInLayout, chooseOutsideInMarkdownPath, isOutsideInTargetPath, resolveOutsideInLayout };

package/dist/outside-in/layout.js

@@ -1,11 +1,13 @@
 import {
   OUTSIDE_IN_FORMAT_IDS,
+  OUTSIDE_IN_OUTPUT_TEMPLATE_KEY,
   chooseOutsideInMarkdownPath,
   isOutsideInTargetPath,
   resolveOutsideInLayout
-} from "../chunk-C23JYVPG.js";
+} from "../chunk-WJTC5OD6.js";
 export {
   OUTSIDE_IN_FORMAT_IDS,
+  OUTSIDE_IN_OUTPUT_TEMPLATE_KEY,
   chooseOutsideInMarkdownPath,
   isOutsideInTargetPath,
   resolveOutsideInLayout

package/dist/registry/index.js

@@ -9,7 +9,7 @@ import {
   defaultRegistry,
   prepareConversion,
   resolveConversionLimits
-} from "../chunk-ALDCFHZT.js";
+} from "../chunk-GDUZJ75A.js";
 import {
   ConversionError
 } from "../chunk-KXOZMWBS.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bendyline/squisq-formats",
-  "version": "2.8.6",
+  "version": "2.8.8",
   "description": "Document format converters — DOCX, PDF, OOXML import/export",
   "license": "MIT",
   "author": "Bendyline",
@@ -125,7 +125,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@bendyline/squisq": "2.13.5",
+    "@bendyline/squisq": "2.13.7",
     "@pdf-lib/fontkit": "1.1.1",
     "@pdf-lib/upng": "1.0.1",
     "@xmldom/xmldom": "0.9.12",