@tscircuit/cli 0.1.1142 → 0.1.1144

package/dist/cli/main.js

@@ -124180,7 +124180,7 @@ var import_perfect_cli = __toESM2(require_dist2(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.1141";
+var version = "0.1.1143";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -124196,6 +124196,7 @@ var package_default = {
     "@tscircuit/circuit-json-routing-analysis": "^0.0.1",
     "@tscircuit/fake-snippets": "^0.0.182",
     "@tscircuit/file-server": "^0.0.32",
+    "@tscircuit/image-utils": "^0.0.3",
     "@tscircuit/math-utils": "0.0.36",
     "@tscircuit/props": "^0.0.496",
     "@tscircuit/runframe": "^0.0.1748",
@@ -124234,7 +124235,6 @@ var package_default = {
     kicadts: "^0.0.24",
     kleur: "^4.1.5",
     ky: "^1.7.4",
-    "looks-same": "^9.0.1",
     "make-vfs": "^1.0.15",
     md5: "^2.3.0",
     "perfect-cli": "^1.0.21",
@@ -124243,7 +124243,6 @@ var package_default = {
     prompts: "^2.4.2",
     redaxios: "^0.5.1",
     semver: "^7.6.3",
-    sharp: "0.32.6",
     tempy: "^3.1.0",
     tscircuit: "0.0.1519-libonly",
     tsx: "^4.7.1",
@@ -375417,17 +375416,2708 @@ import {
 } from "circuit-to-svg";
 import { renderGLTFToPNGBufferFromGLBBuffer as renderGLTFToPNGBufferFromGLBBuffer2 } from "poppygl";
 
+// node_modules/@tscircuit/image-utils/dist/looks-same.js
+import { readFile, writeFile } from "fs/promises";
+
+// node_modules/color-diff/lib/convert.js
+function rgbaToLab(c4, bc3) {
+  bc3 = normalize8(bc3 || { R: 255, G: 255, B: 255 });
+  c4 = normalize8(c4);
+  let newC = c4;
+  if (c4.A !== undefined) {
+    newC = {
+      R: bc3.R + (c4.R - bc3.R) * c4.A,
+      G: bc3.G + (c4.G - bc3.G) * c4.A,
+      B: bc3.B + (c4.B - bc3.B) * c4.A
+    };
+  }
+  return xyzToLab(rgbToXyz(newC));
+}
+function rgbToXyz(c4) {
+  let R5 = c4.R / 255;
+  let G4 = c4.G / 255;
+  let B4 = c4.B / 255;
+  if (R5 > 0.04045)
+    R5 = Math.pow((R5 + 0.055) / 1.055, 2.4);
+  else
+    R5 = R5 / 12.92;
+  if (G4 > 0.04045)
+    G4 = Math.pow((G4 + 0.055) / 1.055, 2.4);
+  else
+    G4 = G4 / 12.92;
+  if (B4 > 0.04045)
+    B4 = Math.pow((B4 + 0.055) / 1.055, 2.4);
+  else
+    B4 = B4 / 12.92;
+  R5 *= 100;
+  G4 *= 100;
+  B4 *= 100;
+  const X4 = R5 * 0.4124 + G4 * 0.3576 + B4 * 0.1805;
+  const Y4 = R5 * 0.2126 + G4 * 0.7152 + B4 * 0.0722;
+  const Z7 = R5 * 0.0193 + G4 * 0.1192 + B4 * 0.9505;
+  return { X: X4, Y: Y4, Z: Z7 };
+}
+function xyzToLab(c4) {
+  const refY = 100;
+  const refZ = 108.883;
+  const refX = 95.047;
+  let Y4 = c4.Y / refY;
+  let Z7 = c4.Z / refZ;
+  let X4 = c4.X / refX;
+  if (X4 > 0.008856)
+    X4 = Math.pow(X4, 1 / 3);
+  else
+    X4 = 7.787 * X4 + 16 / 116;
+  if (Y4 > 0.008856)
+    Y4 = Math.pow(Y4, 1 / 3);
+  else
+    Y4 = 7.787 * Y4 + 16 / 116;
+  if (Z7 > 0.008856)
+    Z7 = Math.pow(Z7, 1 / 3);
+  else
+    Z7 = 7.787 * Z7 + 16 / 116;
+  const L5 = 116 * Y4 - 16;
+  const a3 = 500 * (X4 - Y4);
+  const b = 200 * (Y4 - Z7);
+  return { L: L5, a: a3, b };
+}
+function normalize8(c4) {
+  let r4, g8, b, a3;
+  if ("R" in c4) {
+    r4 = c4.R;
+    g8 = c4.G;
+    b = c4.B;
+    a3 = c4.A;
+  } else {
+    r4 = c4.r;
+    g8 = c4.g;
+    b = c4.b;
+    a3 = c4.a;
+  }
+  const normalizedC = { R: r4, G: g8, B: b };
+  if (a3 !== undefined)
+    normalizedC.A = a3;
+  return normalizedC;
+}
+
+// node_modules/color-diff/lib/diff.js
+function ciede2000(c13, c23, bc3) {
+  if ("R" in c13 || "r" in c13) {
+    c13 = rgbaToLab(c13, bc3);
+  }
+  if ("R" in c23 || "r" in c23) {
+    c23 = rgbaToLab(c23, bc3);
+  }
+  const L13 = c13.L;
+  const a13 = c13.a;
+  const b13 = c13.b;
+  const L24 = c23.L;
+  const a22 = c23.a;
+  const b23 = c23.b;
+  const kL = 1;
+  const kC = 1;
+  const kH = 1;
+  const C13 = Math.sqrt(Math.pow(a13, 2) + Math.pow(b13, 2));
+  const C23 = Math.sqrt(Math.pow(a22, 2) + Math.pow(b23, 2));
+  const aC1C2 = (C13 + C23) / 2;
+  const G4 = 0.5 * (1 - Math.sqrt(Math.pow(aC1C2, 7) / (Math.pow(aC1C2, 7) + Math.pow(25, 7))));
+  const a1p = (1 + G4) * a13;
+  const a2p = (1 + G4) * a22;
+  const C1p = Math.sqrt(Math.pow(a1p, 2) + Math.pow(b13, 2));
+  const C2p = Math.sqrt(Math.pow(a2p, 2) + Math.pow(b23, 2));
+  const h1p = hpF(b13, a1p);
+  const h2p = hpF(b23, a2p);
+  const dLp = L24 - L13;
+  const dCp = C2p - C1p;
+  const dhp = dhpF(C13, C23, h1p, h2p);
+  const dHp = 2 * Math.sqrt(C1p * C2p) * Math.sin(radians(dhp) / 2);
+  const aL = (L13 + L24) / 2;
+  const aCp = (C1p + C2p) / 2;
+  const aHp = aHpF(C13, C23, h1p, h2p);
+  const T4 = 1 - 0.17 * Math.cos(radians(aHp - 30)) + 0.24 * Math.cos(radians(2 * aHp)) + 0.32 * Math.cos(radians(3 * aHp + 6)) - 0.2 * Math.cos(radians(4 * aHp - 63));
+  const dRo = 30 * Math.exp(-Math.pow((aHp - 275) / 25, 2));
+  const RC = Math.sqrt(Math.pow(aCp, 7) / (Math.pow(aCp, 7) + Math.pow(25, 7)));
+  const SL = 1 + 0.015 * Math.pow(aL - 50, 2) / Math.sqrt(20 + Math.pow(aL - 50, 2));
+  const SC = 1 + 0.045 * aCp;
+  const SH = 1 + 0.015 * aCp * T4;
+  const RT = -2 * RC * Math.sin(radians(2 * dRo));
+  const dE = Math.sqrt(Math.pow(dLp / (SL * kL), 2) + Math.pow(dCp / (SC * kC), 2) + Math.pow(dHp / (SH * kH), 2) + RT * (dCp / (SC * kC)) * (dHp / (SH * kH)));
+  return dE;
+}
+function degrees(n4) {
+  return n4 * (180 / Math.PI);
+}
+function radians(n4) {
+  return n4 * (Math.PI / 180);
+}
+function hpF(x4, y5) {
+  if (x4 === 0 && y5 === 0)
+    return 0;
+  else {
+    const tmphp = degrees(Math.atan2(x4, y5));
+    if (tmphp >= 0)
+      return tmphp;
+    else
+      return tmphp + 360;
+  }
+}
+function dhpF(C13, C23, h1p, h2p) {
+  if (C13 * C23 === 0)
+    return 0;
+  else if (Math.abs(h2p - h1p) <= 180)
+    return h2p - h1p;
+  else if (h2p - h1p > 180)
+    return h2p - h1p - 360;
+  else if (h2p - h1p < -180)
+    return h2p - h1p + 360;
+  else
+    throw new Error;
+}
+function aHpF(C13, C23, h1p, h2p) {
+  if (C13 * C23 === 0)
+    return h1p + h2p;
+  else if (Math.abs(h1p - h2p) <= 180)
+    return (h1p + h2p) / 2;
+  else if (Math.abs(h1p - h2p) > 180 && h1p + h2p < 360)
+    return (h1p + h2p + 360) / 2;
+  else if (Math.abs(h1p - h2p) > 180 && h1p + h2p >= 360)
+    return (h1p + h2p - 360) / 2;
+  else
+    throw new Error;
+}
+
+// node_modules/color-diff/index.js
+function rgb_to_lab(c4) {
+  return rgbaToLab(c4);
+}
+
+// node_modules/fflate/esm/index.mjs
+import { createRequire as createRequire4 } from "module";
+var require3 = createRequire4("/");
+var Worker2;
+try {
+  Worker2 = require3("worker_threads").Worker;
+} catch (e5) {}
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0, 0]);
+var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 0, 0]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+  var b = new u16(31);
+  for (var i3 = 0;i3 < 31; ++i3) {
+    b[i3] = start += 1 << eb[i3 - 1];
+  }
+  var r4 = new i32(b[30]);
+  for (var i3 = 1;i3 < 30; ++i3) {
+    for (var j5 = b[i3];j5 < b[i3 + 1]; ++j5) {
+      r4[j5] = j5 - b[i3] << 5 | i3;
+    }
+  }
+  return { b, r: r4 };
+};
+var _a5 = freb(fleb, 2);
+var fl5 = _a5.b;
+var revfl = _a5.r;
+fl5[28] = 258, revfl[258] = 28;
+var _b3 = freb(fdeb, 0);
+var fd5 = _b3.b;
+var revfd = _b3.r;
+var rev = new u16(32768);
+for (i3 = 0;i3 < 32768; ++i3) {
+  x5 = (i3 & 43690) >> 1 | (i3 & 21845) << 1;
+  x5 = (x5 & 52428) >> 2 | (x5 & 13107) << 2;
+  x5 = (x5 & 61680) >> 4 | (x5 & 3855) << 4;
+  rev[i3] = ((x5 & 65280) >> 8 | (x5 & 255) << 8) >> 1;
+}
+var x5;
+var i3;
+var hMap = function(cd5, mb3, r4) {
+  var s3 = cd5.length;
+  var i4 = 0;
+  var l4 = new u16(mb3);
+  for (;i4 < s3; ++i4) {
+    if (cd5[i4])
+      ++l4[cd5[i4] - 1];
+  }
+  var le5 = new u16(mb3);
+  for (i4 = 1;i4 < mb3; ++i4) {
+    le5[i4] = le5[i4 - 1] + l4[i4 - 1] << 1;
+  }
+  var co5;
+  if (r4) {
+    co5 = new u16(1 << mb3);
+    var rvb = 15 - mb3;
+    for (i4 = 0;i4 < s3; ++i4) {
+      if (cd5[i4]) {
+        var sv = i4 << 4 | cd5[i4];
+        var r_1 = mb3 - cd5[i4];
+        var v4 = le5[cd5[i4] - 1]++ << r_1;
+        for (var m4 = v4 | (1 << r_1) - 1;v4 <= m4; ++v4) {
+          co5[rev[v4] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co5 = new u16(s3);
+    for (i4 = 0;i4 < s3; ++i4) {
+      if (cd5[i4]) {
+        co5[i4] = rev[le5[cd5[i4] - 1]++] >> 15 - cd5[i4];
+      }
+    }
+  }
+  return co5;
+};
+var flt = new u8(288);
+for (i3 = 0;i3 < 144; ++i3)
+  flt[i3] = 8;
+var i3;
+for (i3 = 144;i3 < 256; ++i3)
+  flt[i3] = 9;
+var i3;
+for (i3 = 256;i3 < 280; ++i3)
+  flt[i3] = 7;
+var i3;
+for (i3 = 280;i3 < 288; ++i3)
+  flt[i3] = 8;
+var i3;
+var fdt = new u8(32);
+for (i3 = 0;i3 < 32; ++i3)
+  fdt[i3] = 5;
+var i3;
+var flm = /* @__PURE__ */ hMap(flt, 9, 0);
+var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+var fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
+var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = function(a3) {
+  var m4 = a3[0];
+  for (var i4 = 1;i4 < a3.length; ++i4) {
+    if (a3[i4] > m4)
+      m4 = a3[i4];
+  }
+  return m4;
+};
+var bits = function(d4, p4, m4) {
+  var o4 = p4 / 8 | 0;
+  return (d4[o4] | d4[o4 + 1] << 8) >> (p4 & 7) & m4;
+};
+var bits16 = function(d4, p4) {
+  var o4 = p4 / 8 | 0;
+  return (d4[o4] | d4[o4 + 1] << 8 | d4[o4 + 2] << 16) >> (p4 & 7);
+};
+var shft = function(p4) {
+  return (p4 + 7) / 8 | 0;
+};
+var slc = function(v4, s3, e5) {
+  if (s3 == null || s3 < 0)
+    s3 = 0;
+  if (e5 == null || e5 > v4.length)
+    e5 = v4.length;
+  return new u8(v4.subarray(s3, e5));
+};
+var ec3 = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+];
+var err = function(ind, msg, nt5) {
+  var e5 = new Error(msg || ec3[ind]);
+  e5.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e5, err);
+  if (!nt5)
+    throw e5;
+  return e5;
+};
+var inflt = function(dat, st5, buf, dict) {
+  var sl5 = dat.length, dl5 = dict ? dict.length : 0;
+  if (!sl5 || st5.f && !st5.l)
+    return buf || new u8(0);
+  var noBuf = !buf;
+  var resize = noBuf || st5.i != 2;
+  var noSt = st5.i;
+  if (noBuf)
+    buf = new u8(sl5 * 3);
+  var cbuf = function(l5) {
+    var bl5 = buf.length;
+    if (l5 > bl5) {
+      var nbuf = new u8(Math.max(bl5 * 2, l5));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  };
+  var final = st5.f || 0, pos = st5.p || 0, bt4 = st5.b || 0, lm3 = st5.l, dm3 = st5.d, lbt = st5.m, dbt = st5.n;
+  var tbts = sl5 * 8;
+  do {
+    if (!lm3) {
+      final = bits(dat, pos, 1);
+      var type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        var s3 = shft(pos) + 4, l4 = dat[s3 - 4] | dat[s3 - 3] << 8, t19 = s3 + l4;
+        if (t19 > sl5) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt4 + l4);
+        buf.set(dat.subarray(s3, t19), bt4);
+        st5.b = bt4 += l4, st5.p = pos = t19 * 8, st5.f = final;
+        continue;
+      } else if (type == 1)
+        lm3 = flrm, dm3 = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        var tl5 = hLit + bits(dat, pos + 5, 31) + 1;
+        pos += 14;
+        var ldt = new u8(tl5);
+        var clt = new u8(19);
+        for (var i4 = 0;i4 < hcLen; ++i4) {
+          clt[clim[i4]] = bits(dat, pos + i4 * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i4 = 0;i4 < tl5; ) {
+          var r4 = clm[bits(dat, pos, clbmsk)];
+          pos += r4 & 15;
+          var s3 = r4 >> 4;
+          if (s3 < 16) {
+            ldt[i4++] = s3;
+          } else {
+            var c4 = 0, n4 = 0;
+            if (s3 == 16)
+              n4 = 3 + bits(dat, pos, 3), pos += 2, c4 = ldt[i4 - 1];
+            else if (s3 == 17)
+              n4 = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s3 == 18)
+              n4 = 11 + bits(dat, pos, 127), pos += 7;
+            while (n4--)
+              ldt[i4++] = c4;
+          }
+        }
+        var lt5 = ldt.subarray(0, hLit), dt5 = ldt.subarray(hLit);
+        lbt = max(lt5);
+        dbt = max(dt5);
+        lm3 = hMap(lt5, lbt, 1);
+        dm3 = hMap(dt5, dbt, 1);
+      } else
+        err(1);
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+    }
+    if (resize)
+      cbuf(bt4 + 131072);
+    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+    var lpos = pos;
+    for (;; lpos = pos) {
+      var c4 = lm3[bits16(dat, pos) & lms], sym = c4 >> 4;
+      pos += c4 & 15;
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+      if (!c4)
+        err(2);
+      if (sym < 256)
+        buf[bt4++] = sym;
+      else if (sym == 256) {
+        lpos = pos, lm3 = null;
+        break;
+      } else {
+        var add = sym - 254;
+        if (sym > 264) {
+          var i4 = sym - 257, b = fleb[i4];
+          add = bits(dat, pos, (1 << b) - 1) + fl5[i4];
+          pos += b;
+        }
+        var d4 = dm3[bits16(dat, pos) & dms], dsym = d4 >> 4;
+        if (!d4)
+          err(3);
+        pos += d4 & 15;
+        var dt5 = fd5[dsym];
+        if (dsym > 3) {
+          var b = fdeb[dsym];
+          dt5 += bits16(dat, pos) & (1 << b) - 1, pos += b;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt4 + 131072);
+        var end = bt4 + add;
+        if (bt4 < dt5) {
+          var shift = dl5 - dt5, dend = Math.min(dt5, end);
+          if (shift + bt4 < 0)
+            err(3);
+          for (;bt4 < dend; ++bt4)
+            buf[bt4] = dict[shift + bt4];
+        }
+        for (;bt4 < end; ++bt4)
+          buf[bt4] = buf[bt4 - dt5];
+      }
+    }
+    st5.l = lm3, st5.p = lpos, st5.b = bt4, st5.f = final;
+    if (lm3)
+      final = 1, st5.m = lbt, st5.d = dm3, st5.n = dbt;
+  } while (!final);
+  return bt4 != buf.length && noBuf ? slc(buf, 0, bt4) : buf.subarray(0, bt4);
+};
+var wbits = function(d4, p4, v4) {
+  v4 <<= p4 & 7;
+  var o4 = p4 / 8 | 0;
+  d4[o4] |= v4;
+  d4[o4 + 1] |= v4 >> 8;
+};
+var wbits16 = function(d4, p4, v4) {
+  v4 <<= p4 & 7;
+  var o4 = p4 / 8 | 0;
+  d4[o4] |= v4;
+  d4[o4 + 1] |= v4 >> 8;
+  d4[o4 + 2] |= v4 >> 16;
+};
+var hTree = function(d4, mb3) {
+  var t19 = [];
+  for (var i4 = 0;i4 < d4.length; ++i4) {
+    if (d4[i4])
+      t19.push({ s: i4, f: d4[i4] });
+  }
+  var s3 = t19.length;
+  var t25 = t19.slice();
+  if (!s3)
+    return { t: et5, l: 0 };
+  if (s3 == 1) {
+    var v4 = new u8(t19[0].s + 1);
+    v4[t19[0].s] = 1;
+    return { t: v4, l: 1 };
+  }
+  t19.sort(function(a3, b) {
+    return a3.f - b.f;
+  });
+  t19.push({ s: -1, f: 25001 });
+  var l4 = t19[0], r4 = t19[1], i03 = 0, i13 = 1, i22 = 2;
+  t19[0] = { s: -1, f: l4.f + r4.f, l: l4, r: r4 };
+  while (i13 != s3 - 1) {
+    l4 = t19[t19[i03].f < t19[i22].f ? i03++ : i22++];
+    r4 = t19[i03 != i13 && t19[i03].f < t19[i22].f ? i03++ : i22++];
+    t19[i13++] = { s: -1, f: l4.f + r4.f, l: l4, r: r4 };
+  }
+  var maxSym = t25[0].s;
+  for (var i4 = 1;i4 < s3; ++i4) {
+    if (t25[i4].s > maxSym)
+      maxSym = t25[i4].s;
+  }
+  var tr5 = new u16(maxSym + 1);
+  var mbt = ln5(t19[i13 - 1], tr5, 0);
+  if (mbt > mb3) {
+    var i4 = 0, dt5 = 0;
+    var lft = mbt - mb3, cst = 1 << lft;
+    t25.sort(function(a3, b) {
+      return tr5[b.s] - tr5[a3.s] || a3.f - b.f;
+    });
+    for (;i4 < s3; ++i4) {
+      var i2_1 = t25[i4].s;
+      if (tr5[i2_1] > mb3) {
+        dt5 += cst - (1 << mbt - tr5[i2_1]);
+        tr5[i2_1] = mb3;
+      } else
+        break;
+    }
+    dt5 >>= lft;
+    while (dt5 > 0) {
+      var i2_2 = t25[i4].s;
+      if (tr5[i2_2] < mb3)
+        dt5 -= 1 << mb3 - tr5[i2_2]++ - 1;
+      else
+        ++i4;
+    }
+    for (;i4 >= 0 && dt5; --i4) {
+      var i2_3 = t25[i4].s;
+      if (tr5[i2_3] == mb3) {
+        --tr5[i2_3];
+        ++dt5;
+      }
+    }
+    mbt = mb3;
+  }
+  return { t: new u8(tr5), l: mbt };
+};
+var ln5 = function(n4, l4, d4) {
+  return n4.s == -1 ? Math.max(ln5(n4.l, l4, d4 + 1), ln5(n4.r, l4, d4 + 1)) : l4[n4.s] = d4;
+};
+var lc5 = function(c4) {
+  var s3 = c4.length;
+  while (s3 && !c4[--s3])
+    ;
+  var cl5 = new u16(++s3);
+  var cli = 0, cln = c4[0], cls = 1;
+  var w4 = function(v4) {
+    cl5[cli++] = v4;
+  };
+  for (var i4 = 1;i4 <= s3; ++i4) {
+    if (c4[i4] == cln && i4 != s3)
+      ++cls;
+    else {
+      if (!cln && cls > 2) {
+        for (;cls > 138; cls -= 138)
+          w4(32754);
+        if (cls > 2) {
+          w4(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
+          cls = 0;
+        }
+      } else if (cls > 3) {
+        w4(cln), --cls;
+        for (;cls > 6; cls -= 6)
+          w4(8304);
+        if (cls > 2)
+          w4(cls - 3 << 5 | 8208), cls = 0;
+      }
+      while (cls--)
+        w4(cln);
+      cls = 1;
+      cln = c4[i4];
+    }
+  }
+  return { c: cl5.subarray(0, cli), n: s3 };
+};
+var clen = function(cf4, cl5) {
+  var l4 = 0;
+  for (var i4 = 0;i4 < cl5.length; ++i4)
+    l4 += cf4[i4] * cl5[i4];
+  return l4;
+};
+var wfblk = function(out, pos, dat) {
+  var s3 = dat.length;
+  var o4 = shft(pos + 2);
+  out[o4] = s3 & 255;
+  out[o4 + 1] = s3 >> 8;
+  out[o4 + 2] = out[o4] ^ 255;
+  out[o4 + 3] = out[o4 + 1] ^ 255;
+  for (var i4 = 0;i4 < s3; ++i4)
+    out[o4 + i4 + 4] = dat[i4];
+  return (o4 + 4 + s3) * 8;
+};
+var wblk = function(dat, out, final, syms, lf4, df4, eb, li5, bs5, bl5, p4) {
+  wbits(out, p4++, final);
+  ++lf4[256];
+  var _a6 = hTree(lf4, 15), dlt = _a6.t, mlb = _a6.l;
+  var _b4 = hTree(df4, 15), ddt = _b4.t, mdb = _b4.l;
+  var _c5 = lc5(dlt), lclt = _c5.c, nlc = _c5.n;
+  var _d5 = lc5(ddt), lcdt = _d5.c, ndc = _d5.n;
+  var lcfreq = new u16(19);
+  for (var i4 = 0;i4 < lclt.length; ++i4)
+    ++lcfreq[lclt[i4] & 31];
+  for (var i4 = 0;i4 < lcdt.length; ++i4)
+    ++lcfreq[lcdt[i4] & 31];
+  var _e5 = hTree(lcfreq, 7), lct = _e5.t, mlcb = _e5.l;
+  var nlcc = 19;
+  for (;nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
+    ;
+  var flen = bl5 + 5 << 3;
+  var ftlen = clen(lf4, flt) + clen(df4, fdt) + eb;
+  var dtlen = clen(lf4, dlt) + clen(df4, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
+  if (bs5 >= 0 && flen <= ftlen && flen <= dtlen)
+    return wfblk(out, p4, dat.subarray(bs5, bs5 + bl5));
+  var lm3, ll5, dm3, dl5;
+  wbits(out, p4, 1 + (dtlen < ftlen)), p4 += 2;
+  if (dtlen < ftlen) {
+    lm3 = hMap(dlt, mlb, 0), ll5 = dlt, dm3 = hMap(ddt, mdb, 0), dl5 = ddt;
+    var llm = hMap(lct, mlcb, 0);
+    wbits(out, p4, nlc - 257);
+    wbits(out, p4 + 5, ndc - 1);
+    wbits(out, p4 + 10, nlcc - 4);
+    p4 += 14;
+    for (var i4 = 0;i4 < nlcc; ++i4)
+      wbits(out, p4 + 3 * i4, lct[clim[i4]]);
+    p4 += 3 * nlcc;
+    var lcts = [lclt, lcdt];
+    for (var it5 = 0;it5 < 2; ++it5) {
+      var clct = lcts[it5];
+      for (var i4 = 0;i4 < clct.length; ++i4) {
+        var len = clct[i4] & 31;
+        wbits(out, p4, llm[len]), p4 += lct[len];
+        if (len > 15)
+          wbits(out, p4, clct[i4] >> 5 & 127), p4 += clct[i4] >> 12;
+      }
+    }
+  } else {
+    lm3 = flm, ll5 = flt, dm3 = fdm, dl5 = fdt;
+  }
+  for (var i4 = 0;i4 < li5; ++i4) {
+    var sym = syms[i4];
+    if (sym > 255) {
+      var len = sym >> 18 & 31;
+      wbits16(out, p4, lm3[len + 257]), p4 += ll5[len + 257];
+      if (len > 7)
+        wbits(out, p4, sym >> 23 & 31), p4 += fleb[len];
+      var dst = sym & 31;
+      wbits16(out, p4, dm3[dst]), p4 += dl5[dst];
+      if (dst > 3)
+        wbits16(out, p4, sym >> 5 & 8191), p4 += fdeb[dst];
+    } else {
+      wbits16(out, p4, lm3[sym]), p4 += ll5[sym];
+    }
+  }
+  wbits16(out, p4, lm3[256]);
+  return p4 + ll5[256];
+};
+var deo = /* @__PURE__ */ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
+var et5 = /* @__PURE__ */ new u8(0);
+var dflt = function(dat, lvl, plvl, pre, post, st5) {
+  var s3 = st5.z || dat.length;
+  var o4 = new u8(pre + s3 + 5 * (1 + Math.ceil(s3 / 7000)) + post);
+  var w4 = o4.subarray(pre, o4.length - post);
+  var lst = st5.l;
+  var pos = (st5.r || 0) & 7;
+  if (lvl) {
+    if (pos)
+      w4[0] = st5.r >> 3;
+    var opt = deo[lvl - 1];
+    var n4 = opt >> 13, c4 = opt & 8191;
+    var msk_1 = (1 << plvl) - 1;
+    var prev = st5.p || new u16(32768), head = st5.h || new u16(msk_1 + 1);
+    var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
+    var hsh = function(i5) {
+      return (dat[i5] ^ dat[i5 + 1] << bs1_1 ^ dat[i5 + 2] << bs2_1) & msk_1;
+    };
+    var syms = new i32(25000);
+    var lf4 = new u16(288), df4 = new u16(32);
+    var lc_1 = 0, eb = 0, i4 = st5.i || 0, li5 = 0, wi5 = st5.w || 0, bs5 = 0;
+    for (;i4 + 2 < s3; ++i4) {
+      var hv = hsh(i4);
+      var imod = i4 & 32767, pimod = head[hv];
+      prev[imod] = pimod;
+      head[hv] = imod;
+      if (wi5 <= i4) {
+        var rem = s3 - i4;
+        if ((lc_1 > 7000 || li5 > 24576) && (rem > 423 || !lst)) {
+          pos = wblk(dat, w4, 0, syms, lf4, df4, eb, li5, bs5, i4 - bs5, pos);
+          li5 = lc_1 = eb = 0, bs5 = i4;
+          for (var j5 = 0;j5 < 286; ++j5)
+            lf4[j5] = 0;
+          for (var j5 = 0;j5 < 30; ++j5)
+            df4[j5] = 0;
+        }
+        var l4 = 2, d4 = 0, ch_1 = c4, dif = imod - pimod & 32767;
+        if (rem > 2 && hv == hsh(i4 - dif)) {
+          var maxn = Math.min(n4, rem) - 1;
+          var maxd = Math.min(32767, i4);
+          var ml5 = Math.min(258, rem);
+          while (dif <= maxd && --ch_1 && imod != pimod) {
+            if (dat[i4 + l4] == dat[i4 + l4 - dif]) {
+              var nl5 = 0;
+              for (;nl5 < ml5 && dat[i4 + nl5] == dat[i4 + nl5 - dif]; ++nl5)
+                ;
+              if (nl5 > l4) {
+                l4 = nl5, d4 = dif;
+                if (nl5 > maxn)
+                  break;
+                var mmd = Math.min(dif, nl5 - 2);
+                var md3 = 0;
+                for (var j5 = 0;j5 < mmd; ++j5) {
+                  var ti5 = i4 - dif + j5 & 32767;
+                  var pti = prev[ti5];
+                  var cd5 = ti5 - pti & 32767;
+                  if (cd5 > md3)
+                    md3 = cd5, pimod = ti5;
+                }
+              }
+            }
+            imod = pimod, pimod = prev[imod];
+            dif += imod - pimod & 32767;
+          }
+        }
+        if (d4) {
+          syms[li5++] = 268435456 | revfl[l4] << 18 | revfd[d4];
+          var lin = revfl[l4] & 31, din = revfd[d4] & 31;
+          eb += fleb[lin] + fdeb[din];
+          ++lf4[257 + lin];
+          ++df4[din];
+          wi5 = i4 + l4;
+          ++lc_1;
+        } else {
+          syms[li5++] = dat[i4];
+          ++lf4[dat[i4]];
+        }
+      }
+    }
+    for (i4 = Math.max(i4, wi5);i4 < s3; ++i4) {
+      syms[li5++] = dat[i4];
+      ++lf4[dat[i4]];
+    }
+    pos = wblk(dat, w4, lst, syms, lf4, df4, eb, li5, bs5, i4 - bs5, pos);
+    if (!lst) {
+      st5.r = pos & 7 | w4[pos / 8 | 0] << 3;
+      pos -= 7;
+      st5.h = head, st5.p = prev, st5.i = i4, st5.w = wi5;
+    }
+  } else {
+    for (var i4 = st5.w || 0;i4 < s3 + lst; i4 += 65535) {
+      var e5 = i4 + 65535;
+      if (e5 >= s3) {
+        w4[pos / 8 | 0] = lst;
+        e5 = s3;
+      }
+      pos = wfblk(w4, pos + 1, dat.subarray(i4, e5));
+    }
+    st5.i = s3;
+  }
+  return slc(o4, 0, pre + shft(pos) + post);
+};
+var adler = function() {
+  var a3 = 1, b = 0;
+  return {
+    p: function(d4) {
+      var n4 = a3, m4 = b;
+      var l4 = d4.length | 0;
+      for (var i4 = 0;i4 != l4; ) {
+        var e5 = Math.min(i4 + 2655, l4);
+        for (;i4 < e5; ++i4)
+          m4 += n4 += d4[i4];
+        n4 = (n4 & 65535) + 15 * (n4 >> 16), m4 = (m4 & 65535) + 15 * (m4 >> 16);
+      }
+      a3 = n4, b = m4;
+    },
+    d: function() {
+      a3 %= 65521, b %= 65521;
+      return (a3 & 255) << 24 | (a3 & 65280) << 8 | (b & 255) << 8 | b >> 8;
+    }
+  };
+};
+var dopt = function(dat, opt, pre, post, st5) {
+  if (!st5) {
+    st5 = { l: 1 };
+    if (opt.dictionary) {
+      var dict = opt.dictionary.subarray(-32768);
+      var newDat = new u8(dict.length + dat.length);
+      newDat.set(dict);
+      newDat.set(dat, dict.length);
+      dat = newDat;
+      st5.w = dict.length;
+    }
+  }
+  return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st5.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st5);
+};
+var wbytes = function(d4, b, v4) {
+  for (;v4; ++b)
+    d4[b] = v4, v4 >>>= 8;
+};
+var zlh = function(c4, o4) {
+  var lv = o4.level, fl6 = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2;
+  c4[0] = 120, c4[1] = fl6 << 6 | (o4.dictionary && 32);
+  c4[1] |= 31 - (c4[0] << 8 | c4[1]) % 31;
+  if (o4.dictionary) {
+    var h6 = adler();
+    h6.p(o4.dictionary);
+    wbytes(c4, 2, h6.d());
+  }
+};
+var zls = function(d4, dict) {
+  if ((d4[0] & 15) != 8 || d4[0] >> 4 > 7 || (d4[0] << 8 | d4[1]) % 31)
+    err(6, "invalid zlib data");
+  if ((d4[1] >> 5 & 1) == +!dict)
+    err(6, "invalid zlib data: " + (d4[1] & 32 ? "need" : "unexpected") + " dictionary");
+  return (d4[1] >> 3 & 4) + 2;
+};
+var Inflate = /* @__PURE__ */ function() {
+  function Inflate2(opts, cb3) {
+    if (typeof opts == "function")
+      cb3 = opts, opts = {};
+    this.ondata = cb3;
+    var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768);
+    this.s = { i: 0, b: dict ? dict.length : 0 };
+    this.o = new u8(32768);
+    this.p = new u8(0);
+    if (dict)
+      this.o.set(dict);
+  }
+  Inflate2.prototype.e = function(c4) {
+    if (!this.ondata)
+      err(5);
+    if (this.d)
+      err(4);
+    if (!this.p.length)
+      this.p = c4;
+    else if (c4.length) {
+      var n4 = new u8(this.p.length + c4.length);
+      n4.set(this.p), n4.set(c4, this.p.length), this.p = n4;
+    }
+  };
+  Inflate2.prototype.c = function(final) {
+    this.s.i = +(this.d = final || false);
+    var bts = this.s.b;
+    var dt5 = inflt(this.p, this.s, this.o);
+    this.ondata(slc(dt5, bts, this.s.b), this.d);
+    this.o = slc(dt5, this.s.b - 32768), this.s.b = this.o.length;
+    this.p = slc(this.p, this.s.p / 8 | 0), this.s.p &= 7;
+  };
+  Inflate2.prototype.push = function(chunk, final) {
+    this.e(chunk), this.c(final);
+  };
+  return Inflate2;
+}();
+function zlibSync(data, opts) {
+  if (!opts)
+    opts = {};
+  var a3 = adler();
+  a3.p(data);
+  var d4 = dopt(data, opts, opts.dictionary ? 6 : 2, 4);
+  return zlh(d4, opts), wbytes(d4, d4.length - 4, a3.d()), d4;
+}
+var Unzlib = /* @__PURE__ */ function() {
+  function Unzlib2(opts, cb3) {
+    Inflate.call(this, opts, cb3);
+    this.v = opts && opts.dictionary ? 2 : 1;
+  }
+  Unzlib2.prototype.push = function(chunk, final) {
+    Inflate.prototype.e.call(this, chunk);
+    if (this.v) {
+      if (this.p.length < 6 && !final)
+        return;
+      this.p = this.p.subarray(zls(this.p, this.v - 1)), this.v = 0;
+    }
+    if (final) {
+      if (this.p.length < 4)
+        err(6, "invalid zlib data");
+      this.p = this.p.subarray(0, -4);
+    }
+    Inflate.prototype.c.call(this, final);
+  };
+  return Unzlib2;
+}();
+function unzlibSync(data, opts) {
+  return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
+var td5 = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder;
+var tds = 0;
+try {
+  td5.decode(et5, { stream: true });
+  tds = 1;
+} catch (e5) {}
+
+// node_modules/iobuffer/lib/text.js
+function decode(bytes, encoding = "utf8") {
+  const decoder = new TextDecoder(encoding);
+  return decoder.decode(bytes);
+}
+var encoder = new TextEncoder;
+function encode(str) {
+  return encoder.encode(str);
+}
+
+// node_modules/iobuffer/lib/iobuffer.js
+var defaultByteLength = 1024 * 8;
+var hostBigEndian = (() => {
+  const array = new Uint8Array(4);
+  const view = new Uint32Array(array.buffer);
+  return !((view[0] = 1) & array[0]);
+})();
+var typedArrays = {
+  int8: globalThis.Int8Array,
+  uint8: globalThis.Uint8Array,
+  int16: globalThis.Int16Array,
+  uint16: globalThis.Uint16Array,
+  int32: globalThis.Int32Array,
+  uint32: globalThis.Uint32Array,
+  uint64: globalThis.BigUint64Array,
+  int64: globalThis.BigInt64Array,
+  float32: globalThis.Float32Array,
+  float64: globalThis.Float64Array
+};
+
+class IOBuffer {
+  buffer;
+  byteLength;
+  byteOffset;
+  length;
+  offset;
+  lastWrittenByte;
+  littleEndian;
+  _data;
+  _mark;
+  _marks;
+  constructor(data = defaultByteLength, options = {}) {
+    let dataIsGiven = false;
+    if (typeof data === "number") {
+      data = new ArrayBuffer(data);
+    } else {
+      dataIsGiven = true;
+      this.lastWrittenByte = data.byteLength;
+    }
+    const offset = options.offset ? options.offset >>> 0 : 0;
+    const byteLength = data.byteLength - offset;
+    let dvOffset = offset;
+    if (ArrayBuffer.isView(data) || data instanceof IOBuffer) {
+      if (data.byteLength !== data.buffer.byteLength) {
+        dvOffset = data.byteOffset + offset;
+      }
+      data = data.buffer;
+    }
+    if (dataIsGiven) {
+      this.lastWrittenByte = byteLength;
+    } else {
+      this.lastWrittenByte = 0;
+    }
+    this.buffer = data;
+    this.length = byteLength;
+    this.byteLength = byteLength;
+    this.byteOffset = dvOffset;
+    this.offset = 0;
+    this.littleEndian = true;
+    this._data = new DataView(this.buffer, dvOffset, byteLength);
+    this._mark = 0;
+    this._marks = [];
+  }
+  available(byteLength = 1) {
+    return this.offset + byteLength <= this.length;
+  }
+  isLittleEndian() {
+    return this.littleEndian;
+  }
+  setLittleEndian() {
+    this.littleEndian = true;
+    return this;
+  }
+  isBigEndian() {
+    return !this.littleEndian;
+  }
+  setBigEndian() {
+    this.littleEndian = false;
+    return this;
+  }
+  skip(n4 = 1) {
+    this.offset += n4;
+    return this;
+  }
+  back(n4 = 1) {
+    this.offset -= n4;
+    return this;
+  }
+  seek(offset) {
+    this.offset = offset;
+    return this;
+  }
+  mark() {
+    this._mark = this.offset;
+    return this;
+  }
+  reset() {
+    this.offset = this._mark;
+    return this;
+  }
+  pushMark() {
+    this._marks.push(this.offset);
+    return this;
+  }
+  popMark() {
+    const offset = this._marks.pop();
+    if (offset === undefined) {
+      throw new Error("Mark stack empty");
+    }
+    this.seek(offset);
+    return this;
+  }
+  rewind() {
+    this.offset = 0;
+    return this;
+  }
+  ensureAvailable(byteLength = 1) {
+    if (!this.available(byteLength)) {
+      const lengthNeeded = this.offset + byteLength;
+      const newLength = lengthNeeded * 2;
+      const newArray = new Uint8Array(newLength);
+      newArray.set(new Uint8Array(this.buffer));
+      this.buffer = newArray.buffer;
+      this.length = newLength;
+      this.byteLength = newLength;
+      this._data = new DataView(this.buffer);
+    }
+    return this;
+  }
+  readBoolean() {
+    return this.readUint8() !== 0;
+  }
+  readInt8() {
+    return this._data.getInt8(this.offset++);
+  }
+  readUint8() {
+    return this._data.getUint8(this.offset++);
+  }
+  readByte() {
+    return this.readUint8();
+  }
+  readBytes(n4 = 1) {
+    return this.readArray(n4, "uint8");
+  }
+  readArray(size3, type) {
+    const bytes = typedArrays[type].BYTES_PER_ELEMENT * size3;
+    const offset = this.byteOffset + this.offset;
+    const slice = this.buffer.slice(offset, offset + bytes);
+    if (this.littleEndian === hostBigEndian && type !== "uint8" && type !== "int8") {
+      const slice2 = new Uint8Array(this.buffer.slice(offset, offset + bytes));
+      slice2.reverse();
+      const returnArray2 = new typedArrays[type](slice2.buffer);
+      this.offset += bytes;
+      returnArray2.reverse();
+      return returnArray2;
+    }
+    const returnArray = new typedArrays[type](slice);
+    this.offset += bytes;
+    return returnArray;
+  }
+  readInt16() {
+    const value = this._data.getInt16(this.offset, this.littleEndian);
+    this.offset += 2;
+    return value;
+  }
+  readUint16() {
+    const value = this._data.getUint16(this.offset, this.littleEndian);
+    this.offset += 2;
+    return value;
+  }
+  readInt32() {
+    const value = this._data.getInt32(this.offset, this.littleEndian);
+    this.offset += 4;
+    return value;
+  }
+  readUint32() {
+    const value = this._data.getUint32(this.offset, this.littleEndian);
+    this.offset += 4;
+    return value;
+  }
+  readFloat32() {
+    const value = this._data.getFloat32(this.offset, this.littleEndian);
+    this.offset += 4;
+    return value;
+  }
+  readFloat64() {
+    const value = this._data.getFloat64(this.offset, this.littleEndian);
+    this.offset += 8;
+    return value;
+  }
+  readBigInt64() {
+    const value = this._data.getBigInt64(this.offset, this.littleEndian);
+    this.offset += 8;
+    return value;
+  }
+  readBigUint64() {
+    const value = this._data.getBigUint64(this.offset, this.littleEndian);
+    this.offset += 8;
+    return value;
+  }
+  readChar() {
+    return String.fromCharCode(this.readInt8());
+  }
+  readChars(n4 = 1) {
+    let result = "";
+    for (let i4 = 0;i4 < n4; i4++) {
+      result += this.readChar();
+    }
+    return result;
+  }
+  readUtf8(n4 = 1) {
+    return decode(this.readBytes(n4));
+  }
+  decodeText(n4 = 1, encoding = "utf8") {
+    return decode(this.readBytes(n4), encoding);
+  }
+  writeBoolean(value) {
+    this.writeUint8(value ? 255 : 0);
+    return this;
+  }
+  writeInt8(value) {
+    this.ensureAvailable(1);
+    this._data.setInt8(this.offset++, value);
+    this._updateLastWrittenByte();
+    return this;
+  }
+  writeUint8(value) {
+    this.ensureAvailable(1);
+    this._data.setUint8(this.offset++, value);
+    this._updateLastWrittenByte();
+    return this;
+  }
+  writeByte(value) {
+    return this.writeUint8(value);
+  }
+  writeBytes(bytes) {
+    this.ensureAvailable(bytes.length);
+    for (let i4 = 0;i4 < bytes.length; i4++) {
+      this._data.setUint8(this.offset++, bytes[i4]);
+    }
+    this._updateLastWrittenByte();
+    return this;
+  }
+  writeInt16(value) {
+    this.ensureAvailable(2);
+    this._data.setInt16(this.offset, value, this.littleEndian);
+    this.offset += 2;
+    this._updateLastWrittenByte();
+    return this;
+  }
+  writeUint16(value) {
+    this.ensureAvailable(2);
+    this._data.setUint16(this.offset, value, this.littleEndian);
+    this.offset += 2;
+    this._updateLastWrittenByte();
+    return this;
+  }
+  writeInt32(value) {
+    this.ensureAvailable(4);
+    this._data.setInt32(this.offset, value, this.littleEndian);
+    this.offset += 4;
+    this._updateLastWrittenByte();
+    return this;
+  }
+  writeUint32(value) {
+    this.ensureAvailable(4);
+    this._data.setUint32(this.offset, value, this.littleEndian);
+    this.offset += 4;
+    this._updateLastWrittenByte();
+    return this;
+  }
+  writeFloat32(value) {
+    this.ensureAvailable(4);
+    this._data.setFloat32(this.offset, value, this.littleEndian);
+    this.offset += 4;
+    this._updateLastWrittenByte();
+    return this;
+  }
+  writeFloat64(value) {
+    this.ensureAvailable(8);
+    this._data.setFloat64(this.offset, value, this.littleEndian);
+    this.offset += 8;
+    this._updateLastWrittenByte();
+    return this;
+  }
+  writeBigInt64(value) {
+    this.ensureAvailable(8);
+    this._data.setBigInt64(this.offset, value, this.littleEndian);
+    this.offset += 8;
+    this._updateLastWrittenByte();
+    return this;
+  }
+  writeBigUint64(value) {
+    this.ensureAvailable(8);
+    this._data.setBigUint64(this.offset, value, this.littleEndian);
+    this.offset += 8;
+    this._updateLastWrittenByte();
+    return this;
+  }
+  writeChar(str) {
+    return this.writeUint8(str.charCodeAt(0));
+  }
+  writeChars(str) {
+    for (let i4 = 0;i4 < str.length; i4++) {
+      this.writeUint8(str.charCodeAt(i4));
+    }
+    return this;
+  }
+  writeUtf8(str) {
+    return this.writeBytes(encode(str));
+  }
+  toArray() {
+    return new Uint8Array(this.buffer, this.byteOffset, this.lastWrittenByte);
+  }
+  getWrittenByteLength() {
+    return this.lastWrittenByte - this.byteOffset;
+  }
+  _updateLastWrittenByte() {
+    if (this.offset > this.lastWrittenByte) {
+      this.lastWrittenByte = this.offset;
+    }
+  }
+}
+
+// node_modules/fast-png/lib/helpers/crc.js
+var crcTable = [];
+for (let n4 = 0;n4 < 256; n4++) {
+  let c4 = n4;
+  for (let k4 = 0;k4 < 8; k4++) {
+    if (c4 & 1) {
+      c4 = 3988292384 ^ c4 >>> 1;
+    } else {
+      c4 = c4 >>> 1;
+    }
+  }
+  crcTable[n4] = c4;
+}
+var initialCrc = 4294967295;
+function updateCrc(currentCrc, data, length3) {
+  let c4 = currentCrc;
+  for (let n4 = 0;n4 < length3; n4++) {
+    c4 = crcTable[(c4 ^ data[n4]) & 255] ^ c4 >>> 8;
+  }
+  return c4;
+}
+function crc(data, length3) {
+  return (updateCrc(initialCrc, data, length3) ^ initialCrc) >>> 0;
+}
+function checkCrc(buffer, crcLength, chunkName) {
+  const expectedCrc = buffer.readUint32();
+  const actualCrc = crc(new Uint8Array(buffer.buffer, buffer.byteOffset + buffer.offset - crcLength - 4, crcLength), crcLength);
+  if (actualCrc !== expectedCrc) {
+    throw new Error(`CRC mismatch for chunk ${chunkName}. Expected ${expectedCrc}, found ${actualCrc}`);
+  }
+}
+function writeCrc(buffer, length3) {
+  buffer.writeUint32(crc(new Uint8Array(buffer.buffer, buffer.byteOffset + buffer.offset - length3, length3), length3));
+}
+
+// node_modules/fast-png/lib/helpers/unfilter.js
+function unfilterNone(currentLine, newLine, bytesPerLine) {
+  for (let i4 = 0;i4 < bytesPerLine; i4++) {
+    newLine[i4] = currentLine[i4];
+  }
+}
+function unfilterSub(currentLine, newLine, bytesPerLine, bytesPerPixel) {
+  let i4 = 0;
+  for (;i4 < bytesPerPixel; i4++) {
+    newLine[i4] = currentLine[i4];
+  }
+  for (;i4 < bytesPerLine; i4++) {
+    newLine[i4] = currentLine[i4] + newLine[i4 - bytesPerPixel] & 255;
+  }
+}
+function unfilterUp(currentLine, newLine, prevLine, bytesPerLine) {
+  let i4 = 0;
+  if (prevLine.length === 0) {
+    for (;i4 < bytesPerLine; i4++) {
+      newLine[i4] = currentLine[i4];
+    }
+  } else {
+    for (;i4 < bytesPerLine; i4++) {
+      newLine[i4] = currentLine[i4] + prevLine[i4] & 255;
+    }
+  }
+}
+function unfilterAverage(currentLine, newLine, prevLine, bytesPerLine, bytesPerPixel) {
+  let i4 = 0;
+  if (prevLine.length === 0) {
+    for (;i4 < bytesPerPixel; i4++) {
+      newLine[i4] = currentLine[i4];
+    }
+    for (;i4 < bytesPerLine; i4++) {
+      newLine[i4] = currentLine[i4] + (newLine[i4 - bytesPerPixel] >> 1) & 255;
+    }
+  } else {
+    for (;i4 < bytesPerPixel; i4++) {
+      newLine[i4] = currentLine[i4] + (prevLine[i4] >> 1) & 255;
+    }
+    for (;i4 < bytesPerLine; i4++) {
+      newLine[i4] = currentLine[i4] + (newLine[i4 - bytesPerPixel] + prevLine[i4] >> 1) & 255;
+    }
+  }
+}
+function unfilterPaeth(currentLine, newLine, prevLine, bytesPerLine, bytesPerPixel) {
+  let i4 = 0;
+  if (prevLine.length === 0) {
+    for (;i4 < bytesPerPixel; i4++) {
+      newLine[i4] = currentLine[i4];
+    }
+    for (;i4 < bytesPerLine; i4++) {
+      newLine[i4] = currentLine[i4] + newLine[i4 - bytesPerPixel] & 255;
+    }
+  } else {
+    for (;i4 < bytesPerPixel; i4++) {
+      newLine[i4] = currentLine[i4] + prevLine[i4] & 255;
+    }
+    for (;i4 < bytesPerLine; i4++) {
+      newLine[i4] = currentLine[i4] + paethPredictor(newLine[i4 - bytesPerPixel], prevLine[i4], prevLine[i4 - bytesPerPixel]) & 255;
+    }
+  }
+}
+function paethPredictor(a3, b, c4) {
+  const p4 = a3 + b - c4;
+  const pa5 = Math.abs(p4 - a3);
+  const pb = Math.abs(p4 - b);
+  const pc5 = Math.abs(p4 - c4);
+  if (pa5 <= pb && pa5 <= pc5)
+    return a3;
+  else if (pb <= pc5)
+    return b;
+  else
+    return c4;
+}
+
+// node_modules/fast-png/lib/helpers/apply_unfilter.js
+function applyUnfilter(filterType, currentLine, newLine, prevLine, passLineBytes, bytesPerPixel) {
+  switch (filterType) {
+    case 0:
+      unfilterNone(currentLine, newLine, passLineBytes);
+      break;
+    case 1:
+      unfilterSub(currentLine, newLine, passLineBytes, bytesPerPixel);
+      break;
+    case 2:
+      unfilterUp(currentLine, newLine, prevLine, passLineBytes);
+      break;
+    case 3:
+      unfilterAverage(currentLine, newLine, prevLine, passLineBytes, bytesPerPixel);
+      break;
+    case 4:
+      unfilterPaeth(currentLine, newLine, prevLine, passLineBytes, bytesPerPixel);
+      break;
+    default:
+      throw new Error(`Unsupported filter: ${filterType}`);
+  }
+}
+
+// node_modules/fast-png/lib/helpers/decode_interlace_adam7.js
+var uint16 = new Uint16Array([255]);
+var uint8 = new Uint8Array(uint16.buffer);
+var osIsLittleEndian = uint8[0] === 255;
+function decodeInterlaceAdam7(params2) {
+  const { data, width, height, channels, depth } = params2;
+  const passes = [
+    { x: 0, y: 0, xStep: 8, yStep: 8 },
+    { x: 4, y: 0, xStep: 8, yStep: 8 },
+    { x: 0, y: 4, xStep: 4, yStep: 8 },
+    { x: 2, y: 0, xStep: 4, yStep: 4 },
+    { x: 0, y: 2, xStep: 2, yStep: 4 },
+    { x: 1, y: 0, xStep: 2, yStep: 2 },
+    { x: 0, y: 1, xStep: 1, yStep: 2 }
+  ];
+  const bytesPerPixel = Math.ceil(depth / 8) * channels;
+  const resultData = new Uint8Array(height * width * bytesPerPixel);
+  let offset = 0;
+  for (let passIndex = 0;passIndex < 7; passIndex++) {
+    const pass = passes[passIndex];
+    const passWidth = Math.ceil((width - pass.x) / pass.xStep);
+    const passHeight = Math.ceil((height - pass.y) / pass.yStep);
+    if (passWidth <= 0 || passHeight <= 0)
+      continue;
+    const passLineBytes = passWidth * bytesPerPixel;
+    const prevLine = new Uint8Array(passLineBytes);
+    for (let y5 = 0;y5 < passHeight; y5++) {
+      const filterType = data[offset++];
+      const currentLine = data.subarray(offset, offset + passLineBytes);
+      offset += passLineBytes;
+      const newLine = new Uint8Array(passLineBytes);
+      applyUnfilter(filterType, currentLine, newLine, prevLine, passLineBytes, bytesPerPixel);
+      prevLine.set(newLine);
+      for (let x4 = 0;x4 < passWidth; x4++) {
+        const outputX = pass.x + x4 * pass.xStep;
+        const outputY = pass.y + y5 * pass.yStep;
+        if (outputX >= width || outputY >= height)
+          continue;
+        for (let i4 = 0;i4 < bytesPerPixel; i4++) {
+          resultData[(outputY * width + outputX) * bytesPerPixel + i4] = newLine[x4 * bytesPerPixel + i4];
+        }
+      }
+    }
+  }
+  if (depth === 16) {
+    const uint16Data = new Uint16Array(resultData.buffer);
+    if (osIsLittleEndian) {
+      for (let k4 = 0;k4 < uint16Data.length; k4++) {
+        uint16Data[k4] = swap16(uint16Data[k4]);
+      }
+    }
+    return uint16Data;
+  } else {
+    return resultData;
+  }
+}
+function swap16(val) {
+  return (val & 255) << 8 | val >> 8 & 255;
+}
+
+// node_modules/fast-png/lib/helpers/decode_interlace_null.js
+var uint162 = new Uint16Array([255]);
+var uint82 = new Uint8Array(uint162.buffer);
+var osIsLittleEndian2 = uint82[0] === 255;
+var empty = new Uint8Array(0);
+function decodeInterlaceNull(params2) {
+  const { data, width, height, channels, depth } = params2;
+  const bytesPerPixel = Math.ceil(depth / 8) * channels;
+  const bytesPerLine = Math.ceil(depth / 8 * channels * width);
+  const newData = new Uint8Array(height * bytesPerLine);
+  let prevLine = empty;
+  let offset = 0;
+  let currentLine;
+  let newLine;
+  for (let i4 = 0;i4 < height; i4++) {
+    currentLine = data.subarray(offset + 1, offset + 1 + bytesPerLine);
+    newLine = newData.subarray(i4 * bytesPerLine, (i4 + 1) * bytesPerLine);
+    switch (data[offset]) {
+      case 0:
+        unfilterNone(currentLine, newLine, bytesPerLine);
+        break;
+      case 1:
+        unfilterSub(currentLine, newLine, bytesPerLine, bytesPerPixel);
+        break;
+      case 2:
+        unfilterUp(currentLine, newLine, prevLine, bytesPerLine);
+        break;
+      case 3:
+        unfilterAverage(currentLine, newLine, prevLine, bytesPerLine, bytesPerPixel);
+        break;
+      case 4:
+        unfilterPaeth(currentLine, newLine, prevLine, bytesPerLine, bytesPerPixel);
+        break;
+      default:
+        throw new Error(`Unsupported filter: ${data[offset]}`);
+    }
+    prevLine = newLine;
+    offset += bytesPerLine + 1;
+  }
+  if (depth === 16) {
+    const uint16Data = new Uint16Array(newData.buffer);
+    if (osIsLittleEndian2) {
+      for (let k4 = 0;k4 < uint16Data.length; k4++) {
+        uint16Data[k4] = swap162(uint16Data[k4]);
+      }
+    }
+    return uint16Data;
+  } else {
+    return newData;
+  }
+}
+function swap162(val) {
+  return (val & 255) << 8 | val >> 8 & 255;
+}
+
+// node_modules/fast-png/lib/helpers/signature.js
+var pngSignature = Uint8Array.of(137, 80, 78, 71, 13, 10, 26, 10);
+function writeSignature(buffer) {
+  buffer.writeBytes(pngSignature);
+}
+function checkSignature(buffer) {
+  if (!hasPngSignature(buffer.readBytes(pngSignature.length))) {
+    throw new Error("wrong PNG signature");
+  }
+}
+function hasPngSignature(array) {
+  if (array.length < pngSignature.length) {
+    return false;
+  }
+  for (let i4 = 0;i4 < pngSignature.length; i4++) {
+    if (array[i4] !== pngSignature[i4]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// node_modules/fast-png/lib/helpers/text.js
+var textChunkName = "tEXt";
+var NULL = 0;
+var latin1Decoder = new TextDecoder("latin1");
+function validateKeyword(keyword) {
+  validateLatin1(keyword);
+  if (keyword.length === 0 || keyword.length > 79) {
+    throw new Error("keyword length must be between 1 and 79");
+  }
+}
+var latin1Regex = /^[\u0000-\u00FF]*$/;
+function validateLatin1(text) {
+  if (!latin1Regex.test(text)) {
+    throw new Error("invalid latin1 text");
+  }
+}
+function decodetEXt(text, buffer, length3) {
+  const keyword = readKeyword(buffer);
+  text[keyword] = readLatin1(buffer, length3 - keyword.length - 1);
+}
+function encodetEXt(buffer, keyword, text) {
+  validateKeyword(keyword);
+  validateLatin1(text);
+  const length3 = keyword.length + 1 + text.length;
+  buffer.writeUint32(length3);
+  buffer.writeChars(textChunkName);
+  buffer.writeChars(keyword);
+  buffer.writeByte(NULL);
+  buffer.writeChars(text);
+  writeCrc(buffer, length3 + 4);
+}
+function readKeyword(buffer) {
+  buffer.mark();
+  while (buffer.readByte() !== NULL) {}
+  const end = buffer.offset;
+  buffer.reset();
+  const keyword = latin1Decoder.decode(buffer.readBytes(end - buffer.offset - 1));
+  buffer.skip(1);
+  validateKeyword(keyword);
+  return keyword;
+}
+function readLatin1(buffer, length3) {
+  return latin1Decoder.decode(buffer.readBytes(length3));
+}
+
+// node_modules/fast-png/lib/internal_types.js
+var ColorType = {
+  UNKNOWN: -1,
+  GREYSCALE: 0,
+  TRUECOLOUR: 2,
+  INDEXED_COLOUR: 3,
+  GREYSCALE_ALPHA: 4,
+  TRUECOLOUR_ALPHA: 6
+};
+var CompressionMethod = {
+  UNKNOWN: -1,
+  DEFLATE: 0
+};
+var FilterMethod = {
+  UNKNOWN: -1,
+  ADAPTIVE: 0
+};
+var InterlaceMethod = {
+  UNKNOWN: -1,
+  NO_INTERLACE: 0,
+  ADAM7: 1
+};
+var DisposeOpType = {
+  NONE: 0,
+  BACKGROUND: 1,
+  PREVIOUS: 2
+};
+var BlendOpType = {
+  SOURCE: 0,
+  OVER: 1
+};
+
+// node_modules/fast-png/lib/png_decoder.js
+class PngDecoder extends IOBuffer {
+  _checkCrc;
+  _inflator;
+  _png;
+  _apng;
+  _end;
+  _hasPalette;
+  _palette;
+  _hasTransparency;
+  _transparency;
+  _compressionMethod;
+  _filterMethod;
+  _interlaceMethod;
+  _colorType;
+  _isAnimated;
+  _numberOfFrames;
+  _numberOfPlays;
+  _frames;
+  _writingDataChunks;
+  _chunks;
+  _inflatorResult;
+  constructor(data, options = {}) {
+    super(data);
+    const { checkCrc: checkCrc2 = false } = options;
+    this._checkCrc = checkCrc2;
+    this._inflator = new Unzlib((chunk, final) => {
+      this._chunks.push(chunk);
+      if (final) {
+        const totalLength = this._chunks.reduce((sum, c4) => sum + c4.length, 0);
+        this._inflatorResult = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk2 of this._chunks) {
+          this._inflatorResult.set(chunk2, offset);
+          offset += chunk2.length;
+        }
+        this._chunks = [];
+      }
+    });
+    this._chunks = [];
+    this._png = {
+      width: -1,
+      height: -1,
+      channels: -1,
+      data: new Uint8Array(0),
+      depth: 1,
+      text: {}
+    };
+    this._apng = {
+      width: -1,
+      height: -1,
+      channels: -1,
+      depth: 1,
+      numberOfFrames: 1,
+      numberOfPlays: 0,
+      text: {},
+      frames: []
+    };
+    this._end = false;
+    this._hasPalette = false;
+    this._palette = [];
+    this._hasTransparency = false;
+    this._transparency = new Uint16Array(0);
+    this._compressionMethod = CompressionMethod.UNKNOWN;
+    this._filterMethod = FilterMethod.UNKNOWN;
+    this._interlaceMethod = InterlaceMethod.UNKNOWN;
+    this._colorType = ColorType.UNKNOWN;
+    this._isAnimated = false;
+    this._numberOfFrames = 1;
+    this._numberOfPlays = 0;
+    this._frames = [];
+    this._writingDataChunks = false;
+    this._inflatorResult = new Uint8Array(0);
+    this.setBigEndian();
+  }
+  decode() {
+    checkSignature(this);
+    while (!this._end) {
+      const length3 = this.readUint32();
+      const type = this.readChars(4);
+      this.decodeChunk(length3, type);
+    }
+    this._inflator.push(new Uint8Array(0), true);
+    this.decodeImage();
+    return this._png;
+  }
+  decodeApng() {
+    checkSignature(this);
+    while (!this._end) {
+      const length3 = this.readUint32();
+      const type = this.readChars(4);
+      this.decodeApngChunk(length3, type);
+    }
+    this.decodeApngImage();
+    return this._apng;
+  }
+  decodeChunk(length3, type) {
+    const offset = this.offset;
+    switch (type) {
+      case "IHDR":
+        this.decodeIHDR();
+        break;
+      case "PLTE":
+        this.decodePLTE(length3);
+        break;
+      case "IDAT":
+        this.decodeIDAT(length3);
+        break;
+      case "IEND":
+        this._end = true;
+        break;
+      case "tRNS":
+        this.decodetRNS(length3);
+        break;
+      case "iCCP":
+        this.decodeiCCP(length3);
+        break;
+      case textChunkName:
+        decodetEXt(this._png.text, this, length3);
+        break;
+      case "pHYs":
+        this.decodepHYs();
+        break;
+      default:
+        this.skip(length3);
+        break;
+    }
+    if (this.offset - offset !== length3) {
+      throw new Error(`Length mismatch while decoding chunk ${type}`);
+    }
+    if (this._checkCrc) {
+      checkCrc(this, length3 + 4, type);
+    } else {
+      this.skip(4);
+    }
+  }
+  decodeApngChunk(length3, type) {
+    const offset = this.offset;
+    if (type !== "fdAT" && type !== "IDAT" && this._writingDataChunks) {
+      this.pushDataToFrame();
+    }
+    switch (type) {
+      case "acTL":
+        this.decodeACTL();
+        break;
+      case "fcTL":
+        this.decodeFCTL();
+        break;
+      case "fdAT":
+        this.decodeFDAT(length3);
+        break;
+      default:
+        this.decodeChunk(length3, type);
+        this.offset = offset + length3;
+        break;
+    }
+    if (this.offset - offset !== length3) {
+      throw new Error(`Length mismatch while decoding chunk ${type}`);
+    }
+    if (this._checkCrc) {
+      checkCrc(this, length3 + 4, type);
+    } else {
+      this.skip(4);
+    }
+  }
+  decodeIHDR() {
+    const image = this._png;
+    image.width = this.readUint32();
+    image.height = this.readUint32();
+    image.depth = checkBitDepth(this.readUint8());
+    const colorType = this.readUint8();
+    this._colorType = colorType;
+    let channels;
+    switch (colorType) {
+      case ColorType.GREYSCALE:
+        channels = 1;
+        break;
+      case ColorType.TRUECOLOUR:
+        channels = 3;
+        break;
+      case ColorType.INDEXED_COLOUR:
+        channels = 1;
+        break;
+      case ColorType.GREYSCALE_ALPHA:
+        channels = 2;
+        break;
+      case ColorType.TRUECOLOUR_ALPHA:
+        channels = 4;
+        break;
+      case ColorType.UNKNOWN:
+      default:
+        throw new Error(`Unknown color type: ${colorType}`);
+    }
+    this._png.channels = channels;
+    this._compressionMethod = this.readUint8();
+    if (this._compressionMethod !== CompressionMethod.DEFLATE) {
+      throw new Error(`Unsupported compression method: ${this._compressionMethod}`);
+    }
+    this._filterMethod = this.readUint8();
+    this._interlaceMethod = this.readUint8();
+  }
+  decodeACTL() {
+    this._numberOfFrames = this.readUint32();
+    this._numberOfPlays = this.readUint32();
+    this._isAnimated = true;
+  }
+  decodeFCTL() {
+    const image = {
+      sequenceNumber: this.readUint32(),
+      width: this.readUint32(),
+      height: this.readUint32(),
+      xOffset: this.readUint32(),
+      yOffset: this.readUint32(),
+      delayNumber: this.readUint16(),
+      delayDenominator: this.readUint16(),
+      disposeOp: this.readUint8(),
+      blendOp: this.readUint8(),
+      data: new Uint8Array(0)
+    };
+    this._frames.push(image);
+  }
+  decodePLTE(length3) {
+    if (length3 % 3 !== 0) {
+      throw new RangeError(`PLTE field length must be a multiple of 3. Got ${length3}`);
+    }
+    const l4 = length3 / 3;
+    this._hasPalette = true;
+    const palette = [];
+    this._palette = palette;
+    for (let i4 = 0;i4 < l4; i4++) {
+      palette.push([this.readUint8(), this.readUint8(), this.readUint8()]);
+    }
+  }
+  decodeIDAT(length3) {
+    this._writingDataChunks = true;
+    const dataLength = length3;
+    const dataOffset = this.offset + this.byteOffset;
+    try {
+      this._inflator.push(new Uint8Array(this.buffer, dataOffset, dataLength), false);
+    } catch (error) {
+      throw new Error("Error while decompressing the data:", { cause: error });
+    }
+    this.skip(length3);
+  }
+  decodeFDAT(length3) {
+    this._writingDataChunks = true;
+    let dataLength = length3;
+    let dataOffset = this.offset + this.byteOffset;
+    dataOffset += 4;
+    dataLength -= 4;
+    try {
+      this._inflator.push(new Uint8Array(this.buffer, dataOffset, dataLength), false);
+    } catch (error) {
+      throw new Error("Error while decompressing the data:", { cause: error });
+    }
+    this.skip(length3);
+  }
+  decodetRNS(length3) {
+    switch (this._colorType) {
+      case ColorType.GREYSCALE:
+      case ColorType.TRUECOLOUR: {
+        if (length3 % 2 !== 0) {
+          throw new RangeError(`tRNS chunk length must be a multiple of 2. Got ${length3}`);
+        }
+        if (length3 / 2 > this._png.width * this._png.height) {
+          throw new Error(`tRNS chunk contains more alpha values than there are pixels (${length3 / 2} vs ${this._png.width * this._png.height})`);
+        }
+        this._hasTransparency = true;
+        this._transparency = new Uint16Array(length3 / 2);
+        for (let i4 = 0;i4 < length3 / 2; i4++) {
+          this._transparency[i4] = this.readUint16();
+        }
+        break;
+      }
+      case ColorType.INDEXED_COLOUR: {
+        if (length3 > this._palette.length) {
+          throw new Error(`tRNS chunk contains more alpha values than there are palette colors (${length3} vs ${this._palette.length})`);
+        }
+        let i4 = 0;
+        for (;i4 < length3; i4++) {
+          const alpha = this.readByte();
+          this._palette[i4].push(alpha);
+        }
+        for (;i4 < this._palette.length; i4++) {
+          this._palette[i4].push(255);
+        }
+        break;
+      }
+      case ColorType.UNKNOWN:
+      case ColorType.GREYSCALE_ALPHA:
+      case ColorType.TRUECOLOUR_ALPHA:
+      default: {
+        throw new Error(`tRNS chunk is not supported for color type ${this._colorType}`);
+      }
+    }
+  }
+  decodeiCCP(length3) {
+    const name = readKeyword(this);
+    const compressionMethod = this.readUint8();
+    if (compressionMethod !== CompressionMethod.DEFLATE) {
+      throw new Error(`Unsupported iCCP compression method: ${compressionMethod}`);
+    }
+    const compressedProfile = this.readBytes(length3 - name.length - 2);
+    this._png.iccEmbeddedProfile = {
+      name,
+      profile: unzlibSync(compressedProfile)
+    };
+  }
+  decodepHYs() {
+    const ppuX = this.readUint32();
+    const ppuY = this.readUint32();
+    const unitSpecifier = this.readByte();
+    this._png.resolution = {
+      x: ppuX,
+      y: ppuY,
+      unit: unitSpecifier
+    };
+  }
+  decodeApngImage() {
+    this._apng.width = this._png.width;
+    this._apng.height = this._png.height;
+    this._apng.channels = this._png.channels;
+    this._apng.depth = this._png.depth;
+    this._apng.numberOfFrames = this._numberOfFrames;
+    this._apng.numberOfPlays = this._numberOfPlays;
+    this._apng.text = this._png.text;
+    this._apng.resolution = this._png.resolution;
+    for (let i4 = 0;i4 < this._numberOfFrames; i4++) {
+      const newFrame = {
+        sequenceNumber: this._frames[i4].sequenceNumber,
+        delayNumber: this._frames[i4].delayNumber,
+        delayDenominator: this._frames[i4].delayDenominator,
+        data: this._apng.depth === 8 ? new Uint8Array(this._apng.width * this._apng.height * this._apng.channels) : new Uint16Array(this._apng.width * this._apng.height * this._apng.channels)
+      };
+      const frame = this._frames.at(i4);
+      if (frame) {
+        frame.data = decodeInterlaceNull({
+          data: frame.data,
+          width: frame.width,
+          height: frame.height,
+          channels: this._apng.channels,
+          depth: this._apng.depth
+        });
+        if (this._hasPalette) {
+          this._apng.palette = this._palette;
+        }
+        if (this._hasTransparency) {
+          this._apng.transparency = this._transparency;
+        }
+        if (i4 === 0 || frame.xOffset === 0 && frame.yOffset === 0 && frame.width === this._png.width && frame.height === this._png.height) {
+          newFrame.data = frame.data;
+        } else {
+          const prevFrame = this._apng.frames.at(i4 - 1);
+          this.disposeFrame(frame, prevFrame, newFrame);
+          this.addFrameDataToCanvas(newFrame, frame);
+        }
+        this._apng.frames.push(newFrame);
+      }
+    }
+    return this._apng;
+  }
+  disposeFrame(frame, prevFrame, imageFrame) {
+    switch (frame.disposeOp) {
+      case DisposeOpType.NONE:
+        break;
+      case DisposeOpType.BACKGROUND:
+        for (let row = 0;row < this._png.height; row++) {
+          for (let col = 0;col < this._png.width; col++) {
+            const index = (row * frame.width + col) * this._png.channels;
+            for (let channel = 0;channel < this._png.channels; channel++) {
+              imageFrame.data[index + channel] = 0;
+            }
+          }
+        }
+        break;
+      case DisposeOpType.PREVIOUS:
+        imageFrame.data.set(prevFrame.data);
+        break;
+      default:
+        throw new Error("Unknown disposeOp");
+    }
+  }
+  addFrameDataToCanvas(imageFrame, frame) {
+    const maxValue = 1 << this._png.depth;
+    const calculatePixelIndices = (row, col) => {
+      const index = ((row + frame.yOffset) * this._png.width + frame.xOffset + col) * this._png.channels;
+      const frameIndex = (row * frame.width + col) * this._png.channels;
+      return { index, frameIndex };
+    };
+    switch (frame.blendOp) {
+      case BlendOpType.SOURCE:
+        for (let row = 0;row < frame.height; row++) {
+          for (let col = 0;col < frame.width; col++) {
+            const { index, frameIndex } = calculatePixelIndices(row, col);
+            for (let channel = 0;channel < this._png.channels; channel++) {
+              imageFrame.data[index + channel] = frame.data[frameIndex + channel];
+            }
+          }
+        }
+        break;
+      case BlendOpType.OVER:
+        for (let row = 0;row < frame.height; row++) {
+          for (let col = 0;col < frame.width; col++) {
+            const { index, frameIndex } = calculatePixelIndices(row, col);
+            for (let channel = 0;channel < this._png.channels; channel++) {
+              const sourceAlpha = frame.data[frameIndex + this._png.channels - 1] / maxValue;
+              const foregroundValue = channel % (this._png.channels - 1) === 0 ? 1 : frame.data[frameIndex + channel];
+              const value = Math.floor(sourceAlpha * foregroundValue + (1 - sourceAlpha) * imageFrame.data[index + channel]);
+              imageFrame.data[index + channel] += value;
+            }
+          }
+        }
+        break;
+      default:
+        throw new Error("Unknown blendOp");
+    }
+  }
+  decodeImage() {
+    const data = this._inflatorResult;
+    if (this._filterMethod !== FilterMethod.ADAPTIVE) {
+      throw new Error(`Filter method ${this._filterMethod} not supported`);
+    }
+    if (this._interlaceMethod === InterlaceMethod.NO_INTERLACE) {
+      this._png.data = decodeInterlaceNull({
+        data,
+        width: this._png.width,
+        height: this._png.height,
+        channels: this._png.channels,
+        depth: this._png.depth
+      });
+    } else if (this._interlaceMethod === InterlaceMethod.ADAM7) {
+      this._png.data = decodeInterlaceAdam7({
+        data,
+        width: this._png.width,
+        height: this._png.height,
+        channels: this._png.channels,
+        depth: this._png.depth
+      });
+    } else {
+      throw new Error(`Interlace method ${this._interlaceMethod} not supported`);
+    }
+    if (this._hasPalette) {
+      this._png.palette = this._palette;
+    }
+    if (this._hasTransparency) {
+      this._png.transparency = this._transparency;
+    }
+  }
+  pushDataToFrame() {
+    this._inflator.push(new Uint8Array(0), true);
+    const result = this._inflatorResult;
+    const lastFrame = this._frames.at(-1);
+    if (lastFrame) {
+      lastFrame.data = result;
+    } else {
+      this._frames.push({
+        sequenceNumber: 0,
+        width: this._png.width,
+        height: this._png.height,
+        xOffset: 0,
+        yOffset: 0,
+        delayNumber: 0,
+        delayDenominator: 0,
+        disposeOp: DisposeOpType.NONE,
+        blendOp: BlendOpType.SOURCE,
+        data: result
+      });
+    }
+    this._inflator = new Unzlib((chunk, final) => {
+      this._chunks.push(chunk);
+      if (final) {
+        const totalLength = this._chunks.reduce((sum, c4) => sum + c4.length, 0);
+        this._inflatorResult = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk2 of this._chunks) {
+          this._inflatorResult.set(chunk2, offset);
+          offset += chunk2.length;
+        }
+        this._chunks = [];
+      }
+    });
+    this._chunks = [];
+    this._writingDataChunks = false;
+  }
+}
+function checkBitDepth(value) {
+  if (value !== 1 && value !== 2 && value !== 4 && value !== 8 && value !== 16) {
+    throw new Error(`invalid bit depth: ${value}`);
+  }
+  return value;
+}
+
+// node_modules/fast-png/lib/png_encoder.js
+var defaultZlibOptions = {
+  level: 3
+};
+
+class PngEncoder extends IOBuffer {
+  _png;
+  _zlibOptions;
+  _colorType;
+  _interlaceMethod;
+  constructor(data, options = {}) {
+    super();
+    this._colorType = ColorType.UNKNOWN;
+    this._zlibOptions = { ...defaultZlibOptions, ...options.zlib };
+    this._png = this._checkData(data);
+    this._interlaceMethod = (options.interlace === "Adam7" ? InterlaceMethod.ADAM7 : InterlaceMethod.NO_INTERLACE) ?? InterlaceMethod.NO_INTERLACE;
+    this.setBigEndian();
+  }
+  encode() {
+    writeSignature(this);
+    this.encodeIHDR();
+    if (this._png.palette) {
+      this.encodePLTE();
+      if (this._png.palette[0].length === 4) {
+        this.encodeTRNS();
+      }
+    }
+    this.encodeData();
+    if (this._png.text) {
+      for (const [keyword, text] of Object.entries(this._png.text)) {
+        encodetEXt(this, keyword, text);
+      }
+    }
+    this.encodeIEND();
+    return this.toArray();
+  }
+  encodeIHDR() {
+    this.writeUint32(13);
+    this.writeChars("IHDR");
+    this.writeUint32(this._png.width);
+    this.writeUint32(this._png.height);
+    this.writeByte(this._png.depth);
+    this.writeByte(this._colorType);
+    this.writeByte(CompressionMethod.DEFLATE);
+    this.writeByte(FilterMethod.ADAPTIVE);
+    this.writeByte(this._interlaceMethod);
+    writeCrc(this, 17);
+  }
+  encodeIEND() {
+    this.writeUint32(0);
+    this.writeChars("IEND");
+    writeCrc(this, 4);
+  }
+  encodePLTE() {
+    const paletteLength = this._png.palette?.length * 3;
+    this.writeUint32(paletteLength);
+    this.writeChars("PLTE");
+    for (const color of this._png.palette) {
+      this.writeByte(color[0]);
+      this.writeByte(color[1]);
+      this.writeByte(color[2]);
+    }
+    writeCrc(this, 4 + paletteLength);
+  }
+  encodeTRNS() {
+    const alpha = this._png.palette.filter((color) => {
+      return color.at(-1) !== 255;
+    });
+    this.writeUint32(alpha.length);
+    this.writeChars("tRNS");
+    for (const el5 of alpha) {
+      this.writeByte(el5.at(-1));
+    }
+    writeCrc(this, 4 + alpha.length);
+  }
+  encodeIDAT(data) {
+    this.writeUint32(data.length);
+    this.writeChars("IDAT");
+    this.writeBytes(data);
+    writeCrc(this, data.length + 4);
+  }
+  encodeData() {
+    const { width, height, channels, depth, data } = this._png;
+    const slotsPerLine = depth <= 8 ? Math.ceil(width * depth / 8) * channels : Math.ceil(width * depth / 8 * channels / 2);
+    const newData = new IOBuffer().setBigEndian();
+    let offset = 0;
+    if (this._interlaceMethod === InterlaceMethod.NO_INTERLACE) {
+      for (let i4 = 0;i4 < height; i4++) {
+        newData.writeByte(0);
+        if (depth === 16) {
+          offset = writeDataUint16(data, newData, slotsPerLine, offset);
+        } else {
+          offset = writeDataBytes(data, newData, slotsPerLine, offset);
+        }
+      }
+    } else if (this._interlaceMethod === InterlaceMethod.ADAM7) {
+      offset = writeDataInterlaced(this._png, data, newData, offset);
+    }
+    const buffer = newData.toArray();
+    const compressed = zlibSync(buffer, this._zlibOptions);
+    this.encodeIDAT(compressed);
+  }
+  _checkData(data) {
+    const { colorType, channels, depth } = getColorType(data, data.palette);
+    const png = {
+      width: checkInteger(data.width, "width"),
+      height: checkInteger(data.height, "height"),
+      channels,
+      data: data.data,
+      depth,
+      text: data.text,
+      palette: data.palette
+    };
+    this._colorType = colorType;
+    const expectedSize = depth < 8 ? Math.ceil(png.width * depth / 8) * png.height * channels : png.width * png.height * channels;
+    if (png.data.length !== expectedSize) {
+      throw new RangeError(`wrong data size. Found ${png.data.length}, expected ${expectedSize}`);
+    }
+    return png;
+  }
+}
+function checkInteger(value, name) {
+  if (Number.isInteger(value) && value > 0) {
+    return value;
+  }
+  throw new TypeError(`${name} must be a positive integer`);
+}
+function getColorType(data, palette) {
+  const { channels = 4, depth = 8 } = data;
+  if (channels !== 4 && channels !== 3 && channels !== 2 && channels !== 1) {
+    throw new RangeError(`unsupported number of channels: ${channels}`);
+  }
+  const returnValue = {
+    channels,
+    depth,
+    colorType: ColorType.UNKNOWN
+  };
+  switch (channels) {
+    case 4:
+      returnValue.colorType = ColorType.TRUECOLOUR_ALPHA;
+      break;
+    case 3:
+      returnValue.colorType = ColorType.TRUECOLOUR;
+      break;
+    case 1:
+      if (palette) {
+        returnValue.colorType = ColorType.INDEXED_COLOUR;
+      } else {
+        returnValue.colorType = ColorType.GREYSCALE;
+      }
+      break;
+    case 2:
+      returnValue.colorType = ColorType.GREYSCALE_ALPHA;
+      break;
+    default:
+      throw new Error("unsupported number of channels");
+  }
+  return returnValue;
+}
+function writeDataBytes(data, newData, slotsPerLine, offset) {
+  for (let j5 = 0;j5 < slotsPerLine; j5++) {
+    newData.writeByte(data[offset++]);
+  }
+  return offset;
+}
+function writeDataInterlaced(imageData, data, newData, offset) {
+  const passes = [
+    { x: 0, y: 0, xStep: 8, yStep: 8 },
+    { x: 4, y: 0, xStep: 8, yStep: 8 },
+    { x: 0, y: 4, xStep: 4, yStep: 8 },
+    { x: 2, y: 0, xStep: 4, yStep: 4 },
+    { x: 0, y: 2, xStep: 2, yStep: 4 },
+    { x: 1, y: 0, xStep: 2, yStep: 2 },
+    { x: 0, y: 1, xStep: 1, yStep: 2 }
+  ];
+  const { width, height, channels, depth } = imageData;
+  let pixelSize;
+  if (depth === 16) {
+    pixelSize = channels * depth / 8 / 2;
+  } else {
+    pixelSize = channels * depth / 8;
+  }
+  for (let passIndex = 0;passIndex < 7; passIndex++) {
+    const pass = passes[passIndex];
+    const passWidth = Math.floor((width - pass.x + pass.xStep - 1) / pass.xStep);
+    const passHeight = Math.floor((height - pass.y + pass.yStep - 1) / pass.yStep);
+    if (passWidth <= 0 || passHeight <= 0)
+      continue;
+    const passLineBytes = passWidth * pixelSize;
+    for (let y5 = 0;y5 < passHeight; y5++) {
+      const imageY = pass.y + y5 * pass.yStep;
+      const rawScanline = depth <= 8 ? new Uint8Array(passLineBytes) : new Uint16Array(passLineBytes);
+      let rawOffset = 0;
+      for (let x4 = 0;x4 < passWidth; x4++) {
+        const imageX = pass.x + x4 * pass.xStep;
+        if (imageX < width && imageY < height) {
+          const srcPos = (imageY * width + imageX) * pixelSize;
+          for (let i4 = 0;i4 < pixelSize; i4++) {
+            rawScanline[rawOffset++] = data[srcPos + i4];
+          }
+        }
+      }
+      newData.writeByte(0);
+      if (depth === 8) {
+        newData.writeBytes(rawScanline);
+      } else if (depth === 16) {
+        for (const value of rawScanline) {
+          newData.writeByte(value >> 8 & 255);
+          newData.writeByte(value & 255);
+        }
+      }
+    }
+  }
+  return offset;
+}
+function writeDataUint16(data, newData, slotsPerLine, offset) {
+  for (let j5 = 0;j5 < slotsPerLine; j5++) {
+    newData.writeUint16(data[offset++]);
+  }
+  return offset;
+}
+
+// node_modules/fast-png/lib/index.js
+function decodePng(data, options) {
+  const decoder = new PngDecoder(data, options);
+  return decoder.decode();
+}
+function encodePng(png, options) {
+  const encoder2 = new PngEncoder(png, options);
+  return encoder2.encode();
+}
+
+// node_modules/@tscircuit/image-utils/dist/looks-same.js
+var DEFAULT_TOLERANCE = 2.3;
+var DEFAULT_HIGHLIGHT = { R: 255, G: 0, B: 255 };
+var areColorsSame = ({
+  color1,
+  color2
+}) => {
+  return color1.R === color2.R && color1.G === color2.G && color1.B === color2.B;
+};
+var parsePng = (buffer) => {
+  try {
+    const png = decodePng(buffer);
+    if (png.depth !== 8)
+      return null;
+    const channels = png.channels;
+    const source = png.data;
+    const rgba = new Uint8Array(png.width * png.height * 4);
+    if (channels === 4) {
+      rgba.set(source);
+    } else if (channels === 3) {
+      for (let i4 = 0, j5 = 0;i4 < source.length; i4 += 3, j5 += 4) {
+        rgba[j5] = source[i4];
+        rgba[j5 + 1] = source[i4 + 1];
+        rgba[j5 + 2] = source[i4 + 2];
+        rgba[j5 + 3] = 255;
+      }
+    } else {
+      return null;
+    }
+    return {
+      width: png.width,
+      height: png.height,
+      data: rgba,
+      getPixel: (x4, y5) => {
+        const index = (y5 * png.width + x4) * 4;
+        return {
+          R: rgba[index],
+          G: rgba[index + 1],
+          B: rgba[index + 2]
+        };
+      }
+    };
+  } catch {
+    return null;
+  }
+};
+var getBuffer = async (input) => {
+  if (Buffer.isBuffer(input))
+    return input;
+  return readFile(input);
+};
+var parseHexColor = (color) => {
+  if (!color)
+    return DEFAULT_HIGHLIGHT;
+  const match = /^#?([0-9a-fA-F]{6})$/.exec(color.trim());
+  if (!match)
+    return DEFAULT_HIGHLIGHT;
+  const hex = match[1];
+  return {
+    R: Number.parseInt(hex.slice(0, 2), 16),
+    G: Number.parseInt(hex.slice(2, 4), 16),
+    B: Number.parseInt(hex.slice(4, 6), 16)
+  };
+};
+var makeCIEDE2000Comparator = (tolerance) => {
+  const upperBound2 = tolerance * 6.2;
+  const lowerBound = tolerance * 0.695;
+  let rgbColor1 = null;
+  let rgbColor2 = null;
+  let labColor1 = null;
+  let labColor2 = null;
+  return (data) => {
+    if (areColorsSame(data)) {
+      return true;
+    }
+    let lab1 = null;
+    let lab2 = null;
+    if (rgbColor1 && areColorsSame({ color1: data.color1, color2: rgbColor1 })) {
+      lab1 = labColor1;
+    } else if (rgbColor2 && areColorsSame({ color1: data.color1, color2: rgbColor2 })) {
+      lab1 = labColor2;
+    }
+    if (rgbColor1 && areColorsSame({ color1: data.color2, color2: rgbColor1 })) {
+      lab2 = labColor1;
+    } else if (rgbColor2 && areColorsSame({ color1: data.color2, color2: rgbColor2 })) {
+      lab2 = labColor2;
+    }
+    if (!lab1) {
+      lab1 = rgb_to_lab(data.color1);
+      rgbColor1 = data.color1;
+      labColor1 = lab1;
+    }
+    if (!lab2) {
+      lab2 = rgb_to_lab(data.color2);
+      rgbColor2 = data.color2;
+      labColor2 = lab2;
+    }
+    const cie76 = Math.sqrt((lab1.L - lab2.L) * (lab1.L - lab2.L) + (lab1.a - lab2.a) * (lab1.a - lab2.a) + (lab1.b - lab2.b) * (lab1.b - lab2.b));
+    if (cie76 >= upperBound2)
+      return false;
+    if (cie76 <= lowerBound)
+      return true;
+    return ciede2000(lab1, lab2) < tolerance;
+  };
+};
+var AntialiasingComparator = class {
+  _baseComparator;
+  _img1;
+  _img2;
+  _brightnessTolerance;
+  constructor(baseComparator, img1, img2, { antialiasingTolerance = 0 }) {
+    this._baseComparator = baseComparator;
+    this._img1 = img1;
+    this._img2 = img2;
+    this._brightnessTolerance = antialiasingTolerance;
+  }
+  compare(data) {
+    return this._baseComparator(data) || this._checkIsAntialiased(data);
+  }
+  _checkIsAntialiased(data) {
+    return this._isAntialiased(this._img2, data.x, data.y, data, this._img1) || this._isAntialiased(this._img1, data.x, data.y, data, this._img2);
+  }
+  _isAntialiased(img1, x13, y13, data, img2) {
+    const color1 = img1.getPixel(x13, y13);
+    const x03 = Math.max(x13 - 1, 0);
+    const y03 = Math.max(y13 - 1, 0);
+    const x25 = Math.min(x13 + 1, data.width - 1);
+    const y25 = Math.min(y13 + 1, data.height - 1);
+    const checkExtremePixels = !img2;
+    const brightnessTolerance = checkExtremePixels ? this._brightnessTolerance : 0;
+    let zeroes = 0;
+    let positives = 0;
+    let negatives = 0;
+    let min = 0;
+    let max2 = 0;
+    let minX = 0;
+    let minY = 0;
+    let maxX = 0;
+    let maxY = 0;
+    for (let y5 = y03;y5 <= y25; y5 += 1) {
+      for (let x4 = x03;x4 <= x25; x4 += 1) {
+        if (x4 === x13 && y5 === y13)
+          continue;
+        const delta = this._brightnessDelta(img1.getPixel(x4, y5), color1);
+        if (Math.abs(delta) <= brightnessTolerance) {
+          zeroes += 1;
+        } else if (delta > brightnessTolerance) {
+          positives += 1;
+        } else {
+          negatives += 1;
+        }
+        if (zeroes > 2)
+          return false;
+        if (checkExtremePixels)
+          continue;
+        if (delta < min) {
+          min = delta;
+          minX = x4;
+          minY = y5;
+        }
+        if (delta > max2) {
+          max2 = delta;
+          maxX = x4;
+          maxY = y5;
+        }
+      }
+    }
+    if (checkExtremePixels)
+      return true;
+    if (negatives === 0 || positives === 0)
+      return false;
+    return !this._isAntialiased(img1, minX, minY, data) && !this._isAntialiased(img2, minX, minY, data) || !this._isAntialiased(img1, maxX, maxY, data) && !this._isAntialiased(img2, maxX, maxY, data);
+  }
+  _brightnessDelta(color1, color2) {
+    return color1.R * 0.29889531 + color1.G * 0.58662247 + color1.B * 0.11448223 - (color2.R * 0.29889531 + color2.G * 0.58662247 + color2.B * 0.11448223);
+  }
+};
+var IgnoreCaretComparator = class {
+  pixelRatio;
+  caretTopLeft = null;
+  caretBottomRight = null;
+  _baseComparator;
+  _state = "init";
+  constructor(baseComparator, pixelRatio) {
+    this.pixelRatio = pixelRatio ? Math.floor(pixelRatio) : 1;
+    this._baseComparator = baseComparator;
+  }
+  compare(data) {
+    return this._baseComparator(data) || this._checkIsCaret(data);
+  }
+  _checkIsCaret(data) {
+    if (this._state === "caretDetected") {
+      return this.caretTopLeft !== null && this.caretBottomRight !== null && data.x >= this.caretTopLeft.x && data.x <= this.caretBottomRight.x && data.y >= this.caretTopLeft.y && data.y <= this.caretBottomRight.y;
+    }
+    if (this.caretTopLeft && this.caretBottomRight && data.x >= this.caretTopLeft.x && data.x <= this.caretBottomRight.x && data.y >= this.caretTopLeft.y && data.y <= this.caretBottomRight.y) {
+      return true;
+    }
+    const lastCaretPoint = this._getLastCaretPoint(data);
+    if (!this._looksLikeCaret({ x: data.x, y: data.y }, lastCaretPoint)) {
+      return false;
+    }
+    this.caretTopLeft = { x: data.x, y: data.y };
+    this.caretBottomRight = lastCaretPoint;
+    this._state = "caretDetected";
+    return true;
+  }
+  _getLastCaretPoint(data) {
+    let currPoint = { x: data.x, y: data.y };
+    while (true) {
+      const nextPoint = this._getNextCaretPoint({ x: data.x, y: data.y }, currPoint);
+      if (this._isPointOutsideImages(nextPoint, data) || this._areColorsSame(nextPoint, data)) {
+        return currPoint;
+      }
+      currPoint = nextPoint;
+    }
+  }
+  _isPointOutsideImages(point6, data) {
+    return point6.x >= data.minWidth || point6.y >= data.minHeight;
+  }
+  _areColorsSame(point6, data) {
+    const color1 = data.img1.getPixel(point6.x, point6.y);
+    const color2 = data.img2.getPixel(point6.x, point6.y);
+    return areColorsSame({ color1, color2 });
+  }
+  _getNextCaretPoint(firstCaretPoint, currPoint) {
+    const nextX = currPoint.x + 1;
+    return nextX < firstCaretPoint.x + this.pixelRatio ? { x: nextX, y: currPoint.y } : { x: firstCaretPoint.x, y: currPoint.y + 1 };
+  }
+  _looksLikeCaret(firstCaretPoint, lastCaretPoint) {
+    return this._caretHeight(firstCaretPoint, lastCaretPoint) > 1 && this._caretWidth(firstCaretPoint, lastCaretPoint) === this.pixelRatio;
+  }
+  _caretHeight(firstCaretPoint, lastCaretPoint) {
+    return lastCaretPoint.y - firstCaretPoint.y + 1;
+  }
+  _caretWidth(firstCaretPoint, lastCaretPoint) {
+    return lastCaretPoint.x - firstCaretPoint.x + 1;
+  }
+};
+var prepareOptions = (options = {}) => {
+  if (options.strict && options.tolerance !== undefined) {
+    throw new TypeError('Unable to use "strict" and "tolerance" options together');
+  }
+  if (options.percentThreshold !== undefined && (!Number.isFinite(options.percentThreshold) || options.percentThreshold < 0)) {
+    throw new TypeError('Expected "percentThreshold" to be a non-negative number');
+  }
+  return {
+    strict: Boolean(options.strict),
+    tolerance: options.tolerance ?? DEFAULT_TOLERANCE,
+    ignoreCaret: options.ignoreCaret ?? true,
+    ignoreAntialiasing: options.ignoreAntialiasing ?? true,
+    antialiasingTolerance: options.antialiasingTolerance ?? 0,
+    pixelRatio: options.pixelRatio
+  };
+};
+var createComparator = (img1, img2, options) => {
+  let comparator = options.strict ? (data) => areColorsSame(data) : makeCIEDE2000Comparator(options.tolerance);
+  if (options.ignoreAntialiasing) {
+    const antialiasingComparator = new AntialiasingComparator(comparator, img1, img2, options);
+    comparator = (data) => antialiasingComparator.compare(data);
+  }
+  if (options.ignoreCaret) {
+    const caretComparator = new IgnoreCaretComparator(comparator, options.pixelRatio);
+    comparator = (data) => caretComparator.compare(data);
+  }
+  return comparator;
+};
+var compare = async (buffer1, buffer2, options) => {
+  const reference = parsePng(buffer1);
+  const current3 = parsePng(buffer2);
+  if (!reference || !current3) {
+    return { equal: buffer1.equals(buffer2) };
+  }
+  const comparator = createComparator(reference, current3, options);
+  const width = Math.max(reference.width, current3.width);
+  const height = Math.max(reference.height, current3.height);
+  const minWidth = Math.min(reference.width, current3.width);
+  const minHeight = Math.min(reference.height, current3.height);
+  const totalPixels = width * height;
+  let differentPixels = 0;
+  for (let y5 = 0;y5 < height; y5 += 1) {
+    for (let x4 = 0;x4 < width; x4 += 1) {
+      if (x4 >= minWidth || y5 >= minHeight) {
+        differentPixels += 1;
+        continue;
+      }
+      const color1 = reference.getPixel(x4, y5);
+      const color2 = current3.getPixel(x4, y5);
+      const same = areColorsSame({ color1, color2 }) || comparator({
+        color1,
+        color2,
+        img1: reference,
+        img2: current3,
+        x: x4,
+        y: y5,
+        width,
+        height,
+        minWidth,
+        minHeight
+      });
+      if (!same) {
+        differentPixels += 1;
+      }
+    }
+  }
+  return {
+    equal: differentPixels === 0,
+    differentPixels,
+    totalPixels
+  };
+};
+var looksSameImpl = async (reference, current3, options = {}) => {
+  const prepared = prepareOptions(options);
+  const referenceBuffer = await getBuffer(reference);
+  const currentBuffer = await getBuffer(current3);
+  return compare(referenceBuffer, currentBuffer, prepared);
+};
+var createDiff = async ({
+  reference,
+  current: current3,
+  diff: diff2,
+  highlightColor,
+  ...options
+}) => {
+  const prepared = prepareOptions(options);
+  const referenceBuffer = await getBuffer(reference);
+  const currentBuffer = await getBuffer(current3);
+  const referencePng = parsePng(referenceBuffer);
+  const currentPng = parsePng(currentBuffer);
+  if (!(diff2.endsWith(".png") && referencePng && currentPng)) {
+    await writeFile(diff2, currentBuffer);
+    return;
+  }
+  const comparator = createComparator(referencePng, currentPng, prepared);
+  const width = Math.max(referencePng.width, currentPng.width);
+  const height = Math.max(referencePng.height, currentPng.height);
+  const minWidth = Math.min(referencePng.width, currentPng.width);
+  const minHeight = Math.min(referencePng.height, currentPng.height);
+  const highlight = parseHexColor(highlightColor);
+  const diffData = new Uint8Array(width * height * 4);
+  for (let y5 = 0;y5 < height; y5 += 1) {
+    for (let x4 = 0;x4 < width; x4 += 1) {
+      const index = (y5 * width + x4) * 4;
+      if (x4 >= minWidth || y5 >= minHeight) {
+        diffData[index] = highlight.R;
+        diffData[index + 1] = highlight.G;
+        diffData[index + 2] = highlight.B;
+        diffData[index + 3] = 255;
+        continue;
+      }
+      const color1 = referencePng.getPixel(x4, y5);
+      const color2 = currentPng.getPixel(x4, y5);
+      const same = areColorsSame({ color1, color2 }) || comparator({
+        color1,
+        color2,
+        img1: referencePng,
+        img2: currentPng,
+        x: x4,
+        y: y5,
+        width,
+        height,
+        minWidth,
+        minHeight
+      });
+      if (same) {
+        diffData[index] = color1.R;
+        diffData[index + 1] = color1.G;
+        diffData[index + 2] = color1.B;
+        diffData[index + 3] = 255;
+      } else {
+        diffData[index] = highlight.R;
+        diffData[index + 1] = highlight.G;
+        diffData[index + 2] = highlight.B;
+        diffData[index + 3] = 255;
+      }
+    }
+  }
+  const encoded = encodePng({
+    width,
+    height,
+    data: diffData,
+    channels: 4,
+    depth: 8
+  });
+  await writeFile(diff2, Buffer.from(encoded));
+};
+var looksSame = Object.assign(looksSameImpl, { createDiff });
+var looks_same_default = looksSame;
+
 // lib/shared/compare-images.ts
-import looksSame from "looks-same";
 import fs64 from "node:fs/promises";
-var compareAndCreateDiff = async (buffer1, buffer2, diffPath, createDiff = true) => {
-  const { equal: equal3 } = await looksSame(buffer1, buffer2, {
+var compareAndCreateDiff = async (buffer1, buffer2, diffPath, createDiff2 = true) => {
+  const { equal: equal3 } = await looks_same_default(buffer1, buffer2, {
     strict: false,
     tolerance: 2
   });
-  if (!equal3 && createDiff) {
+  if (!equal3 && createDiff2) {
     if (diffPath.endsWith(".png")) {
-      await looksSame.createDiff({
+      await looks_same_default.createDiff({
         reference: buffer1,
         current: buffer2,
         diff: diffPath,
@@ -375453,7 +378143,7 @@ var processSnapshotFile = async ({
   forceUpdate,
   platformConfig: platformConfig3,
   pcbSnapshotSettings,
-  createDiff,
+  createDiff: createDiff2,
   cameraPreset
 }) => {
   const relativeFilePath = path65.relative(projectDir, file);
@@ -375603,7 +378293,7 @@ var processSnapshotFile = async ({
     const oldContentBuffer = fs65.readFileSync(snapPath);
     let equal3;
     let diffPath;
-    if (createDiff) {
+    if (createDiff2) {
       diffPath = snapPath.replace(is3d ? ".snap.png" : ".snap.svg", is3d ? ".diff.png" : ".diff.svg");
       const comparison = await compareAndCreateDiff(oldContentBuffer, newContentBuffer, diffPath, true);
       equal3 = comparison.equal;
@@ -375651,7 +378341,7 @@ var snapshotProject = async ({
   onError = (msg) => console.error(msg),
   onSuccess = (msg) => console.log(msg),
   platformConfig: platformConfig3,
-  createDiff = false,
+  createDiff: createDiff2 = false,
   cameraPreset,
   concurrency = 1
 } = {}) => {
@@ -375722,7 +378412,7 @@ var snapshotProject = async ({
           forceUpdate,
           platformConfig: platformConfig3,
           pcbSnapshotSettings: projectConfig3?.pcbSnapshotSettings,
-          createDiff,
+          createDiff: createDiff2,
           cameraPreset
         },
         stopOnFailure: true,
@@ -375761,7 +378451,7 @@ var snapshotProject = async ({
         forceUpdate,
         platformConfig: platformConfig3,
         pcbSnapshotSettings: projectConfig3?.pcbSnapshotSettings,
-        createDiff,
+        createDiff: createDiff2,
         cameraPreset
       });
       processResult(result);
@@ -375908,13 +378598,13 @@ program2.command("version").description("Print CLI version").option("--verbose",
   console.log(getVersion({ verbose: options.verbose }));
 });
 if (process.argv.length === 2) {
-  import_perfect_cli.perfectCli(program2, process.argv).catch((err) => {
-    if (err instanceof Error && err.name === "TypeError") {
+  import_perfect_cli.perfectCli(program2, process.argv).catch((err2) => {
+    if (err2 instanceof Error && err2.name === "TypeError") {
       console.error(`
 Aborted.`);
       process.exit(130);
     }
-    throw err;
+    throw err2;
   });
 } else {
   program2.parse();