emf-converter 4.4.16 → 4.5.0

package/dist/index.js

@@ -1210,7 +1210,7 @@ var require_decoder = __commonJS({
         }
         return code[0].children;
       }
-      function decodeScan(data, offset, frame2, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive, opts) {
+      function decodeScan2(data, offset, frame2, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive, opts) {
         frame2.precision;
         frame2.samplesPerLine;
         frame2.scanLines;
@@ -1851,7 +1851,7 @@ var require_decoder = __commonJS({
                 var spectralStart = data[offset++];
                 var spectralEnd = data[offset++];
                 var successiveApproximation = data[offset++];
-                var processed = decodeScan(
+                var processed = decodeScan2(
                   data,
                   offset,
                   frame2,
@@ -2305,14 +2305,14 @@ var require_uint8 = __commonJS({
         for (var i = 0; i < 8; i++) {
           bits[7 - i] = !!(_byte & 1 << i);
         }
-        return Object.keys(schema).reduce(function(res, key) {
+        return Object.keys(schema).reduce(function(res2, key) {
           var def = schema[key];
           if (def.length) {
-            res[key] = subBitsTotal(bits, def.index, def.length);
+            res2[key] = subBitsTotal(bits, def.index, def.length);
           } else {
-            res[key] = bits[def.index];
+            res2[key] = bits[def.index];
           }
-          return res;
+          return res2;
         }, {});
       };
     };
@@ -2921,13 +2921,13 @@ var require_trees = __commonJS({
       );
     }
     function bi_reverse(code, len) {
-      var res = 0;
+      var res2 = 0;
       do {
-        res |= code & 1;
+        res2 |= code & 1;
         code >>>= 1;
-        res <<= 1;
+        res2 <<= 1;
       } while (--len > 0);
-      return res >>> 1;
+      return res2 >>> 1;
     }
     function bi_flush(s) {
       if (s.bi_valid === 16) {
@@ -10312,10 +10312,10 @@ async function decodePng(bytes) {
   return { width, height, data: out };
 }
 
-// src/jpeg-decoder.ts
+// src/jpeg-decoder-legacy.ts
 var import_jpeg_js = __toESM(require_jpeg_js());
 var options = { useTArray: true, formatAsRGBA: true, maxResolutionInMP: 67.108864, maxMemoryUsageInMB: 512 };
-function decodeJpegPixels(bytes, colorTransform) {
+function decodeJpegPixelsLegacy(bytes, colorTransform) {
   let sampling = [];
   let adobeTransform;
   let adobeOffset = -1;
@@ -10372,6 +10372,600 @@ function decodeJpegPixels(bytes, colorTransform) {
   return { ...raw, data };
 }
 
+// src/jpeg-turbo.ts
+var ZIGZAG = [
+  0,
+  1,
+  8,
+  16,
+  9,
+  2,
+  3,
+  10,
+  17,
+  24,
+  32,
+  25,
+  18,
+  11,
+  4,
+  5,
+  12,
+  19,
+  26,
+  33,
+  40,
+  48,
+  41,
+  34,
+  27,
+  20,
+  13,
+  6,
+  7,
+  14,
+  21,
+  28,
+  35,
+  42,
+  49,
+  56,
+  57,
+  50,
+  43,
+  36,
+  29,
+  22,
+  15,
+  23,
+  30,
+  37,
+  44,
+  51,
+  58,
+  59,
+  52,
+  45,
+  38,
+  31,
+  39,
+  46,
+  53,
+  60,
+  61,
+  54,
+  47,
+  55,
+  62,
+  63
+];
+function buildHuffman2(counts, values) {
+  const maxcode = new Int32Array(18).fill(-1);
+  const valptr = new Int32Array(17);
+  const mincode = new Int32Array(17);
+  let code = 0;
+  let k = 0;
+  for (let l = 1; l <= 16; l++) {
+    valptr[l] = k;
+    mincode[l] = code;
+    code += counts[l - 1];
+    k += counts[l - 1];
+    maxcode[l] = counts[l - 1] ? code - 1 : -1;
+    code <<= 1;
+  }
+  return { maxcode, valptr, mincode, values };
+}
+var BitReader = class {
+  constructor(data, start) {
+    this.data = data;
+    this.bits = 0;
+    this.count = 0;
+    this.marker = false;
+    this.pos = start;
+  }
+  reset() {
+    this.bits = 0;
+    this.count = 0;
+    this.marker = false;
+  }
+  bit() {
+    if (this.count === 0) {
+      let b = 0;
+      if (!this.marker && this.pos < this.data.length) {
+        b = this.data[this.pos++];
+        if (b === 255) {
+          let n = this.data[this.pos];
+          while (n === 255) {
+            this.pos++;
+            n = this.data[this.pos];
+          }
+          if (n === 0) {
+            this.pos++;
+          } else {
+            this.marker = true;
+            this.pos--;
+            b = 0;
+          }
+        }
+      }
+      this.bits = b;
+      this.count = 8;
+    }
+    this.count--;
+    return this.bits >> this.count & 1;
+  }
+  receive(n) {
+    let v = 0;
+    while (n--) v = v << 1 | this.bit();
+    return v;
+  }
+  receiveExtend(n) {
+    if (n === 0) return 0;
+    const v = this.receive(n);
+    return v < 1 << n - 1 ? v - (1 << n) + 1 : v;
+  }
+  decode(h) {
+    let code = 0;
+    for (let l = 1; l <= 16; l++) {
+      code = code << 1 | this.bit();
+      if (h.maxcode[l] >= 0 && code <= h.maxcode[l] && code >= h.mincode[l]) return h.values[h.valptr[l] + code - h.mincode[l]];
+    }
+    throw new Error("Bad Huffman code");
+  }
+};
+var CONST_BITS = 13;
+var PASS1_BITS = 2;
+var FIX_0_298631336 = 2446;
+var FIX_0_541196100 = 4433;
+var FIX_0_765366865 = 6270;
+var FIX_1_175875602 = 9633;
+var FIX_1_501321110 = 12299;
+var FIX_2_053119869 = 16819;
+var FIX_3_072711026 = 25172;
+function descale(x, n) {
+  return x + (1 << n - 1) >> n;
+}
+function idct1d(v, r) {
+  let z2 = v[2];
+  let z3 = v[6];
+  let z1 = (z2 + z3) * FIX_0_541196100;
+  let tmp2 = z1 + z3 * -15137;
+  let tmp3 = z1 + z2 * FIX_0_765366865;
+  let tmp0 = v[0] + v[4] << CONST_BITS;
+  let tmp1 = v[0] - v[4] << CONST_BITS;
+  const tmp10 = tmp0 + tmp3;
+  const tmp13 = tmp0 - tmp3;
+  const tmp11 = tmp1 + tmp2;
+  const tmp12 = tmp1 - tmp2;
+  tmp0 = v[7];
+  tmp1 = v[5];
+  tmp2 = v[3];
+  tmp3 = v[1];
+  z1 = tmp0 + tmp3;
+  z2 = tmp1 + tmp2;
+  z3 = tmp0 + tmp2;
+  let z4 = tmp1 + tmp3;
+  const z5 = (z3 + z4) * FIX_1_175875602;
+  tmp0 *= FIX_0_298631336;
+  tmp1 *= FIX_2_053119869;
+  tmp2 *= FIX_3_072711026;
+  tmp3 *= FIX_1_501321110;
+  z1 *= -7373;
+  z2 *= -20995;
+  z3 *= -16069;
+  z4 *= -3196;
+  z3 += z5;
+  z4 += z5;
+  tmp0 += z1 + z3;
+  tmp1 += z2 + z4;
+  tmp2 += z2 + z3;
+  tmp3 += z1 + z4;
+  r[0] = tmp10 + tmp3;
+  r[7] = tmp10 - tmp3;
+  r[1] = tmp11 + tmp2;
+  r[6] = tmp11 - tmp2;
+  r[2] = tmp12 + tmp1;
+  r[5] = tmp12 - tmp1;
+  r[3] = tmp13 + tmp0;
+  r[4] = tmp13 - tmp0;
+}
+var vec = new Array(8).fill(0);
+var res = new Array(8).fill(0);
+function idctBlock(coef, offset, quant, out, outOffset, stride, ws) {
+  for (let col = 0; col < 8; col++) {
+    let ac = 0;
+    for (let r = 0; r < 8; r++) {
+      vec[r] = coef[offset + r * 8 + col] * quant[r * 8 + col];
+      if (r) ac |= vec[r];
+    }
+    if (!ac) {
+      const dc = vec[0] << PASS1_BITS;
+      for (let r = 0; r < 8; r++) ws[r * 8 + col] = dc;
+      continue;
+    }
+    idct1d(vec, res);
+    for (let r = 0; r < 8; r++) ws[r * 8 + col] = descale(res[r], CONST_BITS - PASS1_BITS);
+  }
+  for (let row = 0; row < 8; row++) {
+    let ac = 0;
+    for (let c = 0; c < 8; c++) {
+      vec[c] = ws[row * 8 + c];
+      if (c) ac |= vec[c];
+    }
+    const o = outOffset + row * stride;
+    if (!ac) {
+      const x = descale(vec[0], PASS1_BITS + 3) + 128;
+      const dc = x < 0 ? 0 : x > 255 ? 255 : x;
+      for (let c = 0; c < 8; c++) out[o + c] = dc;
+      continue;
+    }
+    idct1d(vec, res);
+    for (let c = 0; c < 8; c++) {
+      const x = descale(res[c], CONST_BITS + PASS1_BITS + 3) + 128;
+      out[o + c] = x < 0 ? 0 : x > 255 ? 255 : x;
+    }
+  }
+}
+function upsample(plane, stride, cw, ch, hr, vr, width, height) {
+  const out = new Uint8Array(width * height);
+  const at = (x, y) => plane[Math.min(ch - 1, Math.max(0, y)) * stride + x];
+  if (hr === 1 && vr === 1) {
+    for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) out[y * width + x] = plane[y * stride + x];
+    return out;
+  }
+  if (hr === 2 && vr === 1) {
+    for (let y = 0; y < height; y++) {
+      for (let i = 0; i < cw; i++) {
+        const v = at(i, y);
+        const a = i === 0 ? v : 3 * v + at(i - 1, y) + 1 >> 2;
+        const b = i === cw - 1 ? v : 3 * v + at(i + 1, y) + 2 >> 2;
+        if (2 * i < width) out[y * width + 2 * i] = a;
+        if (2 * i + 1 < width) out[y * width + 2 * i + 1] = b;
+      }
+    }
+    return out;
+  }
+  if (hr === 2 && vr === 2) {
+    for (let y = 0; y < height; y++) {
+      const iy = y >> 1;
+      const ny = (y & 1) === 0 ? iy - 1 : iy + 1;
+      const sum = (i) => 3 * at(i, iy) + at(i, ny);
+      for (let i = 0; i < cw; i++) {
+        const t = sum(i);
+        const a = i === 0 ? t * 4 + 8 >> 4 : 3 * t + sum(i - 1) + 8 >> 4;
+        const b = i === cw - 1 ? t * 4 + 7 >> 4 : 3 * t + sum(i + 1) + 7 >> 4;
+        if (2 * i < width) out[y * width + 2 * i] = a;
+        if (2 * i + 1 < width) out[y * width + 2 * i + 1] = b;
+      }
+    }
+    return out;
+  }
+  if (hr === 1 && vr === 2) {
+    for (let y = 0; y < height; y++) {
+      const iy = y >> 1;
+      const upper = (y & 1) === 0;
+      const ny = upper ? iy - 1 : iy + 1;
+      const bias = upper ? 1 : 2;
+      for (let x = 0; x < width; x++) out[y * width + x] = 3 * at(x, iy) + at(x, ny) + bias >> 2;
+    }
+    return out;
+  }
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) out[y * width + x] = plane[Math.min(ch - 1, Math.floor(y / vr)) * stride + Math.min(cw - 1, Math.floor(x / hr))];
+  }
+  return out;
+}
+function decodeJpegTurbo(bytes, colorTransform) {
+  try {
+    return decodeInner(bytes, colorTransform);
+  } catch {
+    return null;
+  }
+}
+function decodeInner(data, colorTransform) {
+  if (data[0] !== 255 || data[1] !== 216) return null;
+  const quant = [];
+  const dcTables = [];
+  const acTables = [];
+  let comps = [];
+  let width = 0;
+  let height = 0;
+  let progressive = false;
+  let restart = 0;
+  let adobe;
+  let maxH = 1;
+  let maxV = 1;
+  let sawScan = false;
+  let pos = 2;
+  const ws = new Int32Array(64);
+  while (pos < data.length) {
+    if (data[pos] !== 255) {
+      pos++;
+      continue;
+    }
+    const marker = data[pos + 1];
+    if (marker === 255) {
+      pos++;
+      continue;
+    }
+    pos += 2;
+    if (marker === 216 || marker === 1 || marker >= 208 && marker <= 215 || marker === 0) continue;
+    if (marker === 217) break;
+    const len = data[pos] * 256 + data[pos + 1];
+    const seg = pos + 2;
+    const end = pos + len;
+    if (marker === 219) {
+      let p = seg;
+      while (p < end) {
+        const pq = data[p] >> 4;
+        const tq = data[p] & 15;
+        p++;
+        const table = new Int32Array(64);
+        for (let i = 0; i < 64; i++) {
+          table[ZIGZAG[i]] = pq ? data[p] * 256 + data[p + 1] : data[p];
+          p += pq ? 2 : 1;
+        }
+        quant[tq] = table;
+      }
+    } else if (marker === 192 || marker === 193 || marker === 194) {
+      if (data[seg] !== 8) return null;
+      progressive = marker === 194;
+      height = data[seg + 1] * 256 + data[seg + 2];
+      width = data[seg + 3] * 256 + data[seg + 4];
+      const n = data[seg + 5];
+      if (n !== 1 && n !== 3 || !width || !height) return null;
+      comps = [];
+      for (let i = 0; i < n; i++) {
+        const h = data[seg + 7 + i * 3] >> 4;
+        const v = data[seg + 7 + i * 3] & 15;
+        if (!h || !v) return null;
+        comps.push({ id: data[seg + 6 + i * 3], h, v, tq: data[seg + 8 + i * 3], blocksW: 0, blocksH: 0, coefs: new Int16Array(0), pred: 0, dc: 0, ac: 0 });
+      }
+      maxH = Math.max(...comps.map((c) => c.h));
+      maxV = Math.max(...comps.map((c) => c.v));
+      const mcusX = Math.ceil(width / (8 * maxH));
+      const mcusY = Math.ceil(height / (8 * maxV));
+      for (const c of comps) {
+        c.blocksW = mcusX * c.h;
+        c.blocksH = mcusY * c.v;
+        c.coefs = new Int16Array(c.blocksW * c.blocksH * 64);
+      }
+    } else if (marker === 195 || marker >= 197 && marker <= 207 && marker !== 200 && marker !== 204) {
+      return null;
+    } else if (marker === 196) {
+      let p = seg;
+      while (p < end) {
+        const tc = data[p] >> 4;
+        const th = data[p] & 15;
+        p++;
+        const counts = data.subarray(p, p + 16);
+        p += 16;
+        let total = 0;
+        for (let i = 0; i < 16; i++) total += counts[i];
+        const table = buildHuffman2(counts, data.subarray(p, p + total));
+        p += total;
+        (tc ? acTables : dcTables)[th] = table;
+      }
+    } else if (marker === 221) {
+      restart = data[seg] * 256 + data[seg + 1];
+    } else if (marker === 238) {
+      if (len >= 14 && String.fromCharCode(...data.subarray(seg, seg + 5)) === "Adobe") adobe = data[seg + 11];
+    } else if (marker === 218) {
+      if (!comps.length) return null;
+      const ns = data[seg];
+      const scanComps = [];
+      for (let i = 0; i < ns; i++) {
+        const c = comps.find((x) => x.id === data[seg + 1 + i * 2]);
+        if (!c) return null;
+        c.dc = data[seg + 2 + i * 2] >> 4;
+        c.ac = data[seg + 2 + i * 2] & 15;
+        scanComps.push(c);
+      }
+      const ss = data[seg + 1 + ns * 2];
+      const se = data[seg + 2 + ns * 2];
+      const ah = data[seg + 3 + ns * 2] >> 4;
+      const al = data[seg + 3 + ns * 2] & 15;
+      pos = decodeScan(data, end, scanComps, comps, width, height, maxH, maxV, progressive, restart, ss, se, ah, al, dcTables, acTables);
+      sawScan = true;
+      continue;
+    }
+    pos = end;
+  }
+  if (!sawScan || !comps.length) return null;
+  const full = comps.map((c) => {
+    if (maxH % c.h || maxV % c.v) throw new Error("Unsupported sampling");
+    const stride = c.blocksW * 8;
+    const plane = new Uint8Array(stride * c.blocksH * 8);
+    const q = quant[c.tq];
+    if (!q) throw new Error("Missing quantisation table");
+    for (let by = 0; by < c.blocksH; by++) {
+      for (let bx = 0; bx < c.blocksW; bx++) idctBlock(c.coefs, (by * c.blocksW + bx) * 64, q, plane, by * 8 * stride + bx * 8, stride, ws);
+    }
+    const cw = Math.ceil(width * c.h / maxH);
+    const ch = Math.ceil(height * c.v / maxV);
+    return upsample(plane, stride, cw, ch, maxH / c.h, maxV / c.v, width, height);
+  });
+  const out = new Uint8Array(width * height * 4);
+  const transform = colorTransform ?? (adobe !== void 0 ? adobe !== 0 : !comps.every((c, i) => c.id === [82, 71, 66][i]));
+  if (comps.length === 1) {
+    for (let i = 0; i < width * height; i++) {
+      out[i * 4] = out[i * 4 + 1] = out[i * 4 + 2] = full[0][i];
+      out[i * 4 + 3] = 255;
+    }
+  } else if (!transform) {
+    for (let i = 0; i < width * height; i++) {
+      out[i * 4] = full[0][i];
+      out[i * 4 + 1] = full[1][i];
+      out[i * 4 + 2] = full[2][i];
+      out[i * 4 + 3] = 255;
+    }
+  } else {
+    const clamp2 = (v) => v < 0 ? 0 : v > 255 ? 255 : v;
+    const fix = (x) => Math.floor(x * 65536 + 0.5);
+    const half = 1 << 15;
+    const crR = fix(1.402);
+    const cbB = fix(1.772);
+    const crG = -fix(0.71414);
+    const cbG = -fix(0.34414);
+    for (let i = 0; i < width * height; i++) {
+      const y = full[0][i];
+      const cb = full[1][i] - 128;
+      const cr = full[2][i] - 128;
+      out[i * 4] = clamp2(y + (crR * cr + half >> 16));
+      out[i * 4 + 1] = clamp2(y + (cbG * cb + half + crG * cr >> 16));
+      out[i * 4 + 2] = clamp2(y + (cbB * cb + half >> 16));
+      out[i * 4 + 3] = 255;
+    }
+  }
+  return { width, height, data: out };
+}
+function decodeScan(data, start, scan, all, width, height, maxH, maxV, progressive, restart, ss, se, ah, al, dcTables, acTables) {
+  const br = new BitReader(data, start);
+  let eobrun = 0;
+  const single = scan.length === 1;
+  const decodeBlock = (c, off) => {
+    const coefs = c.coefs;
+    if (!progressive) {
+      const t = br.decode(dcTables[c.dc]);
+      c.pred += t === 0 ? 0 : br.receiveExtend(t);
+      coefs[off] = c.pred;
+      let k2 = 1;
+      while (k2 < 64) {
+        const rs = br.decode(acTables[c.ac]);
+        const s = rs & 15;
+        const r = rs >> 4;
+        if (s === 0) {
+          if (r < 15) break;
+          k2 += 16;
+          continue;
+        }
+        k2 += r;
+        if (k2 > 63) break;
+        coefs[off + ZIGZAG[k2]] = br.receiveExtend(s);
+        k2++;
+      }
+      return;
+    }
+    if (ss === 0) {
+      if (ah === 0) {
+        const t = br.decode(dcTables[c.dc]);
+        c.pred += t === 0 ? 0 : br.receiveExtend(t);
+        coefs[off] = c.pred * (1 << al);
+      } else if (br.bit()) {
+        coefs[off] |= 1 << al;
+      }
+      return;
+    }
+    if (ah === 0) {
+      if (eobrun > 0) {
+        eobrun--;
+        return;
+      }
+      let k2 = ss;
+      while (k2 <= se) {
+        const rs = br.decode(acTables[c.ac]);
+        const s = rs & 15;
+        const r = rs >> 4;
+        if (s === 0) {
+          if (r < 15) {
+            eobrun = br.receive(r) + (1 << r) - 1;
+            break;
+          }
+          k2 += 16;
+          continue;
+        }
+        k2 += r;
+        if (k2 > 63) break;
+        coefs[off + ZIGZAG[k2]] = br.receiveExtend(s) * (1 << al);
+        k2++;
+      }
+      return;
+    }
+    const p1 = 1 << al;
+    const m1 = -1 << al;
+    let k = ss;
+    if (eobrun <= 0) {
+      for (; k <= se; k++) {
+        const rs = br.decode(acTables[c.ac]);
+        const s = rs & 15;
+        let r = rs >> 4;
+        let value = 0;
+        if (s === 0) {
+          if (r < 15) {
+            eobrun = (1 << r) + br.receive(r);
+            break;
+          }
+        } else {
+          value = br.bit() ? p1 : m1;
+        }
+        for (; k <= se; k++) {
+          const idx = off + ZIGZAG[k];
+          if (coefs[idx] !== 0) {
+            if (br.bit() && (coefs[idx] & p1) === 0) coefs[idx] += coefs[idx] >= 0 ? p1 : m1;
+          } else {
+            if (r === 0) {
+              if (value) coefs[idx] = value;
+              break;
+            }
+            r--;
+          }
+        }
+      }
+    }
+    if (eobrun > 0) {
+      for (; k <= se; k++) {
+        const idx = off + ZIGZAG[k];
+        if (coefs[idx] !== 0 && br.bit() && (coefs[idx] & p1) === 0) coefs[idx] += coefs[idx] >= 0 ? p1 : m1;
+      }
+      eobrun--;
+    }
+  };
+  let total;
+  let mcusX;
+  if (single) {
+    const c = scan[0];
+    mcusX = Math.ceil(Math.ceil(width * c.h / maxH) / 8);
+    total = mcusX * Math.ceil(Math.ceil(height * c.v / maxV) / 8);
+  } else {
+    mcusX = Math.ceil(width / (8 * maxH));
+    total = mcusX * Math.ceil(height / (8 * maxV));
+  }
+  const nextMarker = (from) => {
+    let p = from;
+    while (p + 1 < data.length && !(data[p] === 255 && data[p + 1] !== 0 && data[p + 1] !== 255)) p++;
+    return p;
+  };
+  let n = 0;
+  while (n < total) {
+    for (const c of all) c.pred = 0;
+    eobrun = 0;
+    br.reset();
+    const limit = restart ? Math.min(total, n + restart) : total;
+    for (; n < limit; n++) {
+      if (single) {
+        const c = scan[0];
+        decodeBlock(c, (Math.floor(n / mcusX) * c.blocksW + n % mcusX) * 64);
+      } else {
+        const mx = n % mcusX;
+        const my = Math.floor(n / mcusX);
+        for (const c of scan) {
+          for (let v = 0; v < c.v; v++) for (let h = 0; h < c.h; h++) decodeBlock(c, ((my * c.v + v) * c.blocksW + mx * c.h + h) * 64);
+        }
+      }
+    }
+    const p = nextMarker(br.pos);
+    if (n >= total) return p;
+    if (data[p + 1] >= 208 && data[p + 1] <= 215) br.pos = p + 2;
+    else return p;
+  }
+  return nextMarker(br.pos);
+}
+
+// src/jpeg-decoder.ts
+function decodeJpegPixels(bytes, colorTransform) {
+  return decodeJpegTurbo(bytes, colorTransform) ?? decodeJpegPixelsLegacy(bytes, colorTransform);
+}
+
 // src/image-codec-fallback.ts
 var import_gifuct_js = __toESM(require_lib2());
 var UTIF = __toESM(require_UTIF());
@@ -21930,14 +22524,14 @@ function pixelSnapPlusClip(rCtx, incoming) {
 function applyPlusClipRegion(rCtx, rawIncoming, combineMode, opName) {
   const incoming = pixelSnapPlusClip(rCtx, rawIncoming);
   const op = PLUS_COMBINE_OPS[combineMode];
-  const res = combineClipRegions(
+  const res2 = combineClipRegions(
     rCtx.clipRegion ?? null,
     incoming,
     op ?? "intersect",
     plusClipDomain(rCtx)
   );
-  if (!res.exact) ;
-  rCtx.clipRegion = res.region;
+  if (!res2.exact) ;
+  rCtx.clipRegion = res2.region;
   reapplyPlusClip(rCtx);
 }
 function applyPlusClipShape(rCtx, shape, combineMode, opName) {
@@ -23345,27 +23939,27 @@ var HintedSize = class _HintedSize {
   /** Loads and grid-fits glyph `g`. Never throws. */
   hintGlyph(g) {
     const { advance } = this.font.hMetrics(g);
-    const res = this.loadRecursive(g, 0);
-    const n = res.zone.n - 4;
-    const pp1x = res.zone.curX[n];
-    const pp2x = res.zone.curX[n + 1];
+    const res2 = this.loadRecursive(g, 0);
+    const n = res2.zone.n - 4;
+    const pp1x = res2.zone.curX[n];
+    const pp2x = res2.zone.curX[n + 1];
     const xs = new Float64Array(n);
     const ys = new Float64Array(n);
     const onCurve = new Uint8Array(n);
     for (let i = 0; i < n; i++) {
-      xs[i] = res.zone.curX[i] - pp1x;
-      ys[i] = res.zone.curY[i];
-      onCurve[i] = res.zone.tags[i] & ON_CURVE;
+      xs[i] = res2.zone.curX[i] - pp1x;
+      ys[i] = res2.zone.curY[i];
+      onCurve[i] = res2.zone.tags[i] & ON_CURVE;
     }
     return {
       xs,
       ys,
       onCurve,
-      endPts: res.zone.endPts,
+      endPts: res2.zone.endPts,
       advance: pp2x - pp1x,
       linearAdvance: mulFix(advance, this.xScale),
-      scanControl: res.scanControl,
-      scanType: res.scanType
+      scanControl: res2.scanControl,
+      scanType: res2.scanType
     };
   }
   /**
@@ -32760,15 +33354,15 @@ function handleEmfGdiDrawTextRecord(rCtx, recType, offset, dataOff, recSize) {
 
 // src/emf-gdi-clip-records.ts
 function gdiCombineClip(rCtx, shape, op) {
-  const res = combineClip(op === "replace" ? null : rCtx.clipRegion ?? null, shape, op, {
+  const res2 = combineClip(op === "replace" ? null : rCtx.clipRegion ?? null, shape, op, {
     x: 0,
     y: 0,
     w: rCtx.canvasW,
     h: rCtx.canvasH
   });
-  if (!res.exact) ;
-  rCtx.clipRegion = res.region;
-  reapplyClipRegion(rCtx, res.region);
+  if (!res2.exact) ;
+  rCtx.clipRegion = res2.region;
+  reapplyClipRegion(rCtx, res2.region);
 }
 function readClipRectShape(rCtx, dataOff) {
   const { view } = rCtx;