@docx-editor.dev/docx-to-pdf 2.22.0 → 2.23.0

package/dist/index.js

@@ -208,11 +208,11 @@ var latinSubstitute = (family, prefix) => [
   weight,
   style
 ]);
+var CJK_FAMILY = "Noto Sans CJK JP";
 var supplemental = [
   ["Noto Sans Symbols 2", new NodeURL("NotoSansSymbols2-Regular.ttf", assetRoot), 400, "normal"],
   ["Noto Sans Math", new NodeURL("NotoSansMath-Regular.ttf", assetRoot), 400, "normal"],
   ["Noto Sans Arabic", new NodeURL("NotoSansArabic-Regular.ttf", assetRoot), 400, "normal"],
-  ["Noto Sans CJK JP", new NodeURL("NotoSansCJKjp-Regular.otf", assetRoot), 400, "normal"],
   ["Twemoji Mozilla", new NodeURL("TwemojiMozilla.ttf", assetRoot), 400, "normal"],
   ["Noto Emoji", new NodeURL("NotoEmoji-Regular.ttf", assetRoot), 400, "normal"],
   ...latinSubstitute("Liberation Sans", "LiberationSans"),
@@ -226,10 +226,16 @@ var PDF_GLYPH_FALLBACKS = [
   "Noto Sans Symbols 2",
   "Noto Sans Math",
   "Noto Sans Arabic",
-  // Prefer available Word CJK faces; packaged Noto remains the portable fallback.
+  // Hebrew, and Latin, Greek or Cyrillic letters the faces above lack. A missing glyph falls
+  // back to Times New Roman in the reference renderer. A host without it resolves the packaged
+  // Liberation Serif, whose Latin letters share its widths but whose Hebrew runs about 12%
+  // wider, so Hebrew in that face can wrap earlier.
+  "Times New Roman",
+  // Prefer available Word CJK faces; Noto Sans CJK JP from `@docx-editor.dev/fonts-cjk` is
+  // the portable fallback when that package is installed.
   "SimSun",
   "Batang",
-  "Noto Sans CJK JP",
+  CJK_FAMILY,
   // Color first: a COLR face paints its layers in the writer. The monochrome face stays
   // behind it for the few symbols the color set leaves out.
   "Twemoji Mozilla",
@@ -265,7 +271,7 @@ var substitutes = {
       "Gulim",
       "Dotum",
       "Malgun Gothic"
-    ].map((family) => [family, "Noto Sans CJK JP"])
+    ].map((family) => [family, CJK_FAMILY])
   )
 };
 var localizedFamilies = {
@@ -334,6 +340,7 @@ var substituteFor = (family) => {
 function genericSubstituteFor(family) {
   const name = canonicalFamily(family).family;
   if (/mono|courier|consol|menlo|typewriter|\bcode\b|fixed/i.test(name)) return "Liberation Mono";
+  if (/symbol/i.test(name)) return "Noto Sans Symbols 2";
   if (/sans/i.test(name)) return "Liberation Sans";
   if (/serif|roman|garamond|georgia|times|book|baskerville|cambria|minion|palatino|century|didot|caslon|constantia|sagona|lora|merriweather|playfair|charter|bodoni|perpetua|rockwell|goudy|bembo|sabon|antiqua/i.test(
     name
@@ -343,6 +350,7 @@ function genericSubstituteFor(family) {
 }
 var knownFamilies = /* @__PURE__ */ new Set([
   ...supplemental.map(([family]) => family),
+  CJK_FAMILY,
   ...Object.keys(substitutes),
   ...Object.keys(packagedSubstitutes),
   ...Object.values(packagedSubstitutes),
@@ -353,89 +361,184 @@ var knownFamilies = /* @__PURE__ */ new Set([
   "Webdings",
   "MT Extra"
 ]);
-function isGenericSubstitution(family, sourceFamily) {
-  if (family === sourceFamily) return false;
-  return !knownFamilies.has(canonicalFamily(family).family);
-}
-var supplementalFonts = defineFontResolver(async ({ families, signal }) => {
-  const wanted = /* @__PURE__ */ new Set();
-  for (const family of families) {
-    wanted.add(family);
-    const target = substituteFor(family);
-    if (target) wanted.add(target);
-  }
-  const sources = await Promise.all(
-    supplemental.filter(([family]) => wanted.has(family)).map(async ([family, file, weight, style]) => {
+var cjkWordFamilies = /* @__PURE__ */ new Set([
+  CJK_FAMILY,
+  ...Object.keys(substitutes).filter((family) => substitutes[family] === CJK_FAMILY)
+]);
+var CJK_PACKAGE = "@docx-editor.dev/fonts-cjk";
+function isPackageNotFound(error, specifier) {
+  if (typeof error !== "object" || error === null) return false;
+  const { code, message } = error;
+  if (code !== "ERR_MODULE_NOT_FOUND" && code !== "MODULE_NOT_FOUND") return false;
+  if (typeof message !== "string") return false;
+  return [`Cannot find package '${specifier}'`, `Cannot find module '${specifier}'`].some(
+    (prefix) => message.startsWith(prefix)
+  );
+}
+async function importCjkFace() {
+  let module;
+  try {
+    module = await import(
+      /* webpackIgnore: true */
+      "@docx-editor.dev/fonts-cjk"
+    );
+  } catch (error) {
+    if (isPackageNotFound(error, CJK_PACKAGE)) return null;
+    throw error;
+  }
+  const file = module.NOTO_SANS_CJK_JP_URL;
+  if (typeof file?.href !== "string")
+    throw new TypeError(`${CJK_PACKAGE} does not export NOTO_SANS_CJK_JP_URL`);
+  return new NodeURL(file.href);
+}
+var CJK_TEXT = /[\u1100-\u11ff\u2e80-\u2fdf\u3000-\u9fff\ua960-\ua97f\uac00-\ud7ff\uf900-\ufaff\ufe30-\ufe4f\uff00-\uffef]|[\u{20000}-\u{3ffff}]/u;
+var substitutionsTo = (family, target) => {
+  const { bold, italic } = canonicalFamily(family);
+  return [400, 700].flatMap(
+    (weight) => ["normal", "italic"].map((style) => ({
+      from: face(family, weight, style),
+      // The packaged CJK, symbol and mathematics faces come in one weight and one style.
+      to: target.startsWith("Noto") ? face(target) : face(
+        target,
+        bold || weight === 700 ? 700 : 400,
+        italic || style === "italic" ? "italic" : "normal"
+      )
+    }))
+  );
+};
+function packagedFontResolvers(locateCjkFace = importCjkFace) {
+  let located;
+  let cjkMissing = false;
+  const cjkFace = () => located ??= locateCjkFace().then(
+    (file) => {
+      cjkMissing = file === null;
+      return file;
+    },
+    (error) => {
+      cjkMissing = true;
+      throw error;
+    }
+  );
+  const readFaces = (faces, signal) => Promise.all(
+    faces.map(async ([family, file, weight, style]) => {
       const bytes = new Uint8Array(await readFontFile(file, signal));
       const result = createFontSource(bytes, face(family, weight, style));
-      if ("failure" in result) throw new Error(`Invalid packaged PDF font: ${file.pathname}`);
+      if ("failure" in result) throw new Error(`Invalid packaged PDF font: ${String(file)}`);
       return result.source;
     })
   );
-  return {
-    sources,
-    substitutions: families.flatMap((family) => {
+  const supplementalFonts2 = defineFontResolver(async ({ families, signal }) => {
+    const wanted = /* @__PURE__ */ new Set();
+    for (const family of families) {
+      wanted.add(family);
       const target = substituteFor(family);
-      if (!target) return [];
+      if (target) wanted.add(target);
+    }
+    const sources = await readFaces(
+      supplemental.filter(([family]) => wanted.has(family)),
+      signal
+    );
+    return {
+      sources,
+      substitutions: families.flatMap((family) => {
+        const target = substituteFor(family);
+        return target && target !== CJK_FAMILY ? substitutionsTo(family, target) : [];
+      })
+    };
+  });
+  const cjkFonts2 = defineFontResolver(async ({ families, signal }) => {
+    const planned = families.filter((family) => substituteFor(family) === CJK_FAMILY);
+    if (!families.includes(CJK_FAMILY) && planned.length === 0) return { sources: [] };
+    let sources;
+    try {
+      const file = await cjkFace();
+      if (!file) return { sources: [] };
+      sources = await readFaces([[CJK_FAMILY, file, 400, "normal"]], signal);
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(`${CJK_PACKAGE} could not supply its face: ${detail}`, { cause: error });
+    }
+    return {
+      sources,
+      substitutions: planned.flatMap((family) => substitutionsTo(family, CJK_FAMILY))
+    };
+  });
+  const standInFonts2 = defineFontResolver(async ({ families, signal, resolvedFaces }) => {
+    const covered = new Set(
+      (resolvedFaces ?? []).map(
+        (face2) => `${face2.family.toLowerCase()}/${face2.weight}/${face2.style}`
+      )
+    );
+    const has = (family, weight, style) => covered.has(`${family.toLowerCase()}/${weight}/${style}`);
+    const faces = [
+      [400, "normal"],
+      [700, "normal"],
+      [400, "italic"],
+      [700, "italic"]
+    ];
+    const substitutions = [];
+    const wanted = /* @__PURE__ */ new Set();
+    for (const family of families) {
+      if (has(family, 400, "normal")) {
+        for (const [weight, style] of faces)
+          if (!has(family, weight, style))
+            substitutions.push({ from: face(family, weight, style), to: face(family) });
+        continue;
+      }
+      const canonical = canonicalFamily(family).family;
+      if (knownFamilies.has(canonical) && !cjkWordFamilies.has(canonical)) continue;
+      const target = genericSubstituteFor(family);
+      wanted.add(target);
       const { bold, italic } = canonicalFamily(family);
-      return [400, 700].flatMap(
-        (weight) => ["normal", "italic"].map((style) => ({
+      for (const [weight, style] of faces)
+        substitutions.push({
           from: face(family, weight, style),
-          // The packaged CJK, symbol and mathematics faces come in one weight and one style.
-          to: target.startsWith("Noto") ? face(target) : face(
+          to: face(
             target,
             bold || weight === 700 ? 700 : 400,
             italic || style === "italic" ? "italic" : "normal"
           )
-        }))
-      );
-    })
-  };
-});
-var standInFonts = defineFontResolver(async ({ families, signal, resolvedFaces }) => {
-  const covered = new Set(
-    (resolvedFaces ?? []).map((face2) => `${face2.family.toLowerCase()}/${face2.weight}/${face2.style}`)
-  );
-  const has = (family, weight, style) => covered.has(`${family.toLowerCase()}/${weight}/${style}`);
-  const faces = [
-    [400, "normal"],
-    [700, "normal"],
-    [400, "italic"],
-    [700, "italic"]
-  ];
-  const substitutions = [];
-  const wanted = /* @__PURE__ */ new Set();
-  for (const family of families) {
-    if (has(family, 400, "normal")) {
-      for (const [weight, style] of faces)
-        if (!has(family, weight, style))
-          substitutions.push({ from: face(family, weight, style), to: face(family) });
-      continue;
+        });
     }
-    if (knownFamilies.has(canonicalFamily(family).family)) continue;
-    const target = genericSubstituteFor(family);
-    wanted.add(target);
-    const { bold, italic } = canonicalFamily(family);
-    for (const [weight, style] of faces)
-      substitutions.push({
-        from: face(family, weight, style),
-        to: face(
-          target,
-          bold || weight === 700 ? 700 : 400,
-          italic || style === "italic" ? "italic" : "normal"
-        )
-      });
-  }
-  const sources = await Promise.all(
-    supplemental.filter(([family]) => wanted.has(family)).map(async ([family, file, weight, style]) => {
-      const bytes = new Uint8Array(await readFontFile(file, signal));
-      const result = createFontSource(bytes, face(family, weight, style));
-      if ("failure" in result) throw new Error(`Invalid packaged PDF font: ${file.pathname}`);
-      return result.source;
-    })
-  );
-  return { sources, substitutions };
-});
+    const sources = await readFaces(
+      supplemental.filter(([family]) => wanted.has(family)),
+      signal
+    );
+    return { sources, substitutions };
+  });
+  return {
+    supplementalFonts: supplementalFonts2,
+    cjkFonts: cjkFonts2,
+    standInFonts: standInFonts2,
+    /**
+     * Whether a face resolved through the generic stand-in rather than a metric-compatible
+     * plan: a substitution whose family this package does not answer for, or a Word CJK
+     * family in its stand-in rather than the CJK face. The writer reports these, since the
+     * page carries the text in another font's metrics.
+     */
+    isGenericSubstitution(family, sourceFamily) {
+      if (family === sourceFamily) return false;
+      const canonical = canonicalFamily(family).family;
+      if (cjkWordFamilies.has(canonical)) return sourceFamily === genericSubstituteFor(family);
+      return !knownFamilies.has(canonical);
+    },
+    /**
+     * What a missing-glyph report adds for `text`: the package to install, when the text is
+     * CJK and the lookup found no usable package. Empty otherwise.
+     */
+    missingGlyphHint(text) {
+      return cjkMissing && CJK_TEXT.test(text) ? `; install ${CJK_PACKAGE} for Chinese, Japanese, and Korean text` : "";
+    }
+  };
+}
+var {
+  supplementalFonts,
+  cjkFonts,
+  standInFonts,
+  isGenericSubstitution,
+  missingGlyphHint
+} = packagedFontResolvers();
 var wordFontRoots = process.platform === "darwin" ? [
   "/System/Library/Fonts/Supplemental",
   "/Library/Fonts",
@@ -603,7 +706,8 @@ function openExportSession(source, options, signal) {
     ...useSystemFonts ? [installedWordFonts] : [],
     bundledFonts,
     ...fallbackFonts ? Array.isArray(fallbackFonts) ? fallbackFonts : [fallbackFonts] : [],
-    supplementalFonts
+    supplementalFonts,
+    cjkFonts
   ];
   return openFontBackedDocumentForExport(source, {
     ...core,
@@ -952,9 +1056,17 @@ var EmbeddedFace = class {
       throw new Error("Variable fonts require an exact static instance");
     this.font = font;
     this.colorLayers = Boolean(font.COLR && font.CPAL);
+    const tables = font;
+    const os2 = tables["OS/2"];
+    const macStyle = tables.head?.macStyle;
+    this.bold = (os2?.usWeightClass ?? 400) >= 600 || Boolean(os2?.fsSelection?.bold || macStyle?.bold);
+    this.slanted = Boolean(os2?.fsSelection?.italic || os2?.fsSelection?.oblique || macStyle?.italic) || Number.isFinite(font.italicAngle) && font.italicAngle !== 0;
     this.family = admitted.request.family;
     this.strike = strikeMetrics(admitted);
     this.subset = font.createSubset();
+    this.trueType = Boolean(
+      font.directory?.tables?.glyf
+    );
     this.ref = doc.context.nextRef();
     this.name = `F${index}`;
   }
@@ -969,9 +1081,18 @@ var EmbeddedFace = class {
    * glyph, and the page carries the text in its line's `ActualText` instead.
    */
   colorLayers;
+  /**
+   * Whether the face's own outlines are bold or slanted. A bold or italic run drawn in a
+   * face that is not (a single-weight face, or a substituted regular) gets Word's synthetic
+   * style at paint; a real bold or italic face draws as it is.
+   */
+  bold;
+  slanted;
   /** The family this face was admitted under, for legacy symbol-encoding extraction. */
   family;
   subset;
+  /** A `glyf` face, whose subset has a `loca` table; see {@link encodeSubset}. */
+  trueType;
   codes = /* @__PURE__ */ new Map();
   rows = [];
   widths = /* @__PURE__ */ new Map();
@@ -993,7 +1114,7 @@ var EmbeddedFace = class {
     let code = this.codes.get(key);
     if (code === void 0) {
       if (this.rows.length >= 65534) throw new Error("Font character code limit exceeded");
-      const cid = this.subset.includeGlyph(glyph);
+      const cid = this.cidFor(glyph, text);
       if (!Number.isInteger(cid) || cid < 0 || cid > 65535)
         throw new Error("Invalid subset glyph identifier");
       code = this.rows.length + 1;
@@ -1003,6 +1124,60 @@ var EmbeddedFace = class {
     }
     return hex(code);
   }
+  /** The text each subset glyph first extracted as; see {@link cidFor}. */
+  cidText = /* @__PURE__ */ new Map();
+  /**
+   * The subset glyph for one (glyph, text) pair.
+   *
+   * An Arabic face draws BEH, TEH, NOON and YEH on one dotless base glyph and adds the dots
+   * as separate glyphs, so one glyph extracts as several letters. Codes already differ per
+   * letter, but MuPDF resolves `ToUnicode` per CID, so one shared CID read every such letter
+   * as the last one mapped. The subset takes the glyph again under a new CID, the way
+   * LibreOffice's writer does. Both fontkit subsets write one entry per listed glyph: a
+   * TrueType subset one `glyf` record, a CFF subset one charstring under a single charset
+   * range, so the CID is the subset index either way.
+   *
+   * Bounded: no copy once the copies and every glyph composites could still pull in could
+   * reach 65535, where the glyph count and component ids wrap. A TrueType subset with copies
+   * is written with long `loca` offsets (see `encodeSubset`).
+   */
+  cidFor(glyph, text) {
+    const known = this.subset.mapping[glyph];
+    if (known === void 0) {
+      const cid2 = this.subset.includeGlyph(glyph);
+      this.cidText.set(cid2, text);
+      return cid2;
+    }
+    const glyphs = this.subset.glyphs;
+    if (this.cidText.get(known) === text || !Array.isArray(glyphs)) return known;
+    if (glyphs.length + this.font.numGlyphs >= 65535) return known;
+    glyphs.push(glyph);
+    this.copies += 1;
+    const cid = glyphs.length - 1;
+    this.cidText.set(cid, text);
+    return cid;
+  }
+  /** Glyphs the subset lists more than once; see {@link cidFor}. */
+  copies = 0;
+  /**
+   * Encode the subset. A TrueType face with short `loca` offsets can address 131070 bytes of
+   * `glyf`, and fontkit copies the face's format into the subset; copies can pass that, and
+   * the offsets then wrap and later glyphs draw other glyphs' outlines. fontkit reads the
+   * format from the face's parsed `loca` (whose offsets are already decoded, so the format
+   * no longer affects reads), so it says long while the subset encodes.
+   */
+  encodeSubset() {
+    const loca = this.font.loca;
+    if (!this.trueType || this.copies === 0 || !loca || loca.version !== 0) {
+      return this.subset.encode();
+    }
+    loca.version = 1;
+    try {
+      return this.subset.encode();
+    } finally {
+      loca.version = 0;
+    }
+  }
   /**
    * A code that draws this face's space and extracts as `text`: the carrier for characters
    * painted some other way, such as the palette layers of a color emoji. Drawn invisibly, it
@@ -1029,7 +1204,7 @@ var EmbeddedFace = class {
   async finish(work) {
     if (this.colorLayers) return;
     await work.yield();
-    const bytes = this.subset.encode();
+    const bytes = this.encodeSubset();
     work.check();
     const cff = bytes[0] === 1 && bytes[1] === 0;
     const ctx = this.doc.context;
@@ -1108,8 +1283,54 @@ var EmbeddedFace = class {
 };
 
 // src/color-glyphs.ts
+import { ExportResourceError as ExportResourceError2 } from "@docx-editor.dev/core/export";
 var MAX_LAYERS = 256;
 var MAX_COMMANDS = 8192;
+var MAX_COMPOSITE_DEPTH = 8;
+var MAX_EXPANDED_POINTS = MAX_COMMANDS;
+var pathSafety = /* @__PURE__ */ new WeakMap();
+function pathIsSafe(font, glyph) {
+  const cached = pathSafety.get(glyph);
+  if (cached !== void 0) return cached;
+  let safe;
+  try {
+    const { points, height } = expanded(font, glyph, 0, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
+    safe = points <= MAX_EXPANDED_POINTS && height <= MAX_COMPOSITE_DEPTH;
+  } catch {
+    safe = false;
+  }
+  pathSafety.set(glyph, safe);
+  return safe;
+}
+function expanded(font, glyph, depth, memo, open) {
+  const cached = memo.get(glyph);
+  if (cached) return cached;
+  if (depth > MAX_COMPOSITE_DEPTH || open.has(glyph)) return { points: Infinity, height: Infinity };
+  const decode = glyph._decode;
+  if (typeof decode !== "function") return { points: 0, height: 0 };
+  const decoded = decode.call(glyph);
+  let points = (decoded?.points?.length ?? 0) + 1;
+  let height = 0;
+  open.add(glyph);
+  for (const component of decoded?.components ?? []) {
+    const child = expanded(font, font.getGlyph(component.glyphID), depth + 1, memo, open);
+    points += child.points;
+    height = Math.max(height, child.height + 1);
+    if (points > MAX_EXPANDED_POINTS || height > MAX_COMPOSITE_DEPTH) break;
+  }
+  open.delete(glyph);
+  const result = { points, height };
+  memo.set(glyph, result);
+  return result;
+}
+function boundedPathCommands(font, glyph) {
+  if (!pathIsSafe(font, glyph)) return null;
+  try {
+    return glyph.path.commands;
+  } catch {
+    return null;
+  }
+}
 var cache = /* @__PURE__ */ new WeakMap();
 function colorGlyph(font, glyphId, work) {
   let byGlyph = cache.get(font);
@@ -1119,21 +1340,30 @@ function colorGlyph(font, glyphId, work) {
   }
   const known = byGlyph.get(glyphId);
   if (known) return known;
-  const result = readColorGlyph(font, glyphId, work);
+  let result;
+  try {
+    result = readColorGlyph(font, glyphId, work);
+  } catch (error) {
+    if (error instanceof PdfWorkLimitError || error instanceof ExportResourceError2) throw error;
+    result = { kind: "refused", reason: "the color glyph could not be read" };
+  }
   byGlyph.set(glyphId, result);
   return result;
 }
 function readColorGlyph(font, glyphId, work) {
   const glyph = font.getGlyph(glyphId);
   const layers = glyph.layers;
-  if (!layers || layers.length === 0)
-    return { kind: "none", outlined: glyph.path.commands.length > 0 };
+  if (!layers || layers.length === 0) {
+    const commands = boundedPathCommands(font, glyph);
+    return { kind: "none", outlined: commands === null || commands.length > 0 };
+  }
   if (layers.length > MAX_LAYERS)
     return { kind: "refused", reason: `${layers.length} layers exceed the ${MAX_LAYERS} allowed` };
   const out = [];
   for (const layer of layers) {
     work.tick();
-    const path = pathOperators(layer.glyph.path.commands, work);
+    const commands = boundedPathCommands(font, layer.glyph);
+    const path = commands && pathOperators(commands, work);
     if (path === null)
       return { kind: "refused", reason: "a layer outline is malformed or too long" };
     if (!path) continue;
@@ -1146,6 +1376,19 @@ function readColorGlyph(font, glyphId, work) {
   }
   return { kind: "layers", layers: out };
 }
+var outlines = /* @__PURE__ */ new WeakMap();
+function glyphOutline(font, glyphId, work) {
+  let byGlyph = outlines.get(font);
+  if (!byGlyph) {
+    byGlyph = /* @__PURE__ */ new Map();
+    outlines.set(font, byGlyph);
+  }
+  if (byGlyph.has(glyphId)) return byGlyph.get(glyphId);
+  const commands = boundedPathCommands(font, font.getGlyph(glyphId));
+  const path = commands && pathOperators(commands, work);
+  byGlyph.set(glyphId, path);
+  return path;
+}
 function clampByte(value) {
   return Number.isFinite(value) ? Math.min(255, Math.max(0, Math.round(value))) : 0;
 }
@@ -1193,6 +1436,35 @@ function pathOperators(commands, work) {
   return out.join(" ");
 }
 
+// src/outline-placement.ts
+var MAX_OUTLINE_MOVE = 1e5;
+var movable = (value) => Number.isFinite(value) && Math.abs(value) <= MAX_OUTLINE_MOVE;
+function outlineOperators(placements) {
+  const out = [];
+  let group = null;
+  let [ra, rc, rd, px, py] = [1, 0, 1, 0, 0];
+  for (const placement of placements) {
+    const same = group !== null && group.state === placement.state && group.a === placement.a && group.c === placement.c && group.d === placement.d;
+    const rawV = same && rd !== 0 ? (placement.y - py) / rd : NaN;
+    const v = movable(rawV) ? Number(number(rawV)) : NaN;
+    const rawU = movable(v) && ra !== 0 ? (placement.x - px - rc * v) / ra : NaN;
+    const u = movable(rawU) ? Number(number(rawU)) : NaN;
+    if (movable(u) && movable(v)) {
+      out.push(`1 0 0 1 ${number(u)} ${number(v)} cm /${placement.form} Do`);
+      px += ra * u + rc * v;
+      py += rd * v;
+      continue;
+    }
+    if (group) out.push("Q");
+    group = placement;
+    const { a, c, d, x, y } = placement;
+    out.push(`q ${placement.state}${[a, 0, c, d, x, y].map(number).join(" ")} cm /${placement.form} Do`);
+    [ra, rc, rd, px, py] = [a, c, d, x, y].map((value) => Number(number(value)));
+  }
+  if (group) out.push("Q");
+  return out.join("\n");
+}
+
 // src/text.ts
 var PDF_PAINT_GRID_PT2 = 0.24;
 function reducedHalfPoints(fontSizePt, factor) {
@@ -1213,6 +1485,20 @@ function griddedBaselineInLine(line, face2, paragraph) {
     return units(line.baseline) * PDF_PAINT_GRID_PT2;
   return (units(naturalBox) - units(descent)) * PDF_PAINT_GRID_PT2;
 }
+var SYNTHETIC_ITALIC_SKEW = 87 / 256;
+var SYNTHETIC_BOLD_VERTICAL = 1 / 1.02;
+var syntheticBoldStrokePt = (size) => size / 50 + 0.12;
+var rightToLeftLines = /* @__PURE__ */ new WeakMap();
+function rightToLeftOnly(line) {
+  let known = rightToLeftLines.get(line);
+  if (known === void 0) {
+    known = line.spans.every(
+      (span) => !/\S/u.test(span.text) || (span.style.shaping?.level ?? 0) % 2 === 1
+    );
+    rightToLeftLines.set(line, known);
+  }
+  return known;
+}
 var MAX_TJ_ADJUSTMENT = 1e6;
 function penOrigins(run) {
   const advances = run.exactAdvancesX;
@@ -1232,15 +1518,28 @@ function createGlyphBatch(out, horizontal) {
   let startX = 0;
   let penX = 0;
   let parts = [];
+  let skew = 0;
+  let vertical = 1;
+  let rise = 0;
   const flush = () => {
     if (parts.length === 0) return;
     const show = parts.length === 1 && parts[0].startsWith("<") ? `${parts[0]} Tj` : `[${parts.join("")}] TJ`;
-    out.push(`${number(horizontal)} 0 0 1 ${number(startX)} ${number(baselineY)} Tm ${show}`);
+    out.push(
+      `${number(horizontal)} 0 ${number(skew * vertical)} ${number(vertical)} ${number(startX)} ${number(baselineY + rise)} Tm ${show}`
+    );
     parts = [];
     face2 = null;
   };
   return {
     flush,
+    /** Change the synthetic matrix; the next glyph starts a new batch when it changes. */
+    matrix(nextSkew, nextVertical, nextRise) {
+      if (nextSkew === skew && nextVertical === vertical && nextRise === rise) return;
+      flush();
+      skew = nextSkew;
+      vertical = nextVertical;
+      rise = nextRise;
+    },
     add(nextFace, nextSize, gx, gy, code) {
       const unit = nextSize * horizontal;
       const continues = face2 === nextFace && size === nextSize && baselineY === gy && unit !== 0;
@@ -1274,6 +1573,14 @@ var TextWriter = class {
   work;
   showRevisionMarkup;
   faces = /* @__PURE__ */ new Map();
+  /** Outline glyphs of the current line, for {@link takeOutlines}. */
+  pendingOutlines = [];
+  /** The outline glyphs painted since the last call; the caller places them after a line. */
+  takeOutlines() {
+    const taken = this.pendingOutlines.length > 0 ? outlineOperators(this.pendingOutlines) : "";
+    this.pendingOutlines = [];
+    return taken;
+  }
   refused = /* @__PURE__ */ new Map();
   paint(visit, page) {
     const { span, line, storyOrigin, absoluteBox } = visit;
@@ -1295,7 +1602,10 @@ var TextWriter = class {
         `Core could not provide exact shaping for a visible span in ${family}`
       );
     if (shaped.run.glyphs.some((g) => g.id === 0))
-      return report("missing-glyph", `A visible span in ${family} contains missing glyphs`);
+      return report(
+        "missing-glyph",
+        `A visible span in ${family} contains missing glyphs${missingGlyphHint(span.text)}`
+      );
     const face2 = this.embeddedFace(shaped.font, visit, page);
     if (!face2) return "";
     const style = styleForFontSlot2(span.style, span.fontSlot);
@@ -1325,7 +1635,11 @@ var TextWriter = class {
     const origins = penOrigins(shaped.run);
     const batch = createGlyphBatch(out, horizontal);
     const colorGlyphs = [];
+    const outlineGlyphs = [];
+    const rightToLeft = (style.shaping?.level ?? 0) % 2 === 1;
     let extra = 0;
+    let strokeWidth = 0;
+    let stroked = false;
     let activeSize = size;
     let activeFace = face2;
     let activeIdentity = shaped.font.identity;
@@ -1340,6 +1654,9 @@ var TextWriter = class {
         if (!activeFace.colorLayers) out.push(`/${activeFace.name} ${number(activeSize)} Tf`);
       }
       const text = shaped.run.text.slice(cluster.textStart, cluster.textEnd);
+      let textGlyph = cluster.glyphStart;
+      for (let i = cluster.glyphStart + 1; i < cluster.glyphEnd; i++)
+        if (shaped.run.glyphs[i].advanceX > shaped.run.glyphs[textGlyph].advanceX) textGlyph = i;
       for (let i = cluster.glyphStart; i < cluster.glyphEnd; i++) {
         this.work.tick();
         const glyph = shaped.run.glyphs[i];
@@ -1382,17 +1699,92 @@ var TextWriter = class {
             batch.add(host, activeSize, gx, gy, carrier);
             batch.flush();
             out.push("0 Tr 100 Tz");
+            strokeWidth = 0;
           }
           continue;
         }
-        const code = activeFace.encode(glyph.id, i === cluster.glyphStart ? text : "");
-        batch.add(activeFace, activeSize, gx, gy, code);
+        const synthesizeBold = style.bold && !style.textOutline && !activeFace.bold;
+        const width = synthesizeBold ? syntheticBoldStrokePt(activeSize) : 0;
+        if (width !== strokeWidth) {
+          batch.flush();
+          if (width > 0 && !stroked) out.push(`${color(foreground)} RG`);
+          stroked ||= width > 0;
+          out.push(width > 0 ? `${number(width)} w 2 Tr` : "0 Tr");
+          strokeWidth = width;
+        }
+        batch.matrix(
+          style.italic && !activeFace.slanted ? SYNTHETIC_ITALIC_SKEW : 0,
+          width > 0 ? SYNTHETIC_BOLD_VERTICAL : 1,
+          width > 0 ? width / 2 * SYNTHETIC_BOLD_VERTICAL : 0
+        );
+        if (rightToLeft && /^ +$/.test(text) && rightToLeftOnly(line)) continue;
+        if (i === textGlyph) {
+          batch.add(activeFace, activeSize, gx, gy, activeFace.encode(glyph.id, text));
+          continue;
+        }
+        const outline = glyphOutline(activeFace.font, glyph.id, this.work);
+        if (outline === null) {
+          this.work.report(
+            "glyph-outline",
+            `A glyph outline in ${family} is malformed or too long`,
+            visit.page.index
+          );
+          continue;
+        }
+        if (outline) {
+          outlineGlyphs.push({
+            face: activeFace,
+            id: glyph.id,
+            path: outline,
+            x: gx,
+            y: gy + (width > 0 ? width / 2 * SYNTHETIC_BOLD_VERTICAL : 0),
+            scale: glyphSize / activeFace.font.unitsPerEm,
+            skew: style.italic && !activeFace.slanted ? SYNTHETIC_ITALIC_SKEW : 0,
+            vertical: width > 0 ? SYNTHETIC_BOLD_VERTICAL : 1,
+            strokeWidth: width
+          });
+        }
       }
       extra += text.length * style.characterSpacingPt + (text.match(/ /g)?.length ?? 0) * (style.shaping?.wordSpacingPt ?? 0);
     }
     batch.flush();
+    if (strokeWidth > 0) out.push("0 Tr");
     out.push("ET");
     if (style.textOutline) out.push("Q");
+    const placements = [];
+    for (const glyph of outlineGlyphs) {
+      const matrix = [
+        glyph.scale * horizontal,
+        0,
+        glyph.skew * glyph.scale * glyph.vertical,
+        glyph.scale * glyph.vertical,
+        glyph.x,
+        glyph.y
+      ];
+      const outlineStroke = style.textOutline ? { color: style.textOutline.color, width: style.textOutline.widthPt } : glyph.strokeWidth > 0 ? { color: foreground, width: glyph.strokeWidth } : null;
+      const stroke = outlineStroke ? `${color(outlineStroke.color)} RG ${number(outlineStroke.width / (glyph.scale * glyph.vertical))} w ` : "";
+      const form = this.outlineForm(
+        glyph.face,
+        glyph.id,
+        glyph.path,
+        outlineStroke ? "B" : "f",
+        page
+      );
+      placements.push({
+        state: `${color(foreground)} rg ${stroke}`,
+        a: matrix[0],
+        c: matrix[2],
+        d: matrix[3],
+        x: glyph.x,
+        y: glyph.y,
+        form
+      });
+    }
+    if (visit.paragraph.clipToBox) {
+      if (placements.length > 0) out.push(outlineOperators(placements));
+    } else {
+      for (const placement of placements) this.pendingOutlines.push(placement);
+    }
     for (const { layers, x: gx, y: gy, scale: glyphScale } of colorGlyphs) {
       out.push(`q ${number(glyphScale * horizontal)} 0 0 ${number(glyphScale)} ${number(gx)} ${number(gy)} cm`);
       for (const layer of layers) {
@@ -1543,6 +1935,36 @@ var TextWriter = class {
     const top = line.box.y + line.baseline - faceBaseline - baselineShiftPtOf(styleForFontSlot2(span.style, span.fontSlot));
     return { ...absoluteBox, y: absoluteBox.y + (top - span.box.y) };
   }
+  outlineForms = /* @__PURE__ */ new Map();
+  /**
+   * A form XObject that paints one glyph outline in font units, registered on the page.
+   *
+   * The same few dot and mark glyphs repeat across a page, so each outline is written once
+   * per face and paint operator and placed with `Do`. The form sets no colour or width, so
+   * the caller's fill, stroke and line width apply.
+   */
+  outlineForm(face2, glyphId, path, operator, page) {
+    let forms = this.outlineForms.get(face2);
+    if (!forms) this.outlineForms.set(face2, forms = /* @__PURE__ */ new Map());
+    const key = `${glyphId}:${operator}`;
+    let form = forms.get(key);
+    if (!form) {
+      this.work.reserveContent(path.length + 2);
+      const margin = face2.font.unitsPerEm / 4;
+      const bbox = face2.font.bbox;
+      const ref = this.doc.context.register(
+        flateStream(this.doc.context, `${path} ${operator}`, {
+          Type: "XObject",
+          Subtype: "Form",
+          BBox: [bbox.minX - margin, bbox.minY - margin, bbox.maxX + margin, bbox.maxY + margin]
+        })
+      );
+      form = { name: `${face2.name}G${forms.size + 1}`, ref };
+      forms.set(key, form);
+    }
+    page.node.setXObject(PDFName2.of(form.name), form.ref);
+    return form.name;
+  }
   alphaStates = /* @__PURE__ */ new Map();
   /** A registered constant-alpha graphics state, shared across layers of the same alpha. */
   alphaState(page, alpha) {
@@ -1790,17 +2212,20 @@ import { PDFName as PDFName5, PDFString as PDFString4 } from "pdf-lib";
 
 // src/vector-shapes.ts
 import { PDFName as PDFName4, PDFString as PDFString3 } from "pdf-lib";
+import { vectorShapeInkClip } from "@docx-editor.dev/core/layout";
 function paintVectorShape(doc, page, visit, work) {
   const d = visit.drawing;
   const shape = d.vectorShape;
-  const bounds = visit.absolutePaintBounds;
+  const painted = visit.absolutePaintBounds;
+  const bounds = vectorShapeInkClip(d, painted);
   if (bounds.width <= 0 || bounds.height <= 0 || d.accessibility.hidden) return "";
   const content = d.geometry.contentBounds;
   const x = visit.drawingOrigin.x - d.x - visit.page.box.x;
   const y = visit.drawingOrigin.y - d.y - visit.page.box.y;
   const unit = 12700;
-  const sx = content.width / (shape.extentEmu.cx / unit);
-  const sy = content.height / (shape.extentEmu.cy / unit);
+  const { cx, cy } = shape.extentEmu;
+  const sx = cx > 0 ? content.width / (cx / unit) : content.height / (cy / unit);
+  const sy = cy > 0 ? content.height / (cy / unit) : sx;
   const out = new Commands(work);
   out.push(
     `q ${rect(bounds, -visit.page.box.x, -visit.page.box.y, pageHeight(page))} W n`,
@@ -1828,16 +2253,20 @@ function paintVectorShape(doc, page, visit, work) {
     const stateName = `ShapeAlpha${state.objectNumber}`;
     page.node.setExtGState(PDFName4.of(stateName), state);
     out.push(`q /${stateName} gs`);
+    const inset = component.strokeInset === true && component.strokeHex !== null;
+    const width = Math.max(1, component.strokeWidthEmu) * (inset ? 2 : 1);
     if (component.fillHex !== null) out.push(`${color(component.fillHex)} rg`);
     if (component.strokeHex !== null)
+      out.push(`${color(component.strokeHex)} RG ${number(width / unit)} w`);
+    const geometry = component.subpathsEmu.map((points, index) => path(points, component.subpathsClosed?.[index] !== false)).join("\n");
+    if (inset) {
+      out.push(`q ${geometry} W* n`, geometry, component.fillHex !== null ? "B* Q" : "S Q");
+    } else {
+      out.push(geometry);
       out.push(
-        `${color(component.strokeHex)} RG ${number(Math.max(1, component.strokeWidthEmu) / unit)} w`
+        component.fillHex !== null ? component.strokeHex !== null ? "B*" : "f*" : component.strokeHex !== null ? "S" : "n"
       );
-    for (const [index, points] of component.subpathsEmu.entries())
-      out.push(path(points, component.subpathsClosed?.[index] !== false));
-    out.push(
-      component.fillHex !== null ? component.strokeHex !== null ? "B*" : "f*" : component.strokeHex !== null ? "S" : "n"
-    );
+    }
     if (component.strokeHex !== null && component.arrowheadsEmu?.length) {
       const arrowState = doc.context.register(
         doc.context.obj({
@@ -1855,14 +2284,15 @@ function paintVectorShape(doc, page, visit, work) {
   out.push("Q");
   const uri = d.hyperlinkHref && /^(https?:|mailto:|tel:|ftp:)/i.test(d.hyperlinkHref) ? pdfLiteralUri(d.hyperlinkHref) : null;
   if (uri !== null) {
-    const left = bounds.x - visit.page.box.x;
-    const bottom = pageHeight(page) - bounds.y + visit.page.box.y - bounds.height;
+    const target = painted.width > 0 && painted.height > 0 ? painted : bounds;
+    const left = target.x - visit.page.box.x;
+    const bottom = pageHeight(page) - target.y + visit.page.box.y - target.height;
     page.node.addAnnot(
       doc.context.register(
         doc.context.obj({
           Type: "Annot",
           Subtype: "Link",
-          Rect: [left, bottom, left + bounds.width, bottom + bounds.height],
+          Rect: [left, bottom, left + target.width, bottom + target.height],
           Border: [0, 0, 0],
           A: { S: "URI", URI: PDFString3.of(uri) }
         })
@@ -1997,14 +2427,51 @@ var ImageWriter = class {
   async paint(visit, page) {
     await this.work.yield();
     const d = visit.drawing;
+    if (d.accessibility.hidden) return "";
     const report = (message) => {
       this.work.report("drawing", message, visit.page.index);
       return "";
     };
+    if (d.groupPicture) return this.paintGroupPicture(visit, page, report);
     if (d.vectorShape) return paintVectorShape(this.doc, page, visit, this.work);
     if (d.kind === "anchoredDrawing" && d.textboxStory)
       return report("Textbox story not routed through paintTextbox");
     if (d.placeholderGraphicKind) return report(`Unsupported drawing: ${d.placeholderGraphicKind}`);
+    return this.paintPicture(visit, page, report);
+  }
+  /**
+   * A shape group with a picture member: the picture, then the group's vector members over it.
+   *
+   * The group paints whole or not at all, as it does on screen. Layout already drops an
+   * `mc:AlternateContent` group whose picture resource fails, following the rule for MC
+   * payloads the engine cannot draw. A ready picture in a format this writer cannot embed
+   * gets the same rule here: the MC group is left out and reported at `information`, because
+   * the editor draws it and only this output cannot. A bare group reports every refusal as
+   * `unsupported`, as it reports an unsupported group.
+   */
+  async paintGroupPicture(visit, page, report) {
+    const d = visit.drawing;
+    const { resource } = d;
+    if (d.groupPicture?.alternateContent && resource.kind === "ready" && !EMBEDDABLE_MIMES.has(resource.mime)) {
+      this.work.report(
+        "drawing",
+        `Shape group left out: picture format not embeddable: ${resource.mime}`,
+        visit.page.index,
+        "information"
+      );
+      return "";
+    }
+    let refused = false;
+    const picture = await this.paintPicture(visit, page, (message) => {
+      refused = true;
+      return report(message);
+    });
+    if (refused) return "";
+    const vector = d.vectorShape ? paintVectorShape(this.doc, page, visit, this.work) : "";
+    return [picture, vector].filter((commands) => commands !== "").join("\n");
+  }
+  async paintPicture(visit, page, report) {
+    const d = visit.drawing;
     const bytes = this.session.validatedImageBytes(d);
     if (!bytes || d.resource.kind !== "ready") return report("Image has no validated raster bytes");
     const mime = d.resource.mime;
@@ -2302,6 +2769,12 @@ async function paint(doc, session, layout, work, includeComments) {
         `0 0 0 rg ${rect(separator, record.contentBox.x - record.box.x, record.contentBox.y - record.box.y, height, true)} f`
       );
     for (const area of [record.footnotes, record.endnotes]) {
+      if (area?.fallbackReason === "note-continuation-notice-height-cap")
+        work.report(
+          area.fallbackReason,
+          "Continuation notice exceeds the available page height",
+          record.index
+        );
       const sep = area?.separator;
       if (!sep || !(sep.ruleStyle || sep.synthetic)) continue;
       for (const offset of sep.ruleStyle === "double" ? [0, 2] : [0])
@@ -2405,19 +2878,29 @@ async function paint(doc, session, layout, work, includeComments) {
       const first = group[0];
       const markerText = first.paragraph.lines[0] === first.line ? first.paragraph.marker?.text : void 0;
       const logical = (markerText ? markerText + " " : "") + group.map((v) => v.span.equation?.fallbackText ?? v.span.text).join("");
+      const rightToLeft = group.some((v) => (v.span.style.shaping?.level ?? 0) % 2 === 1);
       group.sort((a, b) => a.absoluteBox.x - b.absoluteBox.x);
-      lineStarts.set(group[0], logical);
+      lineStarts.set(group[0], rightToLeft ? null : logical);
       for (const visit of group) spans.push(visit);
     }
   let activeOut;
+  let lineOut;
+  const placeOutlines = () => {
+    const outlines2 = text.takeOutlines();
+    if (outlines2 && lineOut) lineOut.push(outlines2);
+  };
   const markersByPage = /* @__PURE__ */ new Map();
   for (let i = 0; i < spans.length; i++) {
     if (i % 128 === 0) await work.yield();
     const visit = spans[i], page = pages[visit.page.index], out = outFor(visit);
     if (lineStarts.has(visit)) {
+      placeOutlines();
+      lineOut = out;
       if (activeOut) activeOut.push("EMC");
-      activeOut = out;
-      out.push(`/Span << /ActualText <FEFF${unicodeHex(lineStarts.get(visit) ?? "")}> >> BDC`);
+      const logical = lineStarts.get(visit);
+      activeOut = logical === null ? void 0 : out;
+      if (logical !== null)
+        out.push(`/Span << /ActualText <FEFF${unicodeHex(logical ?? "")}> >> BDC`);
     }
     let markers = markersByPage.get(visit.page.index);
     if (!markers) {
@@ -2439,27 +2922,28 @@ async function paint(doc, session, layout, work, includeComments) {
       ) : "";
       if (picture) out.push(picture);
       else
-        out.push(
-          text.paint(
-            {
-              ...visit,
-              span: {
-                ...visit.span,
-                text: marker.text,
-                style: marker.style,
-                box: marker.box,
-                link: void 0,
-                revisions: void 0
+        for (const piece of marker.pieces ?? [marker])
+          out.push(
+            text.paint(
+              {
+                ...visit,
+                span: {
+                  ...visit.span,
+                  text: piece.text,
+                  style: piece.style,
+                  box: piece.box,
+                  link: void 0,
+                  revisions: void 0
+                },
+                absoluteBox: {
+                  ...piece.box,
+                  x: piece.box.x + visit.storyOrigin.x,
+                  y: piece.box.y + visit.storyOrigin.y
+                }
               },
-              absoluteBox: {
-                ...marker.box,
-                x: marker.box.x + visit.storyOrigin.x,
-                y: marker.box.y + visit.storyOrigin.y
-              }
-            },
-            page
-          )
-        );
+              page
+            )
+          );
     }
     const fill = HIGHLIGHTS[visit.span.style.highlight ?? ""] ?? visit.span.style.shading;
     if (fill)
@@ -2477,6 +2961,7 @@ async function paint(doc, session, layout, work, includeComments) {
     if (clipping) out.push("Q");
     linkAnnotation(doc, page, visit, names);
   }
+  placeOutlines();
   if (activeOut) activeOut.push("EMC");
   for (const lines of pageGroups.values()) {
     for (const group of lines.values()) {
@@ -2556,7 +3041,7 @@ async function paint(doc, session, layout, work, includeComments) {
 }
 
 // src/pdf-work.ts
-import { ExportResourceError as ExportResourceError2 } from "@docx-editor.dev/core/export";
+import { ExportResourceError as ExportResourceError3 } from "@docx-editor.dev/core/export";
 
 // src/types.ts
 var PdfFidelityError = class extends Error {
@@ -2615,12 +3100,12 @@ async function withPdfWork(options, run) {
   const controller = new AbortController();
   const signal = options.signal;
   const abort = () => controller.abort(
-    new ExportResourceError2("aborted", "PDF conversion aborted", { cause: signal?.reason })
+    new ExportResourceError3("aborted", "PDF conversion aborted", { cause: signal?.reason })
   );
   if (signal?.aborted) abort();
   signal?.addEventListener("abort", abort, { once: true });
   const timer = setTimeout(
-    () => controller.abort(new ExportResourceError2("timedOut", "PDF conversion timed out")),
+    () => controller.abort(new ExportResourceError3("timedOut", "PDF conversion timed out")),
     timeoutMs
   );
   const work = new Work(controller.signal, Date.now() + timeoutMs);
@@ -2629,9 +3114,9 @@ async function withPdfWork(options, run) {
     work.check();
     return await run(work, () => Math.round(performance.now() - started));
   } catch (error) {
-    if (error instanceof PdfDocumentOpenError && error.reason === "aborted" || error instanceof ExportResourceError2 && error.code === "aborted")
+    if (error instanceof PdfDocumentOpenError && error.reason === "aborted" || error instanceof ExportResourceError3 && error.code === "aborted")
       work.check();
-    if (error instanceof PdfFidelityError || error instanceof PdfDocumentOpenError || error instanceof ExportResourceError2 || error instanceof RangeError || error instanceof PdfEncodingError || error instanceof PdfWorkLimitError)
+    if (error instanceof PdfFidelityError || error instanceof PdfDocumentOpenError || error instanceof ExportResourceError3 || error instanceof RangeError || error instanceof PdfEncodingError || error instanceof PdfWorkLimitError)
       throw error;
     work.check();
     throw new PdfEncodingError("PDF encoding failed", { cause: error });
@@ -2768,9 +3253,9 @@ async function openDocumentForExport(source, options = {}) {
 
 // src/index.ts
 import { createFontSource as createFontSource2, defineFontResolver as defineFontResolver2 } from "@docx-editor.dev/core/editor";
-import { ExportResourceError as ExportResourceError3 } from "@docx-editor.dev/core/export";
+import { ExportResourceError as ExportResourceError4 } from "@docx-editor.dev/core/export";
 export {
-  ExportResourceError3 as ExportResourceError,
+  ExportResourceError4 as ExportResourceError,
   PdfDocumentOpenError,
   PdfEncodingError,
   PdfFidelityError,