@reportwright/viewer 0.0.0-stage → 0.11.0

package/dist/chunk-3D43XGIN.js

@@ -0,0 +1,1167 @@
+// src/engine/text/fonts.js
+import fontkitModule from "@pdf-lib/fontkit";
+
+// src/engine/text/shaper.js
+var LTR = 4;
+var RTL = 5;
+var PLAIN = ["-kern", "-liga", "-clig", "-calt", "-dlig"];
+async function createShaper(wasm) {
+  let memory;
+  const { instance } = await WebAssembly.instantiate(wasm, {
+    env: {
+      _emscripten_runtime_keepalive_clear() {
+      },
+      _abort_js() {
+        throw new Error("HarfBuzz stopped");
+      },
+      _setitimer_js() {
+        return 0;
+      },
+      emscripten_resize_heap(size) {
+        const need = (size >>> 0) - memory.buffer.byteLength;
+        try {
+          memory.grow(Math.ceil(need / 65536));
+          return 1;
+        } catch {
+          return 0;
+        }
+      }
+    },
+    wasi_snapshot_preview1: { proc_exit(code) {
+      throw new Error(`HarfBuzz exited (${code})`);
+    } }
+  });
+  const x = (
+    /** @type {any} */
+    instance.exports
+  );
+  memory = x.memory;
+  x.__wasm_call_ctors();
+  const featPtr = x.malloc(16 * PLAIN.length);
+  PLAIN.forEach((f, i) => {
+    const s = x.malloc(f.length + 1);
+    new Uint8Array(memory.buffer).set([...f].map((c) => c.charCodeAt(0)).concat(0), s);
+    x.hb_feature_from_string(s, -1, featPtr + 16 * i);
+    x.free(s);
+  });
+  return {
+    /**
+     * A HarfBuzz font for these bytes. It lives as long as the shaper: fonts are few and reused.
+     * @param {Uint8Array} bytes @returns {{ ptr: number, upem: number }}
+     */
+    font(bytes) {
+      const buf = x.malloc(bytes.byteLength);
+      new Uint8Array(memory.buffer).set(bytes, buf);
+      const blob = x.hb_blob_create(buf, bytes.byteLength, 1, 0, 0);
+      const face = x.hb_face_create(blob, 0);
+      const ptr = x.hb_font_create(face);
+      const upem = x.hb_face_get_upem(face);
+      x.hb_face_destroy(face);
+      x.hb_blob_destroy(blob);
+      return { ptr, upem };
+    },
+    /**
+     * Shape one run (one font, one script, one direction).
+     * @param {{ ptr: number }} font @param {string} text @param {boolean} rtl
+     * @param {boolean} [plain] kerning and ligatures off (a simple-script run in a right-to-left context)
+     * @returns {number[]} [glyph id, x advance, x offset, y offset, cluster (UTF-16 index)] per glyph, in visual order
+     */
+    shape(font, text, rtl, plain = false) {
+      const n2 = text.length;
+      const p = x.malloc(n2 * 2 + 2);
+      const u16 = new Uint16Array(memory.buffer, p, n2);
+      for (let i = 0; i < n2; i++) u16[i] = text.charCodeAt(i);
+      const b = x.hb_buffer_create();
+      x.hb_buffer_add_utf16(b, p, n2, 0, n2);
+      x.hb_buffer_set_direction(b, rtl ? RTL : LTR);
+      x.hb_buffer_guess_segment_properties(b);
+      x.hb_shape(font.ptr, b, plain ? featPtr : 0, plain ? PLAIN.length : 0);
+      const len = x.hb_buffer_get_length(b);
+      const info = new Uint32Array(memory.buffer, x.hb_buffer_get_glyph_infos(b, 0), len * 5);
+      const pos = new Int32Array(memory.buffer, x.hb_buffer_get_glyph_positions(b, 0), len * 5);
+      const out = new Array(len * 5);
+      for (let i = 0; i < len; i++) {
+        out[i * 5] = info[i * 5];
+        out[i * 5 + 1] = pos[i * 5];
+        out[i * 5 + 2] = pos[i * 5 + 2];
+        out[i * 5 + 3] = pos[i * 5 + 3];
+        out[i * 5 + 4] = info[i * 5 + 2];
+      }
+      x.hb_buffer_destroy(b);
+      x.free(p);
+      return out;
+    }
+  };
+}
+
+// src/engine/text/fonts.js
+var fontkit = (
+  /** @type {any} */
+  fontkitModule.default || fontkitModule
+);
+var BUNDLED = [
+  ["Inter", "Inter-Regular", 400],
+  ["Inter", "Inter-Italic", 400, "italic"],
+  ["Inter", "Inter-SemiBold", 600],
+  ["Inter", "Inter-Bold", 700],
+  ["Inter", "Inter-BoldItalic", 700, "italic"],
+  ["JetBrains Mono", "JetBrainsMono-Regular", 400],
+  ["JetBrains Mono", "JetBrainsMono-Bold", 700],
+  ["Noto Sans Devanagari", "NotoSansDevanagari-Regular", 400],
+  ["Noto Sans Devanagari", "NotoSansDevanagari-Bold", 700],
+  ["Noto Sans Arabic", "NotoSansArabic-Regular", 400],
+  ["Noto Sans Arabic", "NotoSansArabic-Bold", 700],
+  ["Noto Sans Hebrew", "NotoSansHebrew-Regular", 400],
+  ["Noto Sans Hebrew", "NotoSansHebrew-Bold", 700],
+  // fallbacks loaded only when text uses the script (docs/TEXT.md has the sizes)
+  ...["Thai", "Lao", "Khmer", "Myanmar", "Tamil", "Bengali", "Telugu", "Kannada", "Gujarati"].flatMap((s) => [
+    [`Noto Sans ${s}`, `NotoSans${s}-Regular`, 400],
+    [`Noto Sans ${s}`, `NotoSans${s}-Bold`, 700]
+  ]),
+  // optional, about 40 MB (npm run fonts:cjk fetches them into /fonts/cjk): variable fonts drawn at their default
+  // (regular) weight. Without them the text shows as boxes, and the warning says how to add them.
+  ["Noto Sans JP", "NotoSansJP", 400, "normal", "cjk/NotoSansJP.ttf"],
+  ["Noto Sans KR", "NotoSansKR", 400, "normal", "cjk/NotoSansKR.ttf"],
+  ["Noto Sans SC", "NotoSansSC", 400, "normal", "cjk/NotoSansSC.ttf"],
+  ["Noto Emoji", "NotoEmoji", 400, "normal", "cjk/NotoEmoji.ttf"]
+];
+var OPTIONAL_KEYS = ["NotoSansJP", "NotoSansKR", "NotoSansSC", "NotoEmoji"];
+var FONT_FAMILIES = {};
+var FACES = /* @__PURE__ */ new Map();
+var addFace = (f) => {
+  var _a;
+  (FONT_FAMILIES[_a = f.family] || (FONT_FAMILIES[_a] = [])).push(f);
+  FACES.set(f.key, f);
+};
+for (const [family, key, weight, style = "normal", file] of BUNDLED) {
+  addFace({ family: String(family), key: String(key), weight: Number(weight), style: style === "italic" ? "italic" : "normal", file: String(file || `${key}.ttf`) });
+}
+var BUNDLED_FAMILIES = Object.keys(FONT_FAMILIES);
+var DEFAULT_FAMILY = "Inter";
+var ALL_FONT_KEYS = [...FONT_FAMILIES.Inter, ...FONT_FAMILIES["JetBrains Mono"]].map((f) => f.key);
+var CORE_FONT_KEY = "Inter-Regular";
+var PRELOAD_KEYS = [...ALL_FONT_KEYS];
+var SHAPER = "harfbuzz";
+function fontFile(key) {
+  if (key === SHAPER) return "harfbuzz.wasm";
+  return FACES.get(key)?.file || `${key}.ttf`;
+}
+function setCustomFonts(list) {
+  for (const [k, f] of FACES) if (k.startsWith("u-")) {
+    FACES.delete(k);
+    const left = FONT_FAMILIES[f.family].filter((x) => x.key !== k);
+    if (left.length) FONT_FAMILIES[f.family] = left;
+    else delete FONT_FAMILIES[f.family];
+  }
+  for (const f of list || []) {
+    if (BUNDLED_FAMILIES.includes(f.family) || !/^[a-f0-9]{8,64}$/.test(String(f.id))) continue;
+    addFace({ key: `u-${f.id}`, family: String(f.family), weight: Number(f.weight) || 400, style: f.style === "italic" ? "italic" : "normal", file: `custom/${f.id}` });
+  }
+}
+function resolveFontKey(family, weight, style) {
+  const faces = FONT_FAMILIES[family || DEFAULT_FAMILY] || FONT_FAMILIES[DEFAULT_FAMILY];
+  const w = weight === "bold" ? 700 : weight === "normal" || weight == null ? 400 : Number(weight) || 400;
+  const italic = faces.filter((f) => f.style === "italic");
+  const list = style === "italic" && italic.length ? italic : faces.filter((f) => f.style !== "italic").length ? faces.filter((f) => f.style !== "italic") : faces;
+  const rank = (f) => {
+    const fw = f.weight;
+    if (w >= 400 && w <= 500) return fw >= w && fw <= 500 ? fw - w : fw < w ? 1e3 + w - fw : 2e3 + fw - w;
+    if (w < 400) return fw <= w ? w - fw : 1e3 + fw - w;
+    return fw >= w ? fw - w : 1e3 + w - fw;
+  };
+  return list.reduce((best, f) => rank(f) < rank(best) ? f : best).key;
+}
+function fontCss(key) {
+  const f = FACES.get(key);
+  return f ? { family: f.family, weight: f.weight, style: f.style } : { family: DEFAULT_FAMILY, weight: 400, style: "normal" };
+}
+var FALLBACK = [
+  [1424, 1535, "Noto Sans Hebrew"],
+  [64285, 64335, "Noto Sans Hebrew"],
+  [1536, 2303, "Noto Sans Arabic"],
+  [64336, 65023, "Noto Sans Arabic"],
+  [65136, 65278, "Noto Sans Arabic"],
+  [2304, 2431, "Noto Sans Devanagari"],
+  [43232, 43263, "Noto Sans Devanagari"],
+  [7376, 7423, "Noto Sans Devanagari"],
+  [2432, 2559, "Noto Sans Bengali"],
+  [2688, 2815, "Noto Sans Gujarati"],
+  [2944, 3071, "Noto Sans Tamil"],
+  [73664, 73727, "Noto Sans Tamil"],
+  [3072, 3199, "Noto Sans Telugu"],
+  [3200, 3327, "Noto Sans Kannada"],
+  [3584, 3711, "Noto Sans Thai"],
+  [3712, 3839, "Noto Sans Lao"],
+  [4096, 4255, "Noto Sans Myanmar"],
+  [43488, 43519, "Noto Sans Myanmar"],
+  [43616, 43647, "Noto Sans Myanmar"],
+  [6016, 6143, "Noto Sans Khmer"],
+  [6624, 6655, "Noto Sans Khmer"],
+  // CJK (optional fonts): kana and Han in the Japanese face (Han shapes differ a little from Chinese; a report can
+  // set fontFamily "Noto Sans SC"), Hangul in the Korean one; emoji in Noto Emoji (monochrome)
+  [12352, 12543, "Noto Sans JP"],
+  [12784, 12799, "Noto Sans JP"],
+  [12288, 12351, "Noto Sans JP"],
+  [13312, 19903, "Noto Sans JP"],
+  [19968, 40959, "Noto Sans JP"],
+  [63744, 64255, "Noto Sans JP"],
+  [65280, 65519, "Noto Sans JP"],
+  [4352, 4607, "Noto Sans KR"],
+  [12592, 12687, "Noto Sans KR"],
+  [44032, 55215, "Noto Sans KR"],
+  [126976, 129791, "Noto Emoji"],
+  [9728, 10175, "Noto Emoji"],
+  [11008, 11263, "Noto Emoji"]
+];
+var allFontKeys = () => [...FACES.keys()];
+function fallbackKeys(key) {
+  const c = fontCss(key);
+  return [...new Set(FALLBACK.map((f) => String(f[2])))].map((family) => resolveFontKey(family, c.weight, c.style));
+}
+function unicodeRange(key) {
+  const family = FACES.get(key)?.family;
+  const r = FALLBACK.filter((f) => f[2] === family).map(([a, b]) => `U+${Number(a).toString(16)}-${Number(b).toString(16)}`);
+  return r.length ? [...r, "U+300-36F", "U+2000-206F", "U+25CC", "U+FE00-FE0F"].join(",") : null;
+}
+function fallbackKey(cp, key) {
+  for (const [a, b, family] of FALLBACK) {
+    if (cp >= /** @type {number} */
+    a && cp <= /** @type {number} */
+    b) {
+      const c = fontCss(key);
+      return resolveFontKey(String(family), c.weight, c.style);
+    }
+  }
+  return null;
+}
+var SIMPLE_FALLBACK = /* @__PURE__ */ new Set(["Noto Sans JP", "Noto Sans KR", "Noto Emoji"]);
+var BEYOND_LATIN = /[^\u0000-\u024f\u1e00-\u1eff\u2000-\u20cf\u2100-\u218f]/;
+function fontsForDef(def) {
+  const keys = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (o) => {
+    if (!o || typeof o !== "object" || seen.has(o)) return;
+    seen.add(o);
+    if (Array.isArray(o)) {
+      for (const x of o) walk(x);
+      return;
+    }
+    if (o.fontFamily != null || o.fontWeight != null || o.fontStyle != null) keys.add(resolveFontKey(o.fontFamily, o.fontWeight, o.fontStyle));
+    if (o.type === "chart") keys.add(resolveFontKey(o.fontFamily, "bold", "normal"));
+    for (const [k, v] of Object.entries(o)) if (v && typeof v === "object" && k !== "dataSources" && k !== "data") walk(v);
+  };
+  walk(def);
+  return [...keys];
+}
+function fontsFor(texts) {
+  const keys = /* @__PURE__ */ new Set(), seen = /* @__PURE__ */ new Set();
+  let shaper = false;
+  for (const t of texts) {
+    if (typeof t !== "string" || !BEYOND_LATIN.test(t)) continue;
+    for (const ch of t) {
+      const cp = (
+        /** @type {number} */
+        ch.codePointAt(0)
+      );
+      if (cp < 592 || seen.has(cp)) continue;
+      seen.add(cp);
+      for (const [a, b, family] of FALLBACK) {
+        if (cp < /** @type {number} */
+        a || cp > /** @type {number} */
+        b) continue;
+        keys.add(resolveFontKey(String(family), 400, "normal")).add(resolveFontKey(String(family), 700, "normal"));
+        if (!SIMPLE_FALLBACK.has(String(family))) shaper = true;
+        break;
+      }
+    }
+  }
+  if (shaper) keys.add(SHAPER);
+  return [...keys];
+}
+var FontStore = class {
+  /** @param {(key: string) => Promise<ArrayBuffer|Uint8Array>} loader */
+  constructor(loader) {
+    this.loader = loader;
+    this.fonts = /* @__PURE__ */ new Map();
+    this.bytes = /* @__PURE__ */ new Map();
+    this.pending = /* @__PURE__ */ new Map();
+    this.failed = /* @__PURE__ */ new Set();
+    this.shaper = null;
+    this.hb = /* @__PURE__ */ new Map();
+  }
+  /** @param {string[]} keys */
+  async load(keys = ALL_FONT_KEYS) {
+    await Promise.all(keys.map((k) => {
+      if (this.fonts.has(k) || this.failed.has(k) || k === SHAPER && this.shaper) return null;
+      if (!this.pending.has(k)) {
+        this.pending.set(k, (async () => {
+          try {
+            const b = await this.loader(k);
+            const u8 = b instanceof Uint8Array ? b : new Uint8Array(b);
+            if (k === SHAPER) {
+              this.shaper = await createShaper(u8);
+              return;
+            }
+            this.fonts.set(k, fontkit.create(u8));
+            this.bytes.set(k, u8);
+          } catch (e) {
+            this.pending.delete(k);
+            if (k === CORE_FONT_KEY) throw e;
+            this.failed.add(k);
+          }
+        })());
+      }
+      return this.pending.get(k);
+    }));
+  }
+  /** @param {string} key */
+  has(key) {
+    return this.fonts.has(key);
+  }
+  /** The HarfBuzz font for a loaded key (the shaper must be loaded). @param {string} key */
+  hbFont(key) {
+    let f = this.hb.get(key);
+    if (!f) {
+      f = this.shaper.font(this.bytes.get(key));
+      this.hb.set(key, f);
+    }
+    return f;
+  }
+  /** @param {string} key */
+  get(key) {
+    const f = this.fonts.get(key);
+    if (!f) throw new Error(`Font "${key}" is not loaded`);
+    return f;
+  }
+};
+
+// src/engine/image.js
+var IMAGE_LIMITS = {
+  bytes: 10 * 1024 * 1024,
+  // one image
+  total: 50 * 1024 * 1024,
+  // all images of one render (each distinct image counted once)
+  pixels: 4e7,
+  // a PNG larger than this is not decoded (a small file can inflate to gigabytes)
+  svgBytes: 2 * 1024 * 1024,
+  // an SVG drawn as vector paths in the PDF
+  svgShapes: 1e4
+};
+var PX = 0.75;
+var MIME = { png: "image/png", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp", svg: "image/svg+xml" };
+function sniff(b) {
+  if (b.length >= 8 && b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71) return "png";
+  if (b.length >= 3 && b[0] === 255 && b[1] === 216 && b[2] === 255) return "jpeg";
+  if (b.length >= 6 && b[0] === 71 && b[1] === 73 && b[2] === 70 && b[3] === 56) return "gif";
+  if (b.length >= 12 && b[0] === 82 && b[1] === 73 && b[2] === 70 && b[3] === 70 && b[8] === 87 && b[9] === 69 && b[10] === 66 && b[11] === 80) return "webp";
+  const head = String.fromCharCode(...b.subarray(0, 512)).replace(/^|^\xEF\xBB\xBF/, "").trimStart();
+  if (/^<(\?xml|svg|!--|!DOCTYPE svg)/i.test(head) && /<svg[\s>]/i.test(head + (b.length > 512 ? "<svg " : ""))) return "svg";
+  return null;
+}
+function toBase64(b) {
+  let s = "";
+  for (let i = 0; i < b.length; i += 32768) s += String.fromCharCode(...b.subarray(i, i + 32768));
+  return btoa(s);
+}
+function fromBase64(s) {
+  const bin = atob(s);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+var B64 = /^[A-Za-z0-9+/]+={0,2}$/;
+function toDataUri(v) {
+  if (v instanceof ArrayBuffer) v = new Uint8Array(v);
+  if (v instanceof Uint8Array) {
+    if (v.length > IMAGE_LIMITS.bytes) return null;
+    const type2 = sniff(v);
+    return type2 ? `data:${MIME[type2]};base64,${toBase64(v)}` : null;
+  }
+  if (typeof v !== "string" || v.length < 16 || v.startsWith("data:")) return v;
+  if (/[^A-Za-z0-9+/=\r\n]/.test(v)) return v;
+  const s = v.replace(/[\r\n]/g, "");
+  if (!B64.test(s) || s.length % 4) return v;
+  let type;
+  try {
+    type = sniff(fromBase64(s.slice(0, 700)));
+  } catch {
+    return v;
+  }
+  return type ? `data:${MIME[type]};base64,${s}` : v;
+}
+function splitDataUri(uri) {
+  if (typeof uri !== "string" || !/^data:/i.test(uri)) return null;
+  const c = uri.indexOf(",");
+  if (c < 0) return null;
+  const meta = uri.slice(5, c);
+  return { meta, b64: meta.slice(meta.lastIndexOf(";") + 1).trim().toLowerCase() === "base64" && meta.includes(";"), body: uri.slice(c + 1) };
+}
+function dataUriBytes(uri) {
+  const d = splitDataUri(uri);
+  if (!d) return 0;
+  return d.b64 ? Math.floor(d.body.length * 3 / 4) : d.body.length;
+}
+function dataUriHead(uri, max = 262144) {
+  const d = splitDataUri(uri);
+  if (!d) return null;
+  try {
+    if (d.b64) return fromBase64(d.body.slice(0, Number.isFinite(max) ? Math.ceil(max / 3) * 4 : void 0).replace(/\s/g, ""));
+    return new TextEncoder().encode(decodeURIComponent(d.body.slice(0, max)));
+  } catch {
+    return null;
+  }
+}
+function dataUriBytesOf(uri) {
+  return dataUriHead(uri, Infinity);
+}
+var UNIT = { px: 1, pt: 4 / 3, pc: 16, mm: 96 / 25.4, cm: 96 / 2.54, in: 96, "": 1 };
+function svgLength(v) {
+  const t = String(v ?? "").trim();
+  if (t.length > 64) return null;
+  const m = /^([\d.]+(?:e[-+]?\d+)?)(px|pt|pc|mm|cm|in)?$/i.exec(t);
+  if (!m) return null;
+  const n2 = Number(m[1]) * UNIT[(m[2] || "").toLowerCase()];
+  return Number.isFinite(n2) && n2 > 0 ? n2 : null;
+}
+var isName = (c) => c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c >= "0" && c <= "9" || c === "_" || c === ":" || c === "-" || c === ".";
+var isSpace = (c) => c === " " || c === "	" || c === "\n" || c === "\r";
+function* xmlTags(text) {
+  const n2 = text.length;
+  let i = 0;
+  while (i < n2) {
+    const lt = text.indexOf("<", i);
+    if (lt < 0) return;
+    if (text.startsWith("<!--", lt)) {
+      const e = text.indexOf("-->", lt + 4);
+      if (e < 0) return;
+      i = e + 3;
+      continue;
+    }
+    if (text.startsWith("<![CDATA[", lt)) {
+      const e = text.indexOf("]]>", lt + 9);
+      if (e < 0) return;
+      i = e + 3;
+      continue;
+    }
+    if (text[lt + 1] === "?" || text[lt + 1] === "!") {
+      const e = text.indexOf(">", lt + 2);
+      if (e < 0) return;
+      i = e + 1;
+      continue;
+    }
+    let j = lt + 1, q = "";
+    for (; j < n2; j++) {
+      const c = text[j];
+      if (q) {
+        if (c === q) q = "";
+      } else if (c === '"' || c === "'") q = c;
+      else if (c === ">") break;
+    }
+    if (j >= n2) return;
+    i = j + 1;
+    let body = text.slice(lt + 1, j);
+    const close = body[0] === "/";
+    if (close) body = body.slice(1);
+    const self = body.endsWith("/");
+    if (self) body = body.slice(0, -1);
+    let k = 0;
+    while (k < body.length && isName(body[k])) k++;
+    const name = body.slice(0, k);
+    if (!/^[a-zA-Z]/.test(name)) continue;
+    yield { close, name, attrs: body.slice(k), self };
+  }
+}
+function xmlAttrs(s) {
+  const a = /* @__PURE__ */ Object.create(null);
+  const n2 = s.length;
+  let i = 0;
+  while (i < n2) {
+    while (i < n2 && !isName(s[i])) i++;
+    const st = i;
+    while (i < n2 && isName(s[i])) i++;
+    const name = s.slice(st, i);
+    while (i < n2 && isSpace(s[i])) i++;
+    if (s[i] !== "=") continue;
+    i++;
+    while (i < n2 && isSpace(s[i])) i++;
+    const q = s[i];
+    if (q !== '"' && q !== "'") continue;
+    const e = s.indexOf(q, i + 1);
+    if (e < 0) break;
+    if (name) a[name] = s.slice(i + 1, e);
+    i = e + 1;
+  }
+  return a;
+}
+function svgRootAttrs(text) {
+  for (const t of xmlTags(String(text))) if (!t.close && t.name.toLowerCase() === "svg") return xmlAttrs(t.attrs);
+  return null;
+}
+function svgSize(text) {
+  const a = svgRootAttrs(text);
+  if (!a) return null;
+  const vb = String(a.viewBox || "").trim().split(/[\s,]+/).map(Number);
+  const hasVb = vb.length === 4 && vb.every(Number.isFinite) && vb[2] > 0 && vb[3] > 0;
+  let w = svgLength(a.width), h = svgLength(a.height);
+  if (w && !h) h = hasVb ? w * vb[3] / vb[2] : null;
+  if (h && !w) w = hasVb ? h * vb[2] / vb[3] : null;
+  if (!w && hasVb) {
+    w = vb[2];
+    h = vb[3];
+  }
+  return w && h ? { w, h } : null;
+}
+function imageInfoOf(b) {
+  const type = sniff(b);
+  if (!type) return null;
+  const u32 = (i) => (b[i] << 24 | b[i + 1] << 16 | b[i + 2] << 8 | b[i + 3]) >>> 0;
+  if (type === "png") return pngInfo(b);
+  if (type === "gif" && b.length >= 10) return { type, w: b[6] | b[7] << 8, h: b[8] | b[9] << 8 };
+  if (type === "jpeg") {
+    for (let i = 2; i + 9 < b.length; ) {
+      if (b[i] !== 255) {
+        i++;
+        continue;
+      }
+      const mk = b[i + 1];
+      if (mk === 255) {
+        i++;
+        continue;
+      }
+      if (mk === 216 || mk === 1 || mk >= 208 && mk <= 215) {
+        i += 2;
+        continue;
+      }
+      if (mk >= 192 && mk <= 207 && mk !== 196 && mk !== 200 && mk !== 204) return { type, w: b[i + 7] << 8 | b[i + 8], h: b[i + 5] << 8 | b[i + 6] };
+      i += 2 + (b[i + 2] << 8 | b[i + 3]);
+    }
+    return { type };
+  }
+  if (type === "svg") {
+    const s = svgSize(new TextDecoder().decode(b));
+    return s ? { type, ...s } : { type };
+  }
+  return { type };
+}
+function pngInfo(b) {
+  const u32 = (i) => (b[i] << 24 | b[i + 1] << 16 | b[i + 2] << 8 | b[i + 3]) >>> 0;
+  let w = 0, h = 0, ihdrs = 0, animated = false;
+  for (let off = 8; off + 8 <= b.length; ) {
+    const len = u32(off);
+    const t = String.fromCharCode(b[off + 4], b[off + 5], b[off + 6], b[off + 7]);
+    const d = off + 8;
+    if (t === "IHDR" && d + 8 <= b.length) {
+      w = u32(d);
+      h = u32(d + 4);
+      ihdrs++;
+    } else if (t === "acTL" || t === "fcTL" || t === "fdAT") animated = true;
+    else if (t === "IEND") break;
+    off = d + len + 4;
+  }
+  if (!ihdrs) return { type: "png" };
+  return { type: "png", w, h, ...animated || ihdrs > 1 ? { suspect: true } : {} };
+}
+function imageInfo(uri) {
+  const b = typeof uri === "string" && uri.startsWith("data:") ? dataUriHead(uri) : null;
+  return b ? imageInfoOf(b) : null;
+}
+function resolveImageSrc(v, who, c) {
+  var _a;
+  if (v == null || v === "" || v === "#Error") return null;
+  if (typeof v === "string" && v.startsWith("embedded:")) {
+    const name = v.slice(9);
+    const img = c.images && Object.prototype.hasOwnProperty.call(c.images, name) ? c.images[name] : void 0;
+    if (typeof img !== "string" || !/^data:image\/[\w.+-]+[;,]/i.test(img)) {
+      c.warn(`${who}: there is no embedded image named "${name}" (add it to the report's images as a data:image/… URI)`);
+      return null;
+    }
+    v = img;
+  }
+  const memo = c.budget ? (_a = c.budget).memo || (_a.memo = /* @__PURE__ */ new Map()) : null;
+  let u = memo?.get(v);
+  if (u === void 0) {
+    u = toDataUri(v);
+    memo?.set(v, u);
+  }
+  if (u == null) {
+    c.warn(`${who}: the image data is not a PNG, JPEG, GIF, WebP or SVG image, or is larger than 10 MB`);
+    return null;
+  }
+  const s = String(u);
+  if (s.startsWith("data:")) {
+    const n2 = dataUriBytes(s);
+    if (n2 > IMAGE_LIMITS.bytes) {
+      c.warn(`${who}: the image is ${(n2 / 1048576).toFixed(1)} MB; images are limited to 10 MB each, so it is left out`);
+      return null;
+    }
+    const b = c.budget;
+    if (b && !b.seen.has(s)) {
+      if (b.bytes + n2 > IMAGE_LIMITS.total) {
+        c.warn(`${who}: the report's images pass 50 MB in all, so this one is left out`);
+        return null;
+      }
+      b.seen.add(s);
+      b.bytes += n2;
+    }
+  }
+  return s;
+}
+
+// src/exporters/color.js
+var NAMED = { black: "#000000", white: "#ffffff", red: "#ff0000", green: "#008000", blue: "#0000ff", gray: "#808080", grey: "#808080", orange: "#ffa500", yellow: "#ffff00" };
+function parseColor(c) {
+  if (!c || c === "none" || c === "transparent") return null;
+  let s = String(c).trim().toLowerCase();
+  if (NAMED[s]) s = NAMED[s];
+  let m = /^#([0-9a-f]{3,8})$/.exec(s);
+  if (m) {
+    let h = m[1];
+    if (h.length === 3 || h.length === 4) h = [...h].map((x) => x + x).join("");
+    const n2 = parseInt(h.slice(0, 6), 16);
+    const a = h.length === 8 ? parseInt(h.slice(6, 8), 16) / 255 : 1;
+    return { r: (n2 >> 16 & 255) / 255, g: (n2 >> 8 & 255) / 255, b: (n2 & 255) / 255, a };
+  }
+  m = /^rgba?\(([^)]+)\)$/.exec(s);
+  if (m) {
+    const [r, g, b, a = 1] = m[1].split(/[\s,/]+/).map(Number);
+    return { r: r / 255, g: g / 255, b: b / 255, a };
+  }
+  return null;
+}
+function cssColor(c) {
+  const p = parseColor(c);
+  if (!p) return "none";
+  return `rgba(${Math.round(p.r * 255)},${Math.round(p.g * 255)},${Math.round(p.b * 255)},${p.a})`;
+}
+
+// src/exporters/svg.js
+var fontFamilyCss = (key) => `pw-${key}`;
+var esc = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+function imageHref(src, proxyBase = "") {
+  const s = String(src ?? "").trim();
+  if (/^data:image\/(png|jpe?g|gif|webp|bmp|svg\+xml)[;,]/i.test(s)) return s;
+  if (/^https?:\/\//i.test(s)) return `${proxyBase}/api/data/proxy?url=${encodeURIComponent(s)}`;
+  if (s && !/^[a-z][a-z0-9+.-]*:/i.test(s) && !s.startsWith("//") && !s.includes("\\")) return s;
+  return "";
+}
+var n = (v) => Math.round(v * 100) / 100;
+var ANIM_CSS = "<style>@media (prefers-reduced-motion:no-preference){.pw-a{transform-box:fill-box;animation:pw-fade .55s ease-out both}.pw-a-growY{animation-name:pw-growY}.pw-a-growX{animation-name:pw-growX}.pw-a-scale{animation-name:pw-scale}@keyframes pw-fade{from{opacity:0}}@keyframes pw-growY{from{transform:scaleY(0)}}@keyframes pw-growX{from{transform:scaleX(0)}}@keyframes pw-scale{from{trans\
+form:scale(0);opacity:0}}}</style>";
+var ANIM_KINDS = /* @__PURE__ */ new Set(["growY", "growX", "scale", "fade"]);
+var ANIM_ORIGIN = { bottom: "center bottom", top: "center top", left: "left center", right: "right center" };
+function pageToSvg(page, w, h, { background = true, animate = false, box = void 0, outline = null, proxyBase = "" } = {}) {
+  const vb = box ? `${n(box.x)} ${n(box.y)} ${n(box.w)} ${n(box.h)}` : `0 0 ${n(w)} ${n(h)}`;
+  const out = [`<svg xmlns="http://www.w3.org/2000/svg" viewBox="${vb}" width="${n(w)}" height="${n(h)}" style="font-kerning:none;font-variant-ligatures:none;text-rendering:geometricPrecision">`];
+  if (background) out.push(`<rect width="${n(w)}" height="${n(h)}" fill="#ffffff"/>`);
+  let animated = false;
+  for (const it of page.items.flatMap((i) => i.t === "field" ? i.draw : [i])) {
+    const an = animate && it.anim && ANIM_KINDS.has(it.anim.k) ? it.anim : null;
+    if (an) {
+      if (!animated) {
+        out.push(ANIM_CSS);
+        animated = true;
+      }
+      const origin = ANIM_ORIGIN[an.o] || "center";
+      out.push(`<g class="pw-a pw-a-${an.k}" style="transform-origin:${origin};animation-delay:${Math.min(40, Math.max(0, Math.round(Number(an.i)) || 0)) * 25}ms">`);
+    }
+    if (it.rotate) out.push(`<g transform="rotate(${n(it.rotate.a)} ${n(it.rotate.cx)} ${n(it.rotate.cy)})">`);
+    switch (it.t) {
+      case "rect": {
+        const r = it.radius ? ` rx="${n(it.radius)}"` : "";
+        const stroke = it.stroke ? ` stroke="${cssColor(it.stroke)}" stroke-width="${n(it.strokeWidth || 1)}"${it.dash ? ` stroke-dasharray="${it.dash.join(" ")}"` : ""}` : "";
+        out.push(`<rect x="${n(it.x)}" y="${n(it.y)}" width="${n(it.w)}" height="${n(it.h)}"${r} fill="${cssColor(it.fill)}"${stroke}/>`);
+        break;
+      }
+      case "ellipse": {
+        const stroke = it.stroke ? ` stroke="${cssColor(it.stroke)}" stroke-width="${n(it.strokeWidth || 1)}"` : "";
+        out.push(`<ellipse cx="${n(it.cx)}" cy="${n(it.cy)}" rx="${n(it.rx)}" ry="${n(it.ry)}" fill="${cssColor(it.fill)}"${stroke}/>`);
+        break;
+      }
+      case "line":
+        out.push(`<line x1="${n(it.x1)}" y1="${n(it.y1)}" x2="${n(it.x2)}" y2="${n(it.y2)}" stroke="${cssColor(it.stroke)}" stroke-width="${n(it.strokeWidth)}"${it.dash ? ` stroke-dasharray="${it.dash.join(" ")}"` : ""}/>`);
+        break;
+      case "text": {
+        const d = outline ? textOutline(it, outline) : null;
+        if (d) {
+          out.push(`<path d="${d}" fill="${cssColor(it.color)}"/>`);
+          break;
+        }
+        const paint = `font-size="${n(it.size)}" fill="${cssColor(it.color)}"`;
+        const attrs = `font-family="${fontFamilyCss(it.font)}" ${paint}`;
+        for (const l of it.lines) {
+          if (!l.runs) {
+            out.push(`<text x="${n(l.x)}" y="${n(l.y)}" ${attrs} xml:space="preserve">${esc(l.text)}</text>`);
+            continue;
+          }
+          for (const r of l.runs) {
+            if (!r.text.trim()) continue;
+            const font = `font-family="${fontFamilyCss(r.font)}" ${paint}`;
+            if (!r.shaped && !r.rtl) {
+              out.push(`<text x="${n(l.x + r.x)}" y="${n(l.y)}" ${font}>${esc(r.text)}</text>`);
+              continue;
+            }
+            const style = (r.rtl ? "direction:rtl;unicode-bidi:bidi-override;" : "") + (r.shaped ? "font-kerning:normal;font-variant-ligatures:normal" : "");
+            out.push(`<text x="${n(l.x + r.x + r.w / 2)}" y="${n(l.y)}" text-anchor="middle" ${font} style="${style}">${esc(r.text)}</text>`);
+          }
+        }
+        break;
+      }
+      case "path": {
+        const stroke = it.stroke ? ` stroke="${cssColor(it.stroke)}" stroke-width="${n(it.strokeWidth || 1)}" stroke-linecap="${it.lineCap || "round"}" stroke-linejoin="round"${it.dash ? ` stroke-dasharray="${it.dash.join(" ")}"` : ""}` : "";
+        out.push(`<path transform="translate(${n(it.x)} ${n(it.y)})" d="${esc(it.d)}" fill="${cssColor(it.fill)}"${stroke}/>`);
+        break;
+      }
+      case "link": {
+        const tip = it.tip ?? (it.action ? linkTitle(it.action) : "");
+        const title = tip ? `<title>${esc(tip)}</title>` : "";
+        const tag = it.d ? "path" : "rect";
+        const geo = it.d ? `transform="translate(${n(it.x - (it.x0 ?? it.x))} ${n(it.y - (it.y0 ?? it.y))})" d="${esc(it.d)}"` : `x="${n(it.x)}" y="${n(it.y)}" width="${n(it.w)}" height="${n(it.h)}"`;
+        if (!it.action) out.push(`<${tag} class="pw-tip" ${geo} fill="transparent">${title}</${tag}>`);
+        else out.push(`<${tag} class="pw-link" ${geo} fill="transparent" data-action="${esc(JSON.stringify(it.action))}" style="cursor:pointer">${title}</${tag}>`);
+        break;
+      }
+      case "image": {
+        if (it.fit === "clip") out.push(`<svg x="${n(it.x)}" y="${n(it.y)}" width="${n(it.cw)}" height="${n(it.ch)}" overflow="hidden"><image x="0" y="0" width="${n(it.w)}" height="${n(it.h)}" href="${esc(imageHref(it.src, proxyBase))}" preserveAspectRatio="none"/></svg>`);
+        else {
+          const par = it.fit === "fill" ? "none" : it.fit === "cover" ? "xMidYMid slice" : "xMidYMid meet";
+          out.push(`<image x="${n(it.x)}" y="${n(it.y)}" width="${n(it.w)}" height="${n(it.h)}" href="${esc(imageHref(it.src, proxyBase))}" preserveAspectRatio="${par}"/>`);
+        }
+        break;
+      }
+    }
+    if (it.rotate) out.push("</g>");
+    if (an) out.push("</g>");
+  }
+  out.push("</svg>");
+  return out.join("");
+}
+function linkTitle(a) {
+  if (a.type === "url") return a.href;
+  if (a.type === "drill") return `Open ${a.report}`;
+  if (a.type === "toggle") return "Show or hide details";
+  if (a.type === "sort") return "Sort";
+  if (a.type === "bookmark") return `Go to ${a.target}`;
+  if (a.type === "params") return "Filter the report";
+  return "";
+}
+function fontFaceCss(keys, base = "/fonts") {
+  return keys.map((k) => {
+    const file = fontFile(k), range = unicodeRange(k);
+    return `@font-face{font-family:"${fontFamilyCss(k)}";src:url("${base}/${file}")${file.endsWith(".ttf") ? ' format("truetype")' : ""};font-display:block${range ? `;unicode-range:${range}` : ""}}`;
+  }).join("\n");
+}
+function fontKeysOf(model) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const pg of model?.pages || []) for (const it of pg.items.flatMap((i) => i.t === "field" ? [i, ...i.draw] : [i])) {
+    if (it.font) keys.add(it.font);
+    if (it.t === "text") for (const l of it.lines) for (const r of l.runs || []) keys.add(r.font);
+  }
+  return [...keys];
+}
+
+// src/exporters/figures.js
+var FIGURE_KINDS = /* @__PURE__ */ new Set(["image", "chart", "map", "barcode", "shape", "line", "sparkline", "databar", "bullet", "iconset", "rangebar"]);
+function figures(items) {
+  const shared = items.some((it, i) => i > 0 && it.tag && it.tag === items[i - 1].tag);
+  const same = (a, b) => a === b || !!a && !!b && (a.id != null ? a.id === b.id : !shared && a.k === b.k && a.alt === b.alt && a.h === b.h);
+  const out = [];
+  let cur = null;
+  items.forEach((it, i) => {
+    const t = it.tag;
+    if (!t || !FIGURE_KINDS.has(t.k)) {
+      cur = null;
+      return;
+    }
+    if (cur && same(cur.tag, t) && cur.last === i - 1) {
+      cur.items.push(it);
+      cur.last = i;
+      return;
+    }
+    cur = { tag: t, items: [it], at: i, last: i };
+    out.push(cur);
+  });
+  for (const f of out) f.box = boxOf(f.items);
+  return out.filter((f) => f.box && f.box.w > 0.5 && f.box.h > 0.5);
+}
+function boxOf(items) {
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  const add = (x, y, rot) => {
+    if (rot) {
+      const a = rot.a * Math.PI / 180, dx = x - rot.cx, dy = y - rot.cy;
+      x = rot.cx + dx * Math.cos(a) - dy * Math.sin(a);
+      y = rot.cy + dx * Math.sin(a) + dy * Math.cos(a);
+    }
+    if (!Number.isFinite(x) || !Number.isFinite(y)) return;
+    if (x < x0) x0 = x;
+    if (x > x1) x1 = x;
+    if (y < y0) y0 = y;
+    if (y > y1) y1 = y;
+  };
+  const rect = (x, y, w, h, r) => {
+    add(x, y, r);
+    add(x + w, y, r);
+    add(x, y + h, r);
+    add(x + w, y + h, r);
+  };
+  for (const it of items) {
+    const r = it.rotate;
+    const sw = (it.stroke ? Number(it.strokeWidth) || 1 : 0) / 2;
+    switch (it.t) {
+      case "rect":
+      case "image":
+        rect(it.x - sw, it.y - sw, (it.cw ?? it.w) + 2 * sw, (it.ch ?? it.h) + 2 * sw, r);
+        break;
+      case "ellipse":
+        rect(it.cx - it.rx - sw, it.cy - it.ry - sw, 2 * (it.rx + sw), 2 * (it.ry + sw), r);
+        break;
+      case "line":
+        rect(Math.min(it.x1, it.x2) - sw, Math.min(it.y1, it.y2) - sw, Math.abs(it.x2 - it.x1) + 2 * sw, Math.abs(it.y2 - it.y1) + 2 * sw, r);
+        break;
+      case "text":
+        for (const l of it.lines) rect(l.x, l.y - it.size, l.w ?? l.text.length * it.size * 0.6, it.size * 1.3, r);
+        break;
+      case "path": {
+        const b = pathBox(it.d);
+        if (b) rect(it.x + b.x0 - sw, it.y + b.y0 - sw, b.x1 - b.x0 + 2 * sw, b.y1 - b.y0 + 2 * sw, r);
+        break;
+      }
+    }
+  }
+  return x0 === Infinity ? null : { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+}
+function pathBox(d) {
+  const toks = String(d).match(/[a-zA-Z]|-?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?/g) || [];
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  const add = (x, y) => {
+    if (x < x0) x0 = x;
+    if (x > x1) x1 = x;
+    if (y < y0) y0 = y;
+    if (y > y1) y1 = y;
+  };
+  let cx = 0, cy = 0, sx = 0, sy = 0, cmd = "M", i = 0;
+  const num = () => Number(toks[i++]);
+  const ARGS = { M: 2, L: 2, H: 1, V: 1, C: 6, S: 4, Q: 4, T: 2, A: 7, Z: 0 };
+  let guard = 0;
+  while (i < toks.length && guard++ < 1e6) {
+    if (/[a-zA-Z]/.test(toks[i])) cmd = toks[i++];
+    const C = cmd.toUpperCase(), rel = cmd !== C, n2 = ARGS[C];
+    if (n2 === void 0) break;
+    if (C === "Z") {
+      cx = sx;
+      cy = sy;
+      continue;
+    }
+    if (i + n2 > toks.length) break;
+    const a = Array.from({ length: n2 }, num);
+    if (a.some((v) => !Number.isFinite(v))) break;
+    const ox = rel ? cx : 0, oy = rel ? cy : 0;
+    if (C === "H") {
+      cx = a[0] + ox;
+      add(cx, cy);
+    } else if (C === "V") {
+      cy = a[0] + oy;
+      add(cx, cy);
+    } else if (C === "A") {
+      const ex = a[5] + ox, ey = a[6] + oy;
+      add(cx, cy);
+      add(ex, ey);
+      for (const [px, py] of arcExtremes(cx, cy, a[0], a[1], a[2], a[3], a[4], ex, ey)) add(px, py);
+      cx = ex;
+      cy = ey;
+    } else {
+      for (let k = 0; k < n2; k += 2) add(a[k] + ox, a[k + 1] + oy);
+      cx = a[n2 - 2] + ox;
+      cy = a[n2 - 1] + oy;
+      if (C === "M") {
+        sx = cx;
+        sy = cy;
+        cmd = rel ? "l" : "L";
+      }
+    }
+  }
+  return x0 === Infinity ? null : { x0, y0, x1, y1 };
+}
+function arcExtremes(x1, y1, rx, ry, phi, large, sweep, x2, y2) {
+  rx = Math.abs(rx);
+  ry = Math.abs(ry);
+  if (!rx || !ry || x1 === x2 && y1 === y2) return [];
+  const f = phi % 360 * Math.PI / 180, cf = Math.cos(f), sf = Math.sin(f);
+  const dx = (x1 - x2) / 2, dy = (y1 - y2) / 2;
+  const x1p = cf * dx + sf * dy, y1p = -sf * dx + cf * dy;
+  const lam = x1p * x1p / (rx * rx) + y1p * y1p / (ry * ry);
+  if (lam > 1) {
+    rx *= Math.sqrt(lam);
+    ry *= Math.sqrt(lam);
+  }
+  const num = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
+  const k = (large !== sweep ? 1 : -1) * Math.sqrt(Math.max(0, num / (rx * rx * y1p * y1p + ry * ry * x1p * x1p)));
+  const cxp = k * rx * y1p / ry, cyp = -k * ry * x1p / rx;
+  const cx = cf * cxp - sf * cyp + (x1 + x2) / 2, cy = sf * cxp + cf * cyp + (y1 + y2) / 2;
+  if (Math.abs(sf) > 1e-9) {
+    const R = Math.max(rx, ry);
+    return [[cx - R, cy - R], [cx + R, cy + R]];
+  }
+  const ang = (ux, uy) => Math.atan2(uy, ux);
+  const t1 = ang((x1p - cxp) / rx, (y1p - cyp) / ry);
+  let dt = ang((-x1p - cxp) / rx, (-y1p - cyp) / ry) - t1;
+  if (sweep && dt < 0) dt += 2 * Math.PI;
+  else if (!sweep && dt > 0) dt -= 2 * Math.PI;
+  const out = [];
+  for (let q = -4; q <= 4; q++) {
+    const t = q * Math.PI / 2, rel = dt >= 0 ? t - t1 : t1 - t;
+    const nrm = (rel % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI);
+    if (nrm <= Math.abs(dt) + 1e-9) out.push([cx + rx * Math.cos(t) * cf, cy + ry * Math.sin(t)]);
+  }
+  return out;
+}
+function textOutline(it, fontOf) {
+  let d = "";
+  const glyph = (f, g, x, y, size) => {
+    const s = size / f.unitsPerEm;
+    const p = g.path;
+    for (const c of p.commands) {
+      const a = [];
+      for (let k = 0; k < c.args.length; k += 2) a.push(r2(x + c.args[k] * s), r2(y - c.args[k + 1] * s));
+      d += { moveTo: "M", lineTo: "L", quadraticCurveTo: "Q", bezierCurveTo: "C", closePath: "Z" }[c.command] + a.join(" ");
+    }
+  };
+  for (const l of it.lines) {
+    if (!l.runs) {
+      const f = fontOf(it.font);
+      if (!f) return null;
+      let x = l.x;
+      for (const ch of l.text.replace(/\t/g, "    ")) {
+        const g = f.glyphForCodePoint(
+          /** @type {number} */
+          ch.codePointAt(0)
+        );
+        glyph(f, g, x, l.y, it.size);
+        x += g.advanceWidth * it.size / f.unitsPerEm;
+      }
+      continue;
+    }
+    for (const r of l.runs) {
+      const f = fontOf(r.font);
+      if (!f) return null;
+      const gs = r.glyphs || [];
+      for (let k = 0; k < gs.length; k += 4) glyph(f, f.getGlyph(gs[k]), l.x + r.x + gs[k + 1], l.y - gs[k + 2], it.size);
+    }
+  }
+  return d;
+}
+var r2 = (v) => Math.round(v * 100) / 100;
+function figureSvg(fig, fontStore) {
+  const fontOf = (k) => {
+    try {
+      return fontStore?.get(k) || null;
+    } catch {
+      return null;
+    }
+  };
+  return pageToSvg({ items: fig.items.filter((i) => i.t !== "link" && i.t !== "bookmark") }, fig.box.w, fig.box.h, { background: false, box: fig.box, outline: fontStore ? fontOf : null });
+}
+async function rasterize(svg, w, h, opt = {}) {
+  const scale = opt.scale || 2;
+  const W = Math.max(1, Math.min(8e3, Math.round(w * scale))), H = Math.max(1, Math.min(8e3, Math.round(h * scale)));
+  try {
+    if (opt.rasterize) return await opt.rasterize(svg, w, h, scale);
+    if (typeof document !== "undefined" && typeof Image !== "undefined") {
+      const url = URL.createObjectURL(new Blob([svg], { type: "image/svg+xml" }));
+      try {
+        const img = new Image();
+        img.src = url;
+        await img.decode();
+        const c = document.createElement("canvas");
+        c.width = W;
+        c.height = H;
+        c.getContext("2d")?.drawImage(img, 0, 0, W, H);
+        const blob = await new Promise((res) => c.toBlob(res, "image/png"));
+        return blob ? new Uint8Array(await /** @type {Blob} */
+        blob.arrayBuffer()) : null;
+      } finally {
+        URL.revokeObjectURL(url);
+      }
+    }
+    if (
+      /** @type {any} */
+      globalThis.process?.versions?.node
+    ) {
+      const name = "sharp";
+      const sharp = (await import(
+        /* @vite-ignore */
+        /* webpackIgnore: true */
+        /* turbopackIgnore: true */
+        name
+      )).default;
+      return new Uint8Array(await sharp(Buffer.from(svg), { density: 72 * scale }).resize(W, H, { fit: "fill" }).png().toBuffer());
+    }
+  } catch {
+  }
+  return null;
+}
+async function figurePicture(fig, opt = {}) {
+  const bytesOf = async (src) => {
+    try {
+      const b = /^data:/i.test(src) ? dataUriBytesOf(src) : opt.fetchImage ? await opt.fetchImage(src) : null;
+      const info = b && b.length <= IMAGE_LIMITS.bytes ? imageInfoOf(b) : null;
+      return info && ["png", "jpeg", "svg"].includes(info.type) ? { b, info } : null;
+    } catch {
+      return null;
+    }
+  };
+  const items = [];
+  for (const it of fig.items) {
+    if (it.t !== "image") {
+      items.push(it);
+      continue;
+    }
+    const got = await bytesOf(it.src);
+    if (!got) continue;
+    const alone = fig.items.every((i) => i === it || i.t === "link" || i.t === "bookmark");
+    if (alone && (got.info.type === "png" || got.info.type === "jpeg") && (it.fit === "fill" || (it.fit || "contain") === "contain" && got.info.w > 0)) {
+      if (it.fit === "fill") return { [got.info.type]: got.b, w: it.w, h: it.h, x: it.x, y: it.y };
+      const s = Math.min(it.w / got.info.w, it.h / got.info.h);
+      const w = got.info.w * s, h = got.info.h * s;
+      return { [got.info.type]: got.b, w, h, x: it.x + (it.w - w) / 2, y: it.y + (it.h - h) / 2 };
+    }
+    items.push({ ...it, src: `data:image/${got.info.type === "svg" ? "svg+xml" : got.info.type};base64,${b64(got.b)}` });
+  }
+  const svg = figureSvg({ items, box: fig.box }, opt.fontStore);
+  const png = await rasterize(svg, fig.box.w, fig.box.h, opt);
+  return { svg, png, w: fig.box.w, h: fig.box.h, x: fig.box.x, y: fig.box.y };
+}
+function b64(u8) {
+  if (typeof Buffer !== "undefined") return Buffer.from(u8).toString("base64");
+  let s = "";
+  for (let i = 0; i < u8.length; i += 32768) s += String.fromCharCode.apply(
+    null,
+    /** @type {any} */
+    u8.subarray(i, i + 32768)
+  );
+  return btoa(s);
+}
+var hexOrNull = (c) => {
+  const s = String(c || "").trim();
+  const m = /^#?([0-9a-f]{6})([0-9a-f]{2})?$/i.exec(s) || /^#?([0-9a-f]{3})$/i.exec(s);
+  if (!m || m[2] === "00") return null;
+  return (m[1].length === 3 ? [...m[1]].map((x) => x + x).join("") : m[1]).toUpperCase();
+};
+var altOf = (tag) => tag?.alt || { chart: "Chart", image: "Picture", map: "Map", barcode: "Barcode", shape: "Shape", line: "Line", sparkline: "Sparkline", databar: "Data bar", bullet: "Bullet chart", iconset: "Status icon", rangebar: "Range bar" }[tag?.k] || "Graphic";
+function boxDecor(items, i) {
+  const it = items[i], c = it.clip;
+  if (!c) return null;
+  const near = (a, b) => Math.abs(a - b) < 0.05;
+  const isBox = (r) => r && r.t === "rect" && !r.tag && near(r.x, c.x) && near(r.y, c.y) && near(r.w, c.w) && near(r.h, c.h);
+  let fill = null, radius = 0;
+  for (let k = i - 1; k >= Math.max(0, i - 2); k--) if (isBox(items[k]) && items[k].fill) {
+    fill = hexOrNull(items[k].fill);
+    radius = items[k].radius || 0;
+    break;
+  }
+  const sides = {};
+  for (let k = i + 1; k < items.length && k <= i + 6 + 2 * it.lines.length; k++) {
+    const o = items[k];
+    if (o.tag || o.art !== it.art) break;
+    if (o.t === "rect" && isBox(o) && o.stroke) {
+      for (const s of ["top", "right", "bottom", "left"]) sides[s] = o;
+      radius = o.radius || radius;
+      break;
+    }
+    if (o.t !== "line") break;
+    if (near(o.y1, o.y2) && near(o.y1, c.y) && near(Math.min(o.x1, o.x2), c.x)) sides.top = o;
+    else if (near(o.y1, o.y2) && near(o.y1, c.y + c.h) && near(Math.min(o.x1, o.x2), c.x)) sides.bottom = o;
+    else if (near(o.x1, o.x2) && near(o.x1, c.x) && near(Math.min(o.y1, o.y2), c.y)) sides.left = o;
+    else if (near(o.x1, o.x2) && near(o.x1, c.x + c.w) && near(Math.min(o.y1, o.y2), c.y)) sides.right = o;
+  }
+  return fill || Object.keys(sides).length ? { fill, radius, sides } : null;
+}
+function cellVisuals(items, used, tables) {
+  const out = /* @__PURE__ */ new Map();
+  if (!tables.size) return out;
+  const geo = [...tables.entries()].map(([key, b]) => {
+    const rows = /* @__PURE__ */ new Map();
+    let left = Infinity;
+    for (const it of b.cells) {
+      const c = it.clip;
+      if (!c) continue;
+      if (!rows.has(it.cell.row)) rows.set(it.cell.row, { y: c.y, h: c.h });
+      left = Math.min(left, c.x - it.cell.cols.slice(0, it.cell.col).reduce((s, w) => s + w, 0));
+    }
+    const cols = b.cells[0].cell.cols;
+    const edges = [left];
+    for (const w of cols) edges.push(edges[edges.length - 1] + w);
+    return { key, rows: [...rows.entries()], left, cols, edges, right: edges[edges.length - 1] };
+  });
+  const near = (a, b) => Math.abs(a - b) < 0.05;
+  items.forEach((it, i) => {
+    if (used.has(i) || it.tag || it.art || !["path", "ellipse", "rect"].includes(it.t)) return;
+    const bx = boxOf([it]);
+    if (!bx) return;
+    const cx = bx.x + bx.w / 2, cy = bx.y + bx.h / 2;
+    for (const g of geo) {
+      if (cx < g.left || cx > g.right) continue;
+      const row = g.rows.find(([, r3]) => cy >= r3.y && cy <= r3.y + r3.h);
+      if (!row) continue;
+      const [rid, r] = row;
+      if (it.t === "rect" && g.edges.some((e) => near(e, it.x)) && g.edges.some((e) => near(e, it.x + it.w))) return;
+      let col = 0, x = g.left;
+      while (col < g.cols.length - 1 && cx > x + g.cols[col]) x += g.cols[col++];
+      const m = out.get(g.key) || out.set(g.key, /* @__PURE__ */ new Map()).get(g.key);
+      const k = `${rid}|${col}`;
+      const v = m.get(k) || m.set(k, { items: [], box: null }).get(k);
+      v.items.push(it);
+      used.add(i);
+      return;
+    }
+  });
+  for (const m of out.values()) for (const v of m.values()) v.box = boxOf(v.items);
+  return out;
+}
+
+export {
+  OPTIONAL_KEYS,
+  FONT_FAMILIES,
+  BUNDLED_FAMILIES,
+  DEFAULT_FAMILY,
+  ALL_FONT_KEYS,
+  CORE_FONT_KEY,
+  PRELOAD_KEYS,
+  SHAPER,
+  fontFile,
+  setCustomFonts,
+  resolveFontKey,
+  fontCss,
+  allFontKeys,
+  fallbackKeys,
+  fallbackKey,
+  fontsForDef,
+  fontsFor,
+  FontStore,
+  IMAGE_LIMITS,
+  PX,
+  dataUriBytes,
+  dataUriBytesOf,
+  svgLength,
+  xmlTags,
+  xmlAttrs,
+  svgRootAttrs,
+  imageInfoOf,
+  imageInfo,
+  resolveImageSrc,
+  parseColor,
+  figures,
+  boxOf,
+  figureSvg,
+  rasterize,
+  figurePicture,
+  hexOrNull,
+  altOf,
+  boxDecor,
+  cellVisuals,
+  fontFamilyCss,
+  pageToSvg,
+  linkTitle,
+  fontFaceCss,
+  fontKeysOf
+};
+//# sourceMappingURL=chunk-3D43XGIN.js.map