wand-decks-kit 0.8.0

package/lib/pdf.js

@@ -0,0 +1,517 @@
+/**
+ * lib/pdf.js — a PDF writer with exactly the parts a Wand document needs.
+ *
+ * Why write one rather than reach for a library: the whole system's promise is
+ * that a kit unzips and runs with nothing installed. A PDF renderer that pulls
+ * in a native rasteriser breaks that on the first machine without build tools.
+ * The subset here — text in embedded TrueType, filled and rounded rectangles,
+ * lines, and images — is the whole of these documents.
+ *
+ * Fonts go in as CIDFontType2 with Identity-H encoding: fontkit gives the glyph
+ * ids and advances, so text positions the same way the deck engine measures it.
+ * A ToUnicode CMap goes in beside every font, which is not decoration — it is
+ * what makes `pdftotext` able to read the output back, and that is the coverage
+ * gate.
+ *
+ * Coordinates are top-left and in inches, matching the deck kit, and are
+ * flipped to PDF's bottom-left points on the way out. Layout code should never
+ * have to think in two coordinate systems.
+ */
+
+const zlib = require("zlib");
+const fs = require("fs");
+const path = require("path");
+
+const PT = 72;
+const esc = (s) => s.replace(/([\\()])/g, "\\$1");
+const num = (n) => (Math.round(n * 1000) / 1000).toString();
+
+/** #RRGGBB -> "r g b" in PDF's 0–1 space. */
+function rgb(hex) {
+  const h = String(hex).replace(/^#/, "");
+  const n = parseInt(h, 16);
+  return [((n >> 16) & 255) / 255, ((n >> 8) & 255) / 255, (n & 255) / 255].map(num).join(" ");
+}
+
+class Doc {
+  /** @param {{width:number,height:number,fontkit:any,fontsDir:string}} o  inches */
+  constructor({ width = 8.5, height = 11, fontkit, fontsDir }) {
+    this.W = width; this.H = height;
+    this.fontkit = fontkit; this.fontsDir = fontsDir;
+    this.pages = [];
+    this.fonts = new Map();     // stem -> { font, used:Map<gid,width>, ref }
+    this.images = new Map();    // absolute path -> { ref, w, h, ... }
+    this.alphas = new Map();    // opacity -> ExtGState name
+    this.page = null;
+  }
+
+  addPage() {
+    this.page = { ops: [], fonts: new Set(), images: new Set(), alphas: new Set() };
+    this.pages.push(this.page);
+    return this.page;
+  }
+
+  /* ------------------------------------------------------------ geometry */
+
+  /** y is measured from the top of the page, like every other kit here. */
+  _y(y) { return (this.H - y) * PT; }
+
+  /** A named ExtGState for constant fill opacity, 0–1. */
+  _alpha(a) {
+    const key = Math.round(a * 100) / 100;
+    if (!this.alphas.has(key)) this.alphas.set(key, "GS" + this.alphas.size);
+    const name = this.alphas.get(key);
+    this.page.alphas.add(key);
+    return name;
+  }
+
+  rect({ x, y, w, h, fill, stroke, lineWidth = 0.75, radius = 0, dash, opacity }) {
+    const o = this.page.ops;
+    const soft = opacity != null && opacity < 1;
+    if (soft) o.push("q", `/${this._alpha(opacity)} gs`);
+    if (fill) o.push(`${rgb(fill)} rg`);
+    if (stroke) o.push(`${rgb(stroke)} RG`, `${num(lineWidth)} w`);
+    if (dash) o.push(`[${num(dash)} ${num(dash)}] 0 d`);
+    const X = x * PT, Y = this._y(y + h), Wd = w * PT, Ht = h * PT;
+    const r = Math.min(radius * PT, Wd / 2, Ht / 2);
+    if (r <= 0) {
+      o.push(`${num(X)} ${num(Y)} ${num(Wd)} ${num(Ht)} re`);
+    } else {
+      const k = r * 0.5523;
+      o.push(
+        `${num(X + r)} ${num(Y)} m`,
+        `${num(X + Wd - r)} ${num(Y)} l`,
+        `${num(X + Wd - r + k)} ${num(Y)} ${num(X + Wd)} ${num(Y + r - k)} ${num(X + Wd)} ${num(Y + r)} c`,
+        `${num(X + Wd)} ${num(Y + Ht - r)} l`,
+        `${num(X + Wd)} ${num(Y + Ht - r + k)} ${num(X + Wd - r + k)} ${num(Y + Ht)} ${num(X + Wd - r)} ${num(Y + Ht)} c`,
+        `${num(X + r)} ${num(Y + Ht)} l`,
+        `${num(X + r - k)} ${num(Y + Ht)} ${num(X)} ${num(Y + Ht - r + k)} ${num(X)} ${num(Y + Ht - r)} c`,
+        `${num(X)} ${num(Y + r)} l`,
+        `${num(X)} ${num(Y + r - k)} ${num(X + r - k)} ${num(Y)} ${num(X + r)} ${num(Y)} c`,
+        "h");
+    }
+    o.push(fill && stroke ? "B" : stroke ? "S" : "f");
+    if (dash) o.push("[] 0 d");
+    if (soft) o.push("Q");
+    return this;
+  }
+
+  /** An ellipse, drawn as four beziers. The badge circles need it. */
+  ellipse({ x, y, w, h, fill, stroke, lineWidth = 0.75 }) {
+    const o = this.page.ops;
+    if (fill) o.push(`${rgb(fill)} rg`);
+    if (stroke) o.push(`${rgb(stroke)} RG`, `${num(lineWidth)} w`);
+    const cx = (x + w / 2) * PT, cy = this._y(y + h / 2);
+    const rx = (w / 2) * PT, ry = (h / 2) * PT, k = 0.5523;
+    o.push(`${num(cx + rx)} ${num(cy)} m`,
+      `${num(cx + rx)} ${num(cy + ry * k)} ${num(cx + rx * k)} ${num(cy + ry)} ${num(cx)} ${num(cy + ry)} c`,
+      `${num(cx - rx * k)} ${num(cy + ry)} ${num(cx - rx)} ${num(cy + ry * k)} ${num(cx - rx)} ${num(cy)} c`,
+      `${num(cx - rx)} ${num(cy - ry * k)} ${num(cx - rx * k)} ${num(cy - ry)} ${num(cx)} ${num(cy - ry)} c`,
+      `${num(cx + rx * k)} ${num(cy - ry)} ${num(cx + rx)} ${num(cy - ry * k)} ${num(cx + rx)} ${num(cy)} c`,
+      "h", fill && stroke ? "B" : stroke ? "S" : "f");
+    return this;
+  }
+
+  line({ x1, y1, x2, y2, color = "000000", width = 0.75 }) {
+    this.page.ops.push(`${rgb(color)} RG`, `${num(width)} w`,
+      `${num(x1 * PT)} ${num(this._y(y1))} m ${num(x2 * PT)} ${num(this._y(y2))} l S`);
+    return this;
+  }
+
+  /* ---------------------------------------------------------------- text */
+
+  _font(stem) {
+    if (!this.fonts.has(stem)) {
+      const file = path.join(this.fontsDir, stem + ".ttf");
+      if (!fs.existsSync(file)) throw new Error(`no font ${stem}.ttf in ${this.fontsDir}`);
+      this.fonts.set(stem, { stem, font: this.fontkit.openSync(file), file, used: new Map(), uni: new Map() });
+    }
+    return this.fonts.get(stem);
+  }
+
+  /**
+   * One line of text at (x, y) where y is the BASELINE, from the page top.
+   * Returns the advance width in inches.
+   */
+  text(str, { x, y, stem, size, color = "000000", tracking = 0 }) {
+    if (str == null || str === "") return 0;
+    const F = this._font(stem);
+    const run = F.font.layout(String(str));
+    const upm = F.font.unitsPerEm;
+    const hex = [];
+    let adv = 0;
+    for (const g of run.glyphs) {
+      F.used.set(g.id, g.advanceWidth);
+      if (g.codePoints && g.codePoints.length) F.uni.set(g.id, g.codePoints);
+      hex.push(g.id.toString(16).padStart(4, "0"));
+      adv += g.advanceWidth;
+    }
+    this.page.fonts.add(stem);
+    const o = this.page.ops;
+    o.push("BT", `${rgb(color)} rg`, `/F_${stem.replace(/[^A-Za-z0-9]/g, "")} ${num(size)} Tf`);
+    if (tracking) o.push(`${num(tracking)} Tc`);
+    o.push(`${num(x * PT)} ${num(this._y(y))} Td`, `<${hex.join("")}> Tj`);
+    if (tracking) o.push("0 Tc");
+    o.push("ET");
+    return (adv / upm) * (size / PT) + (tracking / PT) * run.glyphs.length;
+  }
+
+  /* ---------------------------------------------------------------- svg */
+
+  /**
+   * Draw a Lucide-style stroked SVG at (x, y) in a `size` box.
+   *
+   * These are vector paths, so they go into the content stream as path
+   * operators rather than as an image — which is why an icon in a Wand document
+   * is crisp at any zoom and takes about 300 bytes. 58 of the 75 glyphs use
+   * elliptical arcs, so arc support is not optional; `arcTo` converts them to
+   * the beziers PDF understands.
+   */
+  svg(svgText, { x, y, size, color = "000000", strokeWidth = 2 }) {
+    const o = this.page.ops;
+    const s = (size * PT) / 24;                       // the viewBox is always 0 0 24 24
+    o.push("q", `${rgb(color)} RG`, `${num(strokeWidth)} w`, "1 J", "1 j",
+           `${num(s)} 0 0 ${num(-s)} ${num(x * PT)} ${num(this._y(y))} cm`);
+    for (const d of svgToPaths(svgText)) emitPath(o, d);
+    o.push("S", "Q");
+    return this;
+  }
+
+  /* -------------------------------------------------------------- images */
+
+  image(file, { x, y, w, h }) {
+    const abs = path.resolve(file);
+    if (!this.images.has(abs)) this.images.set(abs, decodeImage(abs));
+    const im = this.images.get(abs);
+    const name = "Im" + [...this.images.keys()].indexOf(abs);
+    im.name = name;
+    this.page.images.add(abs);
+    this.page.ops.push("q", `${num(w * PT)} 0 0 ${num(h * PT)} ${num(x * PT)} ${num(this._y(y + h))} cm`,
+                       `/${name} Do`, "Q");
+    return this;
+  }
+
+  /* --------------------------------------------------------------- write */
+
+  toBuffer() {
+    const objs = [];                                   // 1-indexed on output
+    const ref = (n) => `${n} 0 R`;
+    const add = (body) => { objs.push(body); return objs.length; };
+
+    // fonts
+    const fontRefs = new Map();
+    for (const F of this.fonts.values()) {
+      const raw = fs.readFileSync(F.file);
+      const upm = F.font.unitsPerEm;
+      const sc = 1000 / upm;
+      const fileRef = add({ stream: zlib.deflateSync(raw),
+        dict: `/Filter /FlateDecode /Length1 ${raw.length}` });
+      const flags = 4 | (F.font.italicAngle ? 64 : 32);
+      const bb = F.font.bbox;
+      const desc = add(`<< /Type /FontDescriptor /FontName /${psName(F)} /Flags ${flags}` +
+        ` /FontBBox [${Math.round(bb.minX * sc)} ${Math.round(bb.minY * sc)} ${Math.round(bb.maxX * sc)} ${Math.round(bb.maxY * sc)}]` +
+        ` /ItalicAngle ${Math.round(F.font.italicAngle || 0)} /Ascent ${Math.round(F.font.ascent * sc)}` +
+        ` /Descent ${Math.round(F.font.descent * sc)} /CapHeight ${Math.round((F.font.capHeight || 700) * sc)}` +
+        ` /StemV 80 /FontFile2 ${ref(fileRef)} >>`);
+      const gids = [...F.used.keys()].sort((a, b) => a - b);
+      const W = gids.map((g) => `${g} [${Math.round(F.used.get(g) * sc)}]`).join(" ");
+      const cid = add(`<< /Type /Font /Subtype /CIDFontType2 /BaseFont /${psName(F)}` +
+        ` /CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >>` +
+        ` /FontDescriptor ${ref(desc)} /DW 1000 /W [${W}] /CIDToGIDMap /Identity >>`);
+      const tu = add({ stream: zlib.deflateSync(Buffer.from(toUnicode(F), "latin1")),
+                       dict: "/Filter /FlateDecode" });
+      const f0 = add(`<< /Type /Font /Subtype /Type0 /BaseFont /${psName(F)}` +
+        ` /Encoding /Identity-H /DescendantFonts [${ref(cid)}] /ToUnicode ${ref(tu)} >>`);
+      fontRefs.set(F.stem, f0);
+    }
+
+    // images
+    const imageRefs = new Map();
+    for (const [abs, im] of this.images) {
+      let smask = null;
+      if (im.alpha) {
+        smask = add({ stream: zlib.deflateSync(im.alpha),
+          dict: `/Type /XObject /Subtype /Image /Width ${im.w} /Height ${im.h}` +
+                ` /ColorSpace /DeviceGray /BitsPerComponent 8 /Filter /FlateDecode` });
+      }
+      const r = add({ stream: im.filter === "DCTDecode" ? im.data : zlib.deflateSync(im.data),
+        dict: `/Type /XObject /Subtype /Image /Width ${im.w} /Height ${im.h}` +
+              ` /ColorSpace /DeviceRGB /BitsPerComponent 8` +
+              ` /Filter /${im.filter === "DCTDecode" ? "DCTDecode" : "FlateDecode"}` +
+              (smask ? ` /SMask ${ref(smask)}` : "") });
+      imageRefs.set(abs, r);
+    }
+
+    // pages
+    const pagesRef = objs.length + 1 + this.pages.length * 2 + 1;   // filled below
+    const kids = [];
+    for (const pg of this.pages) {
+      const content = add({ stream: zlib.deflateSync(Buffer.from(pg.ops.join("\n"), "latin1")),
+                            dict: "/Filter /FlateDecode" });
+      const fRes = [...pg.fonts].map((s) => `/F_${s.replace(/[^A-Za-z0-9]/g, "")} ${ref(fontRefs.get(s))}`).join(" ");
+      const xRes = [...pg.images].map((a) => `/${this.images.get(a).name} ${ref(imageRefs.get(a))}`).join(" ");
+      const gRes = [...pg.alphas].map((a) => `/${this.alphas.get(a)} << /ca ${a} /CA 1 >>`).join(" ");
+      const p = add(`<< /Type /Page /Parent __PAGES__ /MediaBox [0 0 ${num(this.W * PT)} ${num(this.H * PT)}]` +
+        ` /Resources << /Font << ${fRes} >> /XObject << ${xRes} >>` +
+        (gRes ? ` /ExtGState << ${gRes} >>` : "") + ` >> /Contents ${ref(content)} >>`);
+      kids.push(p);
+    }
+    const pagesObj = add(`<< /Type /Pages /Kids [${kids.map(ref).join(" ")}] /Count ${kids.length} >>`);
+    const catalog = add(`<< /Type /Catalog /Pages ${ref(pagesObj)} >>`);
+    const info = add(`<< /Producer (wand-docs) /Creator (wand-docs) >>`);
+    for (let i = 0; i < objs.length; i++) {
+      if (typeof objs[i] === "string") objs[i] = objs[i].replace("__PAGES__", ref(pagesObj));
+    }
+
+    const chunks = [Buffer.from("%PDF-1.7\n%\xE2\xE3\xCF\xD3\n", "latin1")];
+    let pos = chunks[0].length;
+    const offsets = [0];
+    objs.forEach((o, i) => {
+      const head = Buffer.from(`${i + 1} 0 obj\n`, "latin1");
+      const body = typeof o === "string"
+        ? Buffer.from(o + "\n", "latin1")
+        : Buffer.concat([Buffer.from(`<< ${o.dict} /Length ${o.stream.length} >>\nstream\n`, "latin1"),
+                         o.stream, Buffer.from("\nendstream\n", "latin1")]);
+      const tail = Buffer.from("endobj\n", "latin1");
+      offsets.push(pos);
+      chunks.push(head, body, tail);
+      pos += head.length + body.length + tail.length;
+    });
+    const xref = [`xref\n0 ${objs.length + 1}\n0000000000 65535 f \n`];
+    for (let i = 1; i <= objs.length; i++) xref.push(String(offsets[i]).padStart(10, "0") + " 00000 n \n");
+    chunks.push(Buffer.from(xref.join(""), "latin1"));
+    chunks.push(Buffer.from(`trailer\n<< /Size ${objs.length + 1} /Root ${ref(catalog)} /Info ${ref(info)} >>\n` +
+                            `startxref\n${pos}\n%%EOF\n`, "latin1"));
+    return Buffer.concat(chunks);
+  }
+}
+
+const psName = (F) => F.stem.replace(/[^A-Za-z0-9]/g, "");
+
+/** Without this, the PDF renders correctly and `pdftotext` returns mojibake. */
+function toUnicode(F) {
+  const rev = new Map(F.uni);                       // recorded during layout
+  for (const cp of F.font.characterSet || []) {     // anything layout never saw
+    try {
+      const g = F.font.glyphForCodePoint(cp);
+      if (g && F.used.has(g.id) && !rev.has(g.id)) rev.set(g.id, [cp]);
+    } catch {}
+  }
+  const utf16be = (cps) => cps.map((cp) => {
+    if (cp <= 0xffff) return cp.toString(16).padStart(4, "0").toUpperCase();
+    const v = cp - 0x10000;
+    return ((0xd800 | (v >> 10)).toString(16) + (0xdc00 | (v & 0x3ff)).toString(16)).toUpperCase();
+  }).join("");
+  const lines = [...rev.entries()].map(([g, cps]) =>
+    `<${g.toString(16).padStart(4, "0")}> <${utf16be(cps)}>`);
+  const chunks = [];
+  for (let i = 0; i < lines.length; i += 100) {
+    const part = lines.slice(i, i + 100);
+    chunks.push(`${part.length} beginbfchar\n${part.join("\n")}\nendbfchar`);
+  }
+  return `/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n` +
+    `/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def\n` +
+    `/CMapName /Adobe-Identity-UCS def\n/CMapType 2 def\n1 begincodespacerange\n<0000> <FFFF>\nendcodespacerange\n` +
+    `${chunks.join("\n")}\nendcmap\nCMapName currentdict /CMap defineresource pop\nend\nend`;
+}
+
+/* ------------------------------------------------------------------ images */
+
+function decodeImage(file) {
+  const buf = fs.readFileSync(file);
+  if (buf[0] === 0xff && buf[1] === 0xd8) {
+    let i = 2, w = 0, h = 0;
+    while (i < buf.length) {
+      if (buf[i] !== 0xff) { i++; continue; }
+      const m = buf[i + 1];
+      if (m >= 0xc0 && m <= 0xcf && m !== 0xc4 && m !== 0xc8 && m !== 0xcc) {
+        h = buf.readUInt16BE(i + 5); w = buf.readUInt16BE(i + 7); break;
+      }
+      i += 2 + buf.readUInt16BE(i + 2);
+    }
+    return { w, h, data: buf, filter: "DCTDecode", alpha: null };
+  }
+  return decodePNG(buf, file);
+}
+
+function decodePNG(buf, file) {
+  let pos = 8, idat = [], w = 0, h = 0, bd = 0, ct = 0, plte = null, trns = null;
+  while (pos < buf.length) {
+    const len = buf.readUInt32BE(pos), type = buf.toString("latin1", pos + 4, pos + 8);
+    const data = buf.subarray(pos + 8, pos + 8 + len);
+    if (type === "IHDR") { w = data.readUInt32BE(0); h = data.readUInt32BE(4); bd = data[8]; ct = data[9]; }
+    else if (type === "IDAT") idat.push(data);
+    else if (type === "PLTE") plte = data;
+    else if (type === "tRNS") trns = data;
+    pos += 12 + len;
+  }
+  if (bd !== 8) throw new Error(`${path.basename(file)}: only 8-bit PNG is supported`);
+  const chan = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 }[ct];
+  if (!chan) throw new Error(`${path.basename(file)}: unsupported PNG colour type ${ct}`);
+  const raw = zlib.inflateSync(Buffer.concat(idat));
+  const stride = w * chan;
+  const out = Buffer.alloc(h * stride);
+  let p = 0;
+  for (let y = 0; y < h; y++) {
+    const f = raw[p++];
+    const row = raw.subarray(p, p + stride); p += stride;
+    const cur = out.subarray(y * stride, (y + 1) * stride);
+    const prev = y ? out.subarray((y - 1) * stride, y * stride) : Buffer.alloc(stride);
+    for (let i = 0; i < stride; i++) {
+      const a = i >= chan ? cur[i - chan] : 0, b = prev[i], c = i >= chan ? prev[i - chan] : 0;
+      let v = row[i];
+      if (f === 1) v += a; else if (f === 2) v += b; else if (f === 3) v += (a + b) >> 1;
+      else if (f === 4) {
+        const pp = a + b - c, pa = Math.abs(pp - a), pb = Math.abs(pp - b), pc = Math.abs(pp - c);
+        v += pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+      }
+      cur[i] = v & 255;
+    }
+  }
+  const rgbBuf = Buffer.alloc(w * h * 3);
+  let alpha = null;
+  const needAlpha = ct === 4 || ct === 6 || (ct === 3 && trns);
+  if (needAlpha) alpha = Buffer.alloc(w * h);
+  for (let i = 0, n = w * h; i < n; i++) {
+    let r, g, b, a = 255;
+    if (ct === 6) { r = out[i * 4]; g = out[i * 4 + 1]; b = out[i * 4 + 2]; a = out[i * 4 + 3]; }
+    else if (ct === 2) { r = out[i * 3]; g = out[i * 3 + 1]; b = out[i * 3 + 2]; }
+    else if (ct === 0) { r = g = b = out[i]; }
+    else if (ct === 4) { r = g = b = out[i * 2]; a = out[i * 2 + 1]; }
+    else { const ix = out[i]; r = plte[ix * 3]; g = plte[ix * 3 + 1]; b = plte[ix * 3 + 2];
+           if (trns && ix < trns.length) a = trns[ix]; }
+    rgbBuf[i * 3] = r; rgbBuf[i * 3 + 1] = g; rgbBuf[i * 3 + 2] = b;
+    if (alpha) alpha[i] = a;
+  }
+  return { w, h, data: rgbBuf, filter: "Flate", alpha };
+}
+
+/* --------------------------------------------------------------------- svg */
+
+/** Every drawable in the file, normalised to path data. */
+function svgToPaths(svg) {
+  const out = [];
+  for (const m of svg.matchAll(/<path[^>]*\sd="([^"]+)"/g)) out.push(m[1]);
+  for (const m of svg.matchAll(/<circle[^>]*>/g)) {
+    const a = attrs(m[0]);
+    const [cx, cy, r] = [+a.cx || 0, +a.cy || 0, +a.r || 0];
+    out.push(`M ${cx - r} ${cy} a ${r} ${r} 0 1 0 ${r * 2} 0 a ${r} ${r} 0 1 0 ${-r * 2} 0`);
+  }
+  for (const m of svg.matchAll(/<ellipse[^>]*>/g)) {
+    const a = attrs(m[0]);
+    const [cx, cy, rx, ry] = [+a.cx || 0, +a.cy || 0, +a.rx || 0, +a.ry || 0];
+    out.push(`M ${cx - rx} ${cy} a ${rx} ${ry} 0 1 0 ${rx * 2} 0 a ${rx} ${ry} 0 1 0 ${-rx * 2} 0`);
+  }
+  for (const m of svg.matchAll(/<rect[^>]*>/g)) {
+    const a = attrs(m[0]);
+    const [X, Y, W, H, r] = [+a.x || 0, +a.y || 0, +a.width || 0, +a.height || 0, +a.rx || 0];
+    out.push(r
+      ? `M ${X + r} ${Y} H ${X + W - r} a ${r} ${r} 0 0 1 ${r} ${r} V ${Y + H - r} a ${r} ${r} 0 0 1 ${-r} ${r} ` +
+        `H ${X + r} a ${r} ${r} 0 0 1 ${-r} ${-r} V ${Y + r} a ${r} ${r} 0 0 1 ${r} ${-r} Z`
+      : `M ${X} ${Y} H ${X + W} V ${Y + H} H ${X} Z`);
+  }
+  for (const m of svg.matchAll(/<line[^>]*>/g)) {
+    const a = attrs(m[0]);
+    out.push(`M ${+a.x1 || 0} ${+a.y1 || 0} L ${+a.x2 || 0} ${+a.y2 || 0}`);
+  }
+  for (const m of svg.matchAll(/<(polyline|polygon)[^>]*>/g)) {
+    const a = attrs(m[0]);
+    const pts = (a.points || "").trim().split(/[\s,]+/).map(Number);
+    if (pts.length < 4) continue;
+    let d = `M ${pts[0]} ${pts[1]}`;
+    for (let i = 2; i < pts.length; i += 2) d += ` L ${pts[i]} ${pts[i + 1]}`;
+    out.push(d + (m[1] === "polygon" ? " Z" : ""));
+  }
+  return out;
+}
+
+const attrs = (tag) => Object.fromEntries([...tag.matchAll(/([a-zA-Z-]+)="([^"]*)"/g)].map((m) => [m[1], m[2]]));
+
+function emitPath(o, d) {
+  const tok = d.match(/[a-zA-Z]|-?\d*\.?\d+(?:e[-+]?\d+)?/gi) || [];
+  let i = 0, cmd = "", x = 0, y = 0, sx = 0, sy = 0, px = 0, py = 0;
+  const nx = () => parseFloat(tok[i++]);
+  while (i < tok.length) {
+    if (/[a-zA-Z]/.test(tok[i])) cmd = tok[i++];
+    const rel = cmd === cmd.toLowerCase();
+    const C = cmd.toUpperCase();
+    if (C === "M") {
+      const a = nx(), b = nx();
+      x = rel ? x + a : a; y = rel ? y + b : b; sx = x; sy = y; px = x; py = y;
+      o.push(`${num(x)} ${num(y)} m`);
+      cmd = rel ? "l" : "L";
+    } else if (C === "L") {
+      const a = nx(), b = nx();
+      x = rel ? x + a : a; y = rel ? y + b : b; px = x; py = y;
+      o.push(`${num(x)} ${num(y)} l`);
+    } else if (C === "H") { const a = nx(); x = rel ? x + a : a; px = x; py = y; o.push(`${num(x)} ${num(y)} l`); }
+    else if (C === "V") { const a = nx(); y = rel ? y + a : a; px = x; py = y; o.push(`${num(x)} ${num(y)} l`); }
+    else if (C === "C" || C === "S") {
+      let x1, y1;
+      if (C === "C") { const a = nx(), b = nx(); x1 = rel ? x + a : a; y1 = rel ? y + b : b; }
+      else { x1 = 2 * x - px; y1 = 2 * y - py; }
+      const c = nx(), e = nx(), f = nx(), g = nx();
+      const x2 = rel ? x + c : c, y2 = rel ? y + e : e;
+      const X = rel ? x + f : f, Y = rel ? y + g : g;
+      o.push(`${num(x1)} ${num(y1)} ${num(x2)} ${num(y2)} ${num(X)} ${num(Y)} c`);
+      px = x2; py = y2; x = X; y = Y;
+    } else if (C === "Q" || C === "T") {
+      let qx, qy;
+      if (C === "Q") { const a = nx(), b = nx(); qx = rel ? x + a : a; qy = rel ? y + b : b; }
+      else { qx = 2 * x - px; qy = 2 * y - py; }
+      const c = nx(), e = nx();
+      const X = rel ? x + c : c, Y = rel ? y + e : e;
+      o.push(`${num(x + (2 / 3) * (qx - x))} ${num(y + (2 / 3) * (qy - y))} ` +
+             `${num(X + (2 / 3) * (qx - X))} ${num(Y + (2 / 3) * (qy - Y))} ${num(X)} ${num(Y)} c`);
+      px = qx; py = qy; x = X; y = Y;
+    } else if (C === "A") {
+      const rx = nx(), ry = nx(), rot = nx(), large = nx(), sweep = nx();
+      const a = nx(), b = nx();
+      const X = rel ? x + a : a, Y = rel ? y + b : b;
+      arcTo(o, x, y, rx, ry, rot, large, sweep, X, Y);
+      px = X; py = Y; x = X; y = Y;
+    } else if (C === "Z") { o.push("h"); x = sx; y = sy; px = x; py = y; }
+    else { i++; }
+  }
+}
+
+/** SVG elliptical arc -> up to four cubic beziers (endpoint parameterisation). */
+function arcTo(o, x1, y1, rx, ry, rotDeg, large, sweep, x2, y2) {
+  if (!rx || !ry) { o.push(`${num(x2)} ${num(y2)} l`); return; }
+  rx = Math.abs(rx); ry = Math.abs(ry);
+  const phi = (rotDeg * Math.PI) / 180, cos = Math.cos(phi), sin = Math.sin(phi);
+  const dx = (x1 - x2) / 2, dy = (y1 - y2) / 2;
+  const x1p = cos * dx + sin * dy, y1p = -sin * dx + cos * dy;
+  let lam = (x1p * x1p) / (rx * rx) + (y1p * y1p) / (ry * ry);
+  if (lam > 1) { const s = Math.sqrt(lam); rx *= s; ry *= s; }
+  const sq = Math.max(0, (rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p) /
+                         (rx * rx * y1p * y1p + ry * ry * x1p * x1p));
+  const co = (large !== sweep ? 1 : -1) * Math.sqrt(sq);
+  const cxp = co * (rx * y1p) / ry, cyp = co * -(ry * x1p) / rx;
+  const cx = cos * cxp - sin * cyp + (x1 + x2) / 2;
+  const cy = sin * cxp + cos * cyp + (y1 + y2) / 2;
+  const ang = (ux, uy, vx, vy) => {
+    const d = (ux * vx + uy * vy) / (Math.hypot(ux, uy) * Math.hypot(vx, vy));
+    const a = Math.acos(Math.min(1, Math.max(-1, d)));
+    return ux * vy - uy * vx < 0 ? -a : a;
+  };
+  let th1 = ang(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry);
+  let dth = ang((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry);
+  if (!sweep && dth > 0) dth -= 2 * Math.PI;
+  if (sweep && dth < 0) dth += 2 * Math.PI;
+  const segs = Math.ceil(Math.abs(dth) / (Math.PI / 2));
+  const delta = dth / segs;
+  const t = (4 / 3) * Math.tan(delta / 4);
+  for (let s = 0; s < segs; s++) {
+    const a0 = th1 + s * delta, a1 = a0 + delta;
+    const c0 = Math.cos(a0), s0 = Math.sin(a0), c1 = Math.cos(a1), s1 = Math.sin(a1);
+    const p = (ca, sa) => [cos * rx * ca - sin * ry * sa + cx, sin * rx * ca + cos * ry * sa + cy];
+    const [, ] = p(c0, s0);
+    const [q1x, q1y] = p(c0 - t * s0, s0 + t * c0);
+    const [q2x, q2y] = p(c1 + t * s1, s1 - t * c1);
+    const [ex, ey] = p(c1, s1);
+    o.push(`${num(q1x)} ${num(q1y)} ${num(q2x)} ${num(q2y)} ${num(ex)} ${num(ey)} c`);
+  }
+}
+
+module.exports = { Doc, rgb, PT, svgToPaths };