emf-converter 4.4.7 → 4.4.9

package/dist/browser.mjs

@@ -1367,21 +1367,21 @@ var require_decoder = __commonJS({
               successiveACState = 0;
           }
         }
-        function decodeMcu(component2, decode3, mcu2, row, col) {
+        function decodeMcu(component2, decode4, mcu2, row, col) {
           var mcuRow = mcu2 / mcusPerLine | 0;
           var mcuCol = mcu2 % mcusPerLine;
           var blockRow = mcuRow * component2.v + row;
           var blockCol = mcuCol * component2.h + col;
           if (component2.blocks[blockRow] === void 0 && opts.tolerantDecoding)
             return;
-          decode3(component2, component2.blocks[blockRow][blockCol]);
+          decode4(component2, component2.blocks[blockRow][blockCol]);
         }
-        function decodeBlock(component2, decode3, mcu2) {
+        function decodeBlock(component2, decode4, mcu2) {
           var blockRow = mcu2 / component2.blocksPerLine | 0;
           var blockCol = mcu2 % component2.blocksPerLine;
           if (component2.blocks[blockRow] === void 0 && opts.tolerantDecoding)
             return;
-          decode3(component2, component2.blocks[blockRow][blockCol]);
+          decode4(component2, component2.blocks[blockRow][blockCol]);
         }
         var componentsLength = components.length;
         var component, i, j, k, n;
@@ -2102,12 +2102,12 @@ var require_decoder = __commonJS({
       return constructor;
     })();
     if (typeof module !== "undefined") {
-      module.exports = decode2;
+      module.exports = decode3;
     } else if (typeof window !== "undefined") {
       window["jpeg-js"] = window["jpeg-js"] || {};
-      window["jpeg-js"].decode = decode2;
+      window["jpeg-js"].decode = decode3;
     }
-    function decode2(jpegData, userOpts = {}) {
+    function decode3(jpegData, userOpts = {}) {
       var defaultOpts = {
         // "undefined" means "Choose whether to transform colors based on the image’s color model."
         colorTransform: void 0,
@@ -2159,10 +2159,10 @@ var require_decoder = __commonJS({
 var require_jpeg_js = __commonJS({
   "node_modules/jpeg-js/index.js"(exports, module) {
     var encode2 = require_encoder();
-    var decode2 = require_decoder();
+    var decode3 = require_decoder();
     module.exports = {
       encode: encode2,
-      decode: decode2
+      decode: decode3
     };
   }
 });
@@ -4760,8 +4760,8 @@ var require_deflate2 = __commonJS({
     var Z_DEFAULT_COMPRESSION = -1;
     var Z_DEFAULT_STRATEGY = 0;
     var Z_DEFLATED = 8;
-    function Deflate(options) {
-      if (!(this instanceof Deflate)) return new Deflate(options);
+    function Deflate(options2) {
+      if (!(this instanceof Deflate)) return new Deflate(options2);
       this.options = utils.assign({
         level: Z_DEFAULT_COMPRESSION,
         method: Z_DEFLATED,
@@ -4770,7 +4770,7 @@ var require_deflate2 = __commonJS({
         memLevel: 8,
         strategy: Z_DEFAULT_STRATEGY,
         to: ""
-      }, options || {});
+      }, options2 || {});
       var opt = this.options;
       if (opt.raw && opt.windowBits > 0) {
         opt.windowBits = -opt.windowBits;
@@ -4878,23 +4878,23 @@ var require_deflate2 = __commonJS({
       this.err = status;
       this.msg = this.strm.msg;
     };
-    function deflate(input, options) {
-      var deflator = new Deflate(options);
+    function deflate(input, options2) {
+      var deflator = new Deflate(options2);
       deflator.push(input, true);
       if (deflator.err) {
         throw deflator.msg || msg[deflator.err];
       }
       return deflator.result;
     }
-    function deflateRaw(input, options) {
-      options = options || {};
-      options.raw = true;
-      return deflate(input, options);
+    function deflateRaw(input, options2) {
+      options2 = options2 || {};
+      options2.raw = true;
+      return deflate(input, options2);
     }
-    function gzip(input, options) {
-      options = options || {};
-      options.gzip = true;
-      return deflate(input, options);
+    function gzip(input, options2) {
+      options2 = options2 || {};
+      options2.gzip = true;
+      return deflate(input, options2);
     }
     exports.Deflate = Deflate;
     exports.deflate = deflate;
@@ -6757,13 +6757,13 @@ var require_inflate2 = __commonJS({
     var ZStream = require_zstream();
     var GZheader = require_gzheader();
     var toString = Object.prototype.toString;
-    function Inflate(options) {
-      if (!(this instanceof Inflate)) return new Inflate(options);
+    function Inflate(options2) {
+      if (!(this instanceof Inflate)) return new Inflate(options2);
       this.options = utils.assign({
         chunkSize: 16384,
         windowBits: 0,
         to: ""
-      }, options || {});
+      }, options2 || {});
       var opt = this.options;
       if (opt.raw && opt.windowBits >= 0 && opt.windowBits < 16) {
         opt.windowBits = -opt.windowBits;
@@ -6771,7 +6771,7 @@ var require_inflate2 = __commonJS({
           opt.windowBits = -15;
         }
       }
-      if (opt.windowBits >= 0 && opt.windowBits < 16 && !(options && options.windowBits)) {
+      if (opt.windowBits >= 0 && opt.windowBits < 16 && !(options2 && options2.windowBits)) {
         opt.windowBits += 32;
       }
       if (opt.windowBits > 15 && opt.windowBits < 48) {
@@ -6899,18 +6899,18 @@ var require_inflate2 = __commonJS({
       this.err = status;
       this.msg = this.strm.msg;
     };
-    function inflate(input, options) {
-      var inflator = new Inflate(options);
+    function inflate(input, options2) {
+      var inflator = new Inflate(options2);
       inflator.push(input, true);
       if (inflator.err) {
         throw inflator.msg || msg[inflator.err];
       }
       return inflator.result;
     }
-    function inflateRaw(input, options) {
-      options = options || {};
-      options.raw = true;
-      return inflate(input, options);
+    function inflateRaw(input, options2) {
+      options2 = options2 || {};
+      options2.raw = true;
+      return inflate(input, options2);
     }
     exports.Inflate = Inflate;
     exports.inflate = inflate;
@@ -10043,7 +10043,7 @@ function inflateZlibSync(input) {
     bitCnt -= n;
     return v;
   };
-  const decode2 = (h) => {
+  const decode3 = (h) => {
     let code = 0;
     let first = 0;
     let index = 0;
@@ -10101,7 +10101,7 @@ function inflateZlibSync(input) {
       const clh = buildHuffman(cl, 19);
       const lens = new Uint8Array(hlit + hdist);
       for (let i = 0; i < hlit + hdist; ) {
-        const sym = decode2(clh);
+        const sym = decode3(clh);
         if (sym < 16) {
           lens[i++] = sym;
         } else if (sym === 16) {
@@ -10121,7 +10121,7 @@ function inflateZlibSync(input) {
       throw new Error("inflate: invalid block type");
     }
     for (; ; ) {
-      const sym = decode2(lit);
+      const sym = decode3(lit);
       if (sym < 256) {
         need(1);
         out[outLen++] = sym;
@@ -10130,7 +10130,7 @@ function inflateZlibSync(input) {
       } else {
         const li = sym - 257;
         const len = LENGTH_BASE[li] + bits(LENGTH_EXTRA[li]);
-        const di = decode2(dist);
+        const di = decode3(dist);
         const d = DIST_BASE[di] + bits(DIST_EXTRA[di]);
         need(len);
         for (let k = 0; k < len; k++) {
@@ -10310,15 +10310,74 @@ async function decodePng(bytes) {
   return { width, height, data: out };
 }
 
-// src/image-codec-fallback.ts
+// src/jpeg-decoder.ts
 var import_jpeg_js = __toESM(require_jpeg_js());
+var options = { useTArray: true, formatAsRGBA: true, maxResolutionInMP: 67.108864, maxMemoryUsageInMB: 512 };
+function decodeJpegPixels(bytes, colorTransform) {
+  let sampling = [];
+  let adobeTransform;
+  let adobeOffset = -1;
+  for (let position = 2; position + 4 <= bytes.length; ) {
+    if (bytes[position] !== 255) break;
+    if (bytes[position + 1] === 255) {
+      position++;
+      continue;
+    }
+    const marker = bytes[position + 1];
+    if (marker === 218 || marker === 217) break;
+    const length = bytes[position + 2] * 256 + bytes[position + 3];
+    if (length < 2 || position + length + 2 > bytes.length) break;
+    const start = position + 4;
+    if ([192, 193, 194].includes(marker) && length >= 8) {
+      const count = bytes[start + 5];
+      if (length >= 8 + 3 * count) sampling = Array.from({ length: count }, (_, i) => ({ id: bytes[start + 6 + i * 3], h: bytes[start + 7 + i * 3] >> 4, v: bytes[start + 7 + i * 3] & 15 }));
+    }
+    if (marker === 238 && length >= 14 && String.fromCharCode(...bytes.subarray(start, start + 5)) === "Adobe") {
+      adobeOffset = start + 11;
+      adobeTransform = bytes[adobeOffset];
+    }
+    position += length + 2;
+  }
+  const transform = colorTransform ?? (adobeTransform !== void 0 ? adobeTransform !== 0 : !sampling.every((component, i) => component.id === [82, 71, 66][i]));
+  if (sampling.length !== 3 || !transform) return (0, import_jpeg_js.decode)(bytes, { ...options, colorTransform: sampling.length === 3 ? transform : colorTransform });
+  const maxH = Math.max(...sampling.map((c) => c.h)), maxV = Math.max(...sampling.map((c) => c.v));
+  if (sampling.some((c) => !c.h || !c.v || maxH % c.h || maxV % c.v)) return (0, import_jpeg_js.decode)(bytes, { ...options, colorTransform });
+  let encoded = bytes;
+  if (adobeTransform) {
+    encoded = bytes.slice();
+    encoded[adobeOffset] = 0;
+  }
+  const raw = (0, import_jpeg_js.decode)(encoded, { ...options, colorTransform: false });
+  const { width, height } = raw;
+  const data = new Uint8Array(raw.data.length);
+  const sample2 = (x, y, channel) => {
+    const sx = maxH / sampling[channel].h, sy = maxV / sampling[channel].v;
+    const px = Math.max(0, Math.min(Math.ceil(width / sx) - 1, (x + 0.5) / sx - 0.5));
+    const py = Math.max(0, Math.min(Math.ceil(height / sy) - 1, (y + 0.5) / sy - 0.5));
+    const ix = Math.floor(px), iy = Math.floor(py), fx = px - ix, fy = py - iy;
+    const at = (xx, yy) => raw.data[(Math.min(height - 1, yy * sy) * width + Math.min(width - 1, xx * sx)) * 4 + channel];
+    return (1 - fy) * ((1 - fx) * at(ix, iy) + fx * at(ix + 1, iy)) + fy * ((1 - fx) * at(ix, iy + 1) + fx * at(ix + 1, iy + 1));
+  };
+  const byte = (value) => Math.max(0, Math.min(255, Math.round(value)));
+  for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+    const luma = sample2(x, y, 0), cb = sample2(x, y, 1) - 128, cr = sample2(x, y, 2) - 128;
+    const offset = (y * width + x) * 4;
+    data[offset] = byte(luma + 1.402 * cr);
+    data[offset + 1] = byte(luma - 0.3441363 * cb - 0.71413636 * cr);
+    data[offset + 2] = byte(luma + 1.772 * cb);
+    data[offset + 3] = 255;
+  }
+  return { ...raw, data };
+}
+
+// src/image-codec-fallback.ts
 var import_gifuct_js = __toESM(require_lib2());
 var UTIF = __toESM(require_UTIF());
 
 // src/tiff-group3.ts
 function normalizeGroup3(buffer, page) {
-  const options = Array.isArray(page.t292) ? Number(page.t292[0]) : 0;
-  if (!Array.isArray(page.t259) || page.t259[0] !== 3 || (options & 3) !== 0) return buffer;
+  const options2 = Array.isArray(page.t292) ? Number(page.t292[0]) : 0;
+  if (!Array.isArray(page.t259) || page.t259[0] !== 3 || (options2 & 3) !== 0) return buffer;
   const offsets = page.t273, lengths = page.t279;
   if (!Array.isArray(offsets) || !Array.isArray(lengths) || offsets.length !== lengths.length) return buffer;
   const source = new Uint8Array(buffer);
@@ -10352,16 +10411,50 @@ function normalizeGroup3(buffer, page) {
     return offset;
   });
   page.t279 = strips.map((strip) => strip.length);
-  page.t292 = [options | 1];
+  page.t292 = [options2 | 1];
   return normalized.buffer;
 }
 
+// src/tiff-jpeg.ts
+function decodeJpegTiff(bytes, page) {
+  const values = (tag2) => Array.isArray(page[tag2]) ? page[tag2].map(Number) : [];
+  const first = (tag2, fallback = 0) => values(tag2)[0] ?? fallback;
+  const photo = first("t262");
+  if (first("t259") !== 7 || photo !== 2 && photo !== 6 || first("t277") !== 3 || first("t284", 1) !== 1 || values("t258").some((v) => v !== 8)) return null;
+  const width = first("t256"), height = first("t257");
+  const tiled = !!page.t322;
+  const blockWidth = tiled ? first("t322") : width;
+  const blockHeight = tiled ? first("t323") : first("t278", height);
+  if (!Number.isInteger(blockWidth) || !Number.isInteger(blockHeight) || blockWidth <= 0 || blockHeight <= 0 || blockWidth > 8192 || blockHeight > 8192) throw new Error("Invalid TIFF JPEG block");
+  const offsets = values(tiled ? "t324" : "t273");
+  const lengths = values(tiled ? "t325" : "t279");
+  const columns = Math.ceil(width / blockWidth), rows = Math.ceil(height / blockHeight);
+  if (offsets.length !== columns * rows || lengths.length !== offsets.length) throw new Error("Invalid TIFF JPEG offsets");
+  const tables = page.t347 instanceof Uint8Array ? page.t347 : new Uint8Array(values("t347"));
+  const tableLength = tables.length >= 2 && tables[tables.length - 2] === 255 && tables[tables.length - 1] === 217 ? tables.length - 2 : tables.length;
+  const result = new Uint8ClampedArray(width * height * 4);
+  for (let block = 0; block < offsets.length; block++) {
+    const offset = offsets[block], length = lengths[block];
+    if (!Number.isInteger(offset) || !Number.isInteger(length) || offset < 0 || length <= 0 || offset + length > bytes.length) throw new Error("Invalid TIFF JPEG data");
+    const skip = tableLength && bytes[offset] === 255 && bytes[offset + 1] === 216 ? 2 : 0;
+    const jpeg = new Uint8Array(tableLength + length - skip);
+    jpeg.set(tables.subarray(0, tableLength));
+    jpeg.set(bytes.subarray(offset + skip, offset + length), tableLength);
+    const decoded = decodeJpegPixels(jpeg, photo === 6);
+    const x = block % columns * blockWidth, y = Math.floor(block / columns) * blockHeight;
+    const copyWidth = Math.min(blockWidth, width - x), copyHeight = Math.min(blockHeight, height - y);
+    if (decoded.width !== blockWidth || decoded.height < copyHeight || decoded.height > blockHeight) throw new Error("Invalid TIFF JPEG dimensions");
+    for (let row = 0; row < copyHeight; row++) result.set(decoded.data.subarray(row * decoded.width * 4, (row * decoded.width + copyWidth) * 4), ((y + row) * width + x) * 4);
+  }
+  return result;
+}
+
 // src/image-codec-fallback.ts
 var validSize = (w, h) => Number.isInteger(w) && Number.isInteger(h) && w > 0 && h > 0 && w <= 8192 && h <= 8192;
 function decodeImageCodecFallback(bytes) {
   try {
     if (bytes[0] === 255 && bytes[1] === 216) {
-      const p = (0, import_jpeg_js.decode)(bytes, { useTArray: true, formatAsRGBA: true, maxResolutionInMP: 67.108864, maxMemoryUsageInMB: 512 });
+      const p = decodeJpegPixels(bytes);
       return validSize(p.width, p.height) ? { ...p, data: new Uint8ClampedArray(p.data) } : null;
     }
     if (bytes.length >= 13 && String.fromCharCode(...bytes.subarray(0, 6)).match(/^GIF8[79]a$/)) {
@@ -10395,6 +10488,9 @@ function decodeImageCodecFallback(bytes) {
       const pages = UTIF.decode(buffer);
       const page = pages.find((p) => p.t256 && p.t257);
       if (!page || !Array.isArray(page.t256) || !Array.isArray(page.t257) || !validSize(Number(page.t256[0]), Number(page.t257[0]))) return null;
+      const jpeg = decodeJpegTiff(new Uint8Array(buffer), page);
+      if (jpeg) return { data: jpeg, width: Number(page.t256[0]), height: Number(page.t257[0]) };
+      if (Array.isArray(page.t259) && page.t259[0] === 32946) page.t259 = [8];
       UTIF.decodeImage(normalizeGroup3(buffer, page), page);
       const width = page.width, height = page.height;
       if (!validSize(width, height)) return null;
@@ -14312,13 +14408,13 @@ function writeJsx(node, depth, out, rootSpread) {
   }
   out.push(`${pad}</${node.tag}>`);
 }
-function svgTreeToJsx(node, options = {}) {
-  const name = options.componentName ?? "Metafile";
+function svgTreeToJsx(node, options2 = {}) {
+  const name = options2.componentName ?? "Metafile";
   if (!/^[A-Z][A-Za-z0-9_$]*$/.test(name)) {
     throw new TypeError(`svgTreeToJsx: componentName must be a PascalCase identifier, got ${JSON.stringify(name)}`);
   }
-  const ts = options.typescript ?? true;
-  const spread = options.spreadProps ?? true;
+  const ts = options2.typescript ?? true;
+  const spread = options2.spreadProps ?? true;
   const body = [];
   writeJsx(node, 2, body, spread);
   const params = spread ? ts ? "props: SVGProps<SVGSVGElement>" : "props" : "";
@@ -15761,11 +15857,11 @@ function mirror(p, n) {
   }
   return p;
 }
-function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false) {
+function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical = false, edgeWidth = w, edgeHeight = h) {
   const k = blurKernel(radius);
   const taps = (k.length - 1) / 2;
-  const horizontalIndex = radius <= 16 && radius >= w ? (x) => Math.max(0, Math.min(w - 1, x)) : (x) => mirror(x, w);
-  const verticalIndex = radius <= 16 && radius >= h ? (y) => Math.max(0, Math.min(h - 1, y)) : (y) => mirror(y, h);
+  const horizontalIndex = taps >= edgeWidth ? (x) => Math.max(0, Math.min(w - 1, x)) : (x) => mirror(x, w);
+  const verticalIndex = taps >= edgeHeight ? (y) => Math.max(0, Math.min(h - 1, y)) : (y) => mirror(y, h);
   const out = new Float64Array(w * h * 4);
   for (let y = 0; y < h; y++) {
     const row = y * w * 4;
@@ -15791,7 +15887,7 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false) {
   }
   if (taps > 0 && vRow >= 0 && vRow < h) {
     const horizontal = out.slice();
-    const endRow = Math.min(h, vRow + (radius <= 16 ? Math.ceil(h / w) : 1));
+    const endRow = fullVertical ? h : Math.min(h, vRow + Math.ceil(h / w));
     for (let row = vRow; row < endRow; row++) {
       const col = new Float64Array(w * 4);
       for (let j = -taps; j <= taps; j++) {
@@ -15809,14 +15905,46 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false) {
   }
   return out;
 }
+function blurReduction(radius) {
+  return radius < 20 ? 1 : radius < 40 ? 2 : radius <= 80 ? 4 : radius < 160 ? 8 : 16;
+}
+function effectBlur(src, width, height, radius) {
+  const factor = blurReduction(radius);
+  if (factor === 1 || (width < 4 || height < 4) && (width % factor !== 0 || height % factor !== 0)) {
+    return gdipBlur(src, width, height, radius);
+  }
+  const w = Math.ceil(width / factor);
+  const h = Math.ceil(height / factor);
+  const reduced = new Uint8ClampedArray(w * h * 4);
+  for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
+    const x1 = Math.min(width, (x + 1) * factor), y1 = Math.min(height, (y + 1) * factor);
+    const count = (x1 - x * factor) * (y1 - y * factor);
+    for (let c = 0; c < 4; c++) {
+      let sum = 0;
+      for (let yy = y * factor; yy < y1; yy++) for (let xx = x * factor; xx < x1; xx++) sum += src[(yy * width + xx) * 4 + c];
+      reduced[(y * w + x) * 4 + c] = Math.floor(sum / count);
+    }
+  }
+  const filtered = gdipBlur(reduced, w, h, radius / factor, 0, false, true, Math.floor(width / factor), Math.floor(height / factor));
+  for (let i = 0; i < filtered.length; i++) filtered[i] = Math.round(filtered[i]);
+  const out = new Float64Array(src.length);
+  for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+    const px = clamp((x + 0.5) / factor - 0.5, 0, w - 1), py = clamp((y + 0.5) / factor - 0.5, 0, h - 1);
+    const ix = Math.floor(px), iy = Math.floor(py), fx = px - ix, fy = py - iy;
+    const a = (iy * w + ix) * 4, b = (iy * w + Math.min(w - 1, ix + 1)) * 4;
+    const d = (Math.min(h - 1, iy + 1) * w + ix) * 4, e = (Math.min(h - 1, iy + 1) * w + Math.min(w - 1, ix + 1)) * 4;
+    for (let c = 0; c < 4; c++) out[(y * width + x) * 4 + c] = Math.round((1 - fy) * ((1 - fx) * filtered[a + c] + fx * filtered[b + c]) + fy * ((1 - fx) * filtered[d + c] + fx * filtered[e + c]));
+  }
+  return out;
+}
 function applyBlur(src, w, h, radius) {
-  return Uint8ClampedArray.from(gdipBlur(src, w, h, radius), Math.round);
+  return Uint8ClampedArray.from(effectBlur(src, w, h, radius), Math.round);
 }
 function sharpenGain(_radius, amount) {
   return roundHalfDown(64 * amount / (250 - 2 * amount)) / 64;
 }
 function applySharpen(src, w, h, radius, amount) {
-  const blurred = gdipBlur(src, w, h, radius);
+  const blurred = effectBlur(src, w, h, radius);
   const gain = sharpenGain(radius, amount);
   const out = new Uint8ClampedArray(src);
   for (let i = 0; i < src.length; i += 4) {
@@ -18638,11 +18766,11 @@ function capFigures(path, closeAll) {
   }, [1, 0, 0, 1, 0, 0]);
   return closeAll ? figures.map((f) => ({ ...f, closed: true })) : figures;
 }
-function customCapGeometry(figures, width, start, end, options = {}) {
+function customCapGeometry(figures, width, start, end, options2 = {}) {
   const out = [];
   const capped = [];
   const polygons = [];
-  const minFill = options.minFillScale ?? 2;
+  const minFill = options2.minFillScale ?? 2;
   for (const fig of figures) {
     if (fig.closed || !start && !end) {
       out.push(fig);
@@ -18695,7 +18823,7 @@ function customCapGeometry(figures, width, start, end, options = {}) {
         const pen = {
           // GDI+'s widener never makes an outline thinner than one device pixel.
           half: Math.max(ws, 1) / 2,
-          join: (options.widenJoin ?? ((j) => j))(cap.strokeJoin),
+          join: (options2.widenJoin ?? ((j) => j))(cap.strokeJoin),
           miterLimit: 10,
           startCap: cap.strokeStartCap,
           endCap: cap.strokeEndCap,
@@ -18705,7 +18833,7 @@ function customCapGeometry(figures, width, start, end, options = {}) {
           compound: null,
           inset: false
         };
-        polygons.push(...(options.widen ?? widenFigures)(capFigures(placed, false), pen).map((q) => q.reverse()));
+        polygons.push(...(options2.widen ?? widenFigures)(capFigures(placed, false), pen).map((q) => q.reverse()));
       }
     };
     if (start) {
@@ -20420,7 +20548,7 @@ var BLEND_MODES = /* @__PURE__ */ new Set([
   "luminosity"
 ]);
 var SvgContext = class {
-  constructor(width, height, options = {}) {
+  constructor(width, height, options2 = {}) {
     this.nextId = 0;
     this.stack = [];
     /** The current path, in DEVICE space (see `canvas-path.ts`). */
@@ -20431,9 +20559,9 @@ var SvgContext = class {
     this.group = null;
     this.images = [];
     this.canvas = { width, height, svgContext: this };
-    this.shadow = options.shadow ?? null;
-    this.imageResampling = options.imageResampling ?? "renderer";
-    this.idPrefix = options.idPrefix ?? "emf-";
+    this.shadow = options2.shadow ?? null;
+    this.imageResampling = options2.imageResampling ?? "renderer";
+    this.idPrefix = options2.idPrefix ?? "emf-";
     this.state = {
       transform: [...IDENTITY3],
       fillStyle: "#000000",
@@ -21436,7 +21564,7 @@ var SvgContext = class {
    * Encodes every pending raster payload and returns the finished `<svg>`
    * tree. Call once, after replay (and deferred images) are complete.
    */
-  async toTree(options = {}) {
+  async toTree(options2 = {}) {
     const cache2 = /* @__PURE__ */ new Map();
     for (const img of this.images) {
       let url = cache2.get(img.payload);
@@ -21448,7 +21576,7 @@ var SvgContext = class {
     }
     const { width, height } = this.canvas;
     const attrs = { xmlns: "http://www.w3.org/2000/svg" };
-    if (options.includeSize ?? true) {
+    if (options2.includeSize ?? true) {
       attrs.width = width;
       attrs.height = height;
     }
@@ -32273,12 +32401,12 @@ function drawWithFontEngine(rCtx, offset, dataOff, nChars, offString, viewEnd) {
   if (!fonts) {
     return false;
   }
-  const options = view.getUint32(dataOff + 44, true);
+  const options2 = view.getUint32(dataOff + 44, true);
   const codes = [];
   for (let i = 0; i < nChars; i++) {
     codes.push(view.getUint16(offset + offString + i * 2, true));
   }
-  const pdy = (options & ETO_PDY) !== 0;
+  const pdy = (options2 & ETO_PDY) !== 0;
   const raw = readDxArray(view, offset, dataOff, pdy ? nChars * 2 : nChars, viewEnd);
   let dx = raw;
   let dy = null;
@@ -32292,10 +32420,10 @@ function drawWithFontEngine(rCtx, offset, dataOff, nChars, offString, viewEnd) {
   }
   const adv = drawGdiTextCall(ctx, fonts, state, {
     codes,
-    glyphIndices: (options & ETO_GLYPH_INDEX) !== 0,
+    glyphIndices: (options2 & ETO_GLYPH_INDEX) !== 0,
     x: view.getInt32(dataOff + 28, true),
     y: view.getInt32(dataOff + 32, true),
-    options,
+    options: options2,
     rect: {
       left: view.getInt32(dataOff + 48, true),
       top: view.getInt32(dataOff + 52, true),
@@ -32437,7 +32565,7 @@ function handleExtTextOutW(rCtx, offset, dataOff, recSize) {
   }
   return true;
 }
-function drawTextCall(rCtx, x, y, codes, options, rect, dx) {
+function drawTextCall(rCtx, x, y, codes, options2, rect, dx) {
   const n = codes.length;
   const offString = 76;
   const offDx = offString + n * 2 + 3 & -4;
@@ -32446,7 +32574,7 @@ function drawTextCall(rCtx, x, y, codes, options, rect, dx) {
   const view = new DataView(new ArrayBuffer(size));
   view.setUint32(44, n, true);
   view.setUint32(48, offString, true);
-  view.setUint32(52, options, true);
+  view.setUint32(52, options2, true);
   view.setInt32(36, x, true);
   view.setInt32(40, y, true);
   view.setInt32(56, rect[0], true);
@@ -32490,7 +32618,7 @@ function handlePolyText(rCtx, offset, dataOff, recSize, wide) {
     const e = arrayStart + i * 40;
     const x = view.getInt32(e, true), y = view.getInt32(e + 4, true);
     const n = view.getUint32(e + 8, true), offString = view.getUint32(e + 12, true);
-    const options = view.getUint32(e + 16, true);
+    const options2 = view.getUint32(e + 16, true);
     const rect = [view.getInt32(e + 20, true), view.getInt32(e + 24, true), view.getInt32(e + 28, true), view.getInt32(e + 32, true)];
     const offDx = view.getUint32(e + 36, true);
     const unit = wide ? 2 : 1;
@@ -32498,13 +32626,13 @@ function handlePolyText(rCtx, offset, dataOff, recSize, wide) {
     const ansi = wide ? null : readAnsiRecord(view, offset + offString, n, charSet);
     const codes = wide ? Array.from({ length: n }, (_, j) => view.getUint16(offset + offString + j * 2, true)) : ansi.codes;
     let dx = null;
-    const pdy = (options & ETO_PDY) !== 0;
+    const pdy = (options2 & ETO_PDY) !== 0;
     const dxCount = n * (pdy ? 2 : 1);
     if (offDx && offDx <= end - offset && dxCount <= Math.floor((end - (offset + offDx)) / 4)) {
       dx = Array.from({ length: dxCount }, (_, j) => view.getInt32(offset + offDx + j * 4, true));
       if (!wide) dx = collapseAnsiDx(dx, ansi.byteLengths, pdy);
     }
-    drawTextCall(rCtx, x, y, codes, options, rect, dx);
+    drawTextCall(rCtx, x, y, codes, options2, rect, dx);
   }
   return true;
 }
@@ -32513,13 +32641,13 @@ function handleSmallTextOut(rCtx, offset, dataOff, recSize) {
   const end = Math.min(view.byteLength, offset + recSize);
   if (recSize < 36) return true;
   const x = view.getInt32(dataOff, true), y = view.getInt32(dataOff + 4, true);
-  const n = view.getUint32(dataOff + 8, true), options = view.getUint32(dataOff + 12, true);
-  const small = (options & 512) !== 0, noRect = (options & 256) !== 0;
+  const n = view.getUint32(dataOff + 8, true), options2 = view.getUint32(dataOff + 12, true);
+  const small = (options2 & 512) !== 0, noRect = (options2 & 256) !== 0;
   const base = dataOff + 28 + (noRect ? 0 : 16);
   if (base > end || n > Math.floor((end - base) / (small ? 1 : 2))) return true;
   const rect = noRect ? [0, 0, 0, 0] : [view.getInt32(dataOff + 28, true), view.getInt32(dataOff + 32, true), view.getInt32(dataOff + 36, true), view.getInt32(dataOff + 40, true)];
   const codes = small ? Array.from({ length: n }, (_, i) => view.getUint8(base + i)) : Array.from({ length: n }, (_, i) => view.getUint16(base + i * 2, true));
-  drawTextCall(rCtx, x, y, codes, options, rect, null);
+  drawTextCall(rCtx, x, y, codes, options2, rect, null);
   return true;
 }
 function handleEmfGdiDrawTextRecord(rCtx, recType, offset, dataOff, recSize) {
@@ -32533,20 +32661,20 @@ function handleEmfGdiDrawTextRecord(rCtx, recType, offset, dataOff, recSize) {
     const end = Math.min(view.byteLength, offset + recSize);
     if (recSize < 76) return true;
     const x = view.getInt32(dataOff + 28, true), y = view.getInt32(dataOff + 32, true);
-    const n = view.getUint32(dataOff + 36, true), strOff = view.getUint32(dataOff + 40, true), options = view.getUint32(dataOff + 44, true);
+    const n = view.getUint32(dataOff + 36, true), strOff = view.getUint32(dataOff + 40, true), options2 = view.getUint32(dataOff + 44, true);
     if (!strOff || strOff > end - offset) return true;
     if (n > end - (offset + strOff)) return true;
     const ansi = readAnsiRecord(view, offset + strOff, n, state.fontDetails?.charSet ?? 1);
     const rect = [view.getInt32(dataOff + 48, true), view.getInt32(dataOff + 52, true), view.getInt32(dataOff + 56, true), view.getInt32(dataOff + 60, true)];
     const offDx = view.getUint32(dataOff + 64, true);
     let dx = null;
-    const pdy = (options & ETO_PDY) !== 0;
+    const pdy = (options2 & ETO_PDY) !== 0;
     const dxCount = n * (pdy ? 2 : 1);
     if (offDx && offDx <= end - offset && dxCount <= Math.floor((end - (offset + offDx)) / 4)) {
       dx = Array.from({ length: dxCount }, (_, i) => view.getInt32(offset + offDx + i * 4, true));
       dx = collapseAnsiDx(dx, ansi.byteLengths, pdy);
     }
-    drawTextCall(rCtx, x, y, ansi.codes, options, rect, dx);
+    drawTextCall(rCtx, x, y, ansi.codes, options2, rect, dx);
     return true;
   }
   return false;
@@ -33527,8 +33655,8 @@ function widenBracketPath(rCtx) {
   if (rCtx.inPath || !rCtx.rasterPath || (state.penStyle & 15) === 5) {
     return;
   }
-  const options = penIsCosmetic(rCtx) ? { width: 16, cap: "round", join: "round", miterLimit: state.miterLimit ?? 10 } : penWidenOptions(rCtx);
-  const polys = widenPath(rCtx.rasterPath, options);
+  const options2 = penIsCosmetic(rCtx) ? { width: 16, cap: "round", join: "round", miterLimit: state.miterLimit ?? 10 } : penWidenOptions(rCtx);
+  const polys = widenPath(rCtx.rasterPath, options2);
   const path = new GdiRasterPath();
   for (const poly of polys) {
     if (poly.length < 4) {
@@ -36309,7 +36437,7 @@ function replayEmfRecords(view, ctx, bounds, canvasW, canvasH, dpiScale = 1, rep
   }
   return allDeferredImages;
 }
-function replayNestedEmf(bytes, ctx, canvasW, canvasH, toCanvas, options) {
+function replayNestedEmf(bytes, ctx, canvasW, canvasH, toCanvas, options2) {
   const view = new DataView(bytes);
   const header = parseEmfHeader(view);
   if (!header) {
@@ -36320,11 +36448,11 @@ function replayNestedEmf(bytes, ctx, canvasW, canvasH, toCanvas, options) {
     const left = -e / a;
     const top = -f / d;
     const bounds2 = { left, top, right: left + canvasW / a, bottom: top + canvasH / d };
-    return replayEmfRecords(view, ctx, bounds2, canvasW, canvasH, 1, options);
+    return replayEmfRecords(view, ctx, bounds2, canvasW, canvasH, 1, options2);
   }
   const bounds = { left: 0, top: 0, right: canvasW, bottom: canvasH };
   return replayEmfRecords(view, ctx, bounds, canvasW, canvasH, 1, {
-    ...options,
+    ...options2,
     plusBaseTransform: toCanvas,
     gdiDrawing: false
   });
@@ -37868,8 +37996,8 @@ function wmfExtTextOut(p, dataOff, recEnd) {
   const y = view.getInt16(dataOff, true);
   const x = view.getInt16(dataOff + 2, true);
   const n = view.getInt16(dataOff + 4, true);
-  const options = view.getUint16(dataOff + 6, true);
-  const hasRect = (options & (ETO_OPAQUE | ETO_CLIPPED)) !== 0;
+  const options2 = view.getUint16(dataOff + 6, true);
+  const hasRect = (options2 & (ETO_OPAQUE | ETO_CLIPPED)) !== 0;
   const strOff = dataOff + 8 + (hasRect ? 8 : 0);
   const rect = hasRect && dataOff + 16 <= recEnd ? [view.getInt16(dataOff + 8, true), view.getInt16(dataOff + 10, true), view.getInt16(dataOff + 12, true), view.getInt16(dataOff + 14, true)] : null;
   const count = Math.max(0, n);
@@ -37889,12 +38017,12 @@ function wmfExtTextOut(p, dataOff, recEnd) {
     }
   }
   if (count === 0) {
-    if (rect && options & ETO_OPAQUE) {
-      playText(p, { x, y, bytes: [32], options, rect, dx: [0] });
+    if (rect && options2 & ETO_OPAQUE) {
+      playText(p, { x, y, bytes: [32], options: options2, rect, dx: [0] });
     }
     return;
   }
-  playText(p, { x, y, bytes, options, rect, dx });
+  playText(p, { x, y, bytes, options: options2, rect, dx });
 }
 
 // src/wmf-replay.ts
@@ -38364,7 +38492,7 @@ function replayWmfRecords(view, ctx, header, canvasW, canvasH, replayOptions = {
 
 // src/emf-converter.ts
 var MAX_METAFILE_RECURSION = 3;
-async function replayMetafile(buffer, options, createSurface) {
+async function replayMetafile(buffer, options2, createSurface) {
   emfLog(`replayMetafile: input buffer ${buffer.byteLength} bytes`);
   if (buffer.byteLength >= 16) {
     const hdrBytes = new Uint8Array(buffer, 0, 16);
@@ -38372,7 +38500,7 @@ async function replayMetafile(buffer, options, createSurface) {
       `replayMetafile: first 16 bytes: [${Array.from(hdrBytes).map((b) => b.toString(16).padStart(2, "0")).join(" ")}]`
     );
   }
-  const opts = options ?? {};
+  const opts = options2 ?? {};
   const dpiScale = opts.dpiScale ?? DEFAULT_DPI_SCALE;
   let view = new DataView(buffer);
   let emfHeader = null;
@@ -38578,12 +38706,12 @@ async function processDeferredImages(ctx, deferredImages, recursionDepth) {
   ctx.setTransform(1, 0, 0, 1, 0, 0);
   return complete;
 }
-async function convertMetafileToDataUrl(buffer, options, recursionDepth = 0) {
+async function convertMetafileToDataUrl(buffer, options2, recursionDepth = 0) {
   await ensureNodeCanvasModule();
   if (recursionDepth > MAX_METAFILE_RECURSION) {
     return null;
   }
-  const opts = { ...options, gdiAntialias: options?.gdiAntialias ?? false };
+  const opts = { ...options2, gdiAntialias: options2?.gdiAntialias ?? false };
   let canvas = null;
   const result = await replayMetafile(buffer, opts, (w, h) => {
     const setup = createCanvas(
@@ -38652,7 +38780,7 @@ async function resampleExact(bytes, spec, surface) {
   }
   return resampleImage(pixels.data, pixels.width, pixels.height, spec, { w: surface.width, h: surface.height });
 }
-async function processDeferredImagesSvg(svg, deferredImages, options, recursionDepth) {
+async function processDeferredImagesSvg(svg, deferredImages, options2, recursionDepth) {
   for (let idx = 0; idx < deferredImages.length; idx++) {
     let img = deferredImages[idx];
     try {
@@ -38675,7 +38803,7 @@ async function processDeferredImagesSvg(svg, deferredImages, options, recursionD
         }
         const nested = await convertMetafileToSvgTree(
           bytes,
-          { ...options, includeSize: true, idPrefix: void 0 },
+          { ...options2, includeSize: true, idPrefix: void 0 },
           recursionDepth + 1
         );
         if (nested) {
@@ -38712,7 +38840,7 @@ async function processDeferredImagesSvg(svg, deferredImages, options, recursionD
         continue;
       }
       const slot = img.svgSlot ?? svg.reserveSlot();
-      if (img.resample && options.imageResampling === "exact" && !img.isMetafile) {
+      if (img.resample && options2.imageResampling === "exact" && !img.isMetafile) {
         const block = await resampleExact(bytes, img.resample, svg.canvas);
         if (block) {
           svg.fillSlot(slot, { kind: "rgba", data: block.rgba, width: block.w, height: block.h }, [1, 0, 0, 1, 0, 0], block.x, block.y, block.w, block.h);
@@ -38732,16 +38860,16 @@ async function processDeferredImagesSvg(svg, deferredImages, options, recursionD
     }
   }
 }
-async function convertMetafileToSvgTree(buffer, options, recursionDepth = 0) {
-  const svg = await replayToSvgContext(buffer, options, recursionDepth);
-  return svg ? svg.toTree({ includeSize: options?.includeSize }) : null;
+async function convertMetafileToSvgTree(buffer, options2, recursionDepth = 0) {
+  const svg = await replayToSvgContext(buffer, options2, recursionDepth);
+  return svg ? svg.toTree({ includeSize: options2?.includeSize }) : null;
 }
-async function replayToSvgContext(buffer, options, recursionDepth = 0) {
+async function replayToSvgContext(buffer, options2, recursionDepth = 0) {
   await ensureNodeCanvasModule();
   if (recursionDepth > MAX_METAFILE_RECURSION) {
     return null;
   }
-  const opts = options ?? {};
+  const opts = options2 ?? {};
   const dpiScale = opts.dpiScale ?? DEFAULT_DPI_SCALE;
   const idPrefix = opts.idPrefix ?? `emf${++svgDocumentCounter}-`;
   let svg = null;
@@ -38758,12 +38886,12 @@ async function replayToSvgContext(buffer, options, recursionDepth = 0) {
   await processDeferredImagesSvg(target, result.deferredImages, opts, recursionDepth);
   return target;
 }
-async function convertMetafileToSvg(buffer, options) {
-  const tree = await convertMetafileToSvgTree(buffer, options);
+async function convertMetafileToSvg(buffer, options2) {
+  const tree = await convertMetafileToSvgTree(buffer, options2);
   return tree ? svgTreeToString(tree) : null;
 }
-async function convertMetafileToSvgDataUrl(buffer, options) {
-  const markup = await convertMetafileToSvg(buffer, options);
+async function convertMetafileToSvgDataUrl(buffer, options2) {
+  const markup = await convertMetafileToSvg(buffer, options2);
   return markup ? svgMarkupToDataUrl(markup) : null;
 }