@hufe921/jsofd 1.0.0

package/dist/jsofd.umd.js

@@ -0,0 +1,4390 @@
+"use strict";
+var jsOFD = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __typeError = (msg) => {
+    throw TypeError(msg);
+  };
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+  var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+  var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+  var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    BUILTIN_FONTS: () => BUILTIN_FONTS,
+    FONT_ALIASES: () => FONT_ALIASES,
+    JSOFD_VERSION: () => JSOFD_VERSION,
+    OFD_NAMESPACE: () => OFD_NAMESPACE,
+    PAGE_FORMATS_MM: () => PAGE_FORMATS_MM,
+    UNIT_FACTORS: () => UNIT_FACTORS,
+    default: () => src_default,
+    jsOFD: () => jsOFD,
+    version: () => version
+  });
+
+  // src/utils.ts
+  var MM_PER_PT = 25.4 / 72;
+  var PT_PER_MM = 72 / 25.4;
+  var IS_NODE = typeof process !== "undefined" && !!process.versions && !!process.versions.node;
+  function nodeRequire(name) {
+    try {
+      const req = new Function("m", "return require(m)");
+      return req(name);
+    } catch (e) {
+      return null;
+    }
+  }
+  function fmt(n) {
+    if (typeof n !== "number" || !isFinite(n)) n = 0;
+    let s = n.toFixed(4);
+    if (s.includes(".")) s = s.replace(/\.?0+$/, "");
+    if (s === "-0") s = "0";
+    return s;
+  }
+  function escapeXmlText(s) {
+    return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+  function escapeXmlAttr(s) {
+    return escapeXmlText(s).replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  }
+  function randomHex32() {
+    let s = "";
+    for (let i = 0; i < 32; i++) {
+      s += "0123456789abcdef"[Math.random() * 16 | 0];
+    }
+    return s;
+  }
+  function todayStr(d) {
+    const date = d instanceof Date ? d : /* @__PURE__ */ new Date();
+    const m = date.getMonth() + 1;
+    const day = date.getDate();
+    const mm = m < 10 ? "0" + m : String(m);
+    const dd = day < 10 ? "0" + day : String(day);
+    return `${date.getFullYear()}-${mm}-${dd}`;
+  }
+  function utf8Encode(str) {
+    if (typeof TextEncoder !== "undefined") {
+      return new TextEncoder().encode(str);
+    }
+    const out = [];
+    for (let i = 0; i < str.length; i++) {
+      const c = str.charCodeAt(i);
+      if (c < 128) out.push(c);
+      else if (c < 2048) out.push(192 | c >> 6, 128 | c & 63);
+      else if (c >= 55296 && c < 56320 && i + 1 < str.length) {
+        const c2 = str.charCodeAt(++i);
+        const cp = 65536 + ((c & 1023) << 10) + (c2 & 1023);
+        out.push(
+          240 | cp >> 18,
+          128 | cp >> 12 & 63,
+          128 | cp >> 6 & 63,
+          128 | cp & 63
+        );
+      } else {
+        out.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
+      }
+    }
+    return new Uint8Array(out);
+  }
+  function u8FromBuffer(buf) {
+    if (buf instanceof Uint8Array) return buf;
+    if (typeof ArrayBuffer !== "undefined" && buf instanceof ArrayBuffer) {
+      return new Uint8Array(buf);
+    }
+    throw new Error("jsofd: unrecognized binary data type");
+  }
+  function b64Encode(u8) {
+    let s = "";
+    for (let i = 0; i < u8.length; i++) s += String.fromCharCode(u8[i]);
+    return btoa(s);
+  }
+  function b64Decode(str) {
+    const s = String(str).replace(/^data:.*?;base64,/, "").replace(/[=\s]+$/, "");
+    const bin = atob(s);
+    const u8 = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) u8[i] = bin.charCodeAt(i);
+    return u8;
+  }
+  var CRC_TABLE = (() => {
+    const t = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+      let c = n;
+      for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+      t[n] = c >>> 0;
+    }
+    return t;
+  })();
+  function crc32(u8) {
+    let c = 4294967295;
+    for (let i = 0; i < u8.length; i++) {
+      c = CRC_TABLE[(c ^ u8[i]) & 255] ^ c >>> 8;
+    }
+    return (c ^ 4294967295) >>> 0;
+  }
+  function fnv1a(u8) {
+    let h = 2166136261;
+    for (let i = 0; i < u8.length; i++) {
+      h ^= u8[i];
+      h = h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24)) >>> 0;
+    }
+    return ("0000000" + h.toString(16)).slice(-8);
+  }
+
+  // src/formats.ts
+  var PAGE_FORMATS_MM = {
+    a0: [841, 1189],
+    a1: [594, 841],
+    a2: [420, 594],
+    a3: [297, 420],
+    a4: [210, 297],
+    a5: [148, 210],
+    a6: [105, 148],
+    a7: [74, 105],
+    a8: [52, 74],
+    a9: [37, 52],
+    a10: [26, 37],
+    b0: [1e3, 1414],
+    b1: [707, 1e3],
+    b2: [500, 707],
+    b3: [353, 500],
+    b4: [250, 353],
+    b5: [176, 250],
+    b6: [125, 176],
+    b7: [88, 125],
+    b8: [62, 88],
+    b9: [44, 62],
+    b10: [31, 44],
+    c0: [917, 1297],
+    c1: [648, 917],
+    c2: [458, 648],
+    c3: [324, 458],
+    c4: [229, 324],
+    c5: [162, 229],
+    c6: [114, 162],
+    c7: [81, 114],
+    c8: [57, 81],
+    c9: [40, 57],
+    c10: [28, 40],
+    dl: [110, 220],
+    letter: [215.9, 279.4],
+    "junior-legal": [203.2, 127],
+    "government-letter": [203.2, 266.7],
+    legal: [215.9, 355.6],
+    "government-legal": [215.9, 330.2],
+    ledger: [431.8, 279.4],
+    tabloid: [279.4, 431.8],
+    executive: [184.15, 266.7],
+    folio: [215.9, 330.2],
+    statement: [139.7, 215.9],
+    halfletter: [139.7, 215.9]
+  };
+  var UNIT_FACTORS = {
+    pt: 1,
+    mm: PT_PER_MM,
+    cm: PT_PER_MM * 10,
+    in: 72,
+    inch: 72,
+    px: 0.75,
+    pc: 12,
+    em: 12,
+    ex: 6
+  };
+  function isUnit(u) {
+    return Object.prototype.hasOwnProperty.call(UNIT_FACTORS, u);
+  }
+
+  // src/css-colors.ts
+  var RAW = "aliceblue:f0f8ff|antiquewhite:faebd7|aqua:00ffff|aquamarine:7fffd4|azure:f0ffff|beige:f5f5dc|bisque:ffe4c4|black:000000|blanchedalmond:ffebcd|blue:0000ff|blueviolet:8a2be2|brown:a52a2a|burlywood:deb887|cadetblue:5f9ea0|chartreuse:7fff00|chocolate:d2691e|coral:ff7f50|cornflowerblue:6495ed|cornsilk:fff8dc|crimson:dc143c|cyan:00ffff|darkblue:00008b|darkcyan:008b8b|darkgoldenrod:b8860b|darkgray:a9a9a9|darkgreen:006400|darkgrey:a9a9a9|darkkhaki:bdb76b|darkmagenta:8b008b|darkolivegreen:556b2f|darkorange:ff8c00|darkorchid:9932cc|darkred:8b0000|darksalmon:e9967a|darkseagreen:8fbc8f|darkslateblue:483d8b|darkslategray:2f4f4f|darkslategrey:2f4f4f|darkturquoise:00ced1|darkviolet:9400d3|deeppink:ff1493|deepskyblue:00bfff|dimgray:696969|dimgrey:696969|dodgerblue:1e90ff|firebrick:b22222|floralwhite:fffaf0|forestgreen:228b22|fuchsia:ff00ff|gainsboro:dcdcdc|ghostwhite:f8f8ff|gold:ffd700|goldenrod:daa520|gray:808080|green:008000|greenyellow:adff2f|grey:808080|honeydew:f0fff0|hotpink:ff69b4|indianred:cd5c5c|indigo:4b0082|ivory:fffff0|khaki:f0e68c|lavender:e6e6fa|lavenderblush:fff0f5|lawngreen:7cfc00|lemonchiffon:fffacd|lightblue:add8e6|lightcoral:f08080|lightcyan:e0ffff|lightgoldenrodyellow:fafad2|lightgray:d3d3d3|lightgreen:90ee90|lightgrey:d3d3d3|lightpink:ffb6c1|lightsalmon:ffa07a|lightseagreen:20b2aa|lightskyblue:87cefa|lightslategray:778899|lightslategrey:778899|lightsteelblue:b0c4de|lightyellow:ffffe0|lime:00ff00|limegreen:32cd32|linen:faf0e6|magenta:ff00ff|maroon:800000|mediumaquamarine:66cdaa|mediumblue:0000cd|mediumorchid:ba55d3|mediumpurple:9370db|mediumseagreen:3cb371|mediumslateblue:7b68ee|mediumspringgreen:00fa9a|mediumturquoise:48d1cc|mediumvioletred:c71585|midnightblue:191970|mintcream:f5fffa|mistyrose:ffe4e1|moccasin:ffe4b5|navajowhite:ffdead|navy:000080|oldlace:fdf5e6|olive:808000|olivedrab:6b8e23|orange:ffa500|orangered:ff4500|orchid:da70d6|palegoldenrod:eee8aa|palegreen:98fb98|paleturquoise:afeeee|palevioletred:db7093|papayawhip:ffefd5|peachpuff:ffdab9|peru:cd853f|pink:ffc0cb|plum:dda0dd|powderblue:b0e0e6|purple:800080|rebeccapurple:663399|red:ff0000|rosybrown:bc8f8f|royalblue:4169e1|saddlebrown:8b4513|salmon:fa8072|sandybrown:f4a460|seagreen:2e8b57|seashell:fff5ee|sienna:a0522d|silver:c0c0c0|skyblue:87ceeb|slateblue:6a5acd|slategray:708090|slategrey:708090|snow:fffafa|springgreen:00ff7f|steelblue:4682b4|tan:d2b48c|teal:008080|thistle:d8bfd8|tomato:ff6347|turquoise:40e0d0|violet:ee82ee|wheat:f5deb3|white:ffffff|whitesmoke:f5f5f5|yellow:ffff00|yellowgreen:9acd32";
+  var CSS_COLORS = {};
+  for (const pair of RAW.split("|")) {
+    const i = pair.indexOf(":");
+    CSS_COLORS[pair.slice(0, i)] = pair.slice(i + 1);
+  }
+
+  // src/core/colors.ts
+  function parseColor(args) {
+    var _a;
+    const a0 = args[0];
+    if (typeof a0 === "string") {
+      const m = a0.trim().toLowerCase();
+      if (m.charAt(0) === "#") {
+        let hex = m.slice(1);
+        if (hex.length === 3) {
+          hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+        }
+        if (hex.length !== 6 || /[^0-9a-f]/.test(hex)) return [0, 0, 0];
+        return [
+          parseInt(hex.slice(0, 2), 16),
+          parseInt(hex.slice(2, 4), 16),
+          parseInt(hex.slice(4, 6), 16)
+        ];
+      }
+      const named = CSS_COLORS[m];
+      if (named) {
+        return [
+          parseInt(named.slice(0, 2), 16),
+          parseInt(named.slice(2, 4), 16),
+          parseInt(named.slice(4, 6), 16)
+        ];
+      }
+      const g2 = Number(m);
+      if (!isNaN(g2) && m !== "") {
+        const v = Math.max(0, Math.min(255, Math.round(g2 * 255)));
+        return [v, v, v];
+      }
+      return [0, 0, 0];
+    }
+    const defined = args.filter((v) => v !== void 0 && v !== null && v !== "");
+    const n = defined.map((v) => Number(v) | 0);
+    if (n.length >= 3) return [n[0], n[1], n[2]];
+    const g = (_a = n[0]) != null ? _a : 0;
+    return [g, g, g];
+  }
+  function rgbToHex(c) {
+    const h = (v) => Math.max(0, Math.min(255, v)).toString(16).padStart(2, "0");
+    return `#${h(c[0])}${h(c[1])}${h(c[2])}`;
+  }
+  function styleFlags(style) {
+    const s = String(style || "S").toUpperCase().replace(/\*/g, "");
+    const fill = s.includes("F");
+    const stroke = s.includes("S") || s.includes("D");
+    if (!fill && !stroke) return { fill: false, stroke: true };
+    return { fill, stroke };
+  }
+
+  // src/context2d.ts
+  var IDENT = [1, 0, 0, 1, 0, 0];
+  function mul(m, n) {
+    return [
+      m[0] * n[0] + m[2] * n[1],
+      m[1] * n[0] + m[3] * n[1],
+      m[0] * n[2] + m[2] * n[3],
+      m[1] * n[2] + m[3] * n[3],
+      m[0] * n[4] + m[2] * n[5] + m[4],
+      m[1] * n[4] + m[3] * n[5] + m[5]
+    ];
+  }
+  function apply(m, x, y) {
+    return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+  }
+  var K = 0.5523;
+  function parseFont(font) {
+    const m = /^\s*(italic|oblique)?\s*(bold)?\s*([\d.]+)(px|pt)\s*(.*)$/.exec(font) || /^\s*(italic|oblique)?\s*(bold)?\s*([\d.]+)(px|pt)\s*$/.exec(font);
+    if (!m) return { italic: false, bold: false, px: 16, family: "sans-serif" };
+    return {
+      italic: !!m[1],
+      bold: !!m[2],
+      px: parseFloat(m[3]),
+      family: (m[5] || "").trim()
+    };
+  }
+  function createContext2d(doc) {
+    let matrix = IDENT.slice();
+    const stack = [];
+    let path = [];
+    let cur = [0, 0];
+    let lastMove = [0, 0];
+    const state = {
+      fillStyle: "#000000",
+      strokeStyle: "#000000",
+      lineWidth: 1,
+      globalAlpha: 1,
+      font: "10px sans-serif",
+      textAlign: "left",
+      textBaseline: "alphabetic"
+    };
+    const unsupported = (name) => {
+      throw new Error(`context2d: ${name} is not supported by the OFD vector model`);
+    };
+    const ctx = {
+      __jsofd: true,
+      // ---- state ----
+      save() {
+        stack.push({ matrix: matrix.slice(), state: { ...state } });
+      },
+      restore() {
+        const s = stack.pop();
+        if (s) {
+          matrix = s.matrix;
+          Object.assign(state, s.state);
+        }
+      },
+      get fillStyle() {
+        return state.fillStyle;
+      },
+      set fillStyle(v) {
+        if (typeof v === "object") unsupported("gradient/pattern fill styles");
+        state.fillStyle = typeof v === "number" ? `#${v.toString(16).padStart(6, "0")}` : String(v);
+      },
+      get strokeStyle() {
+        return state.strokeStyle;
+      },
+      set strokeStyle(v) {
+        if (typeof v === "object") unsupported("gradient/pattern stroke styles");
+        state.strokeStyle = typeof v === "number" ? `#${v.toString(16).padStart(6, "0")}` : String(v);
+      },
+      get lineWidth() {
+        return state.lineWidth;
+      },
+      set lineWidth(v) {
+        state.lineWidth = v;
+      },
+      get globalAlpha() {
+        return state.globalAlpha;
+      },
+      set globalAlpha(v) {
+        state.globalAlpha = Math.max(0, Math.min(1, v));
+      },
+      get font() {
+        return state.font;
+      },
+      set font(v) {
+        state.font = v;
+      },
+      get textAlign() {
+        return state.textAlign;
+      },
+      set textAlign(v) {
+        state.textAlign = v;
+      },
+      get textBaseline() {
+        return state.textBaseline;
+      },
+      set textBaseline(v) {
+        state.textBaseline = v;
+      },
+      // ---- transforms ----
+      translate(x, y) {
+        matrix = mul(matrix, [1, 0, 0, 1, x, y]);
+      },
+      rotate(a) {
+        const c = Math.cos(a);
+        const s = Math.sin(a);
+        matrix = mul(matrix, [c, s, -s, c, 0, 0]);
+      },
+      scale(x, y) {
+        matrix = mul(matrix, [x, 0, 0, y, 0, 0]);
+      },
+      transform(a, b, c, d, e, f) {
+        matrix = mul(matrix, [a, b, c, d, e, f]);
+      },
+      setTransform(a, b, c, d, e, f) {
+        matrix = [a, b, c, d, e, f];
+      },
+      resetTransform() {
+        matrix = IDENT.slice();
+      },
+      // ---- paths ----
+      beginPath() {
+        path = [];
+        cur = [0, 0];
+        lastMove = [0, 0];
+      },
+      closePath() {
+        path.push({ kind: "L", pts: [...lastMove] });
+        cur = [...lastMove];
+      },
+      moveTo(x, y) {
+        const [tx, ty] = apply(matrix, x, y);
+        path.push({ kind: "M", pts: [tx, ty] });
+        cur = [x, y];
+        lastMove = [x, y];
+      },
+      lineTo(x, y) {
+        const [tx, ty] = apply(matrix, x, y);
+        if (path.length === 0) path.push({ kind: "M", pts: [tx, ty] });
+        else path.push({ kind: "L", pts: [tx, ty] });
+        cur = [x, y];
+      },
+      bezierCurveTo(c1x, c1y, c2x, c2y, x, y) {
+        const a1 = apply(matrix, c1x, c1y);
+        const a2 = apply(matrix, c2x, c2y);
+        const a3 = apply(matrix, x, y);
+        if (path.length === 0) path.push({ kind: "M", pts: a1 });
+        path.push({ kind: "C", pts: [...a1, ...a2, ...a3] });
+        cur = [x, y];
+      },
+      quadraticCurveTo(cx, cy, x, y) {
+        const c1x = cur[0] + 2 / 3 * (cx - cur[0]);
+        const c1y = cur[1] + 2 / 3 * (cy - cur[1]);
+        const c2x = x + 2 / 3 * (cx - x);
+        const c2y = y + 2 / 3 * (cy - y);
+        ctx.bezierCurveTo(c1x, c1y, c2x, c2y, x, y);
+      },
+      arc(x, y, r, start, end, anticlockwise = false) {
+        let delta = end - start;
+        if (anticlockwise) {
+          while (delta > 0) delta -= Math.PI * 2;
+        } else {
+          while (delta < 0) delta += Math.PI * 2;
+        }
+        const abs = Math.abs(delta);
+        if (abs < 1e-9) return;
+        const steps = Math.max(1, Math.ceil(abs / (Math.PI / 2)));
+        const step = delta / steps;
+        let a = start;
+        if (path.length === 0) {
+          const t0 = apply(matrix, x + r * Math.cos(a), y + r * Math.sin(a));
+          path.push({ kind: "M", pts: t0 });
+        }
+        for (let i = 0; i < steps; i++) {
+          const k = 4 / 3 * Math.tan(step / 4);
+          const tx1 = -Math.sin(a);
+          const ty1 = Math.cos(a);
+          const a3 = a + step;
+          const tx3 = -Math.sin(a3);
+          const ty3 = Math.cos(a3);
+          const p1x = x + r * Math.cos(a);
+          const p1y = y + r * Math.sin(a);
+          const p3x = x + r * Math.cos(a3);
+          const p3y = y + r * Math.sin(a3);
+          const c1 = apply(matrix, p1x + k * r * tx1, p1y + k * r * ty1);
+          const c2 = apply(matrix, p3x - k * r * tx3, p3y - k * r * ty3);
+          const p3 = apply(matrix, p3x, p3y);
+          path.push({ kind: "C", pts: [...c1, ...c2, ...p3] });
+          cur = [p3x, p3y];
+          a = a3;
+        }
+      },
+      ellipse(x, y, rx, ry, rotation, start, end, anticlockwise = false) {
+        ctx.save();
+        ctx.translate(x, y);
+        ctx.rotate(rotation || 0);
+        ctx.scale(1, ry / (rx || 1));
+        ctx.arc(0, 0, rx, start, end, anticlockwise);
+        ctx.restore();
+      },
+      rect(x, y, w, h) {
+        ctx.moveTo(x, y);
+        ctx.lineTo(x + w, y);
+        ctx.lineTo(x + w, y + h);
+        ctx.lineTo(x, y + h);
+        ctx.closePath();
+      },
+      roundRect(x, y, w, h, r) {
+        var _a;
+        const rad = Math.min(typeof r === "number" ? r : (_a = r[0]) != null ? _a : 0, w / 2, h / 2);
+        const k = K;
+        ctx.moveTo(x + rad, y);
+        ctx.lineTo(x + w - rad, y);
+        ctx.bezierCurveTo(x + w - rad + rad * k, y, x + w, y + rad - rad * k, x + w, y + rad);
+        ctx.lineTo(x + w, y + h - rad);
+        ctx.bezierCurveTo(
+          x + w,
+          y + h - rad + rad * k,
+          x + w - rad + rad * k,
+          y + h,
+          x + w - rad,
+          y + h
+        );
+        ctx.lineTo(x + rad, y + h);
+        ctx.bezierCurveTo(x + rad - rad * k, y + h, x, y + h - rad + rad * k, x, y + h - rad);
+        ctx.lineTo(x, y + rad);
+        ctx.bezierCurveTo(x, y + rad - rad * k, x + rad - rad * k, y, x + rad, y);
+        ctx.closePath();
+      },
+      // ---- painting ----
+      fill(path2) {
+        if (path2) unsupported("Path2D arguments");
+        if (!path.length) return;
+        doc.pages[doc.page].objects.push({
+          t: "path",
+          ops: toOps(path, true),
+          fill: true,
+          stroke: false,
+          fillColor: rgb(state.fillStyle),
+          strokeColor: rgb(state.strokeStyle),
+          lineWidth: 0,
+          dash: null,
+          cap: 0,
+          join: 0,
+          miterLimit: 0,
+          opacity: state.globalAlpha < 1 ? state.globalAlpha : null
+        });
+      },
+      stroke(path2) {
+        if (path2) unsupported("Path2D arguments");
+        if (!path.length) return;
+        doc.pages[doc.page].objects.push({
+          t: "path",
+          ops: toOps(path, false),
+          fill: false,
+          stroke: true,
+          fillColor: rgb(state.fillStyle),
+          strokeColor: rgb(state.strokeStyle),
+          lineWidth: state.lineWidth * Math.hypot(matrix[0], matrix[1]),
+          dash: null,
+          cap: 0,
+          join: 0,
+          miterLimit: 0,
+          opacity: state.globalAlpha < 1 ? state.globalAlpha : null
+        });
+      },
+      clip() {
+      },
+      fillRect(x, y, w, h) {
+        ctx.beginPath();
+        ctx.rect(x, y, w, h);
+        ctx.fill();
+      },
+      strokeRect(x, y, w, h) {
+        ctx.beginPath();
+        ctx.rect(x, y, w, h);
+        ctx.stroke();
+      },
+      clearRect() {
+      },
+      fillText(text, x, y) {
+        emitText(String(text), x, y, true);
+      },
+      strokeText(text, x, y) {
+        emitText(String(text), x, y, false);
+      },
+      measureText(text) {
+        const f = parseFont(state.font);
+        const sizePt = f.px * 0.75;
+        const key = mapFamily(f.family);
+        const w = doc.measure(
+          String(text),
+          doc.getFontDef(key),
+          f.bold ? "bold" : f.italic ? "italic" : "normal",
+          sizePt,
+          0
+        ) / doc.scaleFactor;
+        return {
+          width: w,
+          actualBoundingBoxAscent: sizePt * 0.8 / doc.scaleFactor,
+          actualBoundingBoxDescent: sizePt * 0.2 / doc.scaleFactor,
+          fontBoundingBoxAscent: sizePt * 0.9 / doc.scaleFactor,
+          fontBoundingBoxDescent: sizePt * 0.25 / doc.scaleFactor
+        };
+      },
+      drawImage(img, dx, dy, dw, dh) {
+        const w = dw != null ? dw : "width" in img ? Number(img.width) || 0 : 0;
+        const h = dh != null ? dh : "height" in img ? Number(img.height) || 0 : 0;
+        if (!w || !h) return;
+        const sx = Math.hypot(matrix[0], matrix[1]);
+        const sy = Math.hypot(matrix[2], matrix[3]);
+        const angle = Math.atan2(matrix[1], matrix[0]) * 180 / Math.PI;
+        const [cx, cy] = apply(matrix, dx + w / 2, dy + h / 2);
+        const prev = doc.opacity;
+        if (state.globalAlpha < 1) doc.opacity = state.globalAlpha;
+        doc.addImage(img, {
+          x: cx - w * sx / 2,
+          y: cy - h * sy / 2,
+          w: w * sx,
+          h: h * sy,
+          rotation: angle
+        });
+        doc.opacity = prev;
+      },
+      // ---- intentionally unsupported raster/gradient APIs ----
+      createLinearGradient: () => unsupported("createLinearGradient (use solid fills)"),
+      createRadialGradient: () => unsupported("createRadialGradient (use solid fills)"),
+      createPattern: () => unsupported("createPattern"),
+      getImageData: () => unsupported("getImageData"),
+      putImageData: () => unsupported("putImageData"),
+      isPointInPath: () => false
+    };
+    function rgb(css) {
+      return parseColor([css]);
+    }
+    function toOps(segs, close) {
+      const ops = [];
+      for (const s of segs) {
+        if (s.kind === "M") ops.push({ op: "M", x: s.pts[0], y: s.pts[1] });
+        else if (s.kind === "L") ops.push({ op: "L", x: s.pts[0], y: s.pts[1] });
+        else
+          ops.push({
+            op: "C",
+            x1: s.pts[0],
+            y1: s.pts[1],
+            x2: s.pts[2],
+            y2: s.pts[3],
+            x: s.pts[4],
+            y: s.pts[5]
+          });
+      }
+      if (close) ops.push({ op: "Z" });
+      return ops;
+    }
+    function mapFamily(family) {
+      const f = family.toLowerCase();
+      if (f.includes("song") || f.includes("\u5B8B") || f.includes("serif")) return "simsun";
+      if (f.includes("hei") || f.includes("\u9ED1")) return "simhei";
+      if (f.includes("kai") || f.includes("\u6977")) return "kaiti";
+      if (f.includes("fang") || f.includes("\u4EFF")) return "fangsong";
+      if (f.includes("mono")) return "courier";
+      if (f.includes("times")) return "times";
+      return "helvetica";
+    }
+    function emitText(text, x, y, fill) {
+      const f = parseFont(state.font);
+      const sizePt = f.px * 0.75;
+      const sf = doc.scaleFactor;
+      const angle = Math.atan2(matrix[1], matrix[0]) * 180 / Math.PI;
+      const [tx, ty] = apply(matrix, x, y);
+      const key = mapFamily(f.family);
+      const def = doc.getFontDef(key);
+      const ascPt = def.ascent / 1e3 * sizePt;
+      const descPt = -def.descent / 1e3 * sizePt;
+      const wU = doc.measure(text, def, f.bold ? "bold" : "normal", sizePt, 0) / sf;
+      let ax = 0;
+      if (state.textAlign === "center") ax = -wU / 2;
+      else if (state.textAlign === "right") ax = -wU;
+      let ay = 0;
+      if (state.textBaseline === "top") ay = ascPt / sf;
+      else if (state.textBaseline === "middle") ay = (ascPt - descPt) / 2 / sf;
+      else if (state.textBaseline === "bottom") ay = -descPt / sf;
+      else if (state.textBaseline === "hanging") ay = ascPt * 0.8 / sf;
+      const rad = angle * Math.PI / 180;
+      const cos = Math.cos(rad);
+      const sin = Math.sin(rad);
+      const anchor = [tx + ax * cos - ay * sin, ty + ax * sin + ay * cos];
+      const prevFont = doc.activeFontKey;
+      const prevStyle = doc.activeFontStyle;
+      const prevColor = doc.textColor.slice();
+      doc.activeFontKey = key;
+      doc.activeFontStyle = f.bold ? "bold" : f.italic ? "italic" : "normal";
+      doc.textColor = rgb(fill ? state.fillStyle : state.strokeStyle);
+      doc.text(text, anchor[0], anchor[1], {
+        angle,
+        fontSize: sizePt,
+        renderingMode: fill ? "fill" : "stroke",
+        opacity: state.globalAlpha < 1 ? state.globalAlpha : void 0
+      });
+      doc.activeFontKey = prevFont;
+      doc.activeFontStyle = prevStyle;
+      doc.textColor = prevColor;
+    }
+    return ctx;
+  }
+
+  // src/modules/annotations.ts
+  var AnnotationApi = {
+    /**
+     * Add a clickable rectangular area.
+     *
+     * Pass `url` for an external target or `pageNumber` (1-based) for an
+     * in-document jump. The area itself is invisible.
+     */
+    link(x, y, w, h, options = {}) {
+      this.pages[this.page].objects.push({
+        t: "link",
+        x: this._u(Number(x)),
+        y: this._u(Number(y)),
+        w: this._u(Number(w)),
+        h: this._u(Number(h)),
+        url: options.url || null,
+        pageNumber: options.pageNumber || null,
+        magFactor: options.magFactor || null
+      });
+      return this;
+    },
+    /**
+     * Embed a file as an OFD attachment.
+     *
+     * @param data UTF-8 text, a base64 data URL, or binary bytes
+     */
+    addFileAsAttachment(filename, data, options = {}) {
+      let u8;
+      if (typeof data === "string") {
+        if (/^data:.*?;base64,/i.test(data)) u8 = b64Decode(data);
+        else u8 = utf8Encode(data);
+      } else if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
+        u8 = u8FromBuffer(data);
+      } else {
+        throw new Error("addFileAsAttachment: unsupported data type");
+      }
+      this.attachments.push({
+        name: String(filename),
+        data: u8,
+        format: options.format || "",
+        description: options.description || "",
+        creationDate: /* @__PURE__ */ new Date()
+      });
+      return this;
+    }
+  };
+
+  // src/modules/annotate.ts
+  var AnnotationVisualApi = {
+    /**
+     * Draw a visual annotation over the rectangle `(x, y, w, h)` and return the
+     * doc for chaining.
+     *
+     * - `highlight`  translucent marker behind/over text (default yellow)
+     * - `underline`  straight line at the bottom edge
+     * - `strikeout`  line through the vertical middle
+     * - `squiggly`   hand-drawn style zigzag along the bottom edge
+     * - `box`        rectangle outline (optionally filled via `options.fill`)
+     * - `ink`        `options.points` as a freehand polyline (`[[x,y],…]`)
+     * - `freetext`   `options.text` wrapped inside the rectangle
+     */
+    addAnnotation(type, x, y, w, h, options = {}) {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
+      const lw = (_a = options.lineWidth) != null ? _a : 0.6;
+      const prevLw = this.lineWidth;
+      const prevDraw = this.drawColor.slice();
+      const prevFill = this.fillColor.slice();
+      const prevOpacity = this.opacity;
+      const prevFontKey = this.activeFontKey;
+      const prevFontStyle = this.activeFontStyle;
+      const prevFontSize = this.fontSize;
+      const prevText = this.textColor.slice();
+      const setDraw = (c) => {
+        this.drawColor = c;
+        this.lineWidth = lw;
+      };
+      switch (type) {
+        case "highlight": {
+          this.fillColor = (_b = options.color) != null ? _b : [255, 221, 40];
+          this.opacity = (_c = options.opacity) != null ? _c : 0.35;
+          this.rect(x, y, w, h, "F");
+          break;
+        }
+        case "underline": {
+          setDraw((_d = options.color) != null ? _d : [224, 62, 62]);
+          this.opacity = (_e = options.opacity) != null ? _e : 1;
+          this.line(x, y + h, x + w, y + h, "S");
+          break;
+        }
+        case "strikeout": {
+          setDraw((_f = options.color) != null ? _f : [224, 62, 62]);
+          this.opacity = (_g = options.opacity) != null ? _g : 1;
+          this.line(x, y + h / 2, x + w, y + h / 2, "S");
+          break;
+        }
+        case "squiggly": {
+          setDraw((_h = options.color) != null ? _h : [224, 62, 62]);
+          this.opacity = (_i = options.opacity) != null ? _i : 1;
+          const seg = Math.max(w / 12, 1.2);
+          const amp = Math.max(lw * 1.2, 0.5);
+          const steps = Math.max(2, Math.round(w / seg));
+          const s = seg * 1;
+          const yy = y + h;
+          for (let i = 0; i < steps; i++) {
+            const x1 = x + i * s;
+            const x2 = Math.min(x1 + s, x + w);
+            const mid = (x1 + x2) / 2;
+            const up = i % 2 === 0 ? -amp : amp;
+            this.lines(
+              [
+                [mid - x1, up],
+                [x2 - mid, -up]
+              ],
+              x1,
+              yy,
+              1,
+              "S"
+            );
+          }
+          break;
+        }
+        case "box": {
+          if (options.fill) {
+            this.fillColor = options.fill;
+            this.opacity = (_j = options.opacity) != null ? _j : 1;
+            this.rect(x, y, w, h, "F");
+          }
+          setDraw((_k = options.color) != null ? _k : [53, 101, 224]);
+          this.rect(x, y, w, h, "S");
+          break;
+        }
+        case "ink": {
+          const pts = options.points;
+          if (!pts || pts.length < 2)
+            throw new Error("addAnnotation('ink'): options.points required");
+          setDraw((_l = options.color) != null ? _l : [31, 41, 55]);
+          this.opacity = (_m = options.opacity) != null ? _m : 1;
+          let cx = pts[0][0];
+          let cy = pts[0][1];
+          const segs = [];
+          for (let i = 1; i < pts.length; i++) {
+            segs.push([pts[i][0] - cx, pts[i][1] - cy]);
+            cx = pts[i][0];
+            cy = pts[i][1];
+          }
+          this.lines(segs, pts[0][0], pts[0][1], 1, "S");
+          break;
+        }
+        case "freetext": {
+          if (!options.text) throw new Error("addAnnotation('freetext'): options.text required");
+          if (options.fill) {
+            this.fillColor = options.fill;
+            this.opacity = (_n = options.opacity) != null ? _n : 1;
+            this.rect(x, y, w, h, "F");
+          }
+          if (options.fontKey) this.setFont(options.fontKey);
+          this.setFontSize((_o = options.fontSize) != null ? _o : 11);
+          this.textColor = (_p = options.color) != null ? _p : [224, 62, 62];
+          this.text(options.text, x + 1, y + ((_q = options.fontSize) != null ? _q : 11) * 0.9 / this.scaleFactor, {
+            maxWidth: w - 2
+          });
+          break;
+        }
+        default:
+          throw new Error("addAnnotation: unknown type " + String(type));
+      }
+      this.lineWidth = prevLw;
+      this.drawColor = prevDraw;
+      this.fillColor = prevFill;
+      this.opacity = prevOpacity;
+      this.activeFontKey = prevFontKey;
+      this.activeFontStyle = prevFontStyle;
+      this.fontSize = prevFontSize;
+      this.textColor = prevText;
+      return this;
+    }
+  };
+
+  // src/modules/flow.ts
+  var FlowApi = {
+    /**
+     * Flow long text across as many pages as needed.
+     *
+     * Lines wrap at `maxWidth` (same CJK/Latin rules as `text()`); when the
+     * next line would cross the bottom margin a new page is appended and
+     * `onNewPage` fires (for headers, page numbers, …).
+     *
+     * @returns the Y coordinate (active unit) after the last line — chain more
+     * content from there
+     */
+    autoPaging(text, options = {}) {
+      var _a, _b, _c, _d, _e, _f;
+      const pageW = this.getPageWidth();
+      const pageH = this.getPageHeight();
+      const x = (_a = options.x) != null ? _a : 20;
+      const topMargin = (_b = options.topMargin) != null ? _b : 20;
+      const bottomMargin = (_c = options.bottomMargin) != null ? _c : 20;
+      const rightMargin = (_d = options.rightMargin) != null ? _d : 20;
+      const maxWidth = (_e = options.maxWidth) != null ? _e : pageW - x - rightMargin;
+      const startPage = this.page;
+      if (typeof options.lineHeightFactor === "number")
+        this.setLineHeightFactor(options.lineHeightFactor);
+      const lines = this.splitTextToSize(String(text), maxWidth);
+      const leading = this.getLineHeight();
+      const maxBottom = pageH - bottomMargin;
+      let y = options.y !== void 0 ? options.y : topMargin + this.getFontSize() / this.scaleFactor * 0.85;
+      for (const line of lines) {
+        if (y > maxBottom) {
+          this.addPage();
+          y = topMargin + this.getFontSize() / this.scaleFactor * 0.85;
+          (_f = options.onNewPage) == null ? void 0 : _f.call(options, this, { pageNumber: this.pages.length, pageCount: this.pages.length });
+        }
+        this.text(line, x, y, { align: options.align });
+        y += leading;
+      }
+      this.page = startPage;
+      return y;
+    },
+    /**
+     * Draw headers and footers on a page range.
+     *
+     * Hooks receive the document (positioned on the target page — use
+     * `text`/`line`/… normally) and `{ pageNumber, pageCount }`. Common use:
+     *
+     * ```ts
+     * doc.headerFooter({
+     *   header: (d, { pageNumber }) => d.text('季度报告', 20, 12),
+     *   footer: (d, { pageNumber, pageCount }) =>
+     *     d.text(`第 ${pageNumber} 页 / 共 ${pageCount} 页`, 105, 285, { align: 'center' }),
+     * });
+     * ```
+     */
+    headerFooter(options) {
+      var _a, _b, _c, _d;
+      const start = Math.max(1, (_a = options.startPage) != null ? _a : 1);
+      const end = Math.min(this.pages.length, (_b = options.endPage) != null ? _b : this.pages.length);
+      const cur = this.page;
+      for (let n = start; n <= end; n++) {
+        this.setPage(n);
+        const info = { pageNumber: n, pageCount: this.pages.length };
+        (_c = options.header) == null ? void 0 : _c.call(options, this, info);
+        (_d = options.footer) == null ? void 0 : _d.call(options, this, info);
+      }
+      this.page = cur;
+      return this;
+    }
+  };
+
+  // src/modules/html.ts
+  var ENTITIES = {
+    amp: "&",
+    lt: "<",
+    gt: ">",
+    quot: '"',
+    apos: "'",
+    nbsp: "\xA0",
+    copy: "\xA9",
+    reg: "\xAE",
+    trade: "\u2122",
+    mdash: "\u2014",
+    ndash: "\u2013",
+    hellip: "\u2026",
+    laquo: "\xAB",
+    raquo: "\xBB",
+    middot: "\xB7"
+  };
+  function decodeEntities(s) {
+    return s.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z]+);/g, (all, body) => {
+      var _a;
+      if (body.startsWith("#x") || body.startsWith("#X"))
+        return String.fromCodePoint(parseInt(body.slice(2), 16));
+      if (body.startsWith("#")) return String.fromCodePoint(parseInt(body.slice(1), 10));
+      return (_a = ENTITIES[body.toLowerCase()]) != null ? _a : all;
+    });
+  }
+  function parseBlocks(html) {
+    var _a;
+    const blocks = [];
+    let text = "";
+    let bold = false;
+    let italic = false;
+    let container = 0;
+    const containerStack = [];
+    const flush = (gapBefore = 0) => {
+      const t = decodeEntities(text.replace(/\s+/g, " ").trim());
+      if (t) blocks.push({ text: t, kind: container, bold, italic, gapBefore });
+      text = "";
+    };
+    const tagRe = /<\/?([a-zA-Z][a-zA-Z0-9]*)\b[^>]*?(\/?)>|<!--[\s\S]*?-->/g;
+    let last = 0;
+    let m;
+    while ((m = tagRe.exec(html)) !== null) {
+      text += html.slice(last, m.index);
+      last = tagRe.lastIndex;
+      if (!m[1]) continue;
+      const closing = m[0].startsWith("</");
+      const tag = m[1].toLowerCase();
+      if (!closing) {
+        switch (tag) {
+          case "b":
+          case "strong":
+            bold = true;
+            break;
+          case "i":
+          case "em":
+            italic = true;
+            break;
+          case "h1":
+          case "h2":
+          case "h3":
+          case "h4":
+          case "h5":
+          case "h6":
+            flush();
+            containerStack.push(container);
+            container = Number(tag.charAt(1));
+            break;
+          case "p":
+            flush(6);
+            containerStack.push(container);
+            container = 0;
+            break;
+          case "li":
+            flush(2);
+            containerStack.push(container);
+            container = 7;
+            break;
+          case "br":
+            flush();
+            break;
+          case "ul":
+          case "ol":
+          case "div":
+          case "blockquote":
+            flush(4);
+            break;
+          default:
+            break;
+        }
+        if (m[2] === "/") {
+          if (tag === "br") {
+          }
+        }
+      } else {
+        switch (tag) {
+          case "b":
+          case "strong":
+            bold = false;
+            break;
+          case "i":
+          case "em":
+            italic = false;
+            break;
+          case "h1":
+          case "h2":
+          case "h3":
+          case "h4":
+          case "h5":
+          case "h6":
+          case "p":
+          case "li":
+            flush();
+            container = (_a = containerStack.pop()) != null ? _a : 0;
+            break;
+          default:
+            break;
+        }
+      }
+    }
+    text += html.slice(last);
+    flush();
+    return blocks;
+  }
+  function blockStyle(b, base, headingScale) {
+    if (b.kind >= 1 && b.kind <= 6) {
+      const factor = [0, 2, 1.5, 1.25, 1.1, 1, 1][b.kind] * headingScale;
+      return { size: base * factor, bold: true, gap: b.gapBefore + 8 };
+    }
+    if (b.kind === 7) return { size: base, bold: b.bold, gap: b.gapBefore };
+    return { size: base, bold: b.bold, gap: b.gapBefore };
+  }
+  var HtmlApi = {
+    /**
+     * Render an HTML fragment and return the final Y (active unit).
+     *
+     * Supported: `h1–h6`, `p`, `div`, `br`, `ul/ol` + `li`, `b/strong`,
+     * `i/em`, entities. Inline `span` text is preserved. Attributes and CSS
+     * are ignored by design.
+     */
+    html(html, options = {}) {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      const pageW = this.getPageWidth();
+      const pageH = this.getPageHeight();
+      const x = (_a = options.x) != null ? _a : 20;
+      const topMargin = (_b = options.topMargin) != null ? _b : 20;
+      const bottomMargin = (_c = options.bottomMargin) != null ? _c : 20;
+      const width = (_d = options.width) != null ? _d : pageW - x - 20;
+      const base = (_e = options.fontSize) != null ? _e : 11;
+      const headingScale = (_f = options.headingScale) != null ? _f : 1;
+      const lh = (_g = options.lineHeightFactor) != null ? _g : 1.5;
+      const prevLh = this.lineHeightFactor;
+      this.setLineHeightFactor(lh);
+      let y = (_h = options.y) != null ? _h : topMargin + base * 0.85;
+      const maxBottom = pageH - bottomMargin;
+      const sf = this.scaleFactor;
+      const ensureRoom = (neededPt, gapPt) => {
+        var _a2;
+        if (y + (neededPt + gapPt) / sf > maxBottom) {
+          this.addPage();
+          y = topMargin + base * 0.85;
+          (_a2 = options.onNewPage) == null ? void 0 : _a2.call(options, this, { pageNumber: this.pages.length, pageCount: this.pages.length });
+        }
+      };
+      for (const block of parseBlocks(String(html))) {
+        const { size, bold, gap } = blockStyle(block, base, headingScale);
+        this.setFontSize(size);
+        this.activeFontStyle = bold ? "bold" : block.italic ? "italic" : "normal";
+        const lines = this.splitTextToSize(block.text, width);
+        ensureRoom(size * lh, gap);
+        y += gap / sf;
+        const bullet = block.kind === 7 ? "\u2022  " : "";
+        lines.forEach((line, i) => {
+          var _a2;
+          if (y + size / sf > maxBottom && i > 0) {
+            this.addPage();
+            y = topMargin + base * 0.85;
+            (_a2 = options.onNewPage) == null ? void 0 : _a2.call(options, this, {
+              pageNumber: this.pages.length,
+              pageCount: this.pages.length
+            });
+          }
+          const prefix = i === 0 ? bullet : "   ";
+          this.text(prefix + line, x, y);
+          y += size * lh / sf;
+        });
+      }
+      this.setLineHeightFactor(prevLh);
+      return y;
+    }
+  };
+
+  // src/image.ts
+  function jpegSize(u8) {
+    let i = 2;
+    while (i + 9 < u8.length) {
+      if (u8[i] !== 255) {
+        i++;
+        continue;
+      }
+      const marker = u8[i + 1];
+      if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+        const h = u8[i + 5] << 8 | u8[i + 6];
+        const w = u8[i + 7] << 8 | u8[i + 8];
+        return [w, h];
+      }
+      const len = u8[i + 2] << 8 | u8[i + 3];
+      i += 2 + len;
+    }
+    return [null, null];
+  }
+  function sniffImage(u8) {
+    if (u8.length < 8) return null;
+    if (u8[0] === 137 && u8[1] === 80 && u8[2] === 78 && u8[3] === 71) {
+      const w = (u8[16] << 24 | u8[17] << 16 | u8[18] << 8 | u8[19]) >>> 0;
+      const h = (u8[20] << 24 | u8[21] << 16 | u8[22] << 8 | u8[23]) >>> 0;
+      return { format: "PNG", ext: "png", width: w, height: h };
+    }
+    if (u8[0] === 255 && u8[1] === 216 && u8[2] === 255) {
+      const [w, h] = jpegSize(u8);
+      return { format: "JPEG", ext: "jpg", width: w, height: h };
+    }
+    if (u8[0] === 71 && u8[1] === 73 && u8[2] === 70) {
+      return {
+        format: "GIF",
+        ext: "gif",
+        width: u8[6] | u8[7] << 8,
+        height: u8[8] | u8[9] << 8
+      };
+    }
+    if (u8[0] === 66 && u8[1] === 77) {
+      return {
+        format: "BMP",
+        ext: "bmp",
+        width: (u8[18] | u8[19] << 8 | u8[20] << 16 | u8[21] << 24) >>> 0,
+        height: (u8[22] | u8[23] << 8 | u8[24] << 16 | u8[25] << 24) >>> 0
+      };
+    }
+    if (u8[0] === 73 && u8[1] === 73 && u8[2] === 42 || u8[0] === 77 && u8[1] === 77 && u8[2] === 0) {
+      return { format: "TIFF", ext: "tif", width: null, height: null };
+    }
+    return null;
+  }
+
+  // src/modules/images.ts
+  var ImageApi = {
+    /**
+     * Embed an image and place it on the current page.
+     *
+     * Binary data (PNG/JPEG/GIF/BMP/TIFF) is embedded byte-for-byte; data URLs,
+     * bare base64 strings (with `format`), `HTMLImageElement` and
+     * `HTMLCanvasElement` inputs are also accepted.
+     *
+     * When `w`/`h` are omitted the natural size at 72 dpi is used. Identical
+     * data is stored once and referenced multiple times.
+     */
+    addImage(a, b, c, d, e, f, g, h, i) {
+      let format;
+      let px;
+      let py;
+      let pw;
+      let ph;
+      let alias;
+      let rotation;
+      if (typeof b === "object" && b !== null) {
+        const o = b;
+        format = o.format;
+        px = o.x;
+        py = o.y;
+        pw = o.w;
+        ph = o.h;
+        alias = o.alias;
+        rotation = o.rotation || 0;
+      } else if (typeof b === "number") {
+        px = b;
+        py = c;
+        pw = d;
+        ph = e;
+        alias = typeof f === "string" ? f : void 0;
+        rotation = (typeof g === "number" ? g : 0) || (typeof h === "number" ? h : 0);
+      } else {
+        format = b;
+        px = c;
+        py = d;
+        pw = e;
+        ph = f;
+        alias = typeof g === "string" ? g : void 0;
+        rotation = (typeof h === "number" ? h : 0) || (typeof i === "number" ? i : 0);
+      }
+      const imageData = a;
+      let u8 = null;
+      let detectedFormat = format;
+      if (typeof imageData === "string") {
+        if (/^data:/i.test(imageData)) {
+          u8 = b64Decode(imageData);
+          if (!detectedFormat) {
+            const mime = /^data:image\/([a-z0-9]+?)(?:;|$)/i.exec(imageData);
+            if (mime) detectedFormat = mime[1];
+          }
+        } else if (/^[A-Za-z0-9+/=\s]+$/.test(imageData) && imageData.replace(/\s/g, "").length >= 8) {
+          u8 = b64Decode(imageData.replace(/\s/g, ""));
+        } else {
+          throw new Error(
+            "addImage: strings must be data URLs or base64; pass a Uint8Array with an explicit format otherwise"
+          );
+        }
+      } else if (typeof HTMLImageElement !== "undefined" && imageData instanceof HTMLImageElement) {
+        const cv = document.createElement("canvas");
+        cv.width = imageData.naturalWidth || imageData.width || 1;
+        cv.height = imageData.naturalHeight || imageData.height || 1;
+        cv.getContext("2d").drawImage(imageData, 0, 0);
+        u8 = b64Decode(cv.toDataURL("image/png"));
+        detectedFormat = "PNG";
+      } else if (typeof HTMLCanvasElement !== "undefined" && imageData instanceof HTMLCanvasElement) {
+        u8 = b64Decode(imageData.toDataURL("image/png"));
+        detectedFormat = "PNG";
+      } else if (imageData instanceof Uint8Array || imageData instanceof ArrayBuffer) {
+        u8 = u8FromBuffer(imageData);
+      }
+      if (!u8 || !u8.length) throw new Error("addImage: unable to parse image data");
+      const sniff = sniffImage(u8);
+      if (!sniff) {
+        throw new Error("addImage: unsupported image format (PNG/JPEG/GIF/BMP/TIFF)");
+      }
+      if (detectedFormat) {
+        let f2 = String(detectedFormat).toUpperCase();
+        if (f2 === "JPG") f2 = "JPEG";
+        if (f2 === "PNG" || f2 === "JPEG") {
+          sniff.format = f2;
+          sniff.ext = f2 === "JPEG" ? "jpg" : "png";
+        }
+      }
+      const key = alias || `${fnv1a(u8)}-${u8.length}`;
+      let img = this.images[key];
+      if (!img) {
+        img = {
+          alias: key,
+          data: u8,
+          format: sniff.format,
+          ext: sniff.ext,
+          width: sniff.width,
+          height: sniff.height,
+          resId: 0
+        };
+        this.images[key] = img;
+        this.imageList.push(img);
+      }
+      let W;
+      let H;
+      if (pw === void 0 || pw === null || ph === void 0 || ph === null) {
+        if (img.width && img.height) {
+          W = img.width * 0.75;
+          H = img.height * 0.75;
+        } else {
+          throw new Error("addImage: image dimensions unknown; provide w/h explicitly");
+        }
+      } else {
+        W = this._u(Number(pw));
+        H = this._u(Number(ph));
+      }
+      this.pages[this.page].objects.push({
+        t: "image",
+        x: this._u(Number(px)),
+        y: this._u(Number(py)),
+        w: W,
+        h: H,
+        imageRef: img,
+        angle: Number(rotation) || 0,
+        opacity: this.opacity
+      });
+      return this;
+    },
+    /**
+     * Inspect an image without embedding it.
+     *
+     * @returns format, pixel dimensions, byte count and the raw data
+     */
+    getImageProperties(imageData) {
+      let u8;
+      if (typeof imageData === "string") {
+        u8 = b64Decode(imageData);
+      } else if (imageData instanceof Uint8Array || imageData instanceof ArrayBuffer) {
+        u8 = u8FromBuffer(imageData);
+      } else {
+        throw new Error(
+          "getImageProperties: only data URLs, Uint8Array and ArrayBuffer are supported"
+        );
+      }
+      const info = sniffImage(u8);
+      if (!info) throw new Error("getImageProperties: unrecognized image");
+      return {
+        fileType: info.format,
+        width: info.width,
+        height: info.height,
+        bytes: u8.length,
+        data: u8
+      };
+    }
+  };
+
+  // src/modules/shapes.ts
+  var KAPPA = 0.5523;
+  var ShapeApi = {
+    /**
+     * @internal Push a path onto the current page using the active graphics
+     * state. All public shape helpers funnel through this single entry point.
+     */
+    _pushPath(ops, style) {
+      const flags = styleFlags(style);
+      this.pages[this.page].objects.push({
+        t: "path",
+        ops,
+        fill: flags.fill,
+        stroke: flags.stroke,
+        fillColor: this.fillColor.slice(),
+        strokeColor: this.drawColor.slice(),
+        lineWidth: this.lineWidth,
+        dash: this.lineDash ? { pattern: this.lineDash.pattern.slice(), phase: this.lineDash.phase } : null,
+        cap: this.lineCap,
+        join: this.lineJoin,
+        miterLimit: this.miterLimit,
+        opacity: this.opacity
+      });
+      return this;
+    },
+    /** Draw a straight line from `(x1, y1)` to `(x2, y2)`. */
+    line(x1, y1, x2, y2, style) {
+      return this._pushPath(
+        [
+          { op: "M", x: this._u(x1), y: this._u(y1) },
+          { op: "L", x: this._u(x2), y: this._u(y2) }
+        ],
+        style
+      );
+    },
+    /**
+     * Draw a polyline or curve through relative segments (jsPDF `lines`).
+     *
+     * The path starts with `M` at the anchor `(x, y)`. Each segment is a
+     * cumulative delta relative to the current point:
+     * `[dx, dy]` draws a straight line, `[x1, y1, x2, y2, x3, y3]` a cubic
+     * Bézier through three delta points.
+     *
+     * Supports the legacy signature `lines(x, y, lines, scale, style, closed)`.
+     */
+    lines(linesOrX, xOrY, yOrLines, scale1OrStyle, scale2, styleOrClosed, _closedArg) {
+      let segs;
+      let x;
+      let y;
+      let s1 = 1;
+      let s2 = 1;
+      let style;
+      let closed;
+      if (typeof linesOrX === "number") {
+        segs = yOrLines;
+        x = linesOrX;
+        y = Number(xOrY);
+        const sc = scale1OrStyle;
+        if (Array.isArray(sc)) {
+          s1 = Number(sc[0]) || 1;
+          s2 = Number(sc[1]) || 1;
+        } else if (typeof sc === "number") {
+          s1 = sc;
+          s2 = typeof scale2 === "number" ? scale2 : sc;
+        }
+        style = typeof scale2 === "string" ? scale2 : void 0;
+        closed = Boolean(styleOrClosed);
+      } else {
+        segs = linesOrX;
+        x = Number(xOrY);
+        y = Number(yOrLines);
+        const sc = scale1OrStyle;
+        if (Array.isArray(sc)) {
+          s1 = Number(sc[0]) || 1;
+          s2 = Number(sc[1]) || 1;
+        } else {
+          s1 = typeof sc === "number" ? sc : 1;
+          s2 = typeof scale2 === "number" ? scale2 : s1;
+        }
+        style = typeof scale2 === "string" ? scale2 : void 0;
+        closed = Boolean(styleOrClosed);
+      }
+      const cx = this._u(x);
+      const cy = this._u(y);
+      const sf = this.scaleFactor;
+      const ops = [{ op: "M", x: cx, y: cy }];
+      let curX = cx;
+      let curY = cy;
+      for (const seg of segs) {
+        if (seg.length === 2) {
+          curX += seg[0] * sf * s1;
+          curY += seg[1] * sf * s2;
+          ops.push({ op: "L", x: curX, y: curY });
+        } else if (seg.length === 6) {
+          ops.push({
+            op: "C",
+            x1: curX + seg[0] * sf * s1,
+            y1: curY + seg[1] * sf * s2,
+            x2: curX + seg[2] * sf * s1,
+            y2: curY + seg[3] * sf * s2,
+            x: curX + seg[4] * sf * s1,
+            y: curY + seg[5] * sf * s2
+          });
+          curX += seg[4] * sf * s1;
+          curY += seg[5] * sf * s2;
+        }
+      }
+      if (closed) ops.push({ op: "Z" });
+      return this._pushPath(ops, style);
+    },
+    /** Draw a triangle through three vertices. */
+    triangle(x1, y1, x2, y2, x3, y3, style) {
+      return this._pushPath(
+        [
+          { op: "M", x: this._u(x1), y: this._u(y1) },
+          { op: "L", x: this._u(x2), y: this._u(y2) },
+          { op: "L", x: this._u(x3), y: this._u(y3) },
+          { op: "Z" }
+        ],
+        style
+      );
+    },
+    /** Draw a rectangle; `(x, y)` is the top-left corner. */
+    rect(x, y, w, h, style) {
+      const X = this._u(x);
+      const Y = this._u(y);
+      const W = this._u(w);
+      const H = this._u(h);
+      return this._pushPath(
+        [
+          { op: "M", x: X, y: Y },
+          { op: "L", x: X + W, y: Y },
+          { op: "L", x: X + W, y: Y + H },
+          { op: "L", x: X, y: Y + H },
+          { op: "Z" }
+        ],
+        style
+      );
+    },
+    /**
+     * Draw a rounded rectangle; `(x, y)` is the top-left corner.
+     *
+     * `ry` defaults to `rx`. Corners are quarter circles approximated with
+     * cubic Béziers (κ = 0.5523).
+     */
+    roundedRect(x, y, w, h, rx, ry, style) {
+      const X = this._u(x);
+      const Y = this._u(y);
+      const W = this._u(w);
+      const H = this._u(h);
+      const RX = Math.min(this._u(rx), W / 2);
+      const RY = Math.min(ry === void 0 ? this._u(rx) : this._u(ry), H / 2);
+      const k = KAPPA;
+      return this._pushPath(
+        [
+          { op: "M", x: X + RX, y: Y },
+          { op: "L", x: X + W - RX, y: Y },
+          {
+            op: "C",
+            x1: X + W - RX + RX * k,
+            y1: Y,
+            x2: X + W,
+            y2: Y + RY - RY * k,
+            x: X + W,
+            y: Y + RY
+          },
+          { op: "L", x: X + W, y: Y + H - RY },
+          {
+            op: "C",
+            x1: X + W,
+            y1: Y + H - RY + RY * k,
+            x2: X + W - RX + RX * k,
+            y2: Y + H,
+            x: X + W - RX,
+            y: Y + H
+          },
+          { op: "L", x: X + RX, y: Y + H },
+          {
+            op: "C",
+            x1: X + RX - RX * k,
+            y1: Y + H,
+            x2: X,
+            y2: Y + H - RY + RY * k,
+            x: X,
+            y: Y + H - RY
+          },
+          { op: "L", x: X, y: Y + RY },
+          {
+            op: "C",
+            x1: X,
+            y1: Y + RY - RY * k,
+            x2: X + RX - RX * k,
+            y2: Y,
+            x: X + RX,
+            y: Y
+          },
+          { op: "Z" }
+        ],
+        style
+      );
+    },
+    /** Draw an ellipse centered at `(x, y)`. */
+    ellipse(x, y, rx, ry, style) {
+      const cx = this._u(x);
+      const cy = this._u(y);
+      const RX = this._u(rx);
+      const RY = this._u(ry);
+      const k = KAPPA;
+      return this._pushPath(
+        [
+          { op: "M", x: cx - RX, y: cy },
+          {
+            op: "C",
+            x1: cx - RX,
+            y1: cy - RY * k,
+            x2: cx - RX * k,
+            y2: cy - RY,
+            x: cx,
+            y: cy - RY
+          },
+          {
+            op: "C",
+            x1: cx + RX * k,
+            y1: cy - RY,
+            x2: cx + RX,
+            y2: cy - RY * k,
+            x: cx + RX,
+            y: cy
+          },
+          {
+            op: "C",
+            x1: cx + RX,
+            y1: cy + RY * k,
+            x2: cx + RX * k,
+            y2: cy + RY,
+            x: cx,
+            y: cy + RY
+          },
+          {
+            op: "C",
+            x1: cx - RX * k,
+            y1: cy + RY,
+            x2: cx - RX,
+            y2: cy + RY * k,
+            x: cx - RX,
+            y: cy
+          },
+          { op: "Z" }
+        ],
+        style
+      );
+    },
+    /** Draw a circle centered at `(x, y)` with radius `r`. */
+    circle(x, y, r, style) {
+      return this.ellipse(x, y, r, r, style);
+    }
+  };
+
+  // src/font-parse.ts
+  function readTables(dv, base) {
+    const numTables = dv.getUint16(base + 4);
+    const tables = [];
+    for (let i = 0; i < numTables; i++) {
+      const at = base + 12 + i * 16;
+      tables.push({
+        tag: String.fromCharCode(
+          dv.getUint8(at),
+          dv.getUint8(at + 1),
+          dv.getUint8(at + 2),
+          dv.getUint8(at + 3)
+        ),
+        offset: base + dv.getUint32(at + 8),
+        length: dv.getUint32(at + 12)
+      });
+    }
+    return tables;
+  }
+  function parseCmap(dv, table) {
+    const map = /* @__PURE__ */ new Map();
+    const base = table.offset;
+    const numTables = dv.getUint16(base + 2);
+    for (let i = 0; i < numTables; i++) {
+      const subAt = base + 4 + i * 8;
+      const platform = dv.getUint16(subAt);
+      const encoding = dv.getUint16(subAt + 2);
+      const offset = base + dv.getUint32(subAt + 4);
+      const format = dv.getUint16(offset);
+      const interesting = platform === 0 || platform === 3 && (encoding === 1 || encoding === 10);
+      if (!interesting) continue;
+      if (format === 4) {
+        parseCmap4(dv, offset, map);
+      } else if (format === 12) {
+        parseCmap12(dv, offset, map);
+      }
+    }
+    return map;
+  }
+  function parseCmap4(dv, offset, map) {
+    const segCountX2 = dv.getUint16(offset + 6);
+    const segCount = segCountX2 / 2;
+    const endAt = offset + 14;
+    const startAt = endAt + segCountX2 + 2;
+    const deltaAt = startAt + segCountX2;
+    const rangeAt = deltaAt + segCountX2;
+    for (let s = 0; s < segCount; s++) {
+      const end = dv.getUint16(endAt + s * 2);
+      const start = dv.getUint16(startAt + s * 2);
+      const delta = dv.getInt16(deltaAt + s * 2);
+      const rangeOffsetPos = rangeAt + s * 2;
+      const rangeOffset = dv.getUint16(rangeOffsetPos);
+      if (start === 65535) continue;
+      for (let c = start; c <= end && c - start < 1024; c++) {
+        let gid;
+        if (rangeOffset === 0) {
+          gid = c + delta & 65535;
+        } else {
+          const glyphAt = rangeOffsetPos + rangeOffset + (c - start) * 2;
+          if (glyphAt + 1 >= dv.byteLength) continue;
+          gid = dv.getUint16(glyphAt);
+          if (gid !== 0) gid = gid + delta & 65535;
+        }
+        if (gid !== 0 && !map.has(c)) map.set(c, gid);
+      }
+    }
+  }
+  function parseCmap12(dv, offset, map) {
+    const nGroups = dv.getUint32(offset + 12);
+    for (let g = 0; g < nGroups; g++) {
+      const at = offset + 16 + g * 12;
+      const start = dv.getUint32(at);
+      const end = dv.getUint32(at + 4);
+      const startGid = dv.getUint32(at + 8);
+      for (let c = start; c <= end && c - start < 65536; c++) {
+        if (!map.has(c)) map.set(c, startGid + (c - start));
+      }
+    }
+  }
+  function parseFont2(data) {
+    try {
+      const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+      const tag = String.fromCharCode(dv.getUint8(0), dv.getUint8(1), dv.getUint8(2), dv.getUint8(3));
+      const version2 = dv.getUint32(0);
+      let base = 0;
+      if (tag === "ttcf")
+        base = dv.getUint32(12);
+      else if (version2 !== 65536 && tag !== "OTTO" && tag !== "true") return null;
+      const tables = readTables(dv, base);
+      const byTag = (t) => tables.find((x) => x.tag === t);
+      const head = byTag("head");
+      const hhea = byTag("hhea");
+      const hmtx = byTag("hmtx");
+      const cmap = byTag("cmap");
+      if (!head || !hhea || !hmtx || !cmap) return null;
+      const unitsPerEm = dv.getUint16(head.offset + 18);
+      let ascent = dv.getInt16(hhea.offset + 4);
+      let descent = dv.getInt16(hhea.offset + 6);
+      const os2 = byTag("OS/2");
+      if (os2) {
+        const winAscent = dv.getUint16(os2.offset + 74);
+        const winDescent = dv.getUint16(os2.offset + 76);
+        ascent = Math.max(ascent, winAscent);
+        descent = Math.min(descent, -winDescent);
+      }
+      const numHMetrics = dv.getUint16(hhea.offset + 34);
+      const advanceOf = (gid) => {
+        const i = Math.min(gid, numHMetrics - 1);
+        return dv.getUint16(hmtx.offset + i * 4);
+      };
+      const glyphMap = parseCmap(dv, cmap);
+      const widths = /* @__PURE__ */ new Map();
+      for (const [code, gid] of glyphMap) {
+        widths.set(code, advanceOf(gid));
+      }
+      return { unitsPerEm, ascent, descent, widths, glyphs: glyphMap };
+    } catch (e) {
+      return null;
+    }
+  }
+
+  // src/metrics.ts
+  var W_HELV = [
+    278,
+    278,
+    355,
+    556,
+    556,
+    889,
+    667,
+    191,
+    333,
+    333,
+    389,
+    584,
+    278,
+    333,
+    278,
+    278,
+    556,
+    556,
+    556,
+    556,
+    556,
+    556,
+    556,
+    556,
+    556,
+    556,
+    278,
+    278,
+    584,
+    584,
+    584,
+    556,
+    1015,
+    667,
+    667,
+    722,
+    722,
+    667,
+    611,
+    778,
+    722,
+    278,
+    500,
+    667,
+    556,
+    833,
+    722,
+    778,
+    667,
+    778,
+    722,
+    667,
+    611,
+    722,
+    667,
+    944,
+    667,
+    667,
+    611,
+    278,
+    278,
+    278,
+    469,
+    556,
+    333,
+    556,
+    556,
+    500,
+    556,
+    556,
+    278,
+    556,
+    556,
+    222,
+    222,
+    500,
+    222,
+    833,
+    556,
+    556,
+    556,
+    556,
+    333,
+    500,
+    278,
+    556,
+    500,
+    722,
+    500,
+    500,
+    500,
+    334,
+    260,
+    334,
+    584
+  ];
+  var W_HELV_BOLD = [
+    278,
+    333,
+    474,
+    556,
+    556,
+    889,
+    722,
+    238,
+    333,
+    333,
+    389,
+    584,
+    278,
+    333,
+    278,
+    278,
+    556,
+    556,
+    556,
+    556,
+    556,
+    556,
+    556,
+    556,
+    556,
+    556,
+    333,
+    333,
+    584,
+    584,
+    584,
+    611,
+    975,
+    722,
+    722,
+    722,
+    722,
+    667,
+    611,
+    778,
+    722,
+    278,
+    556,
+    722,
+    611,
+    833,
+    722,
+    778,
+    667,
+    778,
+    722,
+    667,
+    611,
+    722,
+    667,
+    944,
+    667,
+    667,
+    611,
+    333,
+    278,
+    333,
+    584,
+    556,
+    333,
+    556,
+    611,
+    556,
+    611,
+    556,
+    333,
+    611,
+    611,
+    278,
+    278,
+    556,
+    278,
+    889,
+    611,
+    611,
+    611,
+    611,
+    389,
+    556,
+    333,
+    611,
+    556,
+    778,
+    556,
+    556,
+    500,
+    389,
+    280,
+    389,
+    584
+  ];
+  var W_TIMES = [
+    250,
+    333,
+    408,
+    500,
+    500,
+    833,
+    778,
+    180,
+    333,
+    333,
+    500,
+    564,
+    250,
+    333,
+    250,
+    278,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    278,
+    278,
+    564,
+    564,
+    564,
+    444,
+    921,
+    722,
+    667,
+    667,
+    722,
+    611,
+    556,
+    722,
+    722,
+    333,
+    389,
+    722,
+    611,
+    889,
+    722,
+    722,
+    556,
+    722,
+    667,
+    556,
+    611,
+    722,
+    722,
+    944,
+    722,
+    722,
+    611,
+    333,
+    278,
+    333,
+    469,
+    500,
+    333,
+    444,
+    500,
+    444,
+    500,
+    444,
+    333,
+    500,
+    500,
+    278,
+    278,
+    500,
+    278,
+    778,
+    500,
+    500,
+    500,
+    500,
+    333,
+    389,
+    278,
+    500,
+    500,
+    722,
+    500,
+    500,
+    444,
+    480,
+    200,
+    480,
+    541
+  ];
+  var W_TIMES_BOLD = [
+    250,
+    333,
+    555,
+    500,
+    500,
+    1e3,
+    833,
+    278,
+    333,
+    333,
+    500,
+    564,
+    250,
+    333,
+    250,
+    278,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    333,
+    333,
+    564,
+    564,
+    564,
+    500,
+    975,
+    722,
+    722,
+    722,
+    722,
+    667,
+    611,
+    778,
+    722,
+    278,
+    556,
+    722,
+    611,
+    833,
+    722,
+    778,
+    667,
+    778,
+    722,
+    667,
+    611,
+    722,
+    667,
+    944,
+    667,
+    667,
+    611,
+    333,
+    278,
+    333,
+    584,
+    556,
+    333,
+    500,
+    556,
+    444,
+    556,
+    556,
+    333,
+    500,
+    556,
+    278,
+    333,
+    556,
+    278,
+    833,
+    556,
+    556,
+    556,
+    556,
+    444,
+    389,
+    333,
+    556,
+    500,
+    722,
+    500,
+    500,
+    444,
+    394,
+    220,
+    394,
+    520
+  ];
+  var W_TIMES_ITALIC = [
+    250,
+    333,
+    420,
+    500,
+    500,
+    833,
+    778,
+    214,
+    333,
+    333,
+    500,
+    675,
+    250,
+    333,
+    250,
+    278,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    333,
+    333,
+    675,
+    675,
+    675,
+    500,
+    920,
+    611,
+    611,
+    667,
+    722,
+    611,
+    611,
+    722,
+    722,
+    333,
+    444,
+    667,
+    556,
+    833,
+    667,
+    722,
+    611,
+    722,
+    611,
+    500,
+    556,
+    722,
+    611,
+    833,
+    611,
+    556,
+    556,
+    389,
+    278,
+    389,
+    422,
+    500,
+    333,
+    500,
+    500,
+    444,
+    500,
+    444,
+    278,
+    500,
+    500,
+    278,
+    278,
+    444,
+    278,
+    722,
+    500,
+    500,
+    500,
+    500,
+    389,
+    389,
+    278,
+    500,
+    444,
+    667,
+    444,
+    444,
+    389,
+    400,
+    275,
+    400,
+    541
+  ];
+  var W_TIMES_BI = [
+    250,
+    389,
+    555,
+    500,
+    500,
+    833,
+    778,
+    278,
+    333,
+    333,
+    500,
+    570,
+    250,
+    333,
+    250,
+    278,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    500,
+    333,
+    333,
+    570,
+    570,
+    570,
+    500,
+    832,
+    667,
+    667,
+    667,
+    722,
+    611,
+    611,
+    778,
+    722,
+    278,
+    500,
+    667,
+    556,
+    833,
+    722,
+    778,
+    667,
+    778,
+    722,
+    667,
+    667,
+    722,
+    667,
+    1e3,
+    667,
+    667,
+    667,
+    333,
+    278,
+    333,
+    584,
+    556,
+    333,
+    500,
+    500,
+    444,
+    500,
+    444,
+    333,
+    500,
+    556,
+    278,
+    278,
+    500,
+    278,
+    778,
+    556,
+    500,
+    500,
+    500,
+    389,
+    389,
+    278,
+    556,
+    444,
+    667,
+    500,
+    444,
+    389,
+    348,
+    220,
+    348,
+    570
+  ];
+  var CJK_FONT_DEF = {
+    serif: true,
+    fixed: false,
+    cjk: true,
+    ascent: 880,
+    descent: -120,
+    widths: null
+  };
+  var BUILTIN_FONTS = {
+    helvetica: {
+      familyName: "Helvetica",
+      displayName: "Helvetica",
+      serif: false,
+      fixed: false,
+      cjk: false,
+      ascent: 718,
+      descent: -207,
+      widths: {
+        normal: W_HELV,
+        bold: W_HELV_BOLD,
+        italic: W_HELV,
+        bolditalic: W_HELV_BOLD
+      }
+    },
+    times: {
+      familyName: "Times New Roman",
+      displayName: "Times New Roman",
+      serif: true,
+      fixed: false,
+      cjk: false,
+      ascent: 683,
+      descent: -217,
+      widths: {
+        normal: W_TIMES,
+        bold: W_TIMES_BOLD,
+        italic: W_TIMES_ITALIC,
+        bolditalic: W_TIMES_BI
+      }
+    },
+    courier: {
+      familyName: "Courier New",
+      displayName: "Courier New",
+      serif: false,
+      fixed: true,
+      cjk: false,
+      ascent: 629,
+      descent: -157,
+      widths: null
+      // monospace 600
+    },
+    simsun: { familyName: "SimSun", displayName: "\u5B8B\u4F53", ...CJK_FONT_DEF },
+    simhei: {
+      familyName: "SimHei",
+      displayName: "\u9ED1\u4F53",
+      serif: false,
+      cjk: true,
+      fixed: false,
+      ascent: 880,
+      descent: -120,
+      widths: null
+    },
+    kaiti: { familyName: "KaiTi", displayName: "\u6977\u4F53", ...CJK_FONT_DEF },
+    fangsong: { familyName: "FangSong", displayName: "\u4EFF\u5B8B", ...CJK_FONT_DEF }
+  };
+  var FONT_ALIASES = {
+    arial: "helvetica",
+    "arial unicode ms": "helvetica",
+    helvetica: "helvetica",
+    "helvetica-bold": "helvetica",
+    times: "times",
+    "times new roman": "times",
+    "times-roman": "times",
+    roman: "times",
+    courier: "courier",
+    "courier new": "courier",
+    "courier-new": "courier",
+    simsun: "simsun",
+    sbsimsun: "simsun",
+    \u5B8B\u4F53: "simsun",
+    songti: "simsun",
+    "song ti": "simsun",
+    simhei: "simhei",
+    \u9ED1\u4F53: "simhei",
+    hei: "simhei",
+    kaiti: "kaiti",
+    \u6977\u4F53: "kaiti",
+    kai: "kaiti",
+    fangsong: "fangsong",
+    \u4EFF\u5B8B: "fangsong",
+    fang: "fangsong"
+  };
+  var STYLE_ALIASES = {
+    normal: "normal",
+    regular: "normal",
+    "": "normal",
+    bold: "bold",
+    b: "bold",
+    italic: "italic",
+    i: "italic",
+    oblique: "italic",
+    bolditalic: "bolditalic",
+    bi: "bolditalic",
+    boldoblique: "bolditalic",
+    "bold italic": "bolditalic"
+  };
+  function normalizeStyle(style) {
+    return STYLE_ALIASES[String(style || "").toLowerCase()] || "normal";
+  }
+  function resolveFontKey(name, customFonts) {
+    const k = String(name || "").toLowerCase().trim();
+    if (FONT_ALIASES[k]) return FONT_ALIASES[k];
+    if (BUILTIN_FONTS[k]) return k;
+    if (customFonts[k]) return k;
+    return null;
+  }
+  function isCJKCode(cp) {
+    return cp >= 11904 && cp <= 40959 || // CJK radicals / Han
+    cp >= 12288 && cp <= 12351 || // CJK punctuation
+    cp >= 65280 && cp <= 65519 || // fullwidth forms
+    cp >= 13312 && cp <= 19903 || // Extension A
+    cp >= 63744 && cp <= 64255 || // compatibility ideographs
+    cp >= 131072 && cp <= 196607;
+  }
+  function hasCJK(text) {
+    for (let i = 0; i < text.length; i++) {
+      if (isCJKCode(text.charCodeAt(i))) return true;
+    }
+    return false;
+  }
+  function glyphWidth(font, style, ch) {
+    const cp = ch.charCodeAt(0);
+    if (font.unicodeWidths) {
+      const w = font.unicodeWidths.get(cp);
+      if (w !== void 0) return w;
+      if (font.cjk && isCJKCode(cp)) return 1e3;
+    }
+    if (font.cjk) {
+      return isCJKCode(cp) ? 1e3 : 500;
+    }
+    if (!font.widths) return 600;
+    const table = font.widths[style] || font.widths.normal;
+    if (!table) return 556;
+    if (cp >= 32 && cp <= 126) return table[cp - 32];
+    if (cp === 160) return 278;
+    if (cp < 8192) return 556;
+    return 500;
+  }
+
+  // src/modules/state.ts
+  var StateApi = {
+    /** Resolve a font key to its definition (custom → builtin → Helvetica). */
+    getFontDef(key) {
+      return this.customFonts[key] || BUILTIN_FONTS[key] || BUILTIN_FONTS.helvetica;
+    },
+    /**
+     * Register a custom font.
+     *
+     * Fonts are referenced by `FontName` and resolved by the reader's local
+     * font table — no font file is embedded.
+     *
+     * @param postScriptName unique registry key
+     * @param fontName       family name written to the OFD font declaration
+     * @param fontStyle      `normal` / `bold` / `italic` / `bolditalic`
+     * @param opts           metrics (ascent/descent/widths) and aliases
+     */
+    addFont(postScriptName, fontName, fontStyle, opts = {}) {
+      var _a, _b;
+      normalizeStyle(fontStyle);
+      const key = String(postScriptName).toLowerCase();
+      this.customFonts[key] = {
+        familyName: fontName || postScriptName,
+        displayName: opts.familyName || fontName || postScriptName,
+        serif: !!opts.serif,
+        fixed: !!opts.fixed,
+        cjk: !!opts.cjk || hasCJK(String(fontName || "")),
+        ascent: (_a = opts.ascent) != null ? _a : 800,
+        descent: (_b = opts.descent) != null ? _b : -200,
+        widths: opts.widths || null
+      };
+      if (opts.alias) {
+        FONT_ALIASES[String(opts.alias).toLowerCase()] = key;
+      }
+      return key;
+    },
+    /**
+     * Register a font with an embedded file (recommended for CJK documents).
+     *
+     * Parses the font for exact metrics (units per em, ascent/descent, per-glyph
+     * advance widths via cmap/hmtx) and writes the bytes into the OFD package as
+     * `FontFile`. Embedded fonts render identically in every reader — unembedded
+     * fonts depend on the reader's local font table and may show garbage glyphs.
+     *
+     * Registering a key that matches a built-in (`'simsun'`, `'simhei'`, ...)
+     * overrides it, so existing code keeps working while gaining embedding.
+     *
+     * @param postScriptName registry key, e.g. `'simsun'` or `'MyFont'`
+     * @param fontName       family name written to the OFD font declaration
+     * @param ttfData        TTF/OTF (or TTC) file bytes
+     */
+    addFontTtf(postScriptName, fontName, ttfData, opts = {}) {
+      var _a, _b, _c;
+      const parsed = parseFont2(ttfData);
+      const key = String(postScriptName).toLowerCase();
+      const scale = (v) => Math.round(v / ((parsed == null ? void 0 : parsed.unitsPerEm) || 1e3) * 1e3);
+      const ext = opts.fontExt || "ttf";
+      const def = {
+        familyName: fontName || postScriptName,
+        displayName: opts.familyName || fontName || postScriptName,
+        serif: !!opts.serif,
+        fixed: !!opts.fixed,
+        cjk: (_a = opts.cjk) != null ? _a : true,
+        // embedded fonts are assumed to cover the glyphs they map
+        ascent: (_b = opts.ascent) != null ? _b : parsed ? scale(parsed.ascent) : 800,
+        descent: (_c = opts.descent) != null ? _c : parsed ? scale(parsed.descent) : -200,
+        widths: opts.widths || null,
+        unicodeWidths: (parsed == null ? void 0 : parsed.widths) ? new Map([...parsed.widths].map(([cp, w]) => [cp, scale(w)])) : void 0,
+        fontFile: { data: ttfData, ext }
+      };
+      this.customFonts[key] = def;
+      if (opts.alias) {
+        FONT_ALIASES[String(opts.alias).toLowerCase()] = key;
+      }
+      return key;
+    },
+    /**
+     * Select the active font.
+     *
+     * Accepts PostScript names (`Helvetica-Bold`), family names (`helvetica`,
+     * `times`), common Chinese names (`宋体`, `黑体`, `楷体`, `仿宋`) and any
+     * previously registered custom key or alias.
+     */
+    setFont(fontName, fontStyle) {
+      if (fontStyle !== void 0) {
+        this.activeFontStyle = normalizeStyle(fontStyle);
+      }
+      const key = resolveFontKey(fontName, this.customFonts) || String(fontName).toLowerCase();
+      if (!this.customFonts[key] && !BUILTIN_FONTS[key]) {
+        this.addFont(fontName, fontName, this.activeFontStyle);
+      }
+      this.activeFontKey = key;
+      return this;
+    },
+    /** Set the font size in points (independent of the document unit, like jsPDF). */
+    setFontSize(size) {
+      this.fontSize = Number(size);
+      return this;
+    },
+    /** Active font size in points (default 16, like jsPDF). */
+    getFontSize() {
+      return this.fontSize;
+    },
+    /** Set extra spacing between glyphs, in the active unit. */
+    setCharSpace(space) {
+      this.charSpace = Number(space) * this.scaleFactor;
+      return this;
+    },
+    /** Active character spacing in the active unit. */
+    getCharSpace() {
+      return this.charSpace / this.scaleFactor;
+    },
+    /** Set the line height factor (default 1.15, like jsPDF). */
+    setLineHeightFactor(f) {
+      this.lineHeightFactor = Number(f) || 1.15;
+      return this;
+    },
+    /** Registered font keys, built-in first. */
+    getFontList() {
+      const list = Object.keys(BUILTIN_FONTS);
+      for (const k of Object.keys(this.customFonts)) {
+        list.push(this.customFonts[k].familyName);
+      }
+      return list;
+    },
+    /** Information about the active font (jsPDF `getFont()`). */
+    getFont() {
+      return {
+        fontName: this.getFontDef(this.activeFontKey).familyName,
+        fontStyle: this.activeFontStyle,
+        key: this.activeFontKey
+      };
+    },
+    /** Set the text fill color (`r` may also be a color name or hex string). */
+    setTextColor(r, g, b) {
+      this.textColor = parseColor([r, g, b]);
+      return this;
+    },
+    /** Active text color as `#rrggbb` (jsPDF getter semantics). */
+    getTextColor() {
+      return rgbToHex(this.textColor);
+    },
+    /** Set the stroke color used by shape outlines. */
+    setDrawColor(r, g, b) {
+      this.drawColor = parseColor([r, g, b]);
+      return this;
+    },
+    /** Active stroke color as `#rrggbb`. */
+    getDrawColor() {
+      return rgbToHex(this.drawColor);
+    },
+    /** Set the fill color used by filled shapes. */
+    setFillColor(r, g, b) {
+      this.fillColor = parseColor([r, g, b]);
+      return this;
+    },
+    /** Active fill color as `#rrggbb`. */
+    getFillColor() {
+      return rgbToHex(this.fillColor);
+    },
+    /** Set the stroke width in the active unit. */
+    setLineWidth(width) {
+      this.lineWidth = Number(width) * this.scaleFactor;
+      return this;
+    },
+    /** Active stroke width in the active unit. */
+    getLineWidth() {
+      return this.lineWidth / this.scaleFactor;
+    },
+    /** Set the dash pattern (active unit); an empty array clears dashing. */
+    setLineDashPattern(dashArray, dashPhase) {
+      const sf = this.scaleFactor;
+      this.lineDash = {
+        pattern: (dashArray || []).map((v) => Number(v) * sf),
+        phase: (Number(dashPhase) || 0) * sf
+      };
+      return this;
+    },
+    /** Active dash pattern in the active unit. */
+    getLineDashPattern() {
+      return this.lineDash ? this.lineDash.pattern.map((v) => v / this.scaleFactor) : [];
+    },
+    /** Set the line cap: 0 butt, 1 round, 2 square (names accepted). */
+    setLineCap(style) {
+      if (typeof style === "number") this.lineCap = style;
+      else this.lineCap = style === "round" ? 1 : style === "square" ? 2 : 0;
+      return this;
+    },
+    /** Active line cap (0-2). */
+    getLineCap() {
+      return this.lineCap;
+    },
+    /** Set the line join: 0 miter, 1 round, 2 bevel (names accepted). */
+    setLineJoin(style) {
+      if (typeof style === "number") this.lineJoin = style;
+      else this.lineJoin = style === "round" ? 1 : style === "bevel" ? 2 : 0;
+      return this;
+    },
+    /** Active line join (0-2). */
+    getLineJoin() {
+      return this.lineJoin;
+    },
+    /** Set the miter limit (active unit); values ≤ 1 omit the attribute. */
+    setLineMiterLimit(limit) {
+      if (typeof limit !== "number" || isNaN(limit)) {
+        throw new Error("Invalid argument passed to jsOFD.setLineMiterLimit");
+      }
+      this.miterLimit = limit * this.scaleFactor;
+      return this;
+    },
+    /** Active miter limit in the active unit. */
+    getLineMiterLimit() {
+      return this.miterLimit / this.scaleFactor;
+    },
+    /** Line height in points: font size × line height factor. */
+    getLineHeight() {
+      return this.fontSize * this.lineHeightFactor;
+    },
+    /** Enable or disable right-to-left rendering. */
+    setR2L(value) {
+      this.r2l = Boolean(value);
+      return this;
+    },
+    /** Whether right-to-left rendering is active. */
+    getR2L() {
+      return this.r2l;
+    },
+    /**
+     * Apply a graphics state.
+     *
+     * Only `opacity` is supported; other GState keys are ignored (OFD models
+     * blend modes differently from PDF).
+     */
+    setGState(gs) {
+      if (gs && typeof gs.opacity === "number") {
+        this.opacity = Math.max(0, Math.min(1, gs.opacity));
+      }
+      return this;
+    },
+    /** Set the rendering opacity for subsequent objects (0-1). */
+    setOpacity(opacity) {
+      this.opacity = Math.max(0, Math.min(1, Number(opacity)));
+      return this;
+    }
+  };
+
+  // src/modules/svg.ts
+  async function svgToPng(svg, widthPx, heightPx, scale, background) {
+    const blob = new Blob([svg], { type: "image/svg+xml;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    try {
+      const img = new Image();
+      img.decoding = "sync";
+      await new Promise((resolve, reject) => {
+        img.onload = () => resolve();
+        img.onerror = () => reject(new Error("svg(): failed to parse the SVG markup"));
+        img.src = url;
+      });
+      const canvas = document.createElement("canvas");
+      canvas.width = Math.max(1, Math.round(widthPx * scale));
+      canvas.height = Math.max(1, Math.round(heightPx * scale));
+      const g = canvas.getContext("2d");
+      if (background) {
+        g.fillStyle = background;
+        g.fillRect(0, 0, canvas.width, canvas.height);
+      }
+      g.drawImage(img, 0, 0, canvas.width, canvas.height);
+      const blob2 = await new Promise((res) => canvas.toBlob(res, "image/png"));
+      if (!blob2) throw new Error("svg(): canvas.toBlob returned null");
+      return new Uint8Array(await blob2.arrayBuffer());
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+  }
+  function intrinsicSize(svg) {
+    const root = /<svg\b([^>]*)>/i.exec(svg);
+    if (!root) return null;
+    const attrs = root[1];
+    const num = (re) => {
+      const m = re.exec(attrs);
+      return m ? parseFloat(m[1]) : null;
+    };
+    let w = num(/\bwidth\s*=\s*["']([\d.]+)/i);
+    let h = num(/\bheight\s*=\s*["']([\d.]+)/i);
+    const vb = /\bviewBox\s*=\s*["']\s*[\d.-]+\s+[\d.-]+\s+([\d.-]+)\s+([\d.-]+)/i.exec(attrs);
+    if (vb) {
+      if (!w) w = parseFloat(vb[1]);
+      if (!h) h = parseFloat(vb[2]);
+    }
+    return w && h ? { w, h } : null;
+  }
+  var SvgApi = {
+    /**
+     * Rasterize an SVG markup string and embed it as a PNG image.
+     *
+     * Browser only (uses `Image` + canvas). The SVG is rendered at `scale`
+     * (default 2×) for crisp output. Use `addImage` when you already have
+     * raster bytes.
+     */
+    async svg(svgMarkup, options) {
+      var _a, _b, _c, _d;
+      if (typeof document === "undefined" || typeof Image === "undefined") {
+        throw new Error(
+          "svg() requires a browser (Image + canvas). In Node, rasterize first and pass bytes to addImage()."
+        );
+      }
+      const size = (_a = intrinsicSize(svgMarkup)) != null ? _a : { w: 300, h: 150 };
+      const wPx = options.w !== void 0 ? options.w * this.scaleFactor : size.w;
+      const hPx = options.h !== void 0 ? options.h * this.scaleFactor : wPx * size.h / size.w;
+      const png = await svgToPng(svgMarkup, wPx, hPx, (_b = options.scale) != null ? _b : 2, options.background);
+      const wU = (_c = options.w) != null ? _c : wPx / this.scaleFactor;
+      const hU = (_d = options.h) != null ? _d : hPx / this.scaleFactor;
+      this.addImage(png, {
+        x: options.x,
+        y: options.y,
+        w: wU,
+        h: hU,
+        format: "PNG",
+        rotation: options.rotation,
+        opacity: options.opacity
+      });
+    }
+  };
+
+  // src/modules/table.ts
+  var TableApi = {
+    /**
+     * Render a table at `(x, y)` and return the bottom Y (active unit).
+     *
+     * Column widths: explicit `width`, otherwise the remaining page width is
+     * shared equally. With `autoPage` (default) rows that would cross the
+     * bottom margin continue on a fresh page under a repeated header.
+     */
+    table(x, y, options) {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+      const st = options.style || {};
+      const cols = options.columns;
+      const sf = this.scaleFactor;
+      const xU = this._u(x);
+      const yU = this._u(y);
+      const padPt = this._u((_a = st.cellPadding) != null ? _a : 2);
+      const bodySize = (_b = st.fontSize) != null ? _b : this.fontSize;
+      const headSize = (_c = st.headFontSize) != null ? _c : bodySize;
+      const autoPage = options.autoPage !== false;
+      const marginU = (_d = options.bottomMargin) != null ? _d : 20;
+      const hasHeader = cols.some((c) => c.header !== void 0);
+      const zebra = (_e = st.zebra) != null ? _e : null;
+      const gridColor = st.borderColor === null ? null : (_f = st.borderColor) != null ? _f : [191, 197, 205];
+      const gridW = this._u((_g = st.lineWidth) != null ? _g : 0.2);
+      const pageW = this.pages[this.page].width;
+      const widths = cols.map((c) => c.width !== void 0 ? this._u(c.width) : null);
+      const used = widths.reduce((s, w) => s + (w != null ? w : 0), 0);
+      const flexCount = widths.filter((w) => w === null).length;
+      const flexW = flexCount ? Math.max((pageW - xU - used) / flexCount, 20) : 0;
+      const W = widths.map((w) => w != null ? w : flexW);
+      const totalW = W.reduce((s, w) => s + w, 0);
+      const save = {
+        fontSize: this.fontSize,
+        fill: this.fillColor.slice(),
+        draw: this.drawColor.slice(),
+        text: this.textColor.slice(),
+        lineW: this.lineWidth,
+        fontKey: this.activeFontKey,
+        fontSt: this.activeFontStyle
+      };
+      const restore = () => {
+        this.fontSize = save.fontSize;
+        this.fillColor = save.fill;
+        this.drawColor = save.draw;
+        this.textColor = save.text;
+        this.lineWidth = save.lineW;
+        this.activeFontKey = save.fontKey;
+        this.activeFontStyle = save.fontSt;
+      };
+      const cellLines = (text, wPt, size, bold) => {
+        this.fontSize = size;
+        this.activeFontStyle = bold ? "bold" : "normal";
+        return this._splitCore(
+          text,
+          wPt - padPt * 2,
+          this.getFontDef(this.activeFontKey),
+          this.activeFontStyle
+        );
+      };
+      const rowHeight = (row) => {
+        if (st.rowHeight !== void 0) return this._u(st.rowHeight);
+        let lines = 1;
+        row.forEach((cell, ci) => {
+          var _a2;
+          const spec = typeof cell === "string" ? { text: cell } : cell;
+          const span = Math.max(1, (_a2 = spec.colSpan) != null ? _a2 : 1);
+          const wPt = W.slice(ci, ci + span).reduce((s, ww) => s + ww, 0);
+          lines = Math.max(lines, cellLines(spec.text, wPt, bodySize, !!spec.bold).length);
+        });
+        return padPt * 2 + lines * bodySize * this.lineHeightFactor;
+      };
+      const drawCellText = (cell, cxPt, cyPt, wPt, hPt, header, align, fill) => {
+        var _a2, _b2;
+        const spec = typeof cell === "string" ? { text: cell } : cell;
+        const size = header ? headSize : bodySize;
+        const bold = header || !!spec.bold;
+        if (fill) {
+          this.fillColor = fill;
+          this.rect(cxPt / sf, cyPt / sf, wPt / sf, hPt / sf, "F");
+        }
+        this.fontSize = size;
+        this.activeFontStyle = bold ? "bold" : "normal";
+        this.textColor = header ? (_a2 = st.headColor) != null ? _a2 : [255, 255, 255] : (_b2 = st.textColor) != null ? _b2 : save.text;
+        const def = this.getFontDef(this.activeFontKey);
+        const lines = cellLines(spec.text, wPt, size, bold);
+        const ascPt = def.ascent / 1e3 * size;
+        let ty = cyPt + padPt + ascPt;
+        for (const line of lines) {
+          const w = this.measure(line, def, this.activeFontStyle, size, 0);
+          let tx = cxPt + padPt;
+          if (align === "center") tx = cxPt + (wPt - w) / 2;
+          else if (align === "right") tx = cxPt + wPt - padPt - w;
+          this.text(line, tx / sf, ty / sf);
+          ty += size * this.lineHeightFactor;
+        }
+      };
+      const hLine = (x1, y1, x2, y2) => {
+        if (!gridColor) return;
+        this.drawColor = gridColor;
+        this.lineWidth = gridW;
+        this.line(x1 / sf, y1 / sf, x2 / sf, y2 / sf, "S");
+      };
+      const headerHeightPt = hasHeader ? st.rowHeight !== void 0 ? this._u(st.rowHeight) : padPt * 2 + headSize * this.lineHeightFactor : 0;
+      const drawHeader = (topPt) => {
+        if (!hasHeader) return;
+        let cx = xU;
+        cols.forEach((col, i) => {
+          var _a2, _b2;
+          drawCellText(
+            (_a2 = col.header) != null ? _a2 : "",
+            cx,
+            topPt,
+            W[i],
+            headerHeightPt,
+            true,
+            col.align,
+            st.headFill === null ? null : (_b2 = st.headFill) != null ? _b2 : [53, 101, 224]
+          );
+          cx += W[i];
+        });
+        let gx = xU;
+        for (let i = 0; i < W.length; i++) {
+          hLine(gx, topPt, gx, topPt + headerHeightPt);
+          gx += W[i];
+        }
+        hLine(gx, topPt, gx, topPt + headerHeightPt);
+        hLine(xU, topPt, xU + totalW, topPt);
+        hLine(xU, topPt + headerHeightPt, xU + totalW, topPt + headerHeightPt);
+      };
+      if (hasHeader) drawHeader(yU);
+      let curY = yU + headerHeightPt;
+      for (let r = 0; r < ((_h = options.rows) != null ? _h : []).length; r++) {
+        const row = ((_i = options.rows) != null ? _i : [])[r];
+        const rowH = rowHeight(row);
+        const pageBottom = this.pages[this.page].height - this._u(marginU);
+        if (autoPage && curY + rowH > pageBottom && this.pages[this.page].height > 0) {
+          this.addPage();
+          (_j = options.onNewPage) == null ? void 0 : _j.call(options, this, { pageNumber: this.pages.length, pageCount: this.pages.length });
+          const topPt = this._u(marginU);
+          drawHeader(topPt);
+          curY = topPt + headerHeightPt;
+        }
+        const fill = zebra ? zebra[r % 2] : null;
+        let cx = xU;
+        row.forEach((cell, ci) => {
+          var _a2, _b2, _c2;
+          const spec = typeof cell === "string" ? { text: cell } : cell;
+          const span = Math.max(1, (_a2 = spec.colSpan) != null ? _a2 : 1);
+          const cw = W.slice(ci, ci + span).reduce((s, ww) => s + ww, 0);
+          drawCellText(cell, cx, curY, cw, rowH, false, (_c2 = spec.align) != null ? _c2 : (_b2 = cols[ci]) == null ? void 0 : _b2.align, fill);
+          cx += cw;
+        });
+        let gx = xU;
+        for (let i = 0; i < W.length; i++) {
+          hLine(gx, curY, gx, curY + rowH);
+          gx += W[i];
+        }
+        hLine(gx, curY, gx, curY + rowH);
+        hLine(xU, curY, xU + totalW, curY);
+        curY += rowH;
+      }
+      if (gridColor) hLine(xU, curY, xU + totalW, curY);
+      restore();
+      return curY / sf;
+    }
+  };
+
+  // src/modules/text.ts
+  var TextApi = {
+    /**
+     * Measure the width of `text` in points for an explicit font and size.
+     *
+     * Exposed publicly because jsPDF relies on `doc.measure`-style hooks for
+     * plugins such as autotable.
+     */
+    measure(text, fontDef, style, sizePt, charSpacePt) {
+      let w = 0;
+      for (let i = 0; i < text.length; i++) {
+        w += glyphWidth(fontDef, style, text.charAt(i));
+      }
+      w = w / 1e3 * sizePt;
+      if (charSpacePt) w += charSpacePt * text.length;
+      return w;
+    },
+    /** String width in font units (jsPDF `getStringUnitWidth`). */
+    getStringUnitWidth(text) {
+      return this.measure(text, this.getFontDef(this.activeFontKey), this.activeFontStyle, 1, 0);
+    },
+    /**
+     * Per-character widths in points (jsPDF `getCharWidthsArray`).
+     *
+     * @param options override `fontSize` (default: active) and `charSpace`
+     */
+    getCharWidthsArray(text, options) {
+      const size = typeof (options == null ? void 0 : options.fontSize) === "number" ? options.fontSize : this.fontSize;
+      const cs = typeof (options == null ? void 0 : options.charSpace) === "number" ? this._u(options.charSpace) : this.charSpace;
+      const def = this.getFontDef(this.activeFontKey);
+      const widths = [];
+      for (let i = 0; i < text.length; i++) {
+        widths.push(glyphWidth(def, this.activeFontStyle, text.charAt(i)) / 1e3 * size + cs);
+      }
+      return widths;
+    },
+    /** Width of `text` at the active font and size, in the active unit. */
+    getTextWidth(text) {
+      return this.measure(
+        text,
+        this.getFontDef(this.activeFontKey),
+        this.activeFontStyle,
+        this.fontSize,
+        this.charSpace
+      ) / this.scaleFactor;
+    },
+    /** Split `text` into lines that fit `maxWidth` (active unit). */
+    splitTextToSize(text, maxWidth) {
+      return this._splitCore(
+        text,
+        this._u(Number(maxWidth)),
+        this.getFontDef(this.activeFontKey),
+        this.activeFontStyle
+      );
+    },
+    /**
+     * Line-breaking core.
+     *
+     * Breaks Latin text at spaces, CJK text between any two characters, and
+     * hard-splits words longer than the line width (jsPDF behaviour).
+     *
+     * @internal maxWidthPt is in points
+     */
+    _splitCore(text, maxWidthPt, fontDef, style) {
+      const size = this.fontSize;
+      const cs = this.charSpace;
+      const width = (s) => this.measure(s, fontDef, style, size, cs);
+      const out = [];
+      for (const para of String(text).split(/\r\n|\r|\n/)) {
+        if (para === "" || width(para) <= maxWidthPt) {
+          out.push(para);
+          continue;
+        }
+        const tokens = [];
+        let buf = "";
+        for (const ch of para) {
+          const cp = ch.charCodeAt(0);
+          if (ch === " ") {
+            if (buf) {
+              tokens.push(buf);
+              buf = "";
+            }
+            tokens.push(" ");
+          } else if (cp >= 11904 && cp <= 40959 || cp >= 12288 && cp <= 12351 || cp >= 65280 && cp <= 65519 || cp >= 13312 && cp <= 19903 || cp >= 63744 && cp <= 64255 || cp >= 131072 && cp <= 196607) {
+            if (buf) {
+              tokens.push(buf);
+              buf = "";
+            }
+            tokens.push(ch);
+          } else {
+            buf += ch;
+          }
+        }
+        if (buf) tokens.push(buf);
+        let line = "";
+        for (const tk of tokens) {
+          const candidate = line + tk;
+          if (width(candidate) <= maxWidthPt) {
+            line = candidate;
+            continue;
+          }
+          if (line !== "") {
+            out.push(line.replace(/ +$/, ""));
+            line = "";
+          }
+          if (tk === " ") continue;
+          if (width(tk) > maxWidthPt) {
+            let piece = "";
+            for (const c of tk) {
+              if (width(piece + c) <= maxWidthPt) {
+                piece += c;
+              } else {
+                out.push(piece);
+                piece = c;
+              }
+            }
+            line = piece;
+          } else {
+            line = tk;
+          }
+        }
+        if (line !== "") out.push(line.replace(/ +$/, ""));
+      }
+      return out;
+    },
+    /**
+     * Write text at `(x, y)`.
+     *
+     * The anchor is the left end of the baseline unless changed through the
+     * `baseline` option. Multi-line input is accepted as `\n` separated text
+     * or an array of lines; `maxWidth` enables automatic wrapping.
+     *
+     * Supports the legacy jsPDF argument order `text(x, y, text, options)`.
+     */
+    text(text, x, y, optionsOrNothing) {
+      let textStr;
+      let xNum;
+      let yNum;
+      let options;
+      if (typeof text === "number") {
+        xNum = text;
+        yNum = Number(x);
+        textStr = y;
+        options = optionsOrNothing || {};
+      } else {
+        textStr = text;
+        xNum = Number(x);
+        yNum = Number(y);
+        options = y || {};
+        if (optionsOrNothing) options = optionsOrNothing;
+      }
+      if (typeof textStr !== "string" && !Array.isArray(textStr)) {
+        throw new Error("Invalid arguments passed to jsOFD.text");
+      }
+      x = this._u(xNum);
+      y = this._u(yNum);
+      const angle = Number(options.angle || 0);
+      const align = String(options.align || "left").toLowerCase();
+      if (!["left", "center", "right", "justify"].includes(align)) {
+        throw new Error('Unrecognized alignment option, use "left", "center", "right" or "justify".');
+      }
+      const baseline = String(options.baseline || "alphabetic").toLowerCase();
+      const charSpace = typeof options.charSpace === "number" ? this._u(options.charSpace) : this.charSpace;
+      const lineHeightFactor = typeof options.lineHeightFactor === "number" ? options.lineHeightFactor : this.lineHeightFactor;
+      const size = typeof options.fontSize === "number" ? options.fontSize : this.fontSize;
+      const style = this.activeFontStyle;
+      let fontKey = this.activeFontKey;
+      let fontDef = this.getFontDef(fontKey);
+      const raw = Array.isArray(textStr) ? textStr.join("\n") : String(textStr);
+      if (!fontDef.cjk && !fontDef.fontFile && hasCJK(raw)) {
+        fontKey = "simsun";
+        fontDef = BUILTIN_FONTS.simsun;
+      }
+      const renderingMode = String(options.renderingMode || "fill");
+      const opacity = typeof options.opacity === "number" ? Math.max(0, Math.min(1, options.opacity)) : this.opacity;
+      const hScale = typeof options.horizontalScale === "number" && options.horizontalScale > 0 ? options.horizontalScale : 1;
+      const r2l = typeof options.R2L === "boolean" ? options.R2L : this.r2l;
+      let lines;
+      if (typeof options.maxWidth === "number" && isFinite(options.maxWidth) && options.maxWidth > 0) {
+        lines = this._splitCore(raw, this._u(options.maxWidth) * hScale, fontDef, style);
+      } else {
+        lines = Array.isArray(textStr) ? textStr.slice() : raw.split(/\r\n|\r|\n/);
+      }
+      if (r2l) {
+        lines = lines.map((l) => Array.from(l).reverse().join(""));
+      }
+      const ascentPt = fontDef.ascent / 1e3 * size;
+      const descentPt = -fontDef.descent / 1e3 * size;
+      const leading = size * lineHeightFactor;
+      const justify = align === "justify";
+      const alignEff = justify ? "left" : align;
+      const rad = angle * Math.PI / 180;
+      for (let i = 0; i < lines.length; i++) {
+        const lineText = lines[i] === void 0 || lines[i] === null ? "" : String(lines[i]);
+        if (lineText.length === 0 && lines.length > 1) continue;
+        const w = this.measure(lineText, fontDef, style, size, charSpace) * hScale;
+        let lineX = x;
+        if (alignEff === "center") lineX = x - w / 2;
+        else if (alignEff === "right") lineX = x - w;
+        let baseY = y;
+        if (baseline === "top") baseY = y + ascentPt;
+        else if (baseline === "middle") baseY = y + (ascentPt - descentPt) / 2;
+        else if (baseline === "bottom") baseY = y + descentPt;
+        else if (baseline === "hanging") baseY = y + ascentPt * 0.8;
+        baseY += i * leading * Math.cos(rad);
+        lineX += -i * leading * Math.sin(rad);
+        this.pages[this.page].objects.push({
+          t: "text",
+          x: lineX,
+          y: baseY,
+          text: lineText,
+          size,
+          fontKey,
+          style,
+          color: this.textColor.slice(),
+          charSpace,
+          angle,
+          ascent: ascentPt,
+          descent: descentPt,
+          renderingMode,
+          opacity,
+          justifyWidth: justify && i < lines.length - 1 ? this._u(Number(options.maxWidth)) * hScale : null,
+          hScale
+        });
+      }
+      return this;
+    },
+    /**
+     * Write text wrapped in a clickable link annotation.
+     *
+     * Pass `url` for an external target or `pageNumber` for an in-document jump.
+     */
+    textWithLink(text, x, y, options = {}) {
+      const sizePt = typeof options.fontSize === "number" ? options.fontSize : this.fontSize;
+      this.text(text, x, y, options);
+      const width = this.getTextWidth(String(text));
+      const sizeU = sizePt / this.scaleFactor;
+      this.link(x, y - sizeU * 0.85, width, sizeU, options);
+      return this;
+    }
+  };
+
+  // src/xml.ts
+  var OFD_NAMESPACE = "http://www.ofdspec.org/2016";
+  function xmlHeader() {
+    return '<?xml version="1.0" encoding="UTF-8"?>\n';
+  }
+  function colorValue(rgb) {
+    return `${rgb[0]} ${rgb[1]} ${rgb[2]}`;
+  }
+
+  // src/builder.ts
+  var CAP_NAMES = ["Butt", "Round", "Square"];
+  var JOIN_NAMES = ["Miter", "Round", "Bevel"];
+  function buildOFDPackage(ctx) {
+    var _a, _b;
+    const files = [];
+    const xmlFiles = {};
+    const fontsUsed = {};
+    for (const page of ctx.pages) {
+      for (const obj of page.objects) {
+        if (obj.t === "text") {
+          const k = `${obj.fontKey}#${obj.style}`;
+          if (!fontsUsed[k]) {
+            fontsUsed[k] = {
+              key: obj.fontKey,
+              style: obj.style,
+              def: ctx.getFontDef(obj.fontKey),
+              id: 0
+            };
+          }
+        }
+      }
+    }
+    let nextId = 1;
+    const colorSpaceId = nextId++;
+    const embeddedFiles = /* @__PURE__ */ new Map();
+    let embeddedIdx = 0;
+    const hashOf = (data) => `${data.length}:${fnv1a(data)}`;
+    for (const k of Object.keys(fontsUsed)) {
+      fontsUsed[k].id = nextId++;
+      const file = fontsUsed[k].def.fontFile;
+      if (file) {
+        const hash = hashOf(file.data);
+        let entry = embeddedFiles.get(hash);
+        if (!entry) {
+          entry = { name: `Font_${embeddedIdx++}.${file.ext}`, data: file.data };
+          embeddedFiles.set(hash, entry);
+        }
+        fontsUsed[k].file = entry;
+      }
+    }
+    for (const img of ctx.imageList) {
+      img.resId = nextId++;
+    }
+    const pageIds = ctx.pages.map(() => nextId++);
+    {
+      let pub = xmlHeader();
+      pub += `<ofd:Res xmlns:ofd="${OFD_NAMESPACE}" BaseLoc="Res">
+`;
+      pub += `  <ofd:ColorSpaces>
+`;
+      pub += `    <ofd:ColorSpace ID="${colorSpaceId}" Type="RGB" BitsPerComponent="8"/>
+`;
+      pub += `  </ofd:ColorSpaces>
+`;
+      if (Object.keys(fontsUsed).length) {
+        pub += `  <ofd:Fonts>
+`;
+        for (const fu of Object.values(fontsUsed)) {
+          if (fu.file) {
+            pub += `    <ofd:Font ID="${fu.id}" FontName="${escapeXmlAttr(fu.def.familyName)}">
+`;
+            if (fu.style === "bold" || fu.style === "bolditalic") pub += ` Bold="true"`;
+            if (fu.style === "italic" || fu.style === "bolditalic") pub += ` Italic="true"`;
+            pub += `      <ofd:FontFile>${fu.file.name}</ofd:FontFile>
+`;
+            pub += `    </ofd:Font>
+`;
+          } else {
+            pub += `    <ofd:Font ID="${fu.id}" FontName="${escapeXmlAttr(fu.def.familyName)}" FamilyName="${escapeXmlAttr(fu.def.displayName)}"`;
+            pub += ` Serif="${fu.def.serif ? "true" : "false"}"`;
+            if (fu.def.fixed) pub += ` FixedWidth="true"`;
+            pub += ` Charset="unicode"`;
+            if (fu.style === "bold" || fu.style === "bolditalic") pub += ` Bold="true"`;
+            if (fu.style === "italic" || fu.style === "bolditalic") pub += ` Italic="true"`;
+            pub += `/>
+`;
+          }
+        }
+        pub += `  </ofd:Fonts>
+`;
+      }
+      pub += `</ofd:Res>
+`;
+      xmlFiles["Doc_0/PublicRes.xml"] = pub;
+    }
+    if (ctx.imageList.length) {
+      let dres = xmlHeader();
+      dres += `<ofd:Res xmlns:ofd="${OFD_NAMESPACE}" BaseLoc="Res">
+`;
+      dres += `  <ofd:MultiMedias>
+`;
+      ctx.imageList.forEach((img, idx) => {
+        dres += `    <ofd:MultiMedia ID="${img.resId}" Type="Image" Format="${img.format}">
+`;
+        dres += `      <ofd:MediaFile>Image_${idx}.${img.ext}</ofd:MediaFile>
+`;
+        dres += `    </ofd:MultiMedia>
+`;
+      });
+      dres += `  </ofd:MultiMedias>
+`;
+      dres += `</ofd:Res>
+`;
+      xmlFiles["Doc_0/DocumentRes.xml"] = dres;
+    }
+    let maxUnitId = nextId - 1;
+    ctx.pages.forEach((page, idx) => {
+      const layerId = nextId++;
+      maxUnitId = Math.max(maxUnitId, layerId);
+      let content = xmlHeader();
+      content += `<ofd:Page xmlns:ofd="${OFD_NAMESPACE}">
+`;
+      if (page.width !== ctx.pages[0].width || page.height !== ctx.pages[0].height) {
+        content += `  <ofd:Area>
+`;
+        content += `    <ofd:PhysicalBox>0 0 ${fmt(page.width * MM_PER_PT)} ${fmt(page.height * MM_PER_PT)}</ofd:PhysicalBox>
+`;
+        content += `  </ofd:Area>
+`;
+      }
+      content += `  <ofd:Content>
+`;
+      content += `    <ofd:Layer ID="${layerId}">
+`;
+      for (const obj of page.objects) {
+        content += objectXml(ctx, fontsUsed, obj, colorSpaceId, pageIds, () => nextId++);
+      }
+      content += `    </ofd:Layer>
+`;
+      content += `  </ofd:Content>
+`;
+      content += `</ofd:Page>
+`;
+      xmlFiles[`Doc_0/Pages/Page_${idx}/Content.xml`] = content;
+    });
+    maxUnitId = Math.max(maxUnitId, nextId - 1);
+    {
+      const w0 = fmt(ctx.pages[0].width * MM_PER_PT);
+      const h0 = fmt(ctx.pages[0].height * MM_PER_PT);
+      let doc = xmlHeader();
+      doc += `<ofd:Document xmlns:ofd="${OFD_NAMESPACE}">
+`;
+      doc += `  <ofd:CommonData>
+`;
+      doc += `    <ofd:MaxUnitID>${maxUnitId}</ofd:MaxUnitID>
+`;
+      doc += `    <ofd:PageArea>
+`;
+      doc += `      <ofd:PhysicalBox>0 0 ${w0} ${h0}</ofd:PhysicalBox>
+`;
+      doc += `      <ofd:ApplicationBox>0 0 ${w0} ${h0}</ofd:ApplicationBox>
+`;
+      doc += `    </ofd:PageArea>
+`;
+      doc += `    <ofd:PublicRes>PublicRes.xml</ofd:PublicRes>
+`;
+      if (ctx.imageList.length) {
+        doc += `    <ofd:DocumentRes>DocumentRes.xml</ofd:DocumentRes>
+`;
+      }
+      doc += `  </ofd:CommonData>
+`;
+      doc += `  <ofd:Pages>
+`;
+      ctx.pages.forEach((_page, idx) => {
+        doc += `    <ofd:Page ID="${pageIds[idx]}" BaseLoc="Pages/Page_${idx}/Content.xml"/>
+`;
+      });
+      doc += `  </ofd:Pages>
+`;
+      if (ctx.outlineRoot.children.length) {
+        doc += `  <ofd:Outlines>
+`;
+        doc += outlineXml(ctx.outlineRoot.children, pageIds, "    ", () => nextId++);
+        doc += `  </ofd:Outlines>
+`;
+        maxUnitId = Math.max(maxUnitId, nextId - 1);
+      }
+      if (ctx.displayMode || Object.keys(ctx.viewerPrefs || {}).length) {
+        doc += `  <ofd:VPreferences>
+`;
+        const pm = (_a = ctx.displayMode) == null ? void 0 : _a.pageMode;
+        const pageMode = pm ? pm === "UseNone" ? "None" : pm : ctx.outlineRoot.children.length ? "UseOutlines" : "None";
+        doc += `    <ofd:PageMode>${pageMode}</ofd:PageMode>
+`;
+        const layoutMap = {
+          continuous: "OneColumn",
+          single: "OnePage",
+          twoleft: "TwoPageL",
+          tworight: "TwoPageR",
+          two: "TwoPageL"
+        };
+        if (ctx.displayMode) {
+          doc += `    <ofd:PageLayout>${layoutMap[ctx.displayMode.layout] || "OneColumn"}</ofd:PageLayout>
+`;
+          const zoomMap = {
+            fullheight: "FitHeight",
+            fullwidth: "FitWidth",
+            fullpage: "FitRect",
+            original: "Default"
+          };
+          const z = ctx.displayMode.zoom;
+          if (typeof z === "number") {
+            doc += `    <ofd:Zoom>${fmt(z)}</ofd:Zoom>
+`;
+          } else if (zoomMap[z]) {
+            doc += `    <ofd:ZoomMode>${zoomMap[z]}</ofd:ZoomMode>
+`;
+          } else if (typeof z === "string" && /^\d+(\.\d+)?%$/.test(z)) {
+            doc += `    <ofd:Zoom>${fmt(parseFloat(z) / 100)}</ofd:Zoom>
+`;
+          }
+        }
+        for (const k of ["HideToolbar", "HideMenubar", "HideWindowUI", "FitWindow"]) {
+          if ((_b = ctx.viewerPrefs) == null ? void 0 : _b[k]) doc += `    <ofd:${k}>true</ofd:${k}>
+`;
+        }
+        doc += `  </ofd:VPreferences>
+`;
+      }
+      if (ctx.attachments.length) {
+        doc += `  <ofd:Attachments>Attachments.xml</ofd:Attachments>
+`;
+      }
+      doc += `</ofd:Document>
+`;
+      xmlFiles["Doc_0/Document.xml"] = doc;
+    }
+    {
+      const p = ctx.properties;
+      let ofd = xmlHeader();
+      ofd += `<ofd:OFD xmlns:ofd="${OFD_NAMESPACE}" Version="1.0" DocType="OFD">
+`;
+      ofd += `  <ofd:DocBody>
+`;
+      ofd += `    <ofd:DocInfo>
+`;
+      ofd += `      <ofd:DocID>${ctx.docID}</ofd:DocID>
+`;
+      if (p.title) ofd += `      <ofd:Title>${escapeXmlText(p.title)}</ofd:Title>
+`;
+      if (p.author) ofd += `      <ofd:Author>${escapeXmlText(p.author)}</ofd:Author>
+`;
+      if (p.subject) ofd += `      <ofd:Subject>${escapeXmlText(p.subject)}</ofd:Subject>
+`;
+      if (p.keywords) ofd += `      <ofd:Keywords>${escapeXmlText(p.keywords)}</ofd:Keywords>
+`;
+      ofd += `      <ofd:Creator>${escapeXmlText(p.creator)}</ofd:Creator>
+`;
+      if (p.creatorVersion)
+        ofd += `      <ofd:CreatorVersion>${escapeXmlText(p.creatorVersion)}</ofd:CreatorVersion>
+`;
+      ofd += `      <ofd:CreationDate>${todayStr(ctx.creationDate)}</ofd:CreationDate>
+`;
+      ofd += `      <ofd:ModDate>${todayStr(ctx.modDate || ctx.creationDate)}</ofd:ModDate>
+`;
+      ofd += `    </ofd:DocInfo>
+`;
+      ofd += `    <ofd:DocRoot>Doc_0/Document.xml</ofd:DocRoot>
+`;
+      ofd += `  </ofd:DocBody>
+`;
+      ofd += `</ofd:OFD>
+`;
+      xmlFiles["OFD.xml"] = ofd;
+    }
+    if (ctx.attachments.length) {
+      let att = xmlHeader();
+      att += `<ofd:Attachments xmlns:ofd="${OFD_NAMESPACE}">
+`;
+      ctx.attachments.forEach((a, i) => {
+        att += `  <ofd:Attachment ID="${i + 1}" Name="${escapeXmlAttr(a.name)}"`;
+        if (a.format) att += ` Format="${escapeXmlAttr(a.format)}"`;
+        att += ` CreationDate="${todayStr(a.creationDate)}" Size="${(a.data.length / 1024).toFixed(6)}">
+`;
+        att += `    <ofd:FileLoc>/Doc_0/Attachments/Attach_${i}/${escapeXmlText(a.name)}</ofd:FileLoc>
+`;
+        att += `  </ofd:Attachment>
+`;
+        files.push({
+          name: `Doc_0/Attachments/Attach_${i}/${a.name}`,
+          data: a.data
+        });
+      });
+      att += `</ofd:Attachments>
+`;
+      xmlFiles["Doc_0/Attachments.xml"] = att;
+    }
+    ctx.imageList.forEach((img, idx) => {
+      files.push({ name: `Doc_0/Res/Image_${idx}.${img.ext}`, data: img.data });
+    });
+    for (const entry of embeddedFiles.values()) {
+      files.push({ name: `Doc_0/Res/${entry.name}`, data: entry.data });
+    }
+    const preferredOrder = [
+      "OFD.xml",
+      "Doc_0/Document.xml",
+      "Doc_0/PublicRes.xml",
+      "Doc_0/DocumentRes.xml",
+      "Doc_0/Attachments.xml"
+    ];
+    const names = Object.keys(xmlFiles);
+    names.sort((a, b) => {
+      const ia = preferredOrder.indexOf(a);
+      const ib = preferredOrder.indexOf(b);
+      if (ia !== -1 && ib !== -1) return ia - ib;
+      if (ia !== -1) return -1;
+      if (ib !== -1) return 1;
+      return a < b ? -1 : a > b ? 1 : 0;
+    });
+    const zipFiles = [];
+    for (const name of names) {
+      zipFiles.push({ name, data: utf8Encode(xmlFiles[name]) });
+    }
+    for (const f of files) zipFiles.push(f);
+    return zipFiles;
+  }
+  function colorEl(name, rgb, csId) {
+    return `      <ofd:${name} Value="${colorValue(rgb)}" ColorSpace="${csId}"/>
+`;
+  }
+  function objectXml(ctx, fontsUsed, obj, colorSpaceId, pageIds, allocId) {
+    switch (obj.t) {
+      case "text":
+        return textObjectXml(ctx, fontsUsed, obj, colorSpaceId, allocId);
+      case "path":
+        return pathObjectXml(obj, colorSpaceId, allocId);
+      case "image":
+        return imageObjectXml(obj, colorSpaceId, allocId);
+      case "link":
+        return linkObjectXml(obj, colorSpaceId, allocId, pageIds);
+    }
+    return "";
+  }
+  function textObjectXml(ctx, fontsUsed, obj, colorSpaceId, allocId) {
+    const M = MM_PER_PT;
+    const id = allocId();
+    const fu = fontsUsed[`${obj.fontKey}#${obj.style}`];
+    if (!fu) return "";
+    const { x, y } = obj;
+    const hS = obj.hScale && obj.hScale !== 1 ? obj.hScale : 1;
+    const naturalWidth = obj.glyphWs ? obj.glyphWs.reduce((s, w) => s + w, 0) + obj.charSpace * Math.max(obj.text.length - 1, 0) : ctx.measure(obj.text, fu.def, obj.style, obj.size, obj.charSpace);
+    const wPt = Math.max(
+      naturalWidth,
+      ctx.measure(obj.text, fu.def, obj.style, obj.size, obj.charSpace)
+    );
+    const wEff = wPt * hS;
+    const asc = fu.def.ascent / 1e3 * obj.size;
+    const desc = -fu.def.descent / 1e3 * obj.size;
+    let bx, by, bw, bh;
+    let ctm = null;
+    let textCodeX = 0;
+    let textCodeY;
+    if (obj.angle || hS !== 1) {
+      const rad = obj.angle * Math.PI / 180;
+      const cos = Math.cos(rad);
+      const sin = Math.sin(rad);
+      const corners = [
+        [0, -asc],
+        [wEff, -asc],
+        [wEff, desc],
+        [0, desc]
+      ];
+      let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+      for (const [px0, py0] of corners) {
+        const px = x + hS * (px0 * cos) - py0 * sin;
+        const py = y + hS * (px0 * sin) + py0 * cos;
+        minX = Math.min(minX, px);
+        minY = Math.min(minY, py);
+        maxX = Math.max(maxX, px);
+        maxY = Math.max(maxY, py);
+      }
+      const pad = (asc + desc) * 0.18;
+      minX -= pad;
+      maxX += pad;
+      minY -= pad;
+      maxY += pad;
+      bx = minX;
+      by = minY;
+      bw = Math.max(maxX - minX, 0.01);
+      bh = Math.max(maxY - minY, 0.01);
+      ctm = [hS * cos, hS * sin, -sin, cos, (x - bx) * M, (y - by) * M];
+      textCodeX = 0;
+      textCodeY = 0;
+    } else {
+      bx = x;
+      const ascPadded = asc * 1.08;
+      by = y - ascPadded;
+      bw = Math.max(wPt, 0.01);
+      bh = Math.max(ascPadded + desc * 2.2, obj.size * 1.4);
+      textCodeY = ascPadded;
+    }
+    let xml = `      <ofd:TextObject ID="${id}"`;
+    xml += ` Boundary="${fmt(bx * M)} ${fmt(by * M)} ${fmt(bw * M)} ${fmt(bh * M)}"`;
+    xml += ` Font="${fu.id}"`;
+    xml += ` Size="${fmt(obj.size * M)}"`;
+    if (ctm) xml += ` CTM="${ctm.map((v) => fmt(v)).join(" ")}"`;
+    if (obj.style === "bold" || obj.style === "bolditalic") xml += ` Weight="700"`;
+    if (obj.style === "italic" || obj.style === "bolditalic") xml += ` Italic="true"`;
+    if (obj.renderingMode === "stroke") xml += ` Fill="false" Stroke="true"`;
+    else if (obj.renderingMode === "fillThenStroke") xml += ` Fill="true" Stroke="true"`;
+    else if (obj.renderingMode === "invisible") xml += ` Visible="false"`;
+    else xml += ` Fill="true" Stroke="false"`;
+    if (obj.opacity !== null && obj.opacity < 1) {
+      xml += ` Alpha="${Math.round(obj.opacity * 255)}"`;
+    }
+    xml += `>
+`;
+    if (obj.renderingMode === "stroke" || obj.renderingMode === "fillThenStroke") {
+      xml += colorEl("StrokeColor", obj.color, colorSpaceId);
+    }
+    xml += colorEl("FillColor", obj.color, colorSpaceId);
+    let deltaAttr = "";
+    if (obj.text.length > 1) {
+      const deltas = [];
+      let extra = 0;
+      if (obj.justifyWidth !== null) {
+        const natural = obj.glyphWs ? obj.glyphWs.reduce((s, w) => s + w, 0) + obj.charSpace * Math.max(obj.text.length - 1, 0) : ctx.measure(obj.text, fu.def, obj.style, obj.size, obj.charSpace);
+        extra = (obj.justifyWidth - natural) / (obj.text.length - 1);
+      }
+      for (let i = 0; i < obj.text.length - 1; i++) {
+        const adv = obj.glyphWs ? obj.glyphWs[i] + obj.charSpace + extra : glyphWidth(fu.def, obj.style, obj.text.charAt(i)) / 1e3 * obj.size + obj.charSpace + extra;
+        deltas.push(fmt(adv * M));
+      }
+      deltaAttr = ` DeltaX="${deltas.join(" ")}"`;
+    }
+    xml += `        <ofd:TextCode X="${fmt(textCodeX * M)}" Y="${fmt(textCodeY * M)}"${deltaAttr}>`;
+    xml += `${escapeXmlText(obj.text)}</ofd:TextCode>
+`;
+    xml += `      </ofd:TextObject>
+`;
+    return xml;
+  }
+  function pathBoundary(ops, stroke, lineWidth) {
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    const pad = stroke ? lineWidth / 2 : 0;
+    const consider = (x, y) => {
+      minX = Math.min(minX, x - pad);
+      minY = Math.min(minY, y - pad);
+      maxX = Math.max(maxX, x + pad);
+      maxY = Math.max(maxY, y + pad);
+    };
+    for (const op of ops) {
+      if (op.op === "M" || op.op === "L") consider(op.x, op.y);
+      else if (op.op === "C") {
+        consider(op.x1, op.y1);
+        consider(op.x2, op.y2);
+        consider(op.x, op.y);
+      }
+    }
+    return { bx: minX, by: minY, bw: maxX - minX, bh: maxY - minY };
+  }
+  function pathObjectXml(obj, colorSpaceId, allocId) {
+    const M = MM_PER_PT;
+    const id = allocId();
+    const { bx, by, bw, bh } = pathBoundary(obj.ops, obj.stroke, obj.lineWidth);
+    if (!isFinite(bx)) return "";
+    let xml = `      <ofd:PathObject ID="${id}"`;
+    xml += ` Boundary="${fmt(bx * M)} ${fmt(by * M)} ${fmt(Math.max(bw, 0.01) * M)} ${fmt(Math.max(bh, 0.01) * M)}"`;
+    xml += ` Fill="${obj.fill ? "true" : "false"}"`;
+    xml += ` Stroke="${obj.stroke ? "true" : "false"}"`;
+    if (obj.stroke) {
+      xml += ` LineWidth="${fmt(obj.lineWidth * M)}"`;
+      if (obj.cap) xml += ` Cap="${CAP_NAMES[obj.cap] || "Butt"}"`;
+      if (obj.join) xml += ` Join="${JOIN_NAMES[obj.join] || "Miter"}"`;
+      if (obj.miterLimit > 1) xml += ` MiterLimit="${fmt(obj.miterLimit * M)}"`;
+      if (obj.dash && obj.dash.pattern.length) {
+        xml += ` DashPattern="${obj.dash.pattern.map((v) => fmt(v * M)).join(" ")}"`;
+        if (obj.dash.phase) xml += ` DashOffset="${fmt(obj.dash.phase * M)}"`;
+      }
+    }
+    if (obj.opacity !== null && obj.opacity < 1) {
+      xml += ` Alpha="${Math.round(obj.opacity * 255)}"`;
+    }
+    xml += `>
+`;
+    if (obj.fill) xml += colorEl("FillColor", obj.fillColor, colorSpaceId);
+    if (obj.stroke) xml += colorEl("StrokeColor", obj.strokeColor, colorSpaceId);
+    const d = [];
+    for (const op of obj.ops) {
+      switch (op.op) {
+        case "M":
+          d.push(`M ${fmt((op.x - bx) * M)} ${fmt((op.y - by) * M)}`);
+          break;
+        case "L":
+          d.push(`L ${fmt((op.x - bx) * M)} ${fmt((op.y - by) * M)}`);
+          break;
+        case "C":
+          d.push(
+            `B ${fmt((op.x1 - bx) * M)} ${fmt((op.y1 - by) * M)} ${fmt((op.x2 - bx) * M)} ${fmt((op.y2 - by) * M)} ${fmt((op.x - bx) * M)} ${fmt((op.y - by) * M)}`
+          );
+          break;
+        case "Z":
+          d.push("C");
+          break;
+      }
+    }
+    xml += `        <ofd:AbbreviatedData>${d.join(" ")} </ofd:AbbreviatedData>
+`;
+    xml += `      </ofd:PathObject>
+`;
+    return xml;
+  }
+  function imageObjectXml(obj, _colorSpaceId, allocId) {
+    const M = MM_PER_PT;
+    const id = allocId();
+    const img = obj.imageRef;
+    if (!img) return "";
+    const w = obj.w * M;
+    const h = obj.h * M;
+    const rad = (obj.angle || 0) * Math.PI / 180;
+    const cos = Math.cos(rad);
+    const sin = Math.sin(rad);
+    if (!obj.angle) {
+      const bx2 = obj.x * M;
+      const by2 = obj.y * M;
+      let xml2 = `      <ofd:ImageObject ID="${id}"`;
+      xml2 += ` Boundary="${fmt(bx2)} ${fmt(by2)} ${fmt(Math.max(w, 0.01))} ${fmt(Math.max(h, 0.01))}"`;
+      xml2 += ` ResourceID="${img.resId}"`;
+      xml2 += ` CTM="${fmt(w)} 0 0 ${fmt(h)} 0 0"`;
+      if (obj.opacity !== null && obj.opacity < 1) {
+        xml2 += ` Alpha="${Math.round(obj.opacity * 255)}"`;
+      }
+      xml2 += `/>
+`;
+      return xml2;
+    }
+    const cx = (obj.x + obj.w / 2) * M;
+    const cy = (obj.y + obj.h / 2) * M;
+    const corners = [
+      [obj.x, obj.y],
+      [obj.x + obj.w, obj.y],
+      [obj.x + obj.w, obj.y + obj.h],
+      [obj.x, obj.y + obj.h]
+    ];
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const [px0, py0] of corners) {
+      const px = cx + (px0 * M - cx) * cos - (py0 * M - cy) * sin;
+      const py = cy + (px0 * M - cx) * sin + (py0 * M - cy) * cos;
+      minX = Math.min(minX, px);
+      minY = Math.min(minY, py);
+      maxX = Math.max(maxX, px);
+      maxY = Math.max(maxY, py);
+    }
+    const bx = minX;
+    const by = minY;
+    const bw = Math.max(maxX - minX, 0.01);
+    const bh = Math.max(maxY - minY, 0.01);
+    const e = cx - cos * w / 2 + sin * h / 2 - bx;
+    const f = cy - sin * w / 2 - cos * h / 2 - by;
+    const ctm = [cos * w, sin * w, -sin * h, cos * h, e, f];
+    let xml = `      <ofd:ImageObject ID="${id}"`;
+    xml += ` Boundary="${fmt(bx)} ${fmt(by)} ${fmt(bw)} ${fmt(bh)}"`;
+    xml += ` ResourceID="${img.resId}"`;
+    xml += ` CTM="${ctm.map((v) => fmt(v)).join(" ")}"`;
+    if (obj.opacity !== null && obj.opacity < 1) {
+      xml += ` Alpha="${Math.round(obj.opacity * 255)}"`;
+    }
+    xml += `/>
+`;
+    return xml;
+  }
+  function gotoActionXml(pageId, indent) {
+    return `${indent}<ofd:Actions>
+${indent}  <ofd:Action Event="Click">
+${indent}    <ofd:Goto>
+${indent}      <ofd:Dest Type="XYZ" PageID="${pageId}">
+${indent}        <ofd:Left>0</ofd:Left>
+${indent}        <ofd:Top>0</ofd:Top>
+${indent}        <ofd:Zoom>0</ofd:Zoom>
+${indent}      </ofd:Dest>
+${indent}    </ofd:Goto>
+${indent}  </ofd:Action>
+${indent}</ofd:Actions>
+`;
+  }
+  function linkObjectXml(obj, colorSpaceId, allocId, pageIds) {
+    let action = "";
+    if (obj.url) {
+      action = `        <ofd:Actions>
+          <ofd:Action Event="Click">
+            <ofd:URI URI="${escapeXmlAttr(obj.url)}"/>
+          </ofd:Action>
+        </ofd:Actions>
+`;
+    } else if (obj.pageNumber && pageIds[obj.pageNumber - 1]) {
+      action = gotoActionXml(pageIds[obj.pageNumber - 1], "        ");
+    }
+    if (!action) return "";
+    const pathObj = {
+      t: "path",
+      miterLimit: 0,
+      ops: [
+        { op: "M", x: obj.x, y: obj.y },
+        { op: "L", x: obj.x + obj.w, y: obj.y },
+        { op: "L", x: obj.x + obj.w, y: obj.y + obj.h },
+        { op: "L", x: obj.x, y: obj.y + obj.h },
+        { op: "Z" }
+      ],
+      fill: false,
+      stroke: false,
+      fillColor: [0, 0, 0],
+      strokeColor: [0, 0, 0],
+      lineWidth: 0,
+      dash: null,
+      cap: 0,
+      join: 0,
+      opacity: null
+    };
+    const xml = pathObjectXml(pathObj, colorSpaceId, allocId);
+    return xml.replace("      </ofd:PathObject>\n", action + "      </ofd:PathObject>\n");
+  }
+  function outlineXml(nodes, pageIds, indent, allocId) {
+    let out = "";
+    for (const n of nodes) {
+      const pageNo = n.options.pageNumber || 1;
+      const pageId = pageIds[pageNo - 1] || pageIds[0];
+      out += `${indent}<ofd:Outline ID="${allocId()}" Title="${escapeXmlAttr(n.title)}">
+`;
+      out += gotoActionXml(pageId, indent + "  ");
+      if (n.children.length) {
+        out += outlineXml(n.children, pageIds, indent + "  ", allocId);
+      }
+      out += `${indent}</ofd:Outline>
+`;
+    }
+    return out;
+  }
+
+  // src/zip.ts
+  function dosDateTime(date) {
+    const d = date instanceof Date ? date : /* @__PURE__ */ new Date();
+    const time = (d.getHours() & 31) << 11 | (d.getMinutes() & 63) << 5 | Math.floor(d.getSeconds() / 2) & 31;
+    const day = (d.getFullYear() - 1980 & 127) << 9 | (d.getMonth() + 1 & 15) << 5 | d.getDate() & 31;
+    return { time: time >>> 0, date: day >>> 0 };
+  }
+  var ByteWriter = class {
+    constructor() {
+      __publicField(this, "buf", new Uint8Array(1024));
+      __publicField(this, "len", 0);
+    }
+    ensure(extra) {
+      if (this.len + extra <= this.buf.length) return;
+      let cap = this.buf.length * 2;
+      while (cap < this.len + extra) cap *= 2;
+      const nb = new Uint8Array(cap);
+      nb.set(this.buf.subarray(0, this.len));
+      this.buf = nb;
+    }
+    byte(v) {
+      this.ensure(1);
+      this.buf[this.len++] = v & 255;
+    }
+    u16(v) {
+      this.byte(v);
+      this.byte(v >>> 8);
+    }
+    u32(v) {
+      this.byte(v);
+      this.byte(v >>> 8);
+      this.byte(v >>> 16);
+      this.byte(v >>> 24);
+    }
+    bytes(b) {
+      this.ensure(b.length);
+      this.buf.set(b, this.len);
+      this.len += b.length;
+    }
+    toUint8Array() {
+      return this.buf.slice(0, this.len);
+    }
+  };
+  function zipStore(files, date) {
+    const dos = dosDateTime(date || /* @__PURE__ */ new Date());
+    const local = new ByteWriter();
+    const central = new ByteWriter();
+    const cdOffsets = [];
+    let offset = 0;
+    for (const f of files) {
+      const nameBytes = utf8Encode(f.name);
+      const data = f.data || new Uint8Array(0);
+      const crc = crc32(data);
+      local.u32(67324752);
+      local.u16(20);
+      local.u16(2048);
+      local.u16(0);
+      local.u16(dos.time);
+      local.u16(dos.date);
+      local.u32(crc);
+      local.u32(data.length);
+      local.u32(data.length);
+      local.u16(nameBytes.length);
+      local.u16(0);
+      local.bytes(nameBytes);
+      local.bytes(data);
+      cdOffsets.push(offset);
+      central.u32(33639248);
+      central.u16(20);
+      central.u16(20);
+      central.u16(2048);
+      central.u16(0);
+      central.u16(dos.time);
+      central.u16(dos.date);
+      central.u32(crc);
+      central.u32(data.length);
+      central.u32(data.length);
+      central.u16(nameBytes.length);
+      central.u16(0);
+      central.u16(0);
+      central.u16(0);
+      central.u16(0);
+      central.u32(0);
+      central.u32(offset);
+      central.bytes(nameBytes);
+      offset += 30 + nameBytes.length + data.length;
+    }
+    const cdStart = offset;
+    const cdSize = central.toUint8Array().length;
+    const eocd = new ByteWriter();
+    eocd.u32(101010256);
+    eocd.u16(0);
+    eocd.u16(0);
+    eocd.u16(files.length);
+    eocd.u16(files.length);
+    eocd.u32(cdSize);
+    eocd.u32(cdStart);
+    eocd.u16(0);
+    const parts = [local.toUint8Array(), central.toUint8Array(), eocd.toUint8Array()];
+    let total = 0;
+    for (const p of parts) total += p.length;
+    const out = new Uint8Array(total);
+    let pos = 0;
+    for (const p of parts) {
+      out.set(p, pos);
+      pos += p.length;
+    }
+    return out;
+  }
+
+  // src/modules/view.ts
+  var ViewApi = {
+    /** Set document metadata (title, subject, author, keywords, creator). */
+    setProperties(properties) {
+      for (const k of Object.keys(properties)) {
+        const v = properties[k];
+        if (v !== void 0 && k in this.properties) {
+          this.properties[k] = String(v);
+        }
+      }
+      return this;
+    },
+    /** Override the document creation date. */
+    setCreationDate(date) {
+      this.creationDate = date instanceof Date ? date : new Date(date);
+      return this;
+    },
+    /**
+     * Read the creation date.
+     *
+     * @param type `'array'` returns `[y, m, d, h, min, s]`; anything else
+     *              returns a `Date` (jsPDF `'jsDate'` semantics)
+     */
+    getCreationDate(type) {
+      if (type === "array") {
+        const d = this.creationDate;
+        return [
+          d.getFullYear(),
+          d.getMonth() + 1,
+          d.getDate(),
+          d.getHours(),
+          d.getMinutes(),
+          d.getSeconds()
+        ];
+      }
+      return this.creationDate;
+    },
+    /**
+     * Configure the initial viewer presentation.
+     *
+     * @param zoom     numeric multiplier, `'N%'`, or `'fullwidth'` /
+     *                 `'fullheight'` / `'fullpage'` / `'original'`
+     * @param layout   `'continuous'` / `'single'` / `'twoleft'` / `'tworight'` / `'two'`
+     * @param pageMode `'UseNone'` / `'UseOutlines'` / `'UseThumbs'` / `'FullScreen'`
+     * @throws on unrecognized values, mirroring jsPDF
+     */
+    setDisplayMode(zoom, layout, pageMode) {
+      if (zoom !== void 0 && zoom !== null) {
+        const z = String(zoom).toLowerCase();
+        const num = Number(zoom);
+        const valid = ["fullheight", "fullwidth", "fullpage", "original"].includes(z) || typeof zoom === "number" && !isNaN(num) && num > 0 || typeof zoom === "string" && /^\d+(\.\d+)?%$/.test(zoom);
+        if (!valid) {
+          throw new Error(
+            `zoom must be Integer (e.g. 2), a percentage Value (e.g. 300%) or fullwidth, fullheight, fullpage, original. "${zoom}" is not recognized.`
+          );
+        }
+      }
+      const layouts = ["continuous", "single", "twoleft", "tworight", "two"];
+      if (layout !== void 0 && layout !== null && !layouts.includes(String(layout))) {
+        throw new Error(
+          `Layout mode must be one of ${layouts.join(", ")}. "${layout}" is not recognized.`
+        );
+      }
+      const pageModes = ["UseNone", "UseOutlines", "UseThumbs", "FullScreen"];
+      if (pageMode !== void 0 && pageMode !== null && !pageModes.includes(String(pageMode))) {
+        throw new Error(
+          `Page mode must be one of ${pageModes.join(", ")}. "${pageMode}" is not recognized.`
+        );
+      }
+      this.displayMode = {
+        zoom: zoom != null ? zoom : 1,
+        layout: layout || "continuous",
+        pageMode: pageMode || ""
+      };
+      return this;
+    },
+    /**
+     * Set reader interface preferences.
+     *
+     * Supported flags: `HideToolbar`, `HideMenubar`, `HideWindowUI`, `FitWindow`.
+     * Pass `doReset` to clear previously set flags first.
+     */
+    viewerPreferences(options, doReset) {
+      if (doReset) {
+        this.viewerPrefs = {};
+      }
+      if (options && typeof options === "object") {
+        for (const k of ["HideToolbar", "HideMenubar", "HideWindowUI", "FitWindow"]) {
+          if (typeof options[k] === "boolean") {
+            this.viewerPrefs[k] = Boolean(options[k]);
+          }
+        }
+      }
+      return this;
+    },
+    /**
+     * Register a total-page-count placeholder (jsPDF `putTotalPages`).
+     *
+     * At output time every occurrence of `pageIndicator` in text objects is
+     * replaced with the page count.
+     */
+    putTotalPages(pageIndicator = "{total}") {
+      this.totalPagesPattern = String(pageIndicator);
+      return this;
+    },
+    /** API-compatibility no-op (OFD carries no language field). */
+    setLanguage() {
+      return this;
+    },
+    /**
+     * @internal Serialize to OFD ZIP entries (`OFD.xml` first).
+     *
+     * Applies the `putTotalPages` substitution on a copy, leaving the live
+     * document untouched so `output()` stays repeatable.
+     */
+    _buildFiles() {
+      let pages = this.pages;
+      if (this.totalPagesPattern) {
+        const total = String(this.pages.length);
+        pages = this.pages.map((p) => ({
+          ...p,
+          objects: p.objects.map(
+            (o) => o.t === "text" && o.text.includes(this.totalPagesPattern) ? { ...o, text: o.text.split(this.totalPagesPattern).join(total) } : o
+          )
+        }));
+      }
+      return buildOFDPackage({
+        pages,
+        customFonts: this.customFonts,
+        imageList: this.imageList,
+        attachments: this.attachments,
+        outlineRoot: this.outlineRoot,
+        properties: this.properties,
+        docID: this.docID,
+        creationDate: this.creationDate,
+        modDate: this.modDate,
+        displayMode: this.displayMode,
+        viewerPrefs: this.viewerPrefs,
+        measure: (text, fontDef, style, sizePt, charSpacePt) => this.measure(text, fontDef, style, sizePt, charSpacePt),
+        getFontDef: (key) => this.getFontDef(key)
+      });
+    },
+    /**
+     * Serialize the document.
+     *
+     * @param type `'arraybuffer'` (default) / `'uint8array'` / `'blob'` /
+     *             `'dataurlstring'` / `'dataurlnewwindow'` / `'binarystring'` /
+     *             `'bloburl'`
+     */
+    output(type = "arraybuffer") {
+      const t = String(type).toLowerCase();
+      const zipBytes = zipStore(this._buildFiles(), this.creationDate);
+      switch (t) {
+        case "arraybuffer":
+          return zipBytes.buffer.slice(
+            zipBytes.byteOffset,
+            zipBytes.byteOffset + zipBytes.byteLength
+          );
+        case "uint8array":
+          return zipBytes;
+        case "binarystring":
+        case "binary": {
+          let s = "";
+          for (let i = 0; i < zipBytes.length; i++) s += String.fromCharCode(zipBytes[i]);
+          return s;
+        }
+        case "dataurlstring":
+        case "datauristring":
+        case "dataurl":
+        case "datauri":
+          return "data:application/ofd;base64," + b64Encode(zipBytes);
+        case "blob":
+          if (typeof Blob === "undefined") {
+            throw new Error('output("blob") requires Blob support; use output("arraybuffer")');
+          }
+          return new Blob([zipBytes], { type: "application/ofd" });
+        case "bloburl":
+        case "blobobject":
+          if (typeof Blob === "undefined" || typeof URL === "undefined" || !URL.createObjectURL) {
+            throw new Error('output("bloburl") requires Blob URL support');
+          }
+          return URL.createObjectURL(
+            new Blob([zipBytes], { type: "application/ofd" })
+          );
+        case "dataurlnewwindow":
+          if (typeof window === "undefined" || !window.open) {
+            throw new Error('output("dataurlnewwindow") requires window.open');
+          }
+          window.open("data:application/ofd;base64," + b64Encode(zipBytes), "_blank");
+          return null;
+        default:
+          throw new Error("output: unknown output type " + type);
+      }
+    },
+    /** Shorthand for `output('dataurlstring')`. */
+    getDataUrl() {
+      return this.output("dataurlstring");
+    },
+    /**
+     * Save the document to a file.
+     *
+     * Browser: triggers a download. Node (CJS): writes into the working
+     * directory. Node ESM has no synchronous `require` — use
+     * `output('arraybuffer')` and write the bytes yourself.
+     */
+    save(filename) {
+      let name = filename || "document.ofd";
+      if (!/\.ofd$/i.test(name)) name += ".ofd";
+      if (IS_NODE) {
+        const fs = nodeRequire("fs");
+        const path = nodeRequire("path");
+        if (fs) {
+          const p = path ? path.join(process.cwd(), name) : name;
+          fs.writeFileSync(p, this.output("uint8array"));
+          return this;
+        }
+        throw new Error('Node ESM: use output("arraybuffer") and write the file yourself');
+      }
+      const blob = this.output("blob");
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = name;
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      setTimeout(() => URL.revokeObjectURL(url), 2e3);
+      return this;
+    }
+  };
+
+  // src/jsofd.ts
+  var JSOFD_VERSION = "1.0.0";
+  var DEFAULT_LINE_WIDTH_PT = 0.2 * PT_PER_MM;
+  var _ctx2d;
+  var jsOFD = class {
+    constructor(options = {}, unitArg, formatArg) {
+      /** Active measurement unit. */
+      __publicField(this, "unit");
+      /** Unit → point scale factor (jsPDF-compatible `internal.scaleFactor`). */
+      __publicField(this, "scaleFactor");
+      /** Decimal places used when serializing numbers. */
+      __publicField(this, "floatPrecision");
+      /** @internal Default orientation for `addPage()` without arguments. */
+      __publicField(this, "defaultOrientation");
+      /** Pages in the document (internal coordinates are points). */
+      __publicField(this, "pages", []);
+      /** Zero-based index of the current page. */
+      __publicField(this, "page", 0);
+      /** User-registered fonts. */
+      __publicField(this, "customFonts", {});
+      /** Image resources, keyed by alias, plus insertion order. */
+      __publicField(this, "images", {});
+      __publicField(this, "imageList", []);
+      /** Embedded file attachments. */
+      __publicField(this, "attachments", []);
+      /** Bookmark tree root. */
+      __publicField(this, "outlineRoot", { children: [] });
+      /** Document metadata (see `setProperties`). */
+      __publicField(this, "properties", {
+        title: "",
+        subject: "",
+        author: "",
+        keywords: "",
+        creator: "jsOFD " + JSOFD_VERSION,
+        creatorVersion: JSOFD_VERSION
+      });
+      /** Random document identifier. */
+      __publicField(this, "docID", randomHex32());
+      __publicField(this, "creationDate", /* @__PURE__ */ new Date());
+      __publicField(this, "modDate", null);
+      __publicField(this, "displayMode", null);
+      __publicField(this, "viewerPrefs", {});
+      /** Placeholder (e.g. `{total}`) replaced at output time, see `putTotalPages`. */
+      __publicField(this, "totalPagesPattern", null);
+      // ---- Graphics state ----------------------------------------------------
+      __publicField(this, "activeFontKey", "helvetica");
+      __publicField(this, "activeFontStyle", "normal");
+      /** Font size in points. Like jsPDF, the size is always in pt regardless of unit. */
+      __publicField(this, "fontSize", 16);
+      __publicField(this, "textColor", [0, 0, 0]);
+      __publicField(this, "drawColor", [0, 0, 0]);
+      __publicField(this, "fillColor", [0, 0, 0]);
+      __publicField(this, "lineWidth", DEFAULT_LINE_WIDTH_PT);
+      __publicField(this, "lineDash", null);
+      __publicField(this, "lineCap", 0);
+      __publicField(this, "lineJoin", 0);
+      /** Miter limit in points; 0 omits the attribute. */
+      __publicField(this, "miterLimit", 0);
+      __publicField(this, "charSpace", 0);
+      // pt
+      __publicField(this, "lineHeightFactor", 1.15);
+      __publicField(this, "opacity", null);
+      __publicField(this, "r2l", false);
+      /** @internal Paper format used by `addPage()` without arguments. */
+      __publicField(this, "_lastFormat", "a4");
+      /** jsPDF-style introspection surface. */
+      __publicField(this, "internal");
+      /** Bookmark API: `doc.outline.add(parent, title, options)`. */
+      __publicField(this, "outline");
+      /** Lazily created canvas-2D adapter, see `createContext2d`. */
+      __privateAdd(this, _ctx2d, null);
+      if (typeof options === "string") {
+        options = {
+          orientation: options,
+          unit: unitArg,
+          format: formatArg
+        };
+      }
+      const unit = String(options.unit || "mm").toLowerCase();
+      if (!isUnit(unit)) {
+        throw new Error(`Invalid unit: ${unit}`);
+      }
+      this.unit = unit;
+      this.scaleFactor = UNIT_FACTORS[unit];
+      const ori = String(options.orientation || "p").toLowerCase();
+      this.defaultOrientation = ori === "landscape" || ori === "l" ? "l" : "p";
+      this.floatPrecision = options.floatPrecision || 4;
+      const firstSize = this._resolveFormat(options.format || "a4", this.defaultOrientation);
+      this._addPageWithSize(firstSize[0], firstSize[1]);
+      const pages = () => this.pages;
+      this.internal = {
+        version: JSOFD_VERSION,
+        scaleFactor: this.scaleFactor,
+        pageSize: {
+          getWidth: () => this.pages[this.page].width / this.scaleFactor,
+          getHeight: () => this.pages[this.page].height / this.scaleFactor
+        },
+        get numberOfPages() {
+          return pages().length;
+        },
+        get pages() {
+          return pages();
+        },
+        getFileId: () => this.docID
+      };
+      this.outline = {
+        add: (parent, title, options2) => {
+          const node = {
+            title: String(title),
+            parent: parent || null,
+            children: [],
+            options: options2 || {}
+          };
+          (parent || this.outlineRoot).children.push(node);
+          return node;
+        }
+      };
+    }
+    /**
+     * Canvas-style drawing context (subset of `CanvasRenderingContext2D`).
+     * Draw calls land on the current page as vector objects.
+     */
+    get context2d() {
+      if (!__privateGet(this, _ctx2d)) __privateSet(this, _ctx2d, createContext2d(this));
+      return __privateGet(this, _ctx2d);
+    }
+    /* ---------------- Page management ---------------- */
+    /** @internal Resolve a named or `[w, h]` format to a pt size pair. */
+    _resolveFormat(format, orientation) {
+      let size;
+      if (typeof format === "string") {
+        const f = PAGE_FORMATS_MM[format.toLowerCase()];
+        if (!f) throw new Error("Unknown paper format: " + format);
+        size = [f[0] * PT_PER_MM, f[1] * PT_PER_MM];
+      } else if (Array.isArray(format) && format.length >= 2) {
+        size = [Number(format[0]) * this.scaleFactor, Number(format[1]) * this.scaleFactor];
+      } else {
+        throw new Error("Invalid format: " + String(format));
+      }
+      if (orientation === "l") {
+        return [Math.max(size[0], size[1]), Math.min(size[0], size[1])];
+      }
+      return [Math.min(size[0], size[1]), Math.max(size[0], size[1])];
+    }
+    /** @internal Convert a coordinate in the active unit to points. */
+    _u(v) {
+      return v * this.scaleFactor;
+    }
+    /** @internal Append a page sized in points and make it current. */
+    _addPageWithSize(wPt, hPt) {
+      this.pages.push({ width: wPt, height: hPt, objects: [] });
+      this.page = this.pages.length - 1;
+      return this;
+    }
+    /** Append a page, optionally with a different format and orientation. */
+    addPage(format, orientation) {
+      const f = format || this._lastFormat;
+      this._lastFormat = f;
+      const ori = orientation ? String(orientation).toLowerCase() : this.defaultOrientation;
+      const size = this._resolveFormat(f, ori === "landscape" || ori === "l" ? "l" : "p");
+      return this._addPageWithSize(size[0], size[1]);
+    }
+    /** Switch to a one-based page number. */
+    setPage(n) {
+      if (n < 1 || n > this.pages.length) {
+        throw new Error(`setPage: page number out of range 1-${this.pages.length}`);
+      }
+      this.page = n - 1;
+      return this;
+    }
+    /** Insert an empty page before the given one-based position. */
+    insertPage(beforePage) {
+      const cur = this.pages[this.page];
+      const page = { width: cur.width, height: cur.height, objects: [] };
+      const at = Math.max(1, Math.min(beforePage || 1, this.pages.length + 1));
+      this.pages.splice(at - 1, 0, page);
+      this.page = at - 1;
+      return this;
+    }
+    /** Move a page (default: the current one) to before another position. */
+    movePage(targetPage, beforePage) {
+      const from = targetPage != null ? targetPage : this.page + 1;
+      if (from < 1 || from > this.pages.length) return this;
+      const pg = this.pages.splice(from - 1, 1)[0];
+      const at = Math.max(1, Math.min(beforePage || 1, this.pages.length + 1));
+      this.pages.splice(at - 1, 0, pg);
+      this.page = at - 1;
+      return this;
+    }
+    /** Delete a page (the last page is replaced by an empty one). */
+    deletePage(target) {
+      const at = typeof target === "number" ? target - 1 : this.page;
+      if (at < 0 || at >= this.pages.length) return this;
+      if (this.pages.length > 1) {
+        this.pages.splice(at, 1);
+        this.page = Math.min(this.page, this.pages.length - 1);
+      } else {
+        this.pages[0].objects = [];
+        this.page = 0;
+      }
+      return this;
+    }
+    /** Number of pages in the document. */
+    getNumberOfPages() {
+      return this.pages.length;
+    }
+    /** Width of the current page in the active unit. */
+    getPageWidth() {
+      return this.pages[this.page].width / this.scaleFactor;
+    }
+    /** Height of the current page in the active unit. */
+    getPageHeight() {
+      return this.pages[this.page].height / this.scaleFactor;
+    }
+  };
+  _ctx2d = new WeakMap();
+  Object.assign(
+    jsOFD.prototype,
+    StateApi,
+    TextApi,
+    ShapeApi,
+    ImageApi,
+    AnnotationApi,
+    AnnotationVisualApi,
+    FlowApi,
+    TableApi,
+    HtmlApi,
+    SvgApi,
+    ViewApi
+  );
+
+  // src/index.ts
+  var version = JSOFD_VERSION;
+  var src_default = jsOFD;
+  return __toCommonJS(src_exports);
+})();