@bendyline/squisq-formats 2.8.15 → 2.8.16

package/dist/{chunk-NQNIFIDP.js → chunk-NNNHOTVM.js}

@@ -21,7 +21,6 @@ import {
 
 // src/pdf/export.ts
 import { PDFDocument, StandardFonts, rgb, PDFString } from "pdf-lib";
-import fontkit2 from "@pdf-lib/fontkit";
 import { contrastRatio } from "@bendyline/squisq/schemas";
 import { docToMarkdown, resolveThemeForDoc } from "@bendyline/squisq/doc";
 import { isHtmlLineBreak, readFrontmatterThemeId, sanitizeUrl } from "@bendyline/squisq/markdown";
@@ -328,56 +327,168 @@ var WinAnsiTracker = class {
   }
   /**
    * One-shot summary for the export, or undefined when nothing was lost.
-   * `unicodeFont` says an embedded Unicode font already drew what it could, so
-   * what remains is beyond it too (CJK and emoji, with the bundled faces).
+   * `unicodeFont` says embedded Unicode fonts already drew what they could, so
+   * what remains is beyond them too (Thai and the Indic scripts, with the
+   * bundled faces).
    */
   warning(options = {}) {
     if (this.count === 0) return void 0;
     if (options.unicodeFont) {
-      return `PDF export replaced ${this.count} character(s) that its fonts cannot draw (${this.samples.join(", ")}). The PDF fonts do not cover CJK scripts or most emoji.`;
+      return `PDF export replaced ${this.count} character(s) that its fonts cannot draw (${this.samples.join(", ")}). The PDF fonts do not cover every script, such as Thai or Devanagari.`;
     }
     return `PDF export replaced ${this.count} character(s) that the standard PDF fonts cannot encode (${this.samples.join(", ")}). Scripts such as emoji, CJK and Cyrillic require an embedded Unicode font.`;
   }
 };
 
-// src/pdf/unicodeText.ts
+// src/pdf/fontkitSubset.ts
 import fontkit from "@pdf-lib/fontkit";
-async function loadBundledUnicodeFonts() {
-  const { dejaVuFontData } = await import("./unicodeFontData.generated-YY6T2K5S.js");
-  return dejaVuFontData();
+function padGlyphsToEvenLength(subset) {
+  const target = subset;
+  const addGlyph = target._addGlyph;
+  if (typeof addGlyph !== "function") return;
+  target._addGlyph = function(glyphId) {
+    const index = addGlyph.call(this, glyphId);
+    const data = this.glyf[index];
+    if (data && data.length % 2 === 1) {
+      const Buffer = data.constructor;
+      this.glyf[index] = Buffer.concat([data, Buffer.alloc(1)]);
+      this.offset += 1;
+    }
+    return index;
+  };
+}
+var subsetSafeFontkit = {
+  create(buffer, postscriptName) {
+    const font = fontkit.create(buffer, postscriptName);
+    if (typeof font.createSubset === "function") {
+      const createSubset = font.createSubset.bind(font);
+      font.createSubset = () => {
+        const subset = createSubset();
+        padGlyphsToEvenLength(subset);
+        return subset;
+      };
+    }
+    return font;
+  }
+};
+
+// src/pdf/lineBreaks.ts
+var BREAKS_BETWEEN = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\u3000-\u303f\uff00-\uffef]/u;
+var NO_LINE_START = /[.,!?;:)\]}、。，．：；！？）］｝」』】〉》〕・ー々ぁぃぅぇぉっゃゅょゎァィゥェォッャュョヮヵヶ]/u;
+var NO_LINE_END = /[（［｛「『【〈《〔]/u;
+function breakBetweenCjk(word) {
+  if (!BREAKS_BETWEEN.test(word)) return [word];
+  const pieces = [];
+  let piece = "";
+  let previousBreaks = false;
+  let previousOpens = false;
+  for (const ch of word) {
+    const breaks = BREAKS_BETWEEN.test(ch);
+    if (piece && (breaks || previousBreaks) && !previousOpens && !NO_LINE_START.test(ch)) {
+      pieces.push(piece);
+      piece = "";
+    }
+    piece += ch;
+    previousBreaks = breaks;
+    previousOpens = NO_LINE_END.test(ch);
+  }
+  if (piece) pieces.push(piece);
+  return pieces;
+}
+
+// src/pdf/unicodeText.ts
+import fontkit2 from "@pdf-lib/fontkit";
+var EMOJI_TEXT = /[\p{Extended_Pictographic}\p{Regional_Indicator}]/u;
+var HAN_OR_KANA_TEXT = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Bopomofo}\u3000-\u303f\uff00-\uffef]/u;
+var HANGUL_TEXT = /\p{Script=Hangul}/u;
+async function loadBundledUnicodeFonts(root) {
+  const text = root === void 0 ? "" : unencodableCharacters(root);
+  const [{ dejaVuFontData }, emoji, cjk, hangul] = await Promise.all([
+    import("./unicodeFontData.generated-YY6T2K5S.js"),
+    EMOJI_TEXT.test(text) ? import("./emojiFontData.generated-EPQOUGVZ.js").then((m) => m.notoEmojiFontData()) : void 0,
+    HAN_OR_KANA_TEXT.test(text) ? import("./cjkFontData.generated-LJKMYRHP.js").then((m) => m.notoSansScFontData()) : void 0,
+    HANGUL_TEXT.test(text) ? import("./hangulFontData.generated-CVLPZH2N.js").then((m) => m.notoSansKrFontData()) : void 0
+  ]);
+  return {
+    ...dejaVuFontData(),
+    emoji,
+    fallbacks: [cjk, hangul].filter((face) => face !== void 0)
+  };
+}
+function isUnencodable(codePoint) {
+  return !isWinAnsiEncodable(codePoint) && !isInvisibleOrSpace(codePoint);
 }
 function hasUnencodableText(value) {
   for (const ch of value) {
-    const codePoint = ch.codePointAt(0);
-    if (!isWinAnsiEncodable(codePoint) && !isInvisibleOrSpace(codePoint)) return true;
+    if (isUnencodable(ch.codePointAt(0))) return true;
   }
   return false;
 }
-function needsUnicodeFont(root) {
+function forEachString(root, visit) {
   const pending = [root];
   while (pending.length > 0) {
     const value = pending.pop();
     if (typeof value === "string") {
-      if (hasUnencodableText(value)) return true;
+      if (visit(value) === true) return;
     } else if (Array.isArray(value)) {
       pending.push(...value);
     } else if (value && typeof value === "object") {
       pending.push(...Object.values(value));
     }
   }
-  return false;
 }
+function needsUnicodeFont(root) {
+  let found = false;
+  forEachString(root, (value) => found = hasUnencodableText(value));
+  return found;
+}
+function unencodableCharacters(root) {
+  const characters = /* @__PURE__ */ new Set();
+  forEachString(root, (value) => {
+    for (const ch of value) {
+      if (isUnencodable(ch.codePointAt(0))) characters.add(ch);
+    }
+  });
+  return [...characters].join("");
+}
+function continuesCluster(ch, codePoint) {
+  return /\p{M}/u.test(ch) || // combining marks, variation selectors, the keycap
+  codePoint === 8205 || // zero-width joiner
+  codePoint >= 127995 && codePoint <= 127999 || // emoji skin tones
+  codePoint >= 917536 && codePoint <= 917631;
+}
+function isRegionalIndicator(codePoint) {
+  return codePoint >= 127462 && codePoint <= 127487;
+}
+function characterClusters(text) {
+  const clusters = [];
+  let loneRegionalIndicator = false;
+  for (const ch of text) {
+    const codePoint = ch.codePointAt(0);
+    const last = clusters.length - 1;
+    const joins = last >= 0 && (continuesCluster(ch, codePoint) || clusters[last].endsWith("\u200D") || loneRegionalIndicator && isRegionalIndicator(codePoint));
+    if (joins) {
+      clusters[last] += ch;
+      loneRegionalIndicator = false;
+    } else {
+      clusters.push(ch);
+      loneRegionalIndicator = isRegionalIndicator(codePoint);
+    }
+  }
+  return clusters;
+}
+var EMOJI_STYLE = /[\p{Emoji_Presentation}\p{Emoji_Modifier}\p{Regional_Indicator}\u{fe0f}\u{20e3}\u{e0020}-\u{e007f}]/u;
 function asBytes(data) {
   return data instanceof Uint8Array ? data : new Uint8Array(data);
 }
 async function embedUnicodeFaces(pdfDoc, fonts, standard) {
-  pdfDoc.registerFontkit(fontkit);
+  pdfDoc.registerFontkit(subsetSafeFontkit);
   const faces = /* @__PURE__ */ new Map();
   const faceFor = (data) => {
     let face = faces.get(data);
     if (!face) {
       const bytes = asBytes(data);
-      const metrics = fontkit.create(bytes);
+      const metrics = fontkit2.create(bytes);
       face = pdfDoc.embedFont(bytes, { subset: true }).then((font) => ({
         font,
         covers: (codePoint) => metrics.hasGlyphForCodePoint(codePoint)
@@ -386,18 +497,21 @@ async function embedUnicodeFaces(pdfDoc, fonts, standard) {
     }
     return face;
   };
-  const [regular, bold, mono] = await Promise.all([
+  const [regular, bold, mono, emoji, fallbacks] = await Promise.all([
     faceFor(fonts.regular),
     faceFor(fonts.bold ?? fonts.regular),
-    faceFor(fonts.mono ?? fonts.regular)
+    faceFor(fonts.mono ?? fonts.regular),
+    fonts.emoji ? faceFor(fonts.emoji) : void 0,
+    Promise.all((fonts.fallbacks ?? []).map(faceFor))
   ]);
+  const withPrimary = (primary) => ({ primary, fallbacks, emoji });
   return /* @__PURE__ */ new Map([
-    [standard.regular, regular],
-    [standard.italic, regular],
-    [standard.bold, bold],
-    [standard.boldItalic, bold],
-    [standard.mono, mono],
-    [standard.monoBold, mono]
+    [standard.regular, withPrimary(regular)],
+    [standard.italic, withPrimary(regular)],
+    [standard.bold, withPrimary(bold)],
+    [standard.boldItalic, withPrimary(bold)],
+    [standard.mono, withPrimary(mono)],
+    [standard.monoBold, withPrimary(mono)]
   ]);
 }
 var PdfTextRuns = class {
@@ -406,8 +520,8 @@ var PdfTextRuns = class {
     this.faces = faces;
   }
   split(text, font) {
-    const face = this.faces.get(font);
-    if (!face || !hasUnencodableText(text)) return [{ text: this.tracker.clean(text), font }];
+    const faces = this.faces.get(font);
+    if (!faces || !hasUnencodableText(text)) return [{ text: this.tracker.clean(text), font }];
     const runs = [];
     const push = (value, runFont) => {
       if (value.length === 0) return;
@@ -415,25 +529,48 @@ var PdfTextRuns = class {
       if (last && last.font === runFont) last.text += value;
       else runs.push({ text: value, font: runFont });
     };
-    const drawable = (codePoint) => !isInvisibleOrSpace(codePoint) && face.covers(codePoint);
+    const { primary } = faces;
+    const drawable = (codePoint) => !isInvisibleOrSpace(codePoint) && primary.covers(codePoint);
     for (const word of text.normalize("NFC").split(/(\s+)/u)) {
       if (word.length === 0) continue;
       const codePoints = Array.from(word, (ch) => ch.codePointAt(0));
       if (codePoints.every(isWinAnsiEncodable)) {
         push(word, font);
-      } else if (codePoints.every(drawable)) {
-        push(word, face.font);
+      } else if (!EMOJI_STYLE.test(word) && codePoints.every(drawable)) {
+        push(word, primary.font);
       } else {
-        for (const ch of word) {
-          const codePoint = ch.codePointAt(0);
-          if (isWinAnsiEncodable(codePoint)) push(ch, font);
-          else if (drawable(codePoint)) push(ch, face.font);
-          else push(this.tracker.clean(ch), font);
-        }
+        for (const cluster of characterClusters(word))
+          this.splitCluster(cluster, font, faces, push);
       }
     }
     return runs.length > 0 ? runs : [{ text: "", font }];
   }
+  /** One reader-visible character: drawn whole by one face where one can. */
+  splitCluster(cluster, font, faces, push) {
+    const codePoints = Array.from(cluster, (ch) => ch.codePointAt(0));
+    if (codePoints.every(isWinAnsiEncodable)) {
+      push(cluster, font);
+      return;
+    }
+    const order = EMOJI_STYLE.test(cluster) ? [faces.emoji, faces.primary, ...faces.fallbacks] : [faces.primary, ...faces.fallbacks, faces.emoji];
+    const candidates = order.filter((face) => face !== void 0);
+    const visible = codePoints.filter((codePoint) => !isInvisibleOrSpace(codePoint));
+    const whole = visible.length > 0 ? candidates.find((face) => visible.every((codePoint) => face.covers(codePoint))) : void 0;
+    if (whole) {
+      push(
+        Array.from(cluster).filter((ch) => whole.covers(ch.codePointAt(0))).join(""),
+        whole.font
+      );
+      return;
+    }
+    for (const ch of cluster) {
+      const codePoint = ch.codePointAt(0);
+      const face = isInvisibleOrSpace(codePoint) ? void 0 : candidates.find((candidate) => candidate.covers(codePoint));
+      if (isWinAnsiEncodable(codePoint)) push(ch, font);
+      else if (face) push(ch, face.font);
+      else push(this.tracker.clean(ch), font);
+    }
+  }
 };
 
 // src/pdf/styles.ts
@@ -567,7 +704,7 @@ async function createExportContext(pdfDoc, options, doc) {
   ]);
   let unicodeFaces = /* @__PURE__ */ new Map();
   if (options.unicodeFonts !== false && needsUnicodeFont(doc)) {
-    const faces = options.unicodeFonts ?? await loadBundledUnicodeFonts();
+    const faces = options.unicodeFonts ?? await loadBundledUnicodeFonts(doc);
     unicodeFaces = await embedUnicodeFaces(pdfDoc, faces, {
       regular,
       bold,
@@ -580,7 +717,7 @@ async function createExportContext(pdfDoc, options, doc) {
   const icons = {};
   const iconFamilies = collectInlineIconFamilies(doc);
   if (iconFamilies.size > 0) {
-    pdfDoc.registerFontkit(fontkit2);
+    pdfDoc.registerFontkit(subsetSafeFontkit);
     await Promise.all(
       fontAwesomeFaces(iconFamilies).map(async (face) => {
         icons[face.family] = await pdfDoc.embedFont(face.data, { subset: true });
@@ -938,22 +1075,6 @@ function breakLongWord(word, span, maxWidth) {
   if (piece) pieces.push(piece);
   return pieces;
 }
-function continuesCluster(ch) {
-  const codePoint = ch.codePointAt(0);
-  return /\p{M}/u.test(ch) || codePoint === 8205 || codePoint === 65038 || codePoint === 65039 || codePoint >= 127995 && codePoint <= 127999;
-}
-function characterClusters(text) {
-  const clusters = [];
-  for (const ch of text) {
-    const last = clusters.length - 1;
-    if (last >= 0 && (continuesCluster(ch) || clusters[last].endsWith("\u200D"))) {
-      clusters[last] += ch;
-    } else {
-      clusters.push(ch);
-    }
-  }
-  return clusters;
-}
 function splitIntoWords(text) {
   const tokens = [];
   let current = "";
@@ -968,7 +1089,7 @@ function splitIntoWords(text) {
     inSpace = isSpace;
   }
   if (current.length > 0) tokens.push(current);
-  return tokens;
+  return tokens.flatMap(breakBetweenCjk);
 }
 function getLineHeight(line) {
   let maxSize = 0;

package/dist/{chunk-S5VXWSRR.js → chunk-SWLDHEZI.js}

@@ -70,6 +70,7 @@ import {
 import { VIEWPORT_PRESETS } from "@bendyline/squisq/schemas";
 import {
   buildPreviewDoc,
+  coverRepeatsLeadingBlock,
   createTemplateContext,
   docToMarkdown,
   expandCoverBlock,
@@ -1366,13 +1367,18 @@ async function docToPptx(doc, options = {}) {
       Math.max(1, expanded.length + 1),
       VIEWPORT_PRESETS.landscape
     );
-    slideBlocks.push({
-      id: "cover-block",
-      startTime: -1,
-      duration: 0,
-      audioSegment: -1,
-      layers: expandCoverBlock(doc.startBlock, coverContext)
-    });
+    const coverLayers = expandCoverBlock(doc.startBlock, coverContext);
+    if (coverRepeatsLeadingBlock(doc) && expanded[0] && expanded[0].id === doc.blocks[0]?.id) {
+      expanded[0] = { ...expanded[0], layers: coverLayers };
+    } else {
+      slideBlocks.push({
+        id: "cover-block",
+        startTime: -1,
+        duration: 0,
+        audioSegment: -1,
+        layers: coverLayers
+      });
+    }
   }
   slideBlocks.push(...expanded);
   if (slideBlocks.length === 0) {