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

package/dist/index.js

@@ -0,0 +1,3270 @@
+// src/export-pdf.ts
+import { PDFDocument as PDFDocument5 } from "pdf-lib";
+import { hasFontBackedExportCapabilities } from "@docx-editor.dev/core/export";
+
+// src/context.ts
+import { ExportResourceError } from "@docx-editor.dev/core/export";
+import { deflateSync } from "zlib";
+var MAX_OUTPUT_BYTES = 64 * 1024 * 1024;
+var MAX_OPERATIONS = 2e6;
+function positiveLimit(value, maximum, name) {
+  if (!Number.isSafeInteger(value) || value <= 0 || value > maximum)
+    throw new RangeError(`${name} must be an integer from 1 to ${maximum}`);
+  return value;
+}
+function number(value) {
+  if (!Number.isFinite(value) || Math.abs(value) > 1e6)
+    throw new RangeError("Invalid PDF coordinate");
+  return String(Number(value.toFixed(6)));
+}
+var PAINT_GRID_PT = 0.24;
+var onGrid = (value) => Math.round(value / PAINT_GRID_PT) * PAINT_GRID_PT;
+function rect(box, x, y, height, grid = false) {
+  const left = box.x + x;
+  const bottom = height - box.y - y - box.height;
+  if (!grid)
+    return `${number(left)} ${number(bottom)} ${number(box.width)} ${number(box.height)} re`;
+  const extent = (value) => value > 0 ? Math.max(PAINT_GRID_PT, Math.floor(value / PAINT_GRID_PT) * PAINT_GRID_PT) : 0;
+  return `${number(onGrid(left))} ${number(onGrid(bottom))} ${number(extent(box.width))} ${number(extent(box.height))} re`;
+}
+function pdfLiteralUri(href) {
+  if (href.length === 0 || href.length > 2048) return null;
+  for (let index = 0; index < href.length; index += 1) {
+    const code = href.charCodeAt(index);
+    if (code < 32 || code > 126) return null;
+  }
+  return href.replace(/[\\()]/g, (character) => `\\${character}`);
+}
+function flateStream(context, contents, dict = {}) {
+  const bytes = typeof contents === "string" ? Buffer.from(contents, "latin1") : contents;
+  const deflated = deflateSync(bytes);
+  const owned = deflated.buffer.byteLength > deflated.byteLength * 2 ? new Uint8Array(deflated) : deflated;
+  return context.stream(owned, { ...dict, Filter: "FlateDecode" });
+}
+var pageHeights = /* @__PURE__ */ new WeakMap();
+function pageHeight(page) {
+  let height = pageHeights.get(page);
+  if (height === void 0) pageHeights.set(page, height = page.getHeight());
+  return height;
+}
+var HEX_BYTES = Array.from({ length: 256 }, (_, byte) => byte.toString(16).padStart(2, "0"));
+function hex(value) {
+  if (value >= 0 && value <= 65535 && Number.isInteger(value))
+    return HEX_BYTES[value >> 8] + HEX_BYTES[value & 255];
+  return value.toString(16).padStart(4, "0");
+}
+function unicodeHex(text) {
+  const out = [];
+  for (let i = 0; i < text.length; i++) out.push(hex(text.charCodeAt(i)));
+  return out.join("");
+}
+function color(value) {
+  const v = value && /^[a-f\d]{6}$/i.test(value) ? value : "000000";
+  return [0, 2, 4].map((i) => number(parseInt(v.slice(i, i + 2), 16) / 255)).join(" ");
+}
+var Work = class {
+  constructor(signal, deadline = Infinity) {
+    this.signal = signal;
+    this.deadline = deadline;
+  }
+  signal;
+  deadline;
+  diagnostics = [];
+  seen = /* @__PURE__ */ new Set();
+  operations = 0;
+  contentBytes = 0;
+  check() {
+    if (Date.now() >= this.deadline)
+      throw new ExportResourceError("timedOut", "PDF conversion timed out");
+    if (this.signal.aborted)
+      throw this.signal.reason instanceof ExportResourceError ? this.signal.reason : new ExportResourceError("aborted", "PDF conversion aborted", {
+        cause: this.signal.reason
+      });
+  }
+  reserveContent(bytes) {
+    this.contentBytes += bytes;
+    if (this.contentBytes > MAX_OUTPUT_BYTES) throw new PdfWorkLimitError();
+  }
+  tick() {
+    this.check();
+    if (++this.operations > MAX_OPERATIONS) throw new PdfWorkLimitError();
+  }
+  async yield() {
+    this.check();
+    await new Promise((resolve) => setImmediate(resolve));
+    this.check();
+  }
+  report(code, message, pageIndex, severity = "unsupported", origin) {
+    const key = `${code}:${pageIndex ?? ""}:${origin?.originIndex ?? ""}:${message}`;
+    if (this.seen.has(key)) return;
+    if (this.diagnostics.length >= 1e4) throw new PdfWorkLimitError();
+    this.seen.add(key);
+    this.diagnostics.push(
+      Object.freeze({
+        code,
+        message,
+        pageIndex,
+        ...pageIndex === void 0 ? {} : { pageNumber: pageIndex + 1 },
+        severity,
+        ...origin
+      })
+    );
+  }
+};
+var PdfWorkLimitError = class extends Error {
+  code = "workLimitExceeded";
+  constructor() {
+    super("PDF content, operation, or diagnostic limit exceeded");
+    this.name = "PdfWorkLimitError";
+  }
+};
+var Commands = class extends Array {
+  constructor(work) {
+    super();
+    this.work = work;
+  }
+  work;
+  push(...values) {
+    for (const value of values) this.work.reserveContent(value.length + 1);
+    return super.push(...values);
+  }
+  unshift(...values) {
+    for (const value of values) this.work.reserveContent(value.length + 1);
+    return super.unshift(...values);
+  }
+};
+
+// src/options.ts
+function validateOptions(options) {
+  if (!options || typeof options !== "object" || Array.isArray(options))
+    throw new TypeError("options must be an object");
+  for (const [name, choices] of [
+    ["fidelityPolicy", ["strict", "best-effort"]],
+    ["fontPolicy", ["strict", "best-effort"]],
+    ["displayMode", ["proposed", "original", "all-markup"]]
+  ]) {
+    const value = options[name];
+    if (value !== void 0 && !choices.includes(value))
+      throw new RangeError(`Invalid ${name}: expected ${choices.join(", ")}`);
+  }
+  for (const name of ["useSystemFonts", "comments", "documentLigatures"]) {
+    if (options[name] !== void 0 && typeof options[name] !== "boolean")
+      throw new TypeError(`${name} must be boolean`);
+  }
+  for (const name of ["resourceTimeoutMs", "fontResolutionTimeoutMs"]) {
+    const value = options[name];
+    if (value !== void 0 && (!Number.isFinite(value) || value <= 0 || value > 2147483647))
+      throw new RangeError(`${name} must be positive and at most 2147483647`);
+  }
+  for (const name of ["onFontResolution", "convertPreservedImage"]) {
+    if (options[name] !== void 0 && typeof options[name] !== "function")
+      throw new TypeError(`${name} must be a function`);
+  }
+  if (options.imageDecodePort !== void 0 && (!options.imageDecodePort || typeof options.imageDecodePort !== "object" || typeof options.imageDecodePort.decode !== "function"))
+    throw new TypeError("imageDecodePort must provide a decode function");
+  const signal = options.signal;
+  if (signal !== void 0 && (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function" || typeof signal.removeEventListener !== "function"))
+    throw new TypeError("signal must be an AbortSignal");
+  for (const name of ["measurer", "producer", "reuseAcrossRevisions"]) {
+    if (options[name] !== void 0)
+      throw new TypeError(`${name} is not supported by exportPdf`);
+  }
+  const { timeoutMs = 6e4, maxOutputBytes = MAX_OUTPUT_BYTES, maxPages = 1e4 } = options;
+  return {
+    timeoutMs: positiveLimit(timeoutMs, 2147483647, "timeoutMs"),
+    maxBytes: positiveLimit(maxOutputBytes, MAX_OUTPUT_BYTES, "maxOutputBytes"),
+    maxPages: positiveLimit(maxPages, 1e4, "maxPages")
+  };
+}
+
+// src/open-session.ts
+import {
+  createPackagedFileFetch,
+  openFontBackedDocumentForExport
+} from "@docx-editor.dev/core/export";
+import { HARD_MAX_FONT_BYTES } from "@docx-editor.dev/core/layout";
+import { FONT_ASSET_ROOT as FONT_ASSET_ROOT2, packagedFonts } from "@docx-editor.dev/fonts";
+
+// src/font-provisioning.ts
+import { create as openFont } from "fontkit";
+import { readFile, stat } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { pathToFileURL, URL as NodeURL } from "url";
+import { createFontSource, defineFontResolver } from "@docx-editor.dev/core/editor";
+import { FONT_ASSET_ROOT } from "@docx-editor.dev/fonts";
+var assetRoot = new NodeURL(
+  "../assets/",
+  typeof __dirname === "string" ? pathToFileURL(__dirname + "/").href : import.meta.url
+);
+var latinSubstitute = (family, prefix) => [
+  ["Regular", 400, "normal"],
+  ["Bold", 700, "normal"],
+  ["Italic", 400, "italic"],
+  ["BoldItalic", 700, "italic"]
+].map(([suffix, weight, style]) => [
+  family,
+  new NodeURL(`${prefix}-${suffix}.ttf`, FONT_ASSET_ROOT),
+  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"],
+  ["Twemoji Mozilla", new NodeURL("TwemojiMozilla.ttf", assetRoot), 400, "normal"],
+  ["Noto Emoji", new NodeURL("NotoEmoji-Regular.ttf", assetRoot), 400, "normal"],
+  ...latinSubstitute("Liberation Sans", "LiberationSans"),
+  ...latinSubstitute("Liberation Serif", "LiberationSerif"),
+  ...latinSubstitute("Liberation Mono", "LiberationMono"),
+  ...latinSubstitute("Carlito", "Carlito"),
+  ...latinSubstitute("Caladea", "Caladea")
+];
+var PDF_GLYPH_FALLBACKS = [
+  "Segoe UI Symbol",
+  "Noto Sans Symbols 2",
+  "Noto Sans Math",
+  "Noto Sans Arabic",
+  // 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",
+  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",
+  "Noto Emoji"
+].map((family) => ({ family, weight: 400, style: "normal" }));
+var face = (family, weight = 400, style = "normal") => ({ family, weight, style });
+var substitutes = {
+  "Cambria Math": "Noto Sans Math",
+  Georgia: "Liberation Serif",
+  Verdana: "Liberation Sans",
+  Helvetica: "Liberation Sans",
+  ...Object.fromEntries(
+    [
+      "MS Gothic",
+      "MS PGothic",
+      "MS UI Gothic",
+      "MS Mincho",
+      "MS PMincho",
+      "Meiryo",
+      "Yu Gothic",
+      "Yu Mincho",
+      "SimSun",
+      "NSimSun",
+      "SimHei",
+      "FangSong",
+      "KaiTi",
+      "DengXian",
+      "Microsoft YaHei",
+      "Microsoft JhengHei",
+      "MingLiU",
+      "PMingLiU",
+      "Batang",
+      "Gulim",
+      "Dotum",
+      "Malgun Gothic"
+    ].map((family) => [family, CJK_FAMILY])
+  )
+};
+var localizedFamilies = {
+  \u5B8B\u4F53: "SimSun",
+  \u65B0\u5B8B\u4F53: "NSimSun",
+  \u9ED1\u4F53: "SimHei",
+  \u4EFF\u5B8B: "FangSong",
+  \u6977\u4F53: "KaiTi",
+  \u7B49\u7EBF: "DengXian",
+  \u5FAE\u8F6F\u96C5\u9ED1: "Microsoft YaHei",
+  \u5FAE\u8EDF\u6B63\u9ED1\u9AD4: "Microsoft JhengHei",
+  \u65B0\u7D30\u660E\u9AD4: "PMingLiU",
+  \u7D30\u660E\u9AD4: "MingLiU",
+  "\uFF2D\uFF33 \u660E\u671D": "MS Mincho",
+  "\uFF2D\uFF33 \uFF30\u660E\u671D": "MS PMincho",
+  "\uFF2D\uFF33 \u30B4\u30B7\u30C3\u30AF": "MS Gothic",
+  "\uFF2D\uFF33 \uFF30\u30B4\u30B7\u30C3\u30AF": "MS PGothic",
+  "\uFF2D\uFF33 \uFF35\uFF29 \uFF27\uFF4F\uFF54\uFF48\uFF49\uFF43": "MS UI Gothic",
+  \u30E1\u30A4\u30EA\u30AA: "Meiryo",
+  \u6E38\u30B4\u30B7\u30C3\u30AF: "Yu Gothic",
+  \u6E38\u660E\u671D: "Yu Mincho",
+  "\uB9D1\uC740 \uACE0\uB515": "Malgun Gothic",
+  \uBC14\uD0D5: "Batang",
+  \uAD74\uB9BC: "Gulim",
+  \uB3CB\uC6C0: "Dotum"
+};
+function canonicalFamily(family) {
+  let base = family;
+  let bold = false;
+  let italic = false;
+  if (family.length <= 128) {
+    const lower = family.toLowerCase();
+    for (const [suffix, flags] of [
+      [" bold italic", [true, true]],
+      [" bolditalic", [true, true]],
+      [" bold", [true, false]],
+      [" italic", [false, true]]
+    ]) {
+      if (!lower.endsWith(suffix) || lower.length === suffix.length) continue;
+      base = family.slice(0, family.length - suffix.length).trimEnd();
+      [bold, italic] = flags;
+      break;
+    }
+  }
+  return {
+    family: Object.hasOwn(localizedFamilies, base) ? localizedFamilies[base] : base,
+    bold,
+    italic
+  };
+}
+var packagedSubstitutes = {
+  Calibri: "Carlito",
+  Cambria: "Caladea",
+  "Times New Roman": "Liberation Serif",
+  Arial: "Liberation Sans",
+  "Courier New": "Liberation Mono",
+  "Century Gothic": "TeX Gyre Adventor"
+};
+var substituteFor = (family) => {
+  const canonical = canonicalFamily(family).family;
+  if (Object.hasOwn(substitutes, canonical)) return substitutes[canonical];
+  if (canonical !== family && Object.hasOwn(packagedSubstitutes, canonical))
+    return packagedSubstitutes[canonical];
+  return void 0;
+};
+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
+  ))
+    return "Liberation Serif";
+  return "Liberation Sans";
+}
+var knownFamilies = /* @__PURE__ */ new Set([
+  ...supplemental.map(([family]) => family),
+  CJK_FAMILY,
+  ...Object.keys(substitutes),
+  ...Object.keys(packagedSubstitutes),
+  ...Object.values(packagedSubstitutes),
+  "Symbol",
+  "Wingdings",
+  "Wingdings 2",
+  "Wingdings 3",
+  "Webdings",
+  "MT Extra"
+]);
+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: ${String(file)}`);
+      return result.source;
+    })
+  );
+  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) 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);
+      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 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",
+  join(homedir(), "Library/Fonts"),
+  "/Applications/Microsoft Word.app/Contents/Resources/DFonts"
+] : process.platform === "win32" ? [join(process.env.WINDIR ?? "C:\\Windows", "Fonts")] : [
+  "/usr/share/fonts/truetype/msttcorefonts",
+  "/usr/share/fonts/truetype/msttcore",
+  join(homedir(), ".local/share/fonts")
+];
+function installedWordFontResolver(roots) {
+  return defineFontResolver(async ({ families, defaultFamily, signal }) => {
+    const names = {
+      Arial: ["Arial", "arial"],
+      "Times New Roman": ["Times New Roman", "times"],
+      "Courier New": ["Courier New", "cour"],
+      Georgia: ["Georgia", "georgia"],
+      Verdana: ["Verdana", "verdana"],
+      Calibri: ["Calibri", "calibri"],
+      "Segoe UI Symbol": ["Segoe UI Symbol", "seguisym"],
+      SimSun: ["SimSun", "simsun"],
+      Batang: ["Batang", "batang"],
+      Cambria: ["Cambria", "cambria"],
+      "Cambria Math": ["Cambria Math"],
+      "MS Gothic": ["MS Gothic", "msgothic"],
+      "MS PGothic": ["MS PGothic"],
+      "MS UI Gothic": ["MS UI Gothic"],
+      "Arial Narrow": ["Arial Narrow", "ArialNarrow"],
+      "Malgun Gothic": ["malgun"],
+      // Legacy symbol-encoded faces. A Word bullet is the font's own byte plus 0xF000
+      // (U+F0B7 in Symbol), a private-use codepoint only these faces carry — and the face
+      // also SIZES the line it sits on, because a 12 pt Symbol ascends 12.06 pt where a
+      // 12 pt text face ascends 11.52. Without them the glyph falls to the shared symbol
+      // fallback, which has neither the right outline nor the right ascent.
+      Symbol: ["Symbol", "symbol"],
+      Wingdings: ["Wingdings", "wingding"],
+      "Wingdings 2": ["Wingdings 2", "wingdng2"],
+      "Wingdings 3": ["Wingdings 3", "wingdng3"],
+      Webdings: ["Webdings", "webdings"]
+    };
+    const files = {
+      Aptos: [["Aptos.ttf"], ["Aptos-Bold.ttf"], ["Aptos-Italic.ttf"], ["Aptos-Bold-Italic.ttf"]],
+      "Aptos Narrow": [
+        ["Aptos-Narrow.ttf"],
+        ["Aptos-Narrow-Bold.ttf"],
+        ["Aptos-Narrow-Italic.ttf"],
+        ["Aptos-Narrow-Bold-Italic.ttf"]
+      ],
+      Helvetica: [["Helvetica.ttc"], ["Helvetica.ttc"], ["Helvetica.ttc"], ["Helvetica.ttc"]],
+      SimHei: [["SimHei.ttf", "simhei.ttf"], [], [], []],
+      FangSong: [["Fangsong.ttf", "simfang.ttf"], [], [], []],
+      KaiTi: [["Kaiti.ttf", "simkai.ttf"], [], [], []],
+      DengXian: [["Deng.ttf"], ["Dengb.ttf"], [], []],
+      "MS Mincho": [["msmincho.ttc"], [], [], []],
+      "MS PMincho": [["msmincho.ttc"], [], [], []],
+      "Microsoft YaHei": [["msyh.ttc"], ["msyhbd.ttc"], [], []],
+      Meiryo: [["meiryo.ttc"], ["meiryob.ttc"], [], []],
+      MingLiU: [["mingliu.ttc"], [], [], []],
+      PMingLiU: [["mingliu.ttc"], [], [], []],
+      Gulim: [["gulim.ttc"], [], [], []],
+      Dotum: [["gulim.ttc"], [], [], []]
+    };
+    const sources = [];
+    for (const requested of /* @__PURE__ */ new Set([...families, ...defaultFamily ? [defaultFamily] : []])) {
+      const { family, bold, italic } = canonicalFamily(requested);
+      if (!Object.hasOwn(names, family) && !Object.hasOwn(files, family)) continue;
+      for (const [weight, style] of [
+        [400, "normal"],
+        [700, "normal"],
+        [400, "italic"],
+        [700, "italic"]
+      ]) {
+        const faceBold = bold || weight === 700;
+        const faceItalic = italic || style === "italic";
+        const slot = (faceBold ? 1 : 0) + (faceItalic ? 2 : 0);
+        const [suffix, short] = [
+          ["", ""],
+          [" Bold", "bd"],
+          [" Italic", "i"],
+          [" Bold Italic", "bi"]
+        ][slot];
+        let found = false;
+        for (const root of roots) {
+          if (found) break;
+          const shortSuffix = ["Georgia", "Verdana", "Calibri", "Cambria"].includes(family) ? { bd: "b", bi: "z" }[short] ?? short : short;
+          const candidates = (names[family] ?? []).flatMap((name) => [
+            name + suffix + ".ttf",
+            name + shortSuffix + ".ttf"
+          ]);
+          candidates.push(...files[family]?.[slot] ?? []);
+          if (slot === 0 && ["Cambria", "Cambria Math"].includes(family))
+            candidates.push("Cambria.ttc", "cambria.ttc");
+          if (slot === 0 && ["MS Gothic", "MS PGothic", "MS UI Gothic"].includes(family))
+            candidates.push("msgothic.ttc", "MSGOTHIC.TTC");
+          if (slot === 0) {
+            if (family === "SimSun") candidates.push("Simsun.ttc", "simsun.ttc");
+            if (family === "Batang") candidates.push("batang.ttc", "Batang.ttc");
+          }
+          for (const filename of new Set(candidates)) {
+            if (signal?.aborted) throw signal.reason;
+            try {
+              const bytes = new Uint8Array(await readFontFile(join(root, filename), signal));
+              let faceIndex = 0;
+              if (filename.toLowerCase().endsWith(".ttc")) {
+                const collection = openFont(Buffer.from(bytes));
+                if (!("fonts" in collection)) continue;
+                faceIndex = collection.fonts.findIndex(
+                  (font) => collectionFaceMatches(font.postscriptName, family, faceBold, faceItalic)
+                );
+                if (faceIndex < 0) continue;
+              }
+              const source = createFontSource(bytes, {
+                ...face(requested, weight, style),
+                faceIndex
+              });
+              if ("failure" in source) continue;
+              sources.push(source.source);
+              found = true;
+              break;
+            } catch (error) {
+              if (signal?.aborted) throw error;
+              if (error.code !== "ENOENT") throw error;
+            }
+          }
+          if (found) break;
+        }
+      }
+    }
+    return { sources };
+  });
+}
+function collectionFaceMatches(postscriptName, family, bold, italic) {
+  if (typeof postscriptName !== "string") return false;
+  const actual = postscriptName.replace(/[- ]/g, "").replace(/Oblique$/, "Italic").toLowerCase();
+  const expected = `${family.replace(/[- ]/g, "")}${bold ? "Bold" : ""}${italic ? "Italic" : ""}`;
+  return actual === expected.toLowerCase();
+}
+var installedWordFonts = installedWordFontResolver(wordFontRoots);
+async function readFontFile(path, signal) {
+  if (signal?.aborted) throw signal.reason;
+  if ((await stat(path)).size > 32 * 1024 * 1024) throw new RangeError("Local font exceeds 32 MiB");
+  let bytes;
+  try {
+    bytes = await readFile(path, signal ? { signal } : void 0);
+  } catch (error) {
+    if (!signal || error.code !== "ERR_INVALID_ARG_TYPE") throw error;
+    bytes = await readFile(path);
+  }
+  if (signal?.aborted) throw signal.reason;
+  return bytes;
+}
+
+// src/open-session.ts
+var bundledFonts = packagedFonts({
+  install: false,
+  fetcher: createPackagedFileFetch({
+    trustedRoot: new URL("./", FONT_ASSET_ROOT2),
+    maxBytes: HARD_MAX_FONT_BYTES
+  })
+});
+function openExportSession(source, options, signal) {
+  const { fonts, fallbackFonts, lastResortFonts, useSystemFonts = true, ...core } = options;
+  const origins = [
+    ...fonts ? Array.isArray(fonts) ? fonts : [fonts] : [],
+    ...useSystemFonts ? [installedWordFonts] : [],
+    bundledFonts,
+    ...fallbackFonts ? Array.isArray(fallbackFonts) ? fallbackFonts : [fallbackFonts] : [],
+    supplementalFonts,
+    cjkFonts
+  ];
+  return openFontBackedDocumentForExport(source, {
+    ...core,
+    documentLigatures: options.documentLigatures ?? true,
+    signal,
+    displayMode: options.displayMode ?? "proposed",
+    reuseAcrossRevisions: false,
+    // Every packaged fallback face is on offer. They are read lazily, only when a family the
+    // document uses needs one, so offering the whole list costs a plain Latin document nothing.
+    glyphFallbacks: options.glyphFallbacks ?? PDF_GLYPH_FALLBACKS,
+    fonts: origins,
+    // After the document's own embedded fonts: a stand-in for what nothing else covers.
+    lastResortFonts: [
+      ...lastResortFonts ? Array.isArray(lastResortFonts) ? lastResortFonts : [lastResortFonts] : [],
+      standInFonts
+    ]
+  });
+}
+
+// src/font-diagnostics.ts
+function reportFontDiagnostics(resolution, work) {
+  for (const failure of resolution.originFailures) {
+    let detail = "unknown error";
+    try {
+      if (failure.cause instanceof Error && typeof failure.cause.message === "string")
+        detail = failure.cause.message.slice(0, 1024);
+    } catch {
+    }
+    work.report("font-origin-failed", `A font source failed: ${detail}`, void 0, "information", {
+      originIndex: failure.originIndex,
+      ...failure.originName === void 0 ? {} : { originName: failure.originName }
+    });
+  }
+  for (const family of resolution.families) {
+    if (family.coverage !== "complete" || family.faces.some(
+      (face2) => face2.via === "substitution" && face2.sourceFamily.toLowerCase() === family.family.toLowerCase()
+    ))
+      work.report(
+        "incomplete-font",
+        family.coverage !== "complete" ? `Font face coverage is incomplete for ${family.family}; inspect fontResolution` : `Font variants use substitute faces from ${family.family}; inspect fontResolution`,
+        void 0,
+        "information"
+      );
+    const stand = family.faces.find(
+      (face2) => face2.via === "substitution" && isGenericSubstitution(family.family, face2.sourceFamily)
+    );
+    if (stand)
+      work.report(
+        "font-substitution",
+        `${family.family} is not available; best-effort export renders it in ${stand.sourceFamily}`
+      );
+  }
+}
+
+// src/paint.ts
+import {
+  forEachSemanticSpan,
+  forEachSemanticStory,
+  forEachSemanticDrawing,
+  runBorderStrokesForLine
+} from "@docx-editor.dev/core/layout";
+
+// src/text.ts
+import { PDFName as PDFName2 } from "pdf-lib";
+import {
+  baselineShiftPtOf,
+  noteSeparatorRuleBox,
+  glyphSizeFactorOf,
+  styleForFontSlot as styleForFontSlot2,
+  TAB_LEADER_GLYPH,
+  tabLeaderPattern
+} from "@docx-editor.dev/core/layout";
+
+// src/underline-gap.ts
+import { styleForFontSlot } from "@docx-editor.dev/core/layout";
+function underlineGap(visit) {
+  const { line, span } = visit;
+  const index = line.spans.indexOf(span);
+  if (index < 0 || (line.drawings?.length ?? 0) > 0) return 0;
+  const next = line.spans[index + 1];
+  if (!next || next.style.hidden || next.equation || next.text.includes("	")) return 0;
+  if (!span.text.endsWith(" ") || /\s/u.test(span.text.slice(0, -1))) return 0;
+  if ((next.wrapAdvanceBefore ?? 0) > 1e-3 || span.link !== next.link) return 0;
+  if (span.range.paragraphId !== next.range.paragraphId) return 0;
+  if (span.revisions?.length || next.revisions?.length) return 0;
+  const left = styleForFontSlot(span.style, span.fontSlot);
+  const right = styleForFontSlot(next.style, next.fontSlot);
+  if (left.underline?.variant !== "single" || right.underline?.variant !== "single") return 0;
+  if (left.horizontalScalePercent !== 100 || right.horizontalScalePercent !== 100) return 0;
+  if (left.shaping?.baseLevel === 1 || right.shaping?.baseLevel === 1) return 0;
+  if (left.fontFamily !== right.fontFamily || left.fontSizePt !== right.fontSizePt || left.bold !== right.bold || left.italic !== right.italic || left.verticalAlign !== right.verticalAlign || left.baselineShiftPt !== right.baselineShiftPt || (left.underline.color ?? left.color) !== (right.underline.color ?? right.color))
+    return 0;
+  const gap = next.box.x - (span.box.x + span.box.width);
+  return gap > 0.25 ? gap : 0;
+}
+
+// src/paragraph-grid-origin.ts
+var PDF_PAINT_GRID_PT = 0.24;
+function paragraphGridOffsetX(visit) {
+  const alignment = visit.paragraph.alignment;
+  const origin = alignment === "left" || alignment === "both" ? visit.storyOrigin.x + visit.line.contentX : visit.storyOrigin.x + visit.paragraph.box.x;
+  return Math.round(origin / PDF_PAINT_GRID_PT) * PDF_PAINT_GRID_PT - origin;
+}
+
+// src/fonts.ts
+import { create as openFont2 } from "fontkit";
+import { PDFName, PDFString } from "pdf-lib";
+import { mapSymbolPuaText } from "@docx-editor.dev/core/layout";
+
+// src/pdf-font-embedding.ts
+import { create as createFontkitFont } from "fontkit";
+var MAX_SFNT_TABLES = 4096;
+var MAX_TTC_FACES = 256;
+var BITMAP_ONLY_EMBEDDING = 512;
+var TTC_VERSION_1 = 65536;
+var TTC_VERSION_2 = 131072;
+function readUint16(bytes, offset) {
+  if (offset < 0 || offset > bytes.byteLength - 2) return null;
+  return bytes[offset] << 8 | bytes[offset + 1];
+}
+function readUint32(bytes, offset) {
+  if (offset < 0 || offset > bytes.byteLength - 4) return null;
+  return bytes[offset] * 16777216 + (bytes[offset + 1] << 16) + (bytes[offset + 2] << 8) + bytes[offset + 3] >>> 0;
+}
+function tagAt(bytes, offset) {
+  if (offset < 0 || offset > bytes.byteLength - 4) return null;
+  return String.fromCharCode(
+    bytes[offset],
+    bytes[offset + 1],
+    bytes[offset + 2],
+    bytes[offset + 3]
+  );
+}
+function isFontCollection(bytes) {
+  return tagAt(bytes, 0) === "ttcf";
+}
+function refuse(reason) {
+  return { kind: "refuse", reason };
+}
+function embed(collectionSelector) {
+  return { kind: "embed", collectionSelector };
+}
+function isFontkitFont(value) {
+  return value !== null && typeof value.hasGlyphForCodePoint === "function";
+}
+function isFontkitCollection(value) {
+  return typeof value.getFont === "function";
+}
+function postscriptSelector(face2) {
+  const name = face2.postscriptName;
+  if (typeof name !== "string") return null;
+  const trimmed = name.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function sfntEmbeddingPermission(bytes, base) {
+  const tableCount = readUint16(bytes, base + 4);
+  if (tableCount === null || tableCount > MAX_SFNT_TABLES) {
+    return refuse("The admitted font has no bounded SFNT table directory");
+  }
+  const directoryEnd = base + 12 + tableCount * 16;
+  if (!Number.isSafeInteger(directoryEnd) || directoryEnd > bytes.byteLength) {
+    return refuse("The admitted font has a truncated SFNT table directory");
+  }
+  for (let index = 0; index < tableCount; index += 1) {
+    const record = base + 12 + index * 16;
+    const tag = tagAt(bytes, record);
+    if (tag !== "OS/2") continue;
+    const offset = readUint32(bytes, record + 8);
+    const length = readUint32(bytes, record + 12);
+    if (offset === null || length === null || offset > bytes.byteLength || length > bytes.byteLength - offset || length < 10) {
+      return refuse("The admitted font has an invalid OS/2 table range");
+    }
+    const fsType = readUint16(bytes, offset + 8);
+    if (fsType === null) {
+      return refuse("The admitted font has a truncated OS/2 fsType value");
+    }
+    if ((fsType & 2) !== 0) {
+      return refuse("The OS/2 fsType forbids font embedding");
+    }
+    if ((fsType & 256) !== 0) {
+      return refuse(
+        "The OS/2 fsType forbids subsetting, and this writer has no safe full-font embedding mode"
+      );
+    }
+    if ((fsType & BITMAP_ONLY_EMBEDDING) !== 0) {
+      return refuse(
+        "The OS/2 fsType permits bitmap embedding only, and this writer embeds outline data"
+      );
+    }
+    return embed(null);
+  }
+  return embed(null);
+}
+function collectionFaceOffset(bytes, faceIndex) {
+  if (bytes.byteLength < 12) {
+    return { reason: "The admitted font collection header is truncated" };
+  }
+  const version = readUint32(bytes, 4);
+  if (version !== TTC_VERSION_1 && version !== TTC_VERSION_2) {
+    return { reason: "The admitted font collection has an unsupported TTC version" };
+  }
+  const faceCount = readUint32(bytes, 8);
+  if (faceCount === null) {
+    return { reason: "The admitted font collection header is truncated" };
+  }
+  if (faceCount === 0) {
+    return { reason: "The admitted font collection has no faces" };
+  }
+  if (faceCount > MAX_TTC_FACES) {
+    return { reason: `The admitted font collection exceeds the ${MAX_TTC_FACES} face limit` };
+  }
+  const offsetsEnd = 12 + faceCount * 4;
+  if (!Number.isSafeInteger(offsetsEnd) || offsetsEnd > bytes.byteLength) {
+    return { reason: "The admitted font collection face directory is truncated" };
+  }
+  if (!Number.isSafeInteger(faceIndex) || faceIndex < 0) {
+    return { reason: "The admitted font collection faceIndex is invalid" };
+  }
+  if (faceIndex >= faceCount) {
+    return {
+      reason: `The admitted font collection faceIndex ${faceIndex} is out of range for ${faceCount} faces`
+    };
+  }
+  const faceOffset = readUint32(bytes, 12 + faceIndex * 4);
+  if (faceOffset === null || faceOffset < offsetsEnd || faceOffset > bytes.byteLength - 12) {
+    return { reason: "The admitted font collection face offset is invalid" };
+  }
+  return { offset: faceOffset };
+}
+function collectionFaceSelector(bytes, faceIndex) {
+  let opened;
+  try {
+    opened = createFontkitFont(Buffer.from(bytes));
+  } catch {
+    return { reason: "The admitted font collection could not be opened" };
+  }
+  if (!isFontkitCollection(opened)) {
+    return { reason: "The admitted font collection did not parse as a font collection" };
+  }
+  const fonts = opened.fonts;
+  if (faceIndex >= fonts.length) {
+    return {
+      reason: `The admitted font collection faceIndex ${faceIndex} is out of range for ${fonts.length} faces`
+    };
+  }
+  const face2 = fonts[faceIndex];
+  if (!isFontkitFont(face2)) {
+    return { reason: "The selected collection face is not a font face" };
+  }
+  const selector = postscriptSelector(face2);
+  if (selector === null) {
+    return { reason: "The selected collection face has no PostScript name" };
+  }
+  for (let index = 0; index < fonts.length; index += 1) {
+    if (index === faceIndex) continue;
+    if (postscriptSelector(fonts[index]) === selector) {
+      return { reason: "The selected collection face PostScript name is not unique" };
+    }
+  }
+  let selected;
+  try {
+    selected = createFontkitFont(Buffer.from(bytes), selector);
+  } catch {
+    return { reason: "The selected collection face PostScript name did not resolve" };
+  }
+  if (!isFontkitFont(selected)) {
+    return { reason: "The selected collection face PostScript name did not resolve" };
+  }
+  return { selector };
+}
+function fontEmbeddingDecision(font) {
+  const { bytes, faceIndex } = font;
+  if (!isFontCollection(bytes)) {
+    if (faceIndex !== 0) {
+      return refuse("A nonzero faceIndex requires a TrueType collection resource");
+    }
+    return sfntEmbeddingPermission(bytes, 0);
+  }
+  const located = collectionFaceOffset(bytes, faceIndex);
+  if ("reason" in located) return refuse(located.reason);
+  const permission = sfntEmbeddingPermission(bytes, located.offset);
+  if (permission.kind === "refuse") return permission;
+  const selected = collectionFaceSelector(bytes, faceIndex);
+  if ("reason" in selected) return refuse(selected.reason);
+  return embed(selected.selector);
+}
+
+// src/font-metrics.ts
+function strikeMetrics(face2) {
+  const bytes = face2.bytes, view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let base = 0;
+  if (bytes.length < 12) return null;
+  if (view.getUint32(0) === 1953784678) {
+    if (12 + face2.faceIndex * 4 + 4 > bytes.length) return null;
+    base = view.getUint32(12 + face2.faceIndex * 4);
+  }
+  if (base + 12 > bytes.length) return null;
+  const count = view.getUint16(base + 4);
+  if (count > 4096 || base + 12 + count * 16 > bytes.length) return null;
+  for (let i = 0; i < count; i++) {
+    const entry = base + 12 + i * 16;
+    if (view.getUint32(entry) !== 1330851634) continue;
+    const offset = view.getUint32(entry + 8), length = view.getUint32(entry + 12);
+    if (length < 30 || offset + length > bytes.length) return null;
+    return { thickness: view.getInt16(offset + 26), position: view.getInt16(offset + 28) };
+  }
+  return null;
+}
+
+// src/fonts.ts
+function cmap(body, type) {
+  return `/CIDInit /ProcSet findresource begin
+12 dict begin
+begincmap
+/CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> def
+/CMapName /Docx${type} def
+/CMapType ${type} def
+1 begincodespacerange
+<0000> <ffff>
+endcodespacerange
+${body}
+endcmap
+CMapName currentdict /CMap defineresource pop
+end
+end`;
+}
+function groups(rows, operator) {
+  const out = [];
+  for (let i = 0; i < rows.length; i += 100) {
+    const slice = rows.slice(i, i + 100);
+    out.push(`${slice.length} begin${operator}
+${slice.join("\n")}
+end${operator}`);
+  }
+  return out.join("\n");
+}
+var EmbeddedFace = class {
+  constructor(doc, admitted, index) {
+    this.doc = doc;
+    const gate = fontEmbeddingDecision(admitted);
+    if (gate.kind === "refuse") throw new Error(gate.reason);
+    const font = gate.collectionSelector ? openFont2(Buffer.from(admitted.bytes), gate.collectionSelector) : openFont2(Buffer.from(admitted.bytes));
+    if (!font || !("createSubset" in font))
+      throw new Error("The selected resource is not a font face");
+    if (Object.keys(font.variationAxes ?? {}).length)
+      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}`;
+  }
+  doc;
+  ref;
+  name;
+  font;
+  strike;
+  /**
+   * A COLR/CPAL face. Its glyphs are painted as filled palette layers by the text writer and
+   * never written as text, so the face is not embedded: the subsetter cannot encode a color
+   * 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();
+  /**
+   * One drawn glyph, and the text it should EXTRACT as.
+   *
+   * A legacy symbol face draws Word's own private-use codepoint (U+F0B7 is Symbol's bullet),
+   * which is the right glyph and the wrong character: copied out of the page it is a private
+   * character that means nothing outside that font. `ToUnicode` therefore carries the Unicode
+   * twin, exactly as Word's own PDF export does. Drawing and extraction stay separate — the
+   * glyph id is untouched — and a codepoint with no exact twin keeps what the file had rather
+   * than gaining an approximate character.
+   */
+  encode(glyph, text) {
+    if (!Number.isInteger(glyph) || glyph <= 0 || glyph >= this.font.numGlyphs)
+      throw new Error("Core produced a missing or invalid glyph");
+    text = mapSymbolPuaText(text, this.family);
+    const key = `${glyph}:${text}`;
+    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.cidFor(glyph, text);
+      if (!Number.isInteger(cid) || cid < 0 || cid > 65535)
+        throw new Error("Invalid subset glyph identifier");
+      code = this.rows.length + 1;
+      this.rows.push({ cid, text });
+      this.codes.set(key, code);
+      this.widths.set(cid, this.font.getGlyph(glyph).advanceWidth * 1e3 / this.font.unitsPerEm);
+    }
+    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
+   * gives a reader that ignores `ActualText` the characters all the same. Null when the face
+   * has no space glyph to lend.
+   */
+  carrier(text) {
+    const space = this.font.glyphForCodePoint(32)?.id;
+    if (!Number.isInteger(space) || space <= 0) return null;
+    return this.encode(space, text);
+  }
+  /**
+   * The advance this PDF declares for a character code, in 1/1000 em.
+   *
+   * What a viewer moves the pen by after drawing the glyph, so it is what a `TJ` adjustment
+   * has to be measured against. Returns 0 for a code that was never encoded, which cannot
+   * happen on the paint path because `encode` always runs first.
+   */
+  declaredWidth(code) {
+    const row = this.rows[parseInt(code, 16) - 1];
+    const width = row === void 0 ? 0 : this.widths.get(row.cid) ?? 0;
+    return Math.round(width * 1e5) / 1e5;
+  }
+  async finish(work) {
+    if (this.colorLayers) return;
+    await work.yield();
+    const bytes = this.encodeSubset();
+    work.check();
+    const cff = bytes[0] === 1 && bytes[1] === 0;
+    const ctx = this.doc.context;
+    const prefix = Number(this.name.slice(1)).toString(26).padStart(6, "0").split("").map((c) => String.fromCharCode(65 + parseInt(c, 26))).join("");
+    const base = PDFName.of(`${prefix}+DocxFont`);
+    const file = ctx.register(
+      flateStream(ctx, bytes, cff ? { Subtype: "CIDFontType0C" } : { Length1: bytes.length })
+    );
+    const factor = 1e3 / this.font.unitsPerEm;
+    const bbox = this.font.bbox;
+    const descriptor = ctx.register(
+      ctx.obj({
+        Type: "FontDescriptor",
+        FontName: base,
+        Flags: 4,
+        FontBBox: [bbox.minX, bbox.minY, bbox.maxX, bbox.maxY].map((v) => v * factor),
+        ItalicAngle: this.font.italicAngle || 0,
+        Ascent: this.font.ascent * factor,
+        Descent: this.font.descent * factor,
+        CapHeight: (this.font.capHeight || this.font.ascent) * factor,
+        StemV: 80,
+        [cff ? "FontFile3" : "FontFile2"]: file
+      })
+    );
+    const widths = [];
+    for (const [cid, width] of [...this.widths].sort((a, b) => a[0] - b[0]))
+      widths.push(cid, [width]);
+    const descendant = ctx.register(
+      ctx.obj({
+        Type: "Font",
+        Subtype: cff ? "CIDFontType0" : "CIDFontType2",
+        BaseFont: base,
+        // Registry and Ordering are PDF byte strings, `(Adobe)` and `(Identity)`, not text
+        // strings. `PDFHexString.fromText` writes UTF-16BE behind a BOM, and a consumer that
+        // compares these as bytes, which Acrobat and PDF/A checkers do, cannot match the
+        // CIDFont to its CMap and drops it.
+        CIDSystemInfo: {
+          Registry: PDFString.of("Adobe"),
+          Ordering: PDFString.of("Identity"),
+          Supplement: 0
+        },
+        FontDescriptor: descriptor,
+        DW: 0,
+        W: widths,
+        ...cff ? {} : { CIDToGIDMap: "Identity" }
+      })
+    );
+    const encoding = ctx.register(
+      flateStream(
+        ctx,
+        cmap(
+          groups(
+            this.rows.map((row, i) => `<${hex(i + 1)}> ${row.cid}`),
+            "cidchar"
+          ),
+          1
+        )
+      )
+    );
+    const mappings = this.rows.flatMap(
+      (row, i) => row.text ? [`<${hex(i + 1)}> <${unicodeHex(row.text)}>`] : []
+    );
+    const unicode = ctx.register(flateStream(ctx, cmap(groups(mappings, "bfchar"), 2)));
+    ctx.assign(
+      this.ref,
+      ctx.obj({
+        Type: "Font",
+        Subtype: "Type0",
+        BaseFont: base,
+        Encoding: encoding,
+        DescendantFonts: [descendant],
+        ToUnicode: unicode
+      })
+    );
+  }
+};
+
+// 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);
+  if (!byGlyph) {
+    byGlyph = /* @__PURE__ */ new Map();
+    cache.set(font, byGlyph);
+  }
+  const known = byGlyph.get(glyphId);
+  if (known) return known;
+  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) {
+    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 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;
+    const { red, green, blue, alpha } = layer.color;
+    out.push({
+      fill: `${number(clampByte(red) / 255)} ${number(clampByte(green) / 255)} ${number(clampByte(blue) / 255)} rg`,
+      alpha: clampByte(alpha) / 255,
+      path
+    });
+  }
+  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;
+}
+function pathOperators(commands, work) {
+  if (commands.length > MAX_COMMANDS) return null;
+  const out = [];
+  let x = 0;
+  let y = 0;
+  for (const { command, args } of commands) {
+    work.tick();
+    if (args.some((value) => !Number.isFinite(value))) return null;
+    let operator;
+    switch (command) {
+      case "moveTo":
+        [x, y] = [args[0], args[1]];
+        operator = `${number(x)} ${number(y)} m`;
+        break;
+      case "lineTo":
+        [x, y] = [args[0], args[1]];
+        operator = `${number(x)} ${number(y)} l`;
+        break;
+      case "quadraticCurveTo": {
+        const [cx, cy, ex, ey] = [args[0], args[1], args[2], args[3]];
+        const c1x = x + 2 / 3 * (cx - x);
+        const c1y = y + 2 / 3 * (cy - y);
+        const c2x = ex + 2 / 3 * (cx - ex);
+        const c2y = ey + 2 / 3 * (cy - ey);
+        operator = `${number(c1x)} ${number(c1y)} ${number(c2x)} ${number(c2y)} ${number(ex)} ${number(ey)} c`;
+        [x, y] = [ex, ey];
+        break;
+      }
+      case "bezierCurveTo":
+        operator = args.slice(0, 6).map(number).join(" ") + " c";
+        [x, y] = [args[4], args[5]];
+        break;
+      case "closePath":
+        operator = "h";
+        break;
+      default:
+        return null;
+    }
+    work.reserveContent(operator.length + 1);
+    out.push(operator);
+  }
+  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) {
+  const authored = Math.max(1, Math.round(fontSizePt * 2));
+  return factor === 1 ? authored : Math.max(1, Math.round(authored * factor));
+}
+function snapToGrid(units) {
+  const snapped = Math.round(units * 2) / 2;
+  return Math.abs(units - snapped) < 1e-9 ? snapped : units;
+}
+function griddedBaselineInLine(line, face2, paragraph) {
+  const units = (value) => Math.round(value / PDF_PAINT_GRID_PT2);
+  const above = Math.abs(face2.font.ascent) + Math.abs(face2.font.lineGap);
+  const descent = above > 0 ? Math.abs(face2.font.descent) / above * line.baseline : 0;
+  const naturalBox = line.baseline + descent;
+  const endsParagraph = paragraph.paragraphEnd === true && paragraph.spacing.after > 0 && paragraph.lines[paragraph.lines.length - 1] === line;
+  if (endsParagraph || !(descent > 0) || line.box.height > naturalBox + 0.01)
+    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;
+  if (!advances || advances.length !== run.glyphs.length) return void 0;
+  const origins = [];
+  let pen = 0;
+  for (const advance of advances) {
+    origins.push(pen);
+    pen += advance;
+  }
+  return origins;
+}
+function createGlyphBatch(out, horizontal) {
+  let face2 = null;
+  let size = 0;
+  let baselineY = 0;
+  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 ${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;
+      const adjustment = continues ? 1e3 * (penX - gx) / unit : Number.NaN;
+      if (!Number.isFinite(adjustment) || Math.abs(adjustment) > MAX_TJ_ADJUSTMENT) {
+        flush();
+        face2 = nextFace;
+        size = nextSize;
+        baselineY = gy;
+        startX = gx;
+        penX = gx;
+      } else if (gx !== penX) {
+        const written = number(adjustment);
+        parts.push(written);
+        penX -= Number(written) / 1e3 * unit;
+      }
+      parts.push(`<${code}>`);
+      penX += nextFace.declaredWidth(code) / 1e3 * unit;
+    }
+  };
+}
+var TextWriter = class {
+  constructor(doc, session, work, showRevisionMarkup) {
+    this.doc = doc;
+    this.session = session;
+    this.work = work;
+    this.showRevisionMarkup = showRevisionMarkup;
+  }
+  doc;
+  session;
+  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;
+    if (span.style.hidden || !span.text) return "";
+    if (span.noteSeparator) {
+      const box = noteSeparatorRuleBox(span, line);
+      return `${color(span.style.color)} rg ${rect(box, storyOrigin.x - visit.page.box.x, storyOrigin.y - visit.page.box.y, pageHeight(page), true)} f`;
+    }
+    if (/^[\t\n\r\f]+$/.test(span.text)) return span.tabLeader ? this.leader(visit, page) : "";
+    const report = (code, message) => {
+      this.work.report(code, message, visit.page.index);
+      return "";
+    };
+    const shaped = this.session.shapeLaidOutText(span);
+    const family = styleForFontSlot2(span.style, span.fontSlot).fontFamily ?? "the default font";
+    if (!shaped)
+      return report(
+        "unshaped-text",
+        `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${missingGlyphHint(span.text)}`
+      );
+    const face2 = this.embeddedFace(shaped.font, visit, page);
+    if (!face2) return "";
+    const style = styleForFontSlot2(span.style, span.fontSlot);
+    const factor = glyphSizeFactorOf(style);
+    const size = Number(
+      (Math.max(
+        1,
+        Math.round(reducedHalfPoints(style.fontSizePt, factor) / 2 / PDF_PAINT_GRID_PT2)
+      ) * PDF_PAINT_GRID_PT2).toFixed(6)
+    );
+    const horizontal = style.horizontalScalePercent / 100;
+    const scale = factor / shaped.fixedPointScale;
+    const x = absoluteBox.x - visit.page.box.x + (span.glyphOffsetPt ?? 0) + paragraphGridOffsetX(visit);
+    const baselineFromTop = storyOrigin.y - visit.page.box.y + line.box.y + griddedBaselineInLine(line, face2, visit.paragraph) - baselineShiftPtOf(style);
+    const unitsFromTop = snapToGrid(baselineFromTop / PDF_PAINT_GRID_PT2);
+    const baseline = pageHeight(page) - Math.ceil(unitsFromTop - 0.5) * PDF_PAINT_GRID_PT2;
+    let foreground = style.color;
+    const revisions = this.showRevisionMarkup ? span.revisions ?? [] : [];
+    const insert = revisions.some((r) => r.kind === "insert" || r.kind === "moveTo");
+    const deleted = revisions.some((r) => r.kind === "delete" || r.kind === "moveFrom");
+    if (insert) foreground = "008000";
+    if (deleted) foreground = "C00000";
+    const out = [`${color(foreground)} rg`, "BT"];
+    if (!face2.colorLayers) out.push(`/${face2.name} ${number(size)} Tf`);
+    if (style.textOutline)
+      out.unshift(`q ${color(style.textOutline.color)} RG ${number(style.textOutline.widthPt)} w 2 Tr`);
+    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;
+    for (const cluster of [...shaped.run.clusters].sort((a, b) => a.glyphStart - b.glyphStart)) {
+      const identity = shaped.fonts?.[cluster.fontSpan];
+      if (identity && identity.identity !== activeIdentity) {
+        const clusterFace = this.embeddedFace(identity, visit, page);
+        if (!clusterFace) return "";
+        activeFace = clusterFace;
+        activeIdentity = identity.identity;
+        batch.flush();
+        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];
+        const glyphSize = size * (glyph.drawScale ?? 1);
+        if (glyphSize !== activeSize) {
+          batch.flush();
+          if (!activeFace.colorLayers) out.push(`/${activeFace.name} ${number(glyphSize)} Tf`);
+          activeSize = glyphSize;
+        }
+        const origin = origins?.[i] ?? glyph.originX;
+        const gx = x + (origin + glyph.offsetX) * scale * horizontal + extra;
+        const gy = baseline + (glyph.originY + glyph.offsetY) * scale;
+        if (activeFace.colorLayers) {
+          const color2 = colorGlyph(activeFace.font, glyph.id, this.work);
+          if (color2.kind === "refused" || color2.kind === "none" && color2.outlined) {
+            this.work.report(
+              "color-glyph",
+              color2.kind === "refused" ? `A color glyph could not be painted: ${color2.reason}` : "A glyph of a color face has no color layers and the face is not embedded",
+              visit.page.index
+            );
+            continue;
+          }
+          if (color2.kind === "layers")
+            colorGlyphs.push({
+              layers: color2.layers,
+              x: gx,
+              y: gy,
+              scale: glyphSize / activeFace.font.unitsPerEm
+            });
+          const host = i === cluster.glyphStart && text ? this.textHost(face2, page) : null;
+          const carrier = host?.carrier(text) ?? null;
+          if (host && carrier) {
+            let advance = 0;
+            for (let j = cluster.glyphStart; j < cluster.glyphEnd; j++)
+              advance += shaped.run.glyphs[j].advanceX * scale;
+            const spaceWidth = host.declaredWidth(carrier) / 1e3 * activeSize;
+            const stretch = spaceWidth > 0 && advance > 0 ? Math.min(1e4, Math.max(1, 100 * advance / spaceWidth)) : 100;
+            batch.flush();
+            out.push(`/${host.name} ${number(activeSize)} Tf 3 Tr ${number(stretch)} Tz`);
+            batch.add(host, activeSize, gx, gy, carrier);
+            batch.flush();
+            out.push("0 Tr 100 Tz");
+            strokeWidth = 0;
+          }
+          continue;
+        }
+        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) {
+        const alpha = layer.alpha < 1 ? this.alphaState(page, layer.alpha) : null;
+        out.push(
+          alpha ? `q /${alpha} gs ${layer.fill} ${layer.path} f Q` : `${layer.fill} ${layer.path} f`
+        );
+      }
+      out.push("Q");
+    }
+    const metricScale = size / face2.font.unitsPerEm;
+    const onGrid2 = (value) => Math.round(value / PDF_PAINT_GRID_PT2) * PDF_PAINT_GRID_PT2;
+    const lineRule = (y, thickness, c = foreground, width = absoluteBox.width) => {
+      const left = onGrid2(x);
+      const right = onGrid2(x + width);
+      const painted = right > left ? right - left : width > 0 ? PDF_PAINT_GRID_PT2 : 0;
+      if (painted <= 0) return;
+      out.push(
+        `${color(c)} rg ${number(left)} ${number(y - thickness / 2)} ${number(painted)} ${number(thickness)} re f`
+      );
+    };
+    if (style.underline || insert) {
+      const variant = style.underline?.variant ?? "single";
+      const metricsUsable = face2.font.underlineThickness > 0 && Number.isFinite(face2.font.underlinePosition);
+      if (!metricsUsable)
+        this.work.report(
+          "underline-metrics",
+          "Font has no valid underline metrics; the underline uses a default position and thickness",
+          visit.page.index,
+          "information"
+        );
+      const rawThickness = metricsUsable ? face2.font.underlineThickness * metricScale : size / 20;
+      const rawOffset = metricsUsable ? -face2.font.underlinePosition * metricScale : size / 10;
+      const thickness = Math.max(1, Math.round(rawThickness / PDF_PAINT_GRID_PT2)) * PDF_PAINT_GRID_PT2;
+      const position = baseline - Math.round(rawOffset / PDF_PAINT_GRID_PT2) * PDF_PAINT_GRID_PT2 - thickness / 2;
+      {
+        const c = style.underline?.color ?? foreground;
+        const supported = [
+          "single",
+          "double",
+          "thick",
+          "dotted",
+          "dash",
+          "dashLong",
+          "dotDash",
+          "dotDotDash",
+          "wave",
+          "wavyDouble",
+          "wavyHeavy",
+          "dottedHeavy",
+          "dashedHeavy",
+          "dashLongHeavy",
+          "dashDotHeavy",
+          "dashDotDotHeavy",
+          "words"
+        ];
+        if (!supported.includes(variant))
+          this.work.report(
+            "underline-style",
+            `Unsupported underline: ${variant}`,
+            visit.page.index
+          );
+        const heavy = variant === "thick" || variant.endsWith("Heavy");
+        const weight = thickness * (heavy ? 2 : 1);
+        if (variant === "wave" || variant.startsWith("wavy")) {
+          const wave = (y) => {
+            const period = Math.max(2, weight * 6), amplitude = Math.max(0.6, weight);
+            const path = [`${number(x)} ${number(y)} m`];
+            for (let dx = 0; dx < absoluteBox.width; dx += period) {
+              this.work.tick();
+              const end = Math.min(dx + period, absoluteBox.width), length = end - dx;
+              path.push(
+                `${number(x + dx + length / 4)} ${number(y + amplitude)} ${number(x + dx + length / 4)} ${number(y + amplitude)} ${number(x + dx + length / 2)} ${number(y)} c`,
+                `${number(x + dx + 3 * length / 4)} ${number(y - amplitude)} ${number(x + dx + 3 * length / 4)} ${number(y - amplitude)} ${number(x + end)} ${number(y)} c`
+              );
+            }
+            out.push(`q ${color(c)} RG ${number(weight)} w ${path.join(" ")} S Q`);
+          };
+          wave(position);
+          if (variant === "wavyDouble") wave(position - weight * 4);
+        } else if (variant.startsWith("dot") || variant.toLowerCase().includes("dash")) {
+          const dotted = variant.startsWith("dotted");
+          const pattern = dotted ? [weight, weight * 2] : variant.toLowerCase().includes("dotdot") ? [weight * 4, weight * 2, weight, weight * 2, weight, weight * 2] : variant.toLowerCase().includes("dot") ? [weight * 4, weight * 2, weight, weight * 2] : [weight * (variant.includes("Long") ? 8 : 4), weight * 2];
+          out.push(
+            `q ${color(c)} RG ${number(weight)} w [${pattern.map(number).join(" ")}] 0 d ${number(x)} ${number(position)} m ${number(x + absoluteBox.width)} ${number(position)} l S Q`
+          );
+        } else if (variant === "words") {
+          for (const cluster of shaped.run.clusters) {
+            if (/^\s+$/.test(shaped.run.text.slice(cluster.textStart, cluster.textEnd))) continue;
+            const glyph = shaped.run.glyphs[cluster.glyphStart];
+            out.push(
+              `${color(c)} rg ${number(x + glyph.originX * scale * horizontal)} ${number(position - thickness / 2)} ${number(cluster.advance * scale * horizontal)} ${number(thickness)} re f`
+            );
+          }
+        } else {
+          lineRule(
+            position,
+            weight,
+            c,
+            absoluteBox.width + (variant === "single" ? underlineGap(visit) : 0)
+          );
+          if (variant === "double") lineRule(position - thickness * 2, thickness, c);
+        }
+      }
+    }
+    if (style.strike || style.doubleStrike || deleted) {
+      const declared = face2.strike && face2.strike.thickness > 0 ? face2.strike : null;
+      if (!declared)
+        this.work.report(
+          "strike-metrics",
+          "Font has no strike metrics; the strike is placed from the ascent",
+          visit.page.index,
+          "information"
+        );
+      const rawThickness = (declared?.thickness ?? face2.font.underlineThickness) * metricScale;
+      const rawOffset = declared ? declared.position * metricScale : Math.abs(face2.font.ascent) * 0.3 * metricScale;
+      const thickness = Math.max(1, Math.round(rawThickness / PDF_PAINT_GRID_PT2)) * PDF_PAINT_GRID_PT2;
+      const position = baseline + Math.round(rawOffset / PDF_PAINT_GRID_PT2) * PDF_PAINT_GRID_PT2;
+      lineRule(position, thickness);
+      if (style.doubleStrike) lineRule(position + thickness * 2, thickness);
+    }
+    return out.join("\n");
+  }
+  /**
+   * The band a highlight or character shading fills: the span's own face box, seated on the
+   * line's baseline.
+   *
+   * Layout publishes every span box at the LINE top with the span's own face height. That is
+   * the selection band, and the screen painter seats it on the baseline with
+   * `vertical-align`. Filling the box where it is published puts a small highlighted run at
+   * the top of a line a larger run made tall, with its glyphs hanging out under the band.
+   * Word draws the band around the run's own face, ascent and external leading above the
+   * baseline and descent below, so a mixed-size line highlights stepped: each run at its own
+   * height, all seated on one baseline. A raised or lowered script carries its band with it.
+   *
+   * The split above and below the baseline comes from the face when it is admitted, and from
+   * the line's own glyph band otherwise, so a span this writer cannot shape (a tab, a face it
+   * refused) still lands on the baseline instead of at the line top.
+   */
+  bandBox(visit) {
+    const { span, line, absoluteBox } = visit;
+    const shaped = this.session.shapeLaidOutText(span);
+    const face2 = shaped ? this.admittedFace(shaped.font, visit) : void 0;
+    const leading = line.leading ?? 0;
+    const above = face2 ? Math.abs(face2.font.ascent) + Math.max(0, face2.font.lineGap) : line.baseline - leading;
+    const total = face2 ? above + Math.abs(face2.font.descent) : line.box.height - leading - (line.trailingSpacing ?? 0);
+    const faceBaseline = total > 0 ? span.box.height * above / total : span.box.height;
+    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) {
+    const key = Math.round(alpha * 1e3);
+    let ref = this.alphaStates.get(key);
+    if (!ref) {
+      ref = this.doc.context.register(
+        this.doc.context.obj({ Type: "ExtGState", ca: key / 1e3, CA: key / 1e3 })
+      );
+      this.alphaStates.set(key, ref);
+    }
+    const name = `LayerAlpha${key}`;
+    page.node.setExtGState(PDFName2.of(name), ref);
+    return name;
+  }
+  /** An embedded text face on this page to carry extractable characters: the run's own, or any. */
+  textHost(face2, page) {
+    const host = face2.colorLayers ? [...this.faces.values()].find((candidate) => !candidate.colorLayers) ?? null : face2;
+    if (host) this.registerFont(page, host);
+    return host;
+  }
+  embeddedFace(font, visit, page) {
+    const face2 = this.admittedFace(font, visit);
+    if (face2 && !face2.colorLayers) this.registerFont(page, face2);
+    return face2;
+  }
+  pageFonts = /* @__PURE__ */ new WeakMap();
+  /**
+   * Name a face in the page's font resources once. pdf-lib re-reads the page's inherited
+   * resources on every call, and nearly every span on a page names a face already there.
+   */
+  registerFont(page, face2) {
+    let registered = this.pageFonts.get(page);
+    if (!registered) this.pageFonts.set(page, registered = /* @__PURE__ */ new Set());
+    if (registered.has(face2)) return;
+    registered.add(face2);
+    page.node.setFontDictionary(PDFName2.of(face2.name), face2.ref);
+  }
+  /** The embedded face for a shaped font, without registering it on a page. */
+  admittedFace(font, visit) {
+    const report = (code, message) => {
+      this.work.report(code, message, visit.page.index);
+      return void 0;
+    };
+    let face2 = this.faces.get(font.identity);
+    try {
+      if (this.refused.has(font.identity))
+        return report("font-embedding", this.refused.get(font.identity));
+      if (!face2) {
+        const admitted = this.session.admittedFontFace(font.request);
+        if (!admitted || admitted.identity !== font.identity)
+          return report("font-identity", "The shaped face does not match the admitted font");
+        face2 = new EmbeddedFace(this.doc, admitted, this.faces.size + 1);
+        this.faces.set(font.identity, face2);
+      }
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : "Font embedding refused";
+      this.refused.set(font.identity, reason);
+      return report("font-embedding", reason);
+    }
+    return face2;
+  }
+  leader(visit, page) {
+    const glyph = TAB_LEADER_GLYPH.get(visit.span.tabLeader);
+    if (!glyph || visit.absoluteBox.width <= 0) return "";
+    const advance = visit.span.tabLeaderAdvancePt;
+    if (!advance || advance <= 0) {
+      this.work.report(
+        "tab-leader-metrics",
+        "Tab leader has no measured advance",
+        visit.page.index
+      );
+      return "";
+    }
+    const x = visit.absoluteBox.x - visit.page.box.x;
+    const pattern = tabLeaderPattern(
+      visit.textboxDepth ? visit.span.box.x : x,
+      visit.absoluteBox.width,
+      advance
+    );
+    const y = pageHeight(page) - (visit.storyOrigin.y + visit.line.box.y - visit.page.box.y) - visit.line.box.height;
+    const out = [
+      `q ${number(x)} ${number(y)} ${number(visit.absoluteBox.width)} ${number(visit.line.box.height)} re W n`
+    ];
+    for (let i = 0; i < pattern.count; i++) {
+      this.work.tick();
+      out.push(
+        this.paint(
+          {
+            ...visit,
+            absoluteBox: {
+              ...visit.absoluteBox,
+              x: visit.absoluteBox.x + pattern.offsetPt + i * advance,
+              width: advance
+            },
+            span: {
+              ...visit.span,
+              text: glyph,
+              tabLeader: void 0,
+              style: {
+                ...visit.span.style,
+                characterSpacingPt: 0,
+                underline: null,
+                bold: visit.span.tabLeader === "heavy" || visit.span.style.bold
+              }
+            }
+          },
+          page
+        )
+      );
+    }
+    out.push("Q");
+    return out.join("\n");
+  }
+};
+
+// src/annotations.ts
+import {
+  PDFDict,
+  PDFHexString,
+  PDFName as PDFName3,
+  PDFString as PDFString2
+} from "pdf-lib";
+function add(doc, page, dictionary) {
+  const ref = doc.context.register(doc.context.obj(dictionary));
+  page.node.addAnnot(ref);
+  return ref;
+}
+function linkAnnotation(doc, page, visit, destinations2) {
+  const link = visit.span.link;
+  if (!link || !link.href) return;
+  const b = visit.absoluteBox;
+  const x = b.x - visit.page.box.x, y = pageHeight(page) - (b.y - visit.page.box.y) - b.height;
+  const base = {
+    Type: "Annot",
+    Subtype: "Link",
+    Rect: [x, y, x + b.width, y + b.height],
+    Border: [0, 0, 0]
+  };
+  if (link.kind === "internal" && link.anchor && destinations2.has(link.anchor))
+    add(doc, page, { ...base, Dest: PDFHexString.fromText(link.anchor) });
+  else if (link.kind === "external" && /^(https?:|mailto:|tel:|ftp:)/i.test(link.href)) {
+    const uri = pdfLiteralUri(link.href);
+    if (uri !== null) add(doc, page, { ...base, A: { S: "URI", URI: PDFString2.of(uri) } });
+  }
+}
+function destinations(doc, pages, layout) {
+  const names = [];
+  const added = /* @__PURE__ */ new Set();
+  for (const dest of [...layout.destinations ?? []].sort(
+    (a, b) => PDFHexString.fromText(a.anchor.name).asString() < PDFHexString.fromText(b.anchor.name).asString() ? -1 : 1
+  )) {
+    if (added.has(dest.anchor.name)) continue;
+    const page = pages[dest.pageIndex], record = layout.pages[dest.pageIndex];
+    if (!page || !record) continue;
+    added.add(dest.anchor.name);
+    names.push(
+      PDFHexString.fromText(dest.anchor.name),
+      doc.context.obj([
+        page.ref,
+        "XYZ",
+        dest.pageStack.x - record.box.x,
+        pageHeight(page) - dest.pageStack.y + record.box.y,
+        null
+      ])
+    );
+  }
+  if (names.length)
+    doc.catalog.set(PDFName3.of("Names"), doc.context.obj({ Dests: { Names: names } }));
+  return added;
+}
+function comments(doc, pages, layout, work) {
+  const primary = /* @__PURE__ */ new Map();
+  const replies = [];
+  let count = 0;
+  for (const comment of layout.reviewArtifacts) {
+    if (comment.kind !== "comment") continue;
+    const occurrences = comment.occurrences.filter((o) => o.geometry?.pageStack.length);
+    const targets = occurrences.length ? occurrences : [null];
+    for (const occurrence of targets) {
+      work.tick();
+      if (++count > 5e4) throw new RangeError("PDF annotation limit exceeded");
+      const pageIndex = occurrence?.pageIndex ?? 0;
+      const page = pages[pageIndex], record = layout.pages[pageIndex];
+      if (!page || !record) continue;
+      const boxes = occurrence?.geometry?.pageStack ?? [];
+      const quads = [];
+      for (const b2 of boxes) {
+        const x2 = b2.x - record.box.x, top = pageHeight(page) - b2.y + record.box.y;
+        if (b2.width > 0)
+          quads.push(x2, top, x2 + b2.width, top, x2, top - b2.height, x2 + b2.width, top - b2.height);
+      }
+      const b = boxes[0];
+      const x = b ? b.x - record.box.x : 12;
+      const y = b ? pageHeight(page) - b.y + record.box.y : pageHeight(page) - 12;
+      const xs = quads.filter((_, i) => i % 2 === 0), ys = quads.filter((_, i) => i % 2 === 1);
+      const min = (a) => a.reduce((v, n) => Math.min(v, n), Infinity);
+      const max = (a) => a.reduce((v, n) => Math.max(v, n), -Infinity);
+      const rect2 = quads.length ? [min(xs), min(ys), max(xs), max(ys)] : [x, y - 18, x + 18, y];
+      const ref = add(doc, page, {
+        Type: "Annot",
+        Subtype: quads.length ? "Highlight" : "Text",
+        Rect: rect2,
+        ...quads.length ? { QuadPoints: quads } : { Name: "Comment" },
+        T: PDFHexString.fromText(comment.author),
+        Contents: PDFHexString.fromText(
+          `${occurrence ? "" : "[Unanchored comment]\n"}${comment.text}`
+        ),
+        NM: PDFHexString.fromText(`comment-${comment.id}-${count}`),
+        C: [1, 0.85, 0.2],
+        CA: 0.25,
+        ...comment.date && Number.isFinite(Date.parse(comment.date)) ? {
+          M: PDFHexString.fromText(
+            `D:${new Date(comment.date).toISOString().replace(/[-:T]/g, "").slice(0, 14)}Z`
+          )
+        } : {},
+        ...comment.resolved ? { StateModel: "Review", State: "Completed" } : {},
+        F: 4
+      });
+      if (!primary.has(comment.id)) primary.set(comment.id, ref);
+      if (comment.parentId) replies.push({ parent: comment.parentId, ref });
+      if (!occurrence)
+        work.report(
+          "unanchored-comment",
+          "A comment without visible geometry is preserved as a first-page note",
+          0,
+          "information"
+        );
+    }
+  }
+  for (const reply of replies) {
+    const parent = primary.get(reply.parent);
+    if (parent) {
+      const dictionary = doc.context.lookup(reply.ref);
+      if (dictionary instanceof PDFDict) {
+        dictionary.set(PDFName3.of("IRT"), parent);
+        dictionary.set(PDFName3.of("RT"), PDFName3.of("R"));
+      }
+    }
+  }
+}
+
+// src/images.ts
+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 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 { 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`,
+    `${number(sx)} 0 0 ${number(-sy)} ${number(content.x + x)} ${number(pageHeight(page) - content.y - y)} cm`,
+    "0 J 0 j 4 M [] 0 d"
+  );
+  const path = (points, closed) => {
+    const commands = [];
+    for (const [index, point] of points.entries()) {
+      work.tick();
+      commands.push(`${number(point.x / unit)} ${number(point.y / unit)} ${index === 0 ? "m" : "l"}`);
+    }
+    if (closed && points.length) commands.push("h");
+    return commands.join(" ");
+  };
+  for (const component of shape.components) {
+    work.tick();
+    const state = doc.context.register(
+      doc.context.obj({
+        Type: "ExtGState",
+        ca: component.fillAlpha,
+        CA: component.strokeAlpha
+      })
+    );
+    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(
+        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({
+          Type: "ExtGState",
+          ca: component.strokeAlpha
+        })
+      );
+      const arrowName = `ShapeAlpha${arrowState.objectNumber}`;
+      page.node.setExtGState(PDFName4.of(arrowName), arrowState);
+      out.push(`/${arrowName} gs ${color(component.strokeHex)} rg`);
+      for (const points of component.arrowheadsEmu) out.push(`${path(points, true)} f`);
+    }
+    out.push("Q");
+  }
+  out.push("Q");
+  const uri = d.hyperlinkHref && /^(https?:|mailto:|tel:|ftp:)/i.test(d.hyperlinkHref) ? pdfLiteralUri(d.hyperlinkHref) : null;
+  if (uri !== null) {
+    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 + target.width, bottom + target.height],
+          Border: [0, 0, 0],
+          A: { S: "URI", URI: PDFString3.of(uri) }
+        })
+      )
+    );
+  }
+  return out.join("\n");
+}
+
+// src/images.ts
+var EMBEDDABLE_MIMES = /* @__PURE__ */ new Set(["image/png", "image/jpeg"]);
+function unpaintableBulletReason(picture, box) {
+  const resource = picture.resource;
+  if (resource.kind === "unrenderable") return `image refused: ${resource.reason}`;
+  if (resource.kind !== "ready") return `image ${resource.kind}`;
+  if (!EMBEDDABLE_MIMES.has(resource.mime)) return `format not embeddable: ${resource.mime}`;
+  if (!(box.width > 0 && box.height > 0)) return "no visible area";
+  return null;
+}
+var ImageWriter = class {
+  constructor(doc, session, work) {
+    this.doc = doc;
+    this.session = session;
+    this.work = work;
+  }
+  doc;
+  session;
+  work;
+  images = /* @__PURE__ */ new Map();
+  /**
+   * Draw a list marker's picture bullet in the box layout published for it.
+   *
+   * Returns '' for anything not drawable — missing, external, still decoding, refused, or a
+   * format this writer cannot embed — and the caller then paints the level's `w:lvlText`.
+   *
+   * That fall back is FOLLOWING the document, not approximating it: the same `w:lvl` authors
+   * `w:lvlText` as this level's marker and `w:lvlPicBulletId` as a picture to use in its
+   * place (ECMA-376 §17.9.12), so the text is the document's own alternative rather than
+   * something this writer invented. It is reported all the same, at `information`: nothing
+   * the document authors is lost from the page, so a strict export is still faithful, while
+   * the reader is still told which of the two markers was drawn. An inline `w:drawing` whose
+   * format cannot be embedded keeps reporting `unsupported`, because there the document
+   * offers no alternative and the page really does lose content.
+   *
+   * No scaling decision is taken here: the box is the extent layout already placed on the
+   * baseline, after the marker font scale.
+   */
+  async paintListMarkerPicture(picture, box, page, pageIndex) {
+    await this.work.yield();
+    const unpaintable = unpaintableBulletReason(picture, box);
+    if (unpaintable !== null) {
+      this.work.report(
+        "list-picture-bullet",
+        `Picture bullet drawn as its level text (${unpaintable})`,
+        pageIndex,
+        "information"
+      );
+      return "";
+    }
+    if (picture.resource.kind !== "ready") return "";
+    const mime = picture.resource.mime;
+    const bytes = this.session.validatedImageBytes(picture);
+    if (!bytes) return "";
+    let image = this.images.get(picture.resource.resourceKey);
+    if (!image) {
+      image = mime === "image/png" ? await this.doc.embedPng(bytes) : await this.doc.embedJpg(bytes);
+      this.images.set(picture.resource.resourceKey, image);
+    }
+    const key = `Im${image.ref.objectNumber}`;
+    page.node.setXObject(PDFName5.of(key), image.ref);
+    const x = box.x;
+    const y = pageHeight(page) - box.y - box.height;
+    return `q ${number(box.width)} 0 0 ${number(box.height)} ${number(x)} ${number(y)} cm /${key} Do Q`;
+  }
+  /**
+   * A textbox: its fill and outline at the extent, then `body` (the story's decorations and
+   * the text its owner collected) clipped to the content box, all clipped to the published
+   * paint bounds — the same three boxes the screen painter draws, in the same order.
+   *
+   * The outline is stroked inside the extent, as a CSS border inside a `border-box` is, so a
+   * bordered textbox is exactly as wide as Word laid it out. Word clips overflowing content
+   * to the box as well, so a height clip is information: the page shows what Word shows.
+   */
+  paintTextbox(visit, page, body) {
+    const d = visit.drawing;
+    if (d.kind !== "anchoredDrawing" || !d.textboxStory) return "";
+    const story = d.textboxStory;
+    const bounds = visit.absolutePaintBounds;
+    if (bounds.width <= 0 || bounds.height <= 0 || d.accessibility.hidden) return "";
+    if (story.fallbackReason === "textbox-height-clip")
+      this.work.report(
+        "textbox-clip",
+        "Textbox content taller than its box is clipped",
+        visit.page.index,
+        "information"
+      );
+    else if (story.fallbackReason) {
+      this.work.report(
+        "textbox",
+        `Textbox story not laid out: ${story.fallbackReason}`,
+        visit.page.index
+      );
+      return "";
+    }
+    const height = pageHeight(page);
+    const x = visit.drawingOrigin.x - visit.page.box.x;
+    const y = visit.drawingOrigin.y - visit.page.box.y;
+    const extent = { x, y, width: d.width, height: d.height };
+    const out = new Commands(this.work);
+    out.push(`q ${rect(bounds, -visit.page.box.x, -visit.page.box.y, height)} W n`);
+    if (story.fillHex !== null)
+      out.push(`${color(story.fillHex)} rg ${rect(extent, 0, 0, height)} f`);
+    if (story.strokeHex !== null) {
+      const width = Math.max(0.5, story.strokeWidthPt);
+      const inner = {
+        x: x + width / 2,
+        y: y + width / 2,
+        width: Math.max(0, d.width - width),
+        height: Math.max(0, d.height - width)
+      };
+      out.push(`${color(story.strokeHex)} RG ${number(width)} w ${rect(inner, 0, 0, height)} S`);
+    }
+    const content = {
+      x: x + story.contentOffset.x,
+      y: y + story.contentOffset.y,
+      width: story.contentWidth,
+      height: Math.max(0, story.contentHeight)
+    };
+    out.push(`q ${rect(content, 0, 0, height)} W n`, ...body, "Q", "Q");
+    return out.join("\n");
+  }
+  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;
+    if (!EMBEDDABLE_MIMES.has(mime)) return report(`Unsupported PDF image format: ${mime}`);
+    if (d.effects.grayscale || d.effects.brightness || d.effects.contrast || d.effects.bilevel !== void 0)
+      this.work.report(
+        "image-effects",
+        "Image color adjustments are not encoded",
+        visit.page.index
+      );
+    let image = this.images.get(d.resource.resourceKey);
+    if (!image) {
+      image = mime === "image/png" ? await this.doc.embedPng(bytes) : await this.doc.embedJpg(bytes);
+      this.images.set(d.resource.resourceKey, image);
+    }
+    let opacityCommand = "";
+    if (d.effects.opacity !== void 0 && d.effects.opacity !== 1) {
+      const opacity = d.effects.opacity;
+      if (!Number.isFinite(opacity) || opacity < 0 || opacity > 1)
+        return report("Invalid image opacity");
+      const name = `Alpha${Math.round(opacity * 1e5)}`;
+      const ref = this.doc.context.register(
+        this.doc.context.obj({ Type: "ExtGState", ca: opacity, CA: opacity })
+      );
+      page.node.setExtGState(PDFName5.of(name), ref);
+      opacityCommand = `/${name} gs `;
+    }
+    const key = `Im${image.ref.objectNumber}`;
+    page.node.setXObject(PDFName5.of(key), image.ref);
+    const points = d.geometry.imageTransformCorners ?? d.geometry.transformedCorners;
+    if (points.length !== 4) return report("Image has no affine rectangle geometry");
+    if (d.geometry.clipFallback !== "none")
+      this.work.report("image-clip", "Image clipping uses a Core fallback", visit.page.index);
+    const offsetX = visit.drawingOrigin.x - d.x - visit.page.box.x;
+    const offsetY = visit.drawingOrigin.y - d.y - visit.page.box.y;
+    const p = points.map((v) => ({ x: v.x + offsetX, y: pageHeight(page) - v.y - offsetY }));
+    const topLeft = p[0], topRight = p[1], bottomLeft = p[3];
+    const ax = topRight.x - topLeft.x, ay = topRight.y - topLeft.y;
+    const bx = topLeft.x - bottomLeft.x, by = topLeft.y - bottomLeft.y;
+    const crop = d.crop;
+    const width = 1 - crop.left - crop.right, height = 1 - crop.top - crop.bottom;
+    if (!(width > 0 && height > 0)) return report("Image crop has no visible area");
+    if (d.geometry.clipPolygon && d.geometry.clipPolygon.length === 0) return "";
+    const clip = d.geometry.clipPolygon?.length ? d.geometry.clipPolygon.map((v) => ({
+      x: v.x + offsetX,
+      y: pageHeight(page) - v.y - offsetY
+    })) : p;
+    const uri = d.hyperlinkHref && /^(https?:|mailto:|tel:|ftp:)/i.test(d.hyperlinkHref) ? pdfLiteralUri(d.hyperlinkHref) : null;
+    if (uri !== null) {
+      const bounds = [Infinity, Infinity, -Infinity, -Infinity];
+      for (const point of clip) {
+        bounds[0] = Math.min(bounds[0], point.x);
+        bounds[1] = Math.min(bounds[1], point.y);
+        bounds[2] = Math.max(bounds[2], point.x);
+        bounds[3] = Math.max(bounds[3], point.y);
+      }
+      page.node.addAnnot(
+        this.doc.context.register(
+          this.doc.context.obj({
+            Type: "Annot",
+            Subtype: "Link",
+            Rect: bounds,
+            Border: [0, 0, 0],
+            A: { S: "URI", URI: PDFString4.of(uri) }
+          })
+        )
+      );
+    }
+    const path = clip.map((v, i) => `${number(v.x)} ${number(v.y)} ${i === 0 ? "m" : "l"}`).join(" ");
+    return `q ${opacityCommand}${path} h W n ${number(ax / width)} ${number(ay / width)} ${number(bx / height)} ${number(by / height)} ${number(bottomLeft.x - ax * crop.left / width - bx * crop.bottom / height)} ${number(bottomLeft.y - ay * crop.left / width - by * crop.bottom / height)} cm /${key} Do Q`;
+  }
+};
+
+// src/equations.ts
+function paintEquation(visit, page, text, work) {
+  const equation = visit.span.equation;
+  if (equation.truncated)
+    work.report("equation-truncated", "Core truncated an equation", visit.page.index);
+  const top = visit.storyOrigin.y + visit.line.box.y + visit.line.baseline - equation.geometry.baseline;
+  const out = [];
+  function node(g, parentX, parentY) {
+    work.tick();
+    const x = parentX + g.box.x, y = parentY + g.box.y;
+    if (g.kind === "text" || g.kind === "fallback") {
+      if (g.kind === "fallback")
+        work.report("equation-fallback", "Core uses fallback equation text", visit.page.index);
+      out.push(
+        text.paint(
+          {
+            ...visit,
+            storyOrigin: { x: 0, y: 0 },
+            line: { ...visit.line, box: { ...visit.line.box, y }, baseline: g.baseline },
+            absoluteBox: { ...g.box, x, y },
+            span: {
+              ...visit.span,
+              text: g.text,
+              equation: void 0,
+              glyphOffsetPt: 0,
+              style: {
+                ...visit.span.style,
+                fontFamily: "Cambria Math",
+                fontFamilyEastAsia: "Cambria Math",
+                fontSizePt: g.fontSizePt,
+                verticalAlign: "baseline",
+                baselineShiftPt: 0
+              }
+            }
+          },
+          page
+        )
+      );
+    } else if (g.kind === "row") for (const child of g.items) node(child, x, y);
+    else if (g.kind === "fraction" || g.kind === "radical") {
+      out.push(
+        `${color(visit.span.style.color)} rg ${rect(g.bar, x - visit.page.box.x, y - visit.page.box.y, pageHeight(page), true)} f`
+      );
+      if (g.kind === "fraction") {
+        node(g.numerator, x, y);
+        node(g.denominator, x, y);
+      } else {
+        node(g.sign, x, y);
+        node(g.radicand, x, y);
+        if (g.degree) node(g.degree, x, y);
+      }
+    } else if (g.kind === "script") {
+      node(g.base, x, y);
+      if (g.subscript) node(g.subscript, x, y);
+      if (g.superscript) node(g.superscript, x, y);
+    } else if (g.kind === "nary") {
+      node(g.operator, x, y);
+      node(g.body, x, y);
+      if (g.lowerLimit) node(g.lowerLimit, x, y);
+      if (g.upperLimit) node(g.upperLimit, x, y);
+    }
+  }
+  node(equation.geometry, visit.absoluteBox.x, top);
+  return out.join("\n");
+}
+
+// src/paint.ts
+function rule(box, colorHex, style, x, y, height) {
+  if (style === "double") {
+    const horizontal2 = box.width >= box.height;
+    const third = (horizontal2 ? box.height : box.width) / 3;
+    return [0, 2 * third].map(
+      (offset) => rule(
+        {
+          ...box,
+          x: box.x + (horizontal2 ? 0 : offset),
+          y: box.y + (horizontal2 ? offset : 0),
+          width: horizontal2 ? box.width : third,
+          height: horizontal2 ? third : box.height
+        },
+        colorHex,
+        "single",
+        x,
+        y,
+        height
+      )
+    ).join("\n");
+  }
+  if (style === "solid" || style === "single" || style === "thick")
+    return `${color(colorHex)} rg ${rect(box, x, y, height, true)} f`;
+  const horizontal = box.width >= box.height;
+  const width = horizontal ? box.height : box.width;
+  const sx = box.x + x + (horizontal ? 0 : width / 2), sy = height - box.y - y - (horizontal ? width / 2 : 0);
+  return `${color(colorHex)} RG ${number(width)} w [${number(style === "dotted" ? width : width * 3)} ${number(width * 2)}] 0 d ${number(sx)} ${number(sy)} m ${number(sx + (horizontal ? box.width : 0))} ${number(sy - (horizontal ? 0 : box.height))} l S [] 0 d`;
+}
+function rotatedCellMatrix(cell, x, y, height) {
+  const left = x + cell.x;
+  const top = y + cell.y;
+  return `0 1 -1 0 ${number(left - top + height)} ${number(height - top - cell.height - left)} cm`;
+}
+function decorations(blocks, x, y, page, work, pageIndex) {
+  const out = [];
+  for (const block of blocks) {
+    work.tick();
+    if (block.kind === "paragraph") {
+      if (block.shading && block.shadingBox)
+        out.push(
+          `${color(block.shading)} rg ${rect(block.shadingBox, x, y, pageHeight(page), true)} f`
+        );
+      for (const border of block.borders ?? (block.bottomBorder ? [{ ...block.bottomBorder, side: "bottom" }] : [])) {
+        const style = border.edge.val;
+        if (border.edge.shadow)
+          work.report("border-shadow", "Paragraph border shadow is not encoded", pageIndex);
+        if (!["single", "thick", "dashed", "dotted", "double"].includes(style))
+          work.report(
+            "paragraph-border-style",
+            `Unsupported paragraph border: ${style}`,
+            pageIndex
+          );
+        out.push(rule(border.box, border.edge.color, style, x, y, pageHeight(page)));
+      }
+    } else {
+      for (const row of block.rows)
+        for (const cell of row.cells) {
+          if (cell.paintInert || cell.vMergeContinue) continue;
+          if (cell.shading)
+            out.push(`${color(cell.shading)} rg ${rect(cell.box, x, y, pageHeight(page), true)} f`);
+          const inner = decorations(cell.blocks, x, y, page, work, pageIndex);
+          if (cell.textDirection && inner.length)
+            out.push("q", rotatedCellMatrix(cell.box, x, y, pageHeight(page)), ...inner, "Q");
+          else out.push(...inner);
+        }
+      for (const row of block.rows)
+        for (const cell of row.cells) {
+          if (cell.paintInert || cell.vMergeContinue) continue;
+          for (const stroke of cell.borders?.strokes ?? [])
+            out.push(
+              rule(
+                stroke,
+                stroke.color,
+                stroke.cssStyle,
+                x + cell.box.x,
+                y + cell.box.y,
+                pageHeight(page)
+              )
+            );
+          const publishedSides = new Set(
+            (cell.borders?.strokes ?? []).map((stroke) => stroke.side)
+          );
+          for (const side of ["top", "right", "bottom", "left"]) {
+            const edge = cell.borders?.[side];
+            if (!edge || publishedSides.has(side)) continue;
+            const b = cell.box, width = edge.widthPt;
+            const box = {
+              x: b.x + (side === "right" ? b.width - width : 0),
+              y: b.y + (side === "bottom" ? b.height - width : 0),
+              width: side === "left" || side === "right" ? width : b.width,
+              height: side === "top" || side === "bottom" ? width : b.height
+            };
+            out.push(rule(box, edge.color, edge.style, x, y, pageHeight(page)));
+          }
+        }
+    }
+  }
+  return out;
+}
+var HIGHLIGHTS = {
+  yellow: "FFFF00",
+  green: "00FF00",
+  cyan: "00FFFF",
+  magenta: "FF00FF",
+  blue: "0000FF",
+  red: "FF0000",
+  darkBlue: "000080",
+  darkCyan: "008080",
+  darkGreen: "008000",
+  darkMagenta: "800080",
+  darkRed: "800000",
+  darkYellow: "808000",
+  darkGray: "808080",
+  lightGray: "C0C0C0",
+  black: "000000",
+  white: "FFFFFF"
+};
+var PAGE_GRID_PT = 0.24;
+function onDeviceGrid(value) {
+  return Number((Math.round(value / PAGE_GRID_PT) * PAGE_GRID_PT).toFixed(6));
+}
+async function paint(doc, session, layout, work, includeComments) {
+  const pages = layout.pages.map((p) => {
+    if (p.box.width <= 0 || p.box.height <= 0 || p.box.width > 14400 || p.box.height > 14400)
+      throw new RangeError("Invalid PDF page dimensions");
+    return doc.addPage([onDeviceGrid(p.box.width), onDeviceGrid(p.box.height)]);
+  });
+  for (const artifact of layout.reviewArtifacts) {
+    if (layout.displayMode === "all-markup" && artifact.kind === "tracked-change" && !["insert", "delete", "replace"].includes(artifact.change))
+      work.report("review-presentation", `Unsupported revision presentation: ${artifact.change}`);
+  }
+  const text = new TextWriter(doc, session, work, layout.displayMode === "all-markup");
+  const images = new ImageWriter(doc, session, work);
+  const names = destinations(doc, pages, layout);
+  const behindStreams = pages.map(() => new Commands(work));
+  const streams = pages.map(() => new Commands(work));
+  const frontBorders = pages.map(() => new Commands(work));
+  for (const record of layout.pages) {
+    const out = streams[record.index];
+    const height = pageHeight(pages[record.index]);
+    if (record.pageBorders) {
+      const borderOut = record.pageBorders.zOrder === "front" ? frontBorders[record.index] : out;
+      for (const border of record.pageBorders.strokes) {
+        if (!["single", "thick", "dashed", "dotted", "double"].includes(border.edge.val) || border.edge.shadow)
+          work.report(
+            "page-border-style",
+            `Unsupported page border: ${border.edge.val}`,
+            record.index
+          );
+        borderOut.push(rule(border.box, border.edge.color, border.edge.val, 0, 0, height));
+      }
+    }
+    for (const separator of record.columnSeparators ?? [])
+      out.push(
+        `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])
+        out.push(
+          `${color(sep.ruleColor)} rg ${rect({ ...sep.box, y: sep.box.y + offset, height: sep.ruleStyle === "double" ? 0.75 : sep.box.height }, -record.box.x, -record.box.y, height, true)} f`
+        );
+    }
+  }
+  const spans = [];
+  const drawings = [];
+  for (const warning of layout.contentWarnings ?? [])
+    work.report(`core-${warning.code}`, warning.code);
+  forEachSemanticSpan(layout, (visit) => {
+    work.tick();
+    spans.push(visit);
+  });
+  forEachSemanticDrawing(layout, (visit) => {
+    work.tick();
+    drawings.push(visit);
+  });
+  forEachSemanticStory(layout, (root) => {
+    streams[root.page.index].push(
+      ...decorations(
+        root.host.fragments,
+        root.origin.x - root.page.box.x,
+        root.origin.y - root.page.box.y,
+        pages[root.page.index],
+        work,
+        root.page.index
+      )
+    );
+  });
+  drawings.sort(
+    (a, b) => (a.drawing.kind === "anchoredDrawing" ? a.drawing.relativeHeight : 0) - (b.drawing.kind === "anchoredDrawing" ? b.drawing.relativeHeight : 0)
+  );
+  const textboxBuffers = /* @__PURE__ */ new Map();
+  const rotatedCellOf = /* @__PURE__ */ new Map();
+  const markRotated = (blocks, cell) => {
+    for (const block of blocks) {
+      work.tick();
+      if (block.kind === "paragraph") {
+        if (cell) rotatedCellOf.set(block, cell);
+        continue;
+      }
+      for (const row of block.rows)
+        for (const inner of row.cells)
+          markRotated(inner.blocks, cell ?? (inner.textDirection ? inner : void 0));
+    }
+  };
+  forEachSemanticStory(layout, (root) => markRotated(root.host.fragments));
+  const rotatedBuffers = /* @__PURE__ */ new Map();
+  const outFor = (visit) => {
+    const cell = visit.paragraph && rotatedCellOf.get(visit.paragraph);
+    if (cell && visit.storyOrigin) {
+      const key = `${visit.page.index}:${cell.id}`;
+      let entry = rotatedBuffers.get(key);
+      if (!entry) {
+        entry = {
+          cell,
+          x: visit.storyOrigin.x - visit.page.box.x,
+          y: visit.storyOrigin.y - visit.page.box.y,
+          page: visit.page.index,
+          commands: new Commands(work),
+          behind: new Commands(work)
+        };
+        rotatedBuffers.set(key, entry);
+      }
+      return entry.commands;
+    }
+    if (visit.story !== "textbox" || !visit.textboxOwner) return streams[visit.page.index];
+    let owners = textboxBuffers.get(visit.page.index);
+    if (!owners) {
+      owners = /* @__PURE__ */ new Map();
+      textboxBuffers.set(visit.page.index, owners);
+    }
+    let buffer = owners.get(visit.textboxOwner);
+    if (!buffer) {
+      buffer = new Commands(work);
+      owners.set(visit.textboxOwner, buffer);
+    }
+    return buffer;
+  };
+  const pageGroups = /* @__PURE__ */ new Map();
+  for (const visit of spans) {
+    let lines = pageGroups.get(visit.page.index);
+    if (!lines) {
+      lines = /* @__PURE__ */ new Map();
+      pageGroups.set(visit.page.index, lines);
+    }
+    let group = lines.get(visit.line);
+    if (!group) {
+      group = [];
+      lines.set(visit.line, group);
+    }
+    group.push(visit);
+  }
+  const lineStarts = /* @__PURE__ */ new Map();
+  spans.length = 0;
+  for (const lines of pageGroups.values())
+    for (const group of lines.values()) {
+      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], 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");
+      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) {
+      markers = /* @__PURE__ */ new Set();
+      markersByPage.set(visit.page.index, markers);
+    }
+    const marker = visit.paragraph.marker;
+    if (marker && !markers.has(visit.paragraph)) {
+      markers.add(visit.paragraph);
+      const picture = marker.picture ? await images.paintListMarkerPicture(
+        marker.picture,
+        {
+          ...marker.picture.box,
+          x: marker.picture.box.x + visit.storyOrigin.x - visit.page.box.x,
+          y: marker.picture.box.y + visit.storyOrigin.y - visit.page.box.y
+        },
+        page,
+        visit.page.index
+      ) : "";
+      if (picture) out.push(picture);
+      else
+        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
+                }
+              },
+              page
+            )
+          );
+    }
+    const fill = HIGHLIGHTS[visit.span.style.highlight ?? ""] ?? visit.span.style.shading;
+    if (fill)
+      out.push(
+        `${color(fill)} rg ${rect(text.bandBox(visit), -visit.page.box.x, -visit.page.box.y, pageHeight(page), true)} f`
+      );
+    const clipping = visit.paragraph.clipToBox;
+    if (clipping)
+      out.push(
+        `q ${rect(visit.paragraph.box, visit.storyOrigin.x - visit.page.box.x, visit.storyOrigin.y - visit.page.box.y, pageHeight(page))} W n`
+      );
+    out.push(
+      visit.span.equation ? paintEquation(visit, page, text, work) : text.paint(visit, page)
+    );
+    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()) {
+      const visit = group[0];
+      const strokes = runBorderStrokesForLine(visit.line);
+      if (strokes.length === 0) continue;
+      work.tick();
+      const out = outFor(visit);
+      const height = pageHeight(pages[visit.page.index]);
+      const x = visit.storyOrigin.x - visit.page.box.x;
+      const y = visit.storyOrigin.y - visit.page.box.y;
+      if (visit.paragraph.clipToBox) out.push(`q ${rect(visit.paragraph.box, x, y, height)} W n`);
+      for (const { box, edge } of strokes) {
+        if (edge.shadow || !["single", "thick", "dashed", "dotted", "double"].includes(edge.val))
+          work.report(
+            "run-border-style",
+            `Unsupported character border: ${edge.val}${edge.shadow ? " with shadow" : ""}`,
+            visit.page.index
+          );
+        out.push(rule(box, edge.color, edge.val, x, y, height));
+      }
+      if (visit.paragraph.clipToBox) out.push("Q");
+    }
+  }
+  const paintDrawing = async (visit) => {
+    const page = pages[visit.page.index];
+    const d = visit.drawing;
+    if (d.kind !== "anchoredDrawing" || !d.textboxStory) return images.paint(visit, page);
+    const story = d.textboxStory;
+    const origin = {
+      x: visit.drawingOrigin.x + story.contentOffset.x - visit.page.box.x,
+      y: visit.drawingOrigin.y + story.contentOffset.y - visit.page.box.y
+    };
+    return images.paintTextbox(visit, page, [
+      ...decorations(story.fragments, origin.x, origin.y, page, work, visit.page.index),
+      ...textboxBuffers.get(visit.page.index)?.get(d) ?? []
+    ]);
+  };
+  const nested = drawings.filter((visit) => visit.story === "textbox" && visit.textboxOwner).sort((a, b) => b.textboxDepth - a.textboxDepth);
+  for (const visit of nested) {
+    const commands = await paintDrawing(visit);
+    if (!commands) continue;
+    const buffer = outFor(visit);
+    if (visit.paintLayer === "behind-text") buffer.unshift(commands);
+    else buffer.push(commands);
+  }
+  for (const visit of drawings) {
+    if (visit.story === "textbox" && visit.textboxOwner) continue;
+    const commands = await paintDrawing(visit);
+    if (visit.paragraph && rotatedCellOf.has(visit.paragraph)) {
+      const cell = rotatedCellOf.get(visit.paragraph);
+      outFor(visit);
+      const entry = rotatedBuffers.get(`${visit.page.index}:${cell.id}`);
+      (visit.paintLayer === "behind-text" ? entry.behind : entry.commands).push(commands);
+      continue;
+    }
+    (visit.paintLayer === "behind-text" ? behindStreams : streams)[visit.page.index].push(
+      commands
+    );
+  }
+  for (const { cell, x, y, page, commands, behind } of rotatedBuffers.values()) {
+    const matrix = rotatedCellMatrix(cell.box, x, y, pageHeight(pages[page]));
+    if (behind.length) behindStreams[page].push("q", matrix, ...behind, "Q");
+    if (commands.length) streams[page].push("q", matrix, ...commands, "Q");
+  }
+  for (let i = 0; i < streams.length; i++) streams[i].push(...frontBorders[i]);
+  for (let i = 0; i < pages.length; i++) {
+    work.check();
+    pages[i].node.addContentStream(
+      doc.context.register(
+        flateStream(doc.context, behindStreams[i].join("\n") + "\n" + streams[i].join("\n"))
+      )
+    );
+  }
+  for (const face2 of text.faces.values()) await face2.finish(work);
+  if (includeComments) comments(doc, pages, layout, work);
+}
+
+// src/pdf-work.ts
+import { ExportResourceError as ExportResourceError3 } from "@docx-editor.dev/core/export";
+
+// src/types.ts
+var PdfFidelityError = class extends Error {
+  constructor(diagnostics) {
+    super("PDF export cannot faithfully represent all requested content");
+    this.diagnostics = diagnostics;
+    this.name = "PdfFidelityError";
+  }
+  diagnostics;
+  code = "fidelityUnsupported";
+};
+var PdfDocumentOpenError = class extends Error {
+  constructor(reason, detail) {
+    super(`Cannot open DOCX: ${reason}${detail ? `: ${detail}` : ""}`);
+    this.reason = reason;
+    this.detail = detail;
+    this.name = "PdfDocumentOpenError";
+  }
+  reason;
+  detail;
+  code = "documentOpenFailed";
+};
+var PdfEncodingError = class extends Error {
+  code = "encodingFailed";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "PdfEncodingError";
+  }
+};
+var PdfOutputLimitError = class extends PdfEncodingError {
+  constructor(limit, actual) {
+    super(`PDF exceeds maxOutputBytes (${limit}); encoded ${actual} bytes`);
+    this.limit = limit;
+    this.actual = actual;
+    this.name = "PdfOutputLimitError";
+  }
+  limit;
+  actual;
+  code = "outputTooLarge";
+};
+var PdfPageLimitError = class extends RangeError {
+  constructor(limit, actual) {
+    super(`PDF exceeds maxPages (${limit}); laid out ${actual} pages`);
+    this.limit = limit;
+    this.actual = actual;
+    this.name = "PdfPageLimitError";
+  }
+  limit;
+  actual;
+  code = "pageLimitExceeded";
+};
+
+// src/pdf-work.ts
+async function withPdfWork(options, run) {
+  const { timeoutMs } = validateOptions(options);
+  const controller = new AbortController();
+  const signal = options.signal;
+  const abort = () => controller.abort(
+    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 ExportResourceError3("timedOut", "PDF conversion timed out")),
+    timeoutMs
+  );
+  const work = new Work(controller.signal, Date.now() + timeoutMs);
+  const started = performance.now();
+  try {
+    work.check();
+    return await run(work, () => Math.round(performance.now() - started));
+  } catch (error) {
+    if (error instanceof PdfDocumentOpenError && error.reason === "aborted" || error instanceof ExportResourceError3 && error.code === "aborted")
+      work.check();
+    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 });
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", abort);
+  }
+}
+function waitForPdfWork(run, work) {
+  work.check();
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      try {
+        work.check();
+      } catch (error) {
+        reject(error);
+      }
+    };
+    work.signal.addEventListener("abort", abort, { once: true });
+    const clear = () => work.signal.removeEventListener("abort", abort);
+    Promise.resolve().then(() => {
+      work.check();
+      return run();
+    }).then(
+      (value) => {
+        clear();
+        resolve(value);
+      },
+      (error) => {
+        clear();
+        reject(error);
+      }
+    );
+  });
+}
+
+// src/export-pdf.ts
+async function exportPdf(source, options = {}) {
+  if (!(source instanceof Uint8Array)) throw new TypeError("source must be a Uint8Array");
+  validateOptions(options);
+  return withPdfWork(options, async (work, phase) => {
+    const {
+      comments: _comments,
+      fidelityPolicy: _fidelity,
+      timeoutMs: _timeout,
+      maxOutputBytes: _bytes,
+      maxPages: _pages,
+      ...open
+    } = options;
+    const opened = await openExportSession(source, open, work.signal);
+    if (!opened.ok) throw new PdfDocumentOpenError(opened.reason, opened.detail);
+    try {
+      return await renderSession(opened.session, options, work, phase, phase());
+    } finally {
+      opened.session.dispose();
+    }
+  });
+}
+async function exportPdfFrom(session, options = {}) {
+  validateOptions(options);
+  for (const key of Object.keys(options)) {
+    if (![
+      "comments",
+      "fidelityPolicy",
+      "timeoutMs",
+      "maxOutputBytes",
+      "maxPages",
+      "signal",
+      "displayMode"
+    ].includes(key))
+      throw new TypeError(`${key} must be configured when opening the PDF session`);
+  }
+  if (!session || typeof session !== "object" || !hasFontBackedExportCapabilities(session) || typeof session.layout !== "function" || typeof session.layoutFor !== "function" || !session.fontResolution)
+    throw new TypeError("exportPdfFrom requires a font-backed export session");
+  return withPdfWork(options, (work, phase) => renderSession(session, options, work, phase, 0));
+}
+async function renderSession(session, options, work, phase, openMs) {
+  const { maxBytes, maxPages } = validateOptions(options);
+  const { comments: comments2 = true, fidelityPolicy = "strict" } = options;
+  work.check();
+  const layout = await waitForPdfWork(
+    () => options.displayMode ? session.layoutFor(options.displayMode) : session.layout(),
+    work
+  );
+  const layoutMs = phase() - openMs;
+  if (layout.pages.length > maxPages) throw new PdfPageLimitError(maxPages, layout.pages.length);
+  reportFontDiagnostics(session.fontResolution, work);
+  const doc = await PDFDocument5.create({ updateMetadata: false });
+  doc.setProducer("docx-editor.dev");
+  doc.setCreator("docx-editor.dev");
+  const date = /* @__PURE__ */ new Date("2020-01-01T00:00:00Z");
+  doc.setCreationDate(date);
+  doc.setModificationDate(date);
+  const metadata = layout.documentMetadata;
+  if (metadata?.title) doc.setTitle(metadata.title);
+  if (metadata?.creator) doc.setAuthor(metadata.creator);
+  if (metadata?.subject) doc.setSubject(metadata.subject);
+  if (metadata?.keywords) doc.setKeywords([metadata.keywords]);
+  await paint(doc, session, layout, work, comments2);
+  const paintMs = phase() - openMs - layoutMs;
+  const diagnostics = Object.freeze([...work.diagnostics]);
+  if (fidelityPolicy === "strict" && diagnostics.some((d) => d.severity !== "information"))
+    throw new PdfFidelityError(diagnostics);
+  work.check();
+  const bytes = await doc.save({ useObjectStreams: false, objectsPerTick: 1e3 });
+  work.check();
+  if (bytes.byteLength > maxBytes) throw new PdfOutputLimitError(maxBytes, bytes.byteLength);
+  return Object.freeze({
+    bytes,
+    pageCount: layout.pages.length,
+    layoutRevision: layout.revision,
+    displayMode: layout.displayMode ?? "proposed",
+    fontResolution: session.fontResolution,
+    diagnostics,
+    timings: Object.freeze({
+      openMs,
+      layoutMs,
+      paintMs,
+      saveMs: phase() - openMs - layoutMs - paintMs
+    })
+  });
+}
+
+// src/pdf-session.ts
+async function openDocumentForExport(source, options = {}) {
+  if (!(source instanceof Uint8Array)) throw new TypeError("source must be a Uint8Array");
+  validateOptions(options);
+  for (const key of ["comments", "fidelityPolicy", "timeoutMs", "maxOutputBytes", "maxPages"]) {
+    if (options[key] !== void 0)
+      throw new TypeError(`${key} must be configured in exportPdfFrom`);
+  }
+  return openExportSession(source, options, options.signal);
+}
+
+// src/index.ts
+import { createFontSource as createFontSource2, defineFontResolver as defineFontResolver2 } from "@docx-editor.dev/core/editor";
+import { ExportResourceError as ExportResourceError4 } from "@docx-editor.dev/core/export";
+export {
+  ExportResourceError4 as ExportResourceError,
+  PdfDocumentOpenError,
+  PdfEncodingError,
+  PdfFidelityError,
+  PdfOutputLimitError,
+  PdfPageLimitError,
+  PdfWorkLimitError,
+  createFontSource2 as createFontSource,
+  defineFontResolver2 as defineFontResolver,
+  exportPdf,
+  exportPdfFrom,
+  openDocumentForExport
+};