@tscircuit/cli 0.1.1142 → 0.1.1144

package/dist/cli/snapshot/snapshot.worker.js

@@ -13257,17 +13257,2708 @@ function getCompletePlatformConfig(userConfig) {
 // lib/shared/process-snapshot-file.ts
 import { renderGLTFToPNGBufferFromGLBBuffer } 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(c, bc) {
+  bc = normalize(bc || { R: 255, G: 255, B: 255 });
+  c = normalize(c);
+  let newC = c;
+  if (c.A !== undefined) {
+    newC = {
+      R: bc.R + (c.R - bc.R) * c.A,
+      G: bc.G + (c.G - bc.G) * c.A,
+      B: bc.B + (c.B - bc.B) * c.A
+    };
+  }
+  return xyzToLab(rgbToXyz(newC));
+}
+function rgbToXyz(c) {
+  let R = c.R / 255;
+  let G = c.G / 255;
+  let B = c.B / 255;
+  if (R > 0.04045)
+    R = Math.pow((R + 0.055) / 1.055, 2.4);
+  else
+    R = R / 12.92;
+  if (G > 0.04045)
+    G = Math.pow((G + 0.055) / 1.055, 2.4);
+  else
+    G = G / 12.92;
+  if (B > 0.04045)
+    B = Math.pow((B + 0.055) / 1.055, 2.4);
+  else
+    B = B / 12.92;
+  R *= 100;
+  G *= 100;
+  B *= 100;
+  const X = R * 0.4124 + G * 0.3576 + B * 0.1805;
+  const Y = R * 0.2126 + G * 0.7152 + B * 0.0722;
+  const Z = R * 0.0193 + G * 0.1192 + B * 0.9505;
+  return { X, Y, Z };
+}
+function xyzToLab(c) {
+  const refY = 100;
+  const refZ = 108.883;
+  const refX = 95.047;
+  let Y = c.Y / refY;
+  let Z = c.Z / refZ;
+  let X = c.X / refX;
+  if (X > 0.008856)
+    X = Math.pow(X, 1 / 3);
+  else
+    X = 7.787 * X + 16 / 116;
+  if (Y > 0.008856)
+    Y = Math.pow(Y, 1 / 3);
+  else
+    Y = 7.787 * Y + 16 / 116;
+  if (Z > 0.008856)
+    Z = Math.pow(Z, 1 / 3);
+  else
+    Z = 7.787 * Z + 16 / 116;
+  const L = 116 * Y - 16;
+  const a = 500 * (X - Y);
+  const b = 200 * (Y - Z);
+  return { L, a, b };
+}
+function normalize(c) {
+  let r, g, b, a;
+  if ("R" in c) {
+    r = c.R;
+    g = c.G;
+    b = c.B;
+    a = c.A;
+  } else {
+    r = c.r;
+    g = c.g;
+    b = c.b;
+    a = c.a;
+  }
+  const normalizedC = { R: r, G: g, B: b };
+  if (a !== undefined)
+    normalizedC.A = a;
+  return normalizedC;
+}
+
+// node_modules/color-diff/lib/diff.js
+function ciede2000(c1, c2, bc) {
+  if ("R" in c1 || "r" in c1) {
+    c1 = rgbaToLab(c1, bc);
+  }
+  if ("R" in c2 || "r" in c2) {
+    c2 = rgbaToLab(c2, bc);
+  }
+  const L1 = c1.L;
+  const a1 = c1.a;
+  const b1 = c1.b;
+  const L2 = c2.L;
+  const a2 = c2.a;
+  const b2 = c2.b;
+  const kL = 1;
+  const kC = 1;
+  const kH = 1;
+  const C1 = Math.sqrt(Math.pow(a1, 2) + Math.pow(b1, 2));
+  const C2 = Math.sqrt(Math.pow(a2, 2) + Math.pow(b2, 2));
+  const aC1C2 = (C1 + C2) / 2;
+  const G = 0.5 * (1 - Math.sqrt(Math.pow(aC1C2, 7) / (Math.pow(aC1C2, 7) + Math.pow(25, 7))));
+  const a1p = (1 + G) * a1;
+  const a2p = (1 + G) * a2;
+  const C1p = Math.sqrt(Math.pow(a1p, 2) + Math.pow(b1, 2));
+  const C2p = Math.sqrt(Math.pow(a2p, 2) + Math.pow(b2, 2));
+  const h1p = hpF(b1, a1p);
+  const h2p = hpF(b2, a2p);
+  const dLp = L2 - L1;
+  const dCp = C2p - C1p;
+  const dhp = dhpF(C1, C2, h1p, h2p);
+  const dHp = 2 * Math.sqrt(C1p * C2p) * Math.sin(radians(dhp) / 2);
+  const aL = (L1 + L2) / 2;
+  const aCp = (C1p + C2p) / 2;
+  const aHp = aHpF(C1, C2, h1p, h2p);
+  const T = 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 * T;
+  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(n) {
+  return n * (180 / Math.PI);
+}
+function radians(n) {
+  return n * (Math.PI / 180);
+}
+function hpF(x, y) {
+  if (x === 0 && y === 0)
+    return 0;
+  else {
+    const tmphp = degrees(Math.atan2(x, y));
+    if (tmphp >= 0)
+      return tmphp;
+    else
+      return tmphp + 360;
+  }
+}
+function dhpF(C1, C2, h1p, h2p) {
+  if (C1 * C2 === 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(C1, C2, h1p, h2p) {
+  if (C1 * C2 === 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(c) {
+  return rgbaToLab(c);
+}
+
+// node_modules/fflate/esm/index.mjs
+import { createRequire as createRequire3 } from "module";
+var require2 = createRequire3("/");
+var Worker;
+try {
+  Worker = require2("worker_threads").Worker;
+} catch (e) {}
+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 i = 0;i < 31; ++i) {
+    b[i] = start += 1 << eb[i - 1];
+  }
+  var r = new i32(b[30]);
+  for (var i = 1;i < 30; ++i) {
+    for (var j = b[i];j < b[i + 1]; ++j) {
+      r[j] = j - b[i] << 5 | i;
+    }
+  }
+  return { b, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0;i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = function(cd, mb, r) {
+  var s = cd.length;
+  var i2 = 0;
+  var l = new u16(mb);
+  for (;i2 < s; ++i2) {
+    if (cd[i2])
+      ++l[cd[i2] - 1];
+  }
+  var le = new u16(mb);
+  for (i2 = 1;i2 < mb; ++i2) {
+    le[i2] = le[i2 - 1] + l[i2 - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i2 = 0;i2 < s; ++i2) {
+      if (cd[i2]) {
+        var sv = i2 << 4 | cd[i2];
+        var r_1 = mb - cd[i2];
+        var v = le[cd[i2] - 1]++ << r_1;
+        for (var m = v | (1 << r_1) - 1;v <= m; ++v) {
+          co[rev[v] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i2 = 0;i2 < s; ++i2) {
+      if (cd[i2]) {
+        co[i2] = rev[le[cd[i2] - 1]++] >> 15 - cd[i2];
+      }
+    }
+  }
+  return co;
+};
+var flt = new u8(288);
+for (i = 0;i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144;i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256;i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280;i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0;i < 32; ++i)
+  fdt[i] = 5;
+var i;
+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(a) {
+  var m = a[0];
+  for (var i2 = 1;i2 < a.length; ++i2) {
+    if (a[i2] > m)
+      m = a[i2];
+  }
+  return m;
+};
+var bits = function(d, p, m) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  return new u8(v.subarray(s, e));
+};
+var ec = [
+  "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, nt) {
+  var e = new Error(msg || ec[ind]);
+  e.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e, err);
+  if (!nt)
+    throw e;
+  return e;
+};
+var inflt = function(dat, st, buf, dict) {
+  var sl = dat.length, dl = dict ? dict.length : 0;
+  if (!sl || st.f && !st.l)
+    return buf || new u8(0);
+  var noBuf = !buf;
+  var resize = noBuf || st.i != 2;
+  var noSt = st.i;
+  if (noBuf)
+    buf = new u8(sl * 3);
+  var cbuf = function(l2) {
+    var bl = buf.length;
+    if (l2 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l2));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  };
+  var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+  var tbts = sl * 8;
+  do {
+    if (!lm) {
+      final = bits(dat, pos, 1);
+      var type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+        if (t > sl) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + l);
+        buf.set(dat.subarray(s, t), bt);
+        st.b = bt += l, st.p = pos = t * 8, st.f = final;
+        continue;
+      } else if (type == 1)
+        lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        var tl = hLit + bits(dat, pos + 5, 31) + 1;
+        pos += 14;
+        var ldt = new u8(tl);
+        var clt = new u8(19);
+        for (var i2 = 0;i2 < hcLen; ++i2) {
+          clt[clim[i2]] = bits(dat, pos + i2 * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i2 = 0;i2 < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i2++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i2 - 1];
+            else if (s == 17)
+              n = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s == 18)
+              n = 11 + bits(dat, pos, 127), pos += 7;
+            while (n--)
+              ldt[i2++] = c;
+          }
+        }
+        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        lbt = max(lt);
+        dbt = max(dt);
+        lm = hMap(lt, lbt, 1);
+        dm = hMap(dt, dbt, 1);
+      } else
+        err(1);
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+    }
+    if (resize)
+      cbuf(bt + 131072);
+    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+    var lpos = pos;
+    for (;; lpos = pos) {
+      var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+      pos += c & 15;
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+      if (!c)
+        err(2);
+      if (sym < 256)
+        buf[bt++] = sym;
+      else if (sym == 256) {
+        lpos = pos, lm = null;
+        break;
+      } else {
+        var add = sym - 254;
+        if (sym > 264) {
+          var i2 = sym - 257, b = fleb[i2];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i2];
+          pos += b;
+        }
+        var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+        if (!d)
+          err(3);
+        pos += d & 15;
+        var dt = fd[dsym];
+        if (dsym > 3) {
+          var b = fdeb[dsym];
+          dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var end = bt + add;
+        if (bt < dt) {
+          var shift = dl - dt, dend = Math.min(dt, end);
+          if (shift + bt < 0)
+            err(3);
+          for (;bt < dend; ++bt)
+            buf[bt] = dict[shift + bt];
+        }
+        for (;bt < end; ++bt)
+          buf[bt] = buf[bt - dt];
+      }
+    }
+    st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+    if (lm)
+      final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+  } while (!final);
+  return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var wbits = function(d, p, v) {
+  v <<= p & 7;
+  var o = p / 8 | 0;
+  d[o] |= v;
+  d[o + 1] |= v >> 8;
+};
+var wbits16 = function(d, p, v) {
+  v <<= p & 7;
+  var o = p / 8 | 0;
+  d[o] |= v;
+  d[o + 1] |= v >> 8;
+  d[o + 2] |= v >> 16;
+};
+var hTree = function(d, mb) {
+  var t = [];
+  for (var i2 = 0;i2 < d.length; ++i2) {
+    if (d[i2])
+      t.push({ s: i2, f: d[i2] });
+  }
+  var s = t.length;
+  var t2 = t.slice();
+  if (!s)
+    return { t: et, l: 0 };
+  if (s == 1) {
+    var v = new u8(t[0].s + 1);
+    v[t[0].s] = 1;
+    return { t: v, l: 1 };
+  }
+  t.sort(function(a, b) {
+    return a.f - b.f;
+  });
+  t.push({ s: -1, f: 25001 });
+  var l = t[0], r = t[1], i0 = 0, i1 = 1, i22 = 2;
+  t[0] = { s: -1, f: l.f + r.f, l, r };
+  while (i1 != s - 1) {
+    l = t[t[i0].f < t[i22].f ? i0++ : i22++];
+    r = t[i0 != i1 && t[i0].f < t[i22].f ? i0++ : i22++];
+    t[i1++] = { s: -1, f: l.f + r.f, l, r };
+  }
+  var maxSym = t2[0].s;
+  for (var i2 = 1;i2 < s; ++i2) {
+    if (t2[i2].s > maxSym)
+      maxSym = t2[i2].s;
+  }
+  var tr = new u16(maxSym + 1);
+  var mbt = ln(t[i1 - 1], tr, 0);
+  if (mbt > mb) {
+    var i2 = 0, dt = 0;
+    var lft = mbt - mb, cst = 1 << lft;
+    t2.sort(function(a, b) {
+      return tr[b.s] - tr[a.s] || a.f - b.f;
+    });
+    for (;i2 < s; ++i2) {
+      var i2_1 = t2[i2].s;
+      if (tr[i2_1] > mb) {
+        dt += cst - (1 << mbt - tr[i2_1]);
+        tr[i2_1] = mb;
+      } else
+        break;
+    }
+    dt >>= lft;
+    while (dt > 0) {
+      var i2_2 = t2[i2].s;
+      if (tr[i2_2] < mb)
+        dt -= 1 << mb - tr[i2_2]++ - 1;
+      else
+        ++i2;
+    }
+    for (;i2 >= 0 && dt; --i2) {
+      var i2_3 = t2[i2].s;
+      if (tr[i2_3] == mb) {
+        --tr[i2_3];
+        ++dt;
+      }
+    }
+    mbt = mb;
+  }
+  return { t: new u8(tr), l: mbt };
+};
+var ln = function(n, l, d) {
+  return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : l[n.s] = d;
+};
+var lc = function(c) {
+  var s = c.length;
+  while (s && !c[--s])
+    ;
+  var cl = new u16(++s);
+  var cli = 0, cln = c[0], cls = 1;
+  var w = function(v) {
+    cl[cli++] = v;
+  };
+  for (var i2 = 1;i2 <= s; ++i2) {
+    if (c[i2] == cln && i2 != s)
+      ++cls;
+    else {
+      if (!cln && cls > 2) {
+        for (;cls > 138; cls -= 138)
+          w(32754);
+        if (cls > 2) {
+          w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
+          cls = 0;
+        }
+      } else if (cls > 3) {
+        w(cln), --cls;
+        for (;cls > 6; cls -= 6)
+          w(8304);
+        if (cls > 2)
+          w(cls - 3 << 5 | 8208), cls = 0;
+      }
+      while (cls--)
+        w(cln);
+      cls = 1;
+      cln = c[i2];
+    }
+  }
+  return { c: cl.subarray(0, cli), n: s };
+};
+var clen = function(cf, cl) {
+  var l = 0;
+  for (var i2 = 0;i2 < cl.length; ++i2)
+    l += cf[i2] * cl[i2];
+  return l;
+};
+var wfblk = function(out, pos, dat) {
+  var s = dat.length;
+  var o = shft(pos + 2);
+  out[o] = s & 255;
+  out[o + 1] = s >> 8;
+  out[o + 2] = out[o] ^ 255;
+  out[o + 3] = out[o + 1] ^ 255;
+  for (var i2 = 0;i2 < s; ++i2)
+    out[o + i2 + 4] = dat[i2];
+  return (o + 4 + s) * 8;
+};
+var wblk = function(dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
+  wbits(out, p++, final);
+  ++lf[256];
+  var _a2 = hTree(lf, 15), dlt = _a2.t, mlb = _a2.l;
+  var _b2 = hTree(df, 15), ddt = _b2.t, mdb = _b2.l;
+  var _c = lc(dlt), lclt = _c.c, nlc = _c.n;
+  var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
+  var lcfreq = new u16(19);
+  for (var i2 = 0;i2 < lclt.length; ++i2)
+    ++lcfreq[lclt[i2] & 31];
+  for (var i2 = 0;i2 < lcdt.length; ++i2)
+    ++lcfreq[lcdt[i2] & 31];
+  var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
+  var nlcc = 19;
+  for (;nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
+    ;
+  var flen = bl + 5 << 3;
+  var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
+  var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
+  if (bs >= 0 && flen <= ftlen && flen <= dtlen)
+    return wfblk(out, p, dat.subarray(bs, bs + bl));
+  var lm, ll, dm, dl;
+  wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
+  if (dtlen < ftlen) {
+    lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
+    var llm = hMap(lct, mlcb, 0);
+    wbits(out, p, nlc - 257);
+    wbits(out, p + 5, ndc - 1);
+    wbits(out, p + 10, nlcc - 4);
+    p += 14;
+    for (var i2 = 0;i2 < nlcc; ++i2)
+      wbits(out, p + 3 * i2, lct[clim[i2]]);
+    p += 3 * nlcc;
+    var lcts = [lclt, lcdt];
+    for (var it = 0;it < 2; ++it) {
+      var clct = lcts[it];
+      for (var i2 = 0;i2 < clct.length; ++i2) {
+        var len = clct[i2] & 31;
+        wbits(out, p, llm[len]), p += lct[len];
+        if (len > 15)
+          wbits(out, p, clct[i2] >> 5 & 127), p += clct[i2] >> 12;
+      }
+    }
+  } else {
+    lm = flm, ll = flt, dm = fdm, dl = fdt;
+  }
+  for (var i2 = 0;i2 < li; ++i2) {
+    var sym = syms[i2];
+    if (sym > 255) {
+      var len = sym >> 18 & 31;
+      wbits16(out, p, lm[len + 257]), p += ll[len + 257];
+      if (len > 7)
+        wbits(out, p, sym >> 23 & 31), p += fleb[len];
+      var dst = sym & 31;
+      wbits16(out, p, dm[dst]), p += dl[dst];
+      if (dst > 3)
+        wbits16(out, p, sym >> 5 & 8191), p += fdeb[dst];
+    } else {
+      wbits16(out, p, lm[sym]), p += ll[sym];
+    }
+  }
+  wbits16(out, p, lm[256]);
+  return p + ll[256];
+};
+var deo = /* @__PURE__ */ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
+var et = /* @__PURE__ */ new u8(0);
+var dflt = function(dat, lvl, plvl, pre, post, st) {
+  var s = st.z || dat.length;
+  var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post);
+  var w = o.subarray(pre, o.length - post);
+  var lst = st.l;
+  var pos = (st.r || 0) & 7;
+  if (lvl) {
+    if (pos)
+      w[0] = st.r >> 3;
+    var opt = deo[lvl - 1];
+    var n = opt >> 13, c = opt & 8191;
+    var msk_1 = (1 << plvl) - 1;
+    var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
+    var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
+    var hsh = function(i3) {
+      return (dat[i3] ^ dat[i3 + 1] << bs1_1 ^ dat[i3 + 2] << bs2_1) & msk_1;
+    };
+    var syms = new i32(25000);
+    var lf = new u16(288), df = new u16(32);
+    var lc_1 = 0, eb = 0, i2 = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
+    for (;i2 + 2 < s; ++i2) {
+      var hv = hsh(i2);
+      var imod = i2 & 32767, pimod = head[hv];
+      prev[imod] = pimod;
+      head[hv] = imod;
+      if (wi <= i2) {
+        var rem = s - i2;
+        if ((lc_1 > 7000 || li > 24576) && (rem > 423 || !lst)) {
+          pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i2 - bs, pos);
+          li = lc_1 = eb = 0, bs = i2;
+          for (var j = 0;j < 286; ++j)
+            lf[j] = 0;
+          for (var j = 0;j < 30; ++j)
+            df[j] = 0;
+        }
+        var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
+        if (rem > 2 && hv == hsh(i2 - dif)) {
+          var maxn = Math.min(n, rem) - 1;
+          var maxd = Math.min(32767, i2);
+          var ml = Math.min(258, rem);
+          while (dif <= maxd && --ch_1 && imod != pimod) {
+            if (dat[i2 + l] == dat[i2 + l - dif]) {
+              var nl = 0;
+              for (;nl < ml && dat[i2 + nl] == dat[i2 + nl - dif]; ++nl)
+                ;
+              if (nl > l) {
+                l = nl, d = dif;
+                if (nl > maxn)
+                  break;
+                var mmd = Math.min(dif, nl - 2);
+                var md = 0;
+                for (var j = 0;j < mmd; ++j) {
+                  var ti = i2 - dif + j & 32767;
+                  var pti = prev[ti];
+                  var cd = ti - pti & 32767;
+                  if (cd > md)
+                    md = cd, pimod = ti;
+                }
+              }
+            }
+            imod = pimod, pimod = prev[imod];
+            dif += imod - pimod & 32767;
+          }
+        }
+        if (d) {
+          syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
+          var lin = revfl[l] & 31, din = revfd[d] & 31;
+          eb += fleb[lin] + fdeb[din];
+          ++lf[257 + lin];
+          ++df[din];
+          wi = i2 + l;
+          ++lc_1;
+        } else {
+          syms[li++] = dat[i2];
+          ++lf[dat[i2]];
+        }
+      }
+    }
+    for (i2 = Math.max(i2, wi);i2 < s; ++i2) {
+      syms[li++] = dat[i2];
+      ++lf[dat[i2]];
+    }
+    pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i2 - bs, pos);
+    if (!lst) {
+      st.r = pos & 7 | w[pos / 8 | 0] << 3;
+      pos -= 7;
+      st.h = head, st.p = prev, st.i = i2, st.w = wi;
+    }
+  } else {
+    for (var i2 = st.w || 0;i2 < s + lst; i2 += 65535) {
+      var e = i2 + 65535;
+      if (e >= s) {
+        w[pos / 8 | 0] = lst;
+        e = s;
+      }
+      pos = wfblk(w, pos + 1, dat.subarray(i2, e));
+    }
+    st.i = s;
+  }
+  return slc(o, 0, pre + shft(pos) + post);
+};
+var adler = function() {
+  var a = 1, b = 0;
+  return {
+    p: function(d) {
+      var n = a, m = b;
+      var l = d.length | 0;
+      for (var i2 = 0;i2 != l; ) {
+        var e = Math.min(i2 + 2655, l);
+        for (;i2 < e; ++i2)
+          m += n += d[i2];
+        n = (n & 65535) + 15 * (n >> 16), m = (m & 65535) + 15 * (m >> 16);
+      }
+      a = n, b = m;
+    },
+    d: function() {
+      a %= 65521, b %= 65521;
+      return (a & 255) << 24 | (a & 65280) << 8 | (b & 255) << 8 | b >> 8;
+    }
+  };
+};
+var dopt = function(dat, opt, pre, post, st) {
+  if (!st) {
+    st = { 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;
+      st.w = dict.length;
+    }
+  }
+  return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st);
+};
+var wbytes = function(d, b, v) {
+  for (;v; ++b)
+    d[b] = v, v >>>= 8;
+};
+var zlh = function(c, o) {
+  var lv = o.level, fl2 = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2;
+  c[0] = 120, c[1] = fl2 << 6 | (o.dictionary && 32);
+  c[1] |= 31 - (c[0] << 8 | c[1]) % 31;
+  if (o.dictionary) {
+    var h = adler();
+    h.p(o.dictionary);
+    wbytes(c, 2, h.d());
+  }
+};
+var zls = function(d, dict) {
+  if ((d[0] & 15) != 8 || d[0] >> 4 > 7 || (d[0] << 8 | d[1]) % 31)
+    err(6, "invalid zlib data");
+  if ((d[1] >> 5 & 1) == +!dict)
+    err(6, "invalid zlib data: " + (d[1] & 32 ? "need" : "unexpected") + " dictionary");
+  return (d[1] >> 3 & 4) + 2;
+};
+var Inflate = /* @__PURE__ */ function() {
+  function Inflate2(opts, cb) {
+    if (typeof opts == "function")
+      cb = opts, opts = {};
+    this.ondata = cb;
+    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(c) {
+    if (!this.ondata)
+      err(5);
+    if (this.d)
+      err(4);
+    if (!this.p.length)
+      this.p = c;
+    else if (c.length) {
+      var n = new u8(this.p.length + c.length);
+      n.set(this.p), n.set(c, this.p.length), this.p = n;
+    }
+  };
+  Inflate2.prototype.c = function(final) {
+    this.s.i = +(this.d = final || false);
+    var bts = this.s.b;
+    var dt = inflt(this.p, this.s, this.o);
+    this.ondata(slc(dt, bts, this.s.b), this.d);
+    this.o = slc(dt, 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 a = adler();
+  a.p(data);
+  var d = dopt(data, opts, opts.dictionary ? 6 : 2, 4);
+  return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d;
+}
+var Unzlib = /* @__PURE__ */ function() {
+  function Unzlib2(opts, cb) {
+    Inflate.call(this, opts, cb);
+    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 td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder;
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {}
+
+// 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(n = 1) {
+    this.offset += n;
+    return this;
+  }
+  back(n = 1) {
+    this.offset -= n;
+    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(n = 1) {
+    return this.readArray(n, "uint8");
+  }
+  readArray(size, type) {
+    const bytes = typedArrays[type].BYTES_PER_ELEMENT * size;
+    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(n = 1) {
+    let result = "";
+    for (let i2 = 0;i2 < n; i2++) {
+      result += this.readChar();
+    }
+    return result;
+  }
+  readUtf8(n = 1) {
+    return decode(this.readBytes(n));
+  }
+  decodeText(n = 1, encoding = "utf8") {
+    return decode(this.readBytes(n), 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 i2 = 0;i2 < bytes.length; i2++) {
+      this._data.setUint8(this.offset++, bytes[i2]);
+    }
+    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 i2 = 0;i2 < str.length; i2++) {
+      this.writeUint8(str.charCodeAt(i2));
+    }
+    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 n = 0;n < 256; n++) {
+  let c = n;
+  for (let k = 0;k < 8; k++) {
+    if (c & 1) {
+      c = 3988292384 ^ c >>> 1;
+    } else {
+      c = c >>> 1;
+    }
+  }
+  crcTable[n] = c;
+}
+var initialCrc = 4294967295;
+function updateCrc(currentCrc, data, length) {
+  let c = currentCrc;
+  for (let n = 0;n < length; n++) {
+    c = crcTable[(c ^ data[n]) & 255] ^ c >>> 8;
+  }
+  return c;
+}
+function crc(data, length) {
+  return (updateCrc(initialCrc, data, length) ^ 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, length) {
+  buffer.writeUint32(crc(new Uint8Array(buffer.buffer, buffer.byteOffset + buffer.offset - length, length), length));
+}
+
+// node_modules/fast-png/lib/helpers/unfilter.js
+function unfilterNone(currentLine, newLine, bytesPerLine) {
+  for (let i2 = 0;i2 < bytesPerLine; i2++) {
+    newLine[i2] = currentLine[i2];
+  }
+}
+function unfilterSub(currentLine, newLine, bytesPerLine, bytesPerPixel) {
+  let i2 = 0;
+  for (;i2 < bytesPerPixel; i2++) {
+    newLine[i2] = currentLine[i2];
+  }
+  for (;i2 < bytesPerLine; i2++) {
+    newLine[i2] = currentLine[i2] + newLine[i2 - bytesPerPixel] & 255;
+  }
+}
+function unfilterUp(currentLine, newLine, prevLine, bytesPerLine) {
+  let i2 = 0;
+  if (prevLine.length === 0) {
+    for (;i2 < bytesPerLine; i2++) {
+      newLine[i2] = currentLine[i2];
+    }
+  } else {
+    for (;i2 < bytesPerLine; i2++) {
+      newLine[i2] = currentLine[i2] + prevLine[i2] & 255;
+    }
+  }
+}
+function unfilterAverage(currentLine, newLine, prevLine, bytesPerLine, bytesPerPixel) {
+  let i2 = 0;
+  if (prevLine.length === 0) {
+    for (;i2 < bytesPerPixel; i2++) {
+      newLine[i2] = currentLine[i2];
+    }
+    for (;i2 < bytesPerLine; i2++) {
+      newLine[i2] = currentLine[i2] + (newLine[i2 - bytesPerPixel] >> 1) & 255;
+    }
+  } else {
+    for (;i2 < bytesPerPixel; i2++) {
+      newLine[i2] = currentLine[i2] + (prevLine[i2] >> 1) & 255;
+    }
+    for (;i2 < bytesPerLine; i2++) {
+      newLine[i2] = currentLine[i2] + (newLine[i2 - bytesPerPixel] + prevLine[i2] >> 1) & 255;
+    }
+  }
+}
+function unfilterPaeth(currentLine, newLine, prevLine, bytesPerLine, bytesPerPixel) {
+  let i2 = 0;
+  if (prevLine.length === 0) {
+    for (;i2 < bytesPerPixel; i2++) {
+      newLine[i2] = currentLine[i2];
+    }
+    for (;i2 < bytesPerLine; i2++) {
+      newLine[i2] = currentLine[i2] + newLine[i2 - bytesPerPixel] & 255;
+    }
+  } else {
+    for (;i2 < bytesPerPixel; i2++) {
+      newLine[i2] = currentLine[i2] + prevLine[i2] & 255;
+    }
+    for (;i2 < bytesPerLine; i2++) {
+      newLine[i2] = currentLine[i2] + paethPredictor(newLine[i2 - bytesPerPixel], prevLine[i2], prevLine[i2 - bytesPerPixel]) & 255;
+    }
+  }
+}
+function paethPredictor(a, b, c) {
+  const p = a + b - c;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc = Math.abs(p - c);
+  if (pa <= pb && pa <= pc)
+    return a;
+  else if (pb <= pc)
+    return b;
+  else
+    return c;
+}
+
+// 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(params) {
+  const { data, width, height, channels, depth } = params;
+  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 y = 0;y < passHeight; y++) {
+      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 x2 = 0;x2 < passWidth; x2++) {
+        const outputX = pass.x + x2 * pass.xStep;
+        const outputY = pass.y + y * pass.yStep;
+        if (outputX >= width || outputY >= height)
+          continue;
+        for (let i2 = 0;i2 < bytesPerPixel; i2++) {
+          resultData[(outputY * width + outputX) * bytesPerPixel + i2] = newLine[x2 * bytesPerPixel + i2];
+        }
+      }
+    }
+  }
+  if (depth === 16) {
+    const uint16Data = new Uint16Array(resultData.buffer);
+    if (osIsLittleEndian) {
+      for (let k = 0;k < uint16Data.length; k++) {
+        uint16Data[k] = swap16(uint16Data[k]);
+      }
+    }
+    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(params) {
+  const { data, width, height, channels, depth } = params;
+  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 i2 = 0;i2 < height; i2++) {
+    currentLine = data.subarray(offset + 1, offset + 1 + bytesPerLine);
+    newLine = newData.subarray(i2 * bytesPerLine, (i2 + 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 k = 0;k < uint16Data.length; k++) {
+        uint16Data[k] = swap162(uint16Data[k]);
+      }
+    }
+    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 i2 = 0;i2 < pngSignature.length; i2++) {
+    if (array[i2] !== pngSignature[i2]) {
+      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, length) {
+  const keyword = readKeyword(buffer);
+  text[keyword] = readLatin1(buffer, length - keyword.length - 1);
+}
+function encodetEXt(buffer, keyword, text) {
+  validateKeyword(keyword);
+  validateLatin1(text);
+  const length = keyword.length + 1 + text.length;
+  buffer.writeUint32(length);
+  buffer.writeChars(textChunkName);
+  buffer.writeChars(keyword);
+  buffer.writeByte(NULL);
+  buffer.writeChars(text);
+  writeCrc(buffer, length + 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, length) {
+  return latin1Decoder.decode(buffer.readBytes(length));
+}
+
+// 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, c) => sum + c.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 length = this.readUint32();
+      const type = this.readChars(4);
+      this.decodeChunk(length, type);
+    }
+    this._inflator.push(new Uint8Array(0), true);
+    this.decodeImage();
+    return this._png;
+  }
+  decodeApng() {
+    checkSignature(this);
+    while (!this._end) {
+      const length = this.readUint32();
+      const type = this.readChars(4);
+      this.decodeApngChunk(length, type);
+    }
+    this.decodeApngImage();
+    return this._apng;
+  }
+  decodeChunk(length, type) {
+    const offset = this.offset;
+    switch (type) {
+      case "IHDR":
+        this.decodeIHDR();
+        break;
+      case "PLTE":
+        this.decodePLTE(length);
+        break;
+      case "IDAT":
+        this.decodeIDAT(length);
+        break;
+      case "IEND":
+        this._end = true;
+        break;
+      case "tRNS":
+        this.decodetRNS(length);
+        break;
+      case "iCCP":
+        this.decodeiCCP(length);
+        break;
+      case textChunkName:
+        decodetEXt(this._png.text, this, length);
+        break;
+      case "pHYs":
+        this.decodepHYs();
+        break;
+      default:
+        this.skip(length);
+        break;
+    }
+    if (this.offset - offset !== length) {
+      throw new Error(`Length mismatch while decoding chunk ${type}`);
+    }
+    if (this._checkCrc) {
+      checkCrc(this, length + 4, type);
+    } else {
+      this.skip(4);
+    }
+  }
+  decodeApngChunk(length, 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(length);
+        break;
+      default:
+        this.decodeChunk(length, type);
+        this.offset = offset + length;
+        break;
+    }
+    if (this.offset - offset !== length) {
+      throw new Error(`Length mismatch while decoding chunk ${type}`);
+    }
+    if (this._checkCrc) {
+      checkCrc(this, length + 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(length) {
+    if (length % 3 !== 0) {
+      throw new RangeError(`PLTE field length must be a multiple of 3. Got ${length}`);
+    }
+    const l = length / 3;
+    this._hasPalette = true;
+    const palette = [];
+    this._palette = palette;
+    for (let i2 = 0;i2 < l; i2++) {
+      palette.push([this.readUint8(), this.readUint8(), this.readUint8()]);
+    }
+  }
+  decodeIDAT(length) {
+    this._writingDataChunks = true;
+    const dataLength = length;
+    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(length);
+  }
+  decodeFDAT(length) {
+    this._writingDataChunks = true;
+    let dataLength = length;
+    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(length);
+  }
+  decodetRNS(length) {
+    switch (this._colorType) {
+      case ColorType.GREYSCALE:
+      case ColorType.TRUECOLOUR: {
+        if (length % 2 !== 0) {
+          throw new RangeError(`tRNS chunk length must be a multiple of 2. Got ${length}`);
+        }
+        if (length / 2 > this._png.width * this._png.height) {
+          throw new Error(`tRNS chunk contains more alpha values than there are pixels (${length / 2} vs ${this._png.width * this._png.height})`);
+        }
+        this._hasTransparency = true;
+        this._transparency = new Uint16Array(length / 2);
+        for (let i2 = 0;i2 < length / 2; i2++) {
+          this._transparency[i2] = this.readUint16();
+        }
+        break;
+      }
+      case ColorType.INDEXED_COLOUR: {
+        if (length > this._palette.length) {
+          throw new Error(`tRNS chunk contains more alpha values than there are palette colors (${length} vs ${this._palette.length})`);
+        }
+        let i2 = 0;
+        for (;i2 < length; i2++) {
+          const alpha = this.readByte();
+          this._palette[i2].push(alpha);
+        }
+        for (;i2 < this._palette.length; i2++) {
+          this._palette[i2].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(length) {
+    const name = readKeyword(this);
+    const compressionMethod = this.readUint8();
+    if (compressionMethod !== CompressionMethod.DEFLATE) {
+      throw new Error(`Unsupported iCCP compression method: ${compressionMethod}`);
+    }
+    const compressedProfile = this.readBytes(length - 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 i2 = 0;i2 < this._numberOfFrames; i2++) {
+      const newFrame = {
+        sequenceNumber: this._frames[i2].sequenceNumber,
+        delayNumber: this._frames[i2].delayNumber,
+        delayDenominator: this._frames[i2].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(i2);
+      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 (i2 === 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(i2 - 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, c) => sum + c.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 el of alpha) {
+      this.writeByte(el.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 i2 = 0;i2 < height; i2++) {
+        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 j = 0;j < slotsPerLine; j++) {
+    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 y = 0;y < passHeight; y++) {
+      const imageY = pass.y + y * pass.yStep;
+      const rawScanline = depth <= 8 ? new Uint8Array(passLineBytes) : new Uint16Array(passLineBytes);
+      let rawOffset = 0;
+      for (let x2 = 0;x2 < passWidth; x2++) {
+        const imageX = pass.x + x2 * pass.xStep;
+        if (imageX < width && imageY < height) {
+          const srcPos = (imageY * width + imageX) * pixelSize;
+          for (let i2 = 0;i2 < pixelSize; i2++) {
+            rawScanline[rawOffset++] = data[srcPos + i2];
+          }
+        }
+      }
+      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 j = 0;j < slotsPerLine; j++) {
+    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 i2 = 0, j = 0;i2 < source.length; i2 += 3, j += 4) {
+        rgba[j] = source[i2];
+        rgba[j + 1] = source[i2 + 1];
+        rgba[j + 2] = source[i2 + 2];
+        rgba[j + 3] = 255;
+      }
+    } else {
+      return null;
+    }
+    return {
+      width: png.width,
+      height: png.height,
+      data: rgba,
+      getPixel: (x2, y) => {
+        const index = (y * png.width + x2) * 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 upperBound = 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 >= upperBound)
+      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, x1, y1, data, img2) {
+    const color1 = img1.getPixel(x1, y1);
+    const x0 = Math.max(x1 - 1, 0);
+    const y0 = Math.max(y1 - 1, 0);
+    const x2 = Math.min(x1 + 1, data.width - 1);
+    const y2 = Math.min(y1 + 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 y = y0;y <= y2; y += 1) {
+      for (let x3 = x0;x3 <= x2; x3 += 1) {
+        if (x3 === x1 && y === y1)
+          continue;
+        const delta = this._brightnessDelta(img1.getPixel(x3, y), 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 = x3;
+          minY = y;
+        }
+        if (delta > max2) {
+          max2 = delta;
+          maxX = x3;
+          maxY = y;
+        }
+      }
+    }
+    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(point, data) {
+    return point.x >= data.minWidth || point.y >= data.minHeight;
+  }
+  _areColorsSame(point, data) {
+    const color1 = data.img1.getPixel(point.x, point.y);
+    const color2 = data.img2.getPixel(point.x, point.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 current = parsePng(buffer2);
+  if (!reference || !current) {
+    return { equal: buffer1.equals(buffer2) };
+  }
+  const comparator = createComparator(reference, current, options);
+  const width = Math.max(reference.width, current.width);
+  const height = Math.max(reference.height, current.height);
+  const minWidth = Math.min(reference.width, current.width);
+  const minHeight = Math.min(reference.height, current.height);
+  const totalPixels = width * height;
+  let differentPixels = 0;
+  for (let y = 0;y < height; y += 1) {
+    for (let x2 = 0;x2 < width; x2 += 1) {
+      if (x2 >= minWidth || y >= minHeight) {
+        differentPixels += 1;
+        continue;
+      }
+      const color1 = reference.getPixel(x2, y);
+      const color2 = current.getPixel(x2, y);
+      const same = areColorsSame({ color1, color2 }) || comparator({
+        color1,
+        color2,
+        img1: reference,
+        img2: current,
+        x: x2,
+        y,
+        width,
+        height,
+        minWidth,
+        minHeight
+      });
+      if (!same) {
+        differentPixels += 1;
+      }
+    }
+  }
+  return {
+    equal: differentPixels === 0,
+    differentPixels,
+    totalPixels
+  };
+};
+var looksSameImpl = async (reference, current, options = {}) => {
+  const prepared = prepareOptions(options);
+  const referenceBuffer = await getBuffer(reference);
+  const currentBuffer = await getBuffer(current);
+  return compare(referenceBuffer, currentBuffer, prepared);
+};
+var createDiff = async ({
+  reference,
+  current,
+  diff: diff2,
+  highlightColor,
+  ...options
+}) => {
+  const prepared = prepareOptions(options);
+  const referenceBuffer = await getBuffer(reference);
+  const currentBuffer = await getBuffer(current);
+  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 y = 0;y < height; y += 1) {
+    for (let x2 = 0;x2 < width; x2 += 1) {
+      const index = (y * width + x2) * 4;
+      if (x2 >= minWidth || y >= minHeight) {
+        diffData[index] = highlight.R;
+        diffData[index + 1] = highlight.G;
+        diffData[index + 2] = highlight.B;
+        diffData[index + 3] = 255;
+        continue;
+      }
+      const color1 = referencePng.getPixel(x2, y);
+      const color2 = currentPng.getPixel(x2, y);
+      const same = areColorsSame({ color1, color2 }) || comparator({
+        color1,
+        color2,
+        img1: referencePng,
+        img2: currentPng,
+        x: x2,
+        y,
+        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 fs8 from "node:fs/promises";
-var compareAndCreateDiff = async (buffer1, buffer2, diffPath, createDiff = true) => {
-  const { equal } = await looksSame(buffer1, buffer2, {
+var compareAndCreateDiff = async (buffer1, buffer2, diffPath, createDiff2 = true) => {
+  const { equal } = await looks_same_default(buffer1, buffer2, {
     strict: false,
     tolerance: 2
   });
-  if (!equal && createDiff) {
+  if (!equal && createDiff2) {
     if (diffPath.endsWith(".png")) {
-      await looksSame.createDiff({
+      await looks_same_default.createDiff({
         reference: buffer1,
         current: buffer2,
         diff: diffPath,
@@ -13299,7 +15990,7 @@ var processSnapshotFile = async ({
   forceUpdate,
   platformConfig,
   pcbSnapshotSettings,
-  createDiff,
+  createDiff: createDiff2,
   cameraPreset
 }) => {
   const relativeFilePath = path10.relative(projectDir, file);
@@ -13449,7 +16140,7 @@ var processSnapshotFile = async ({
     const oldContentBuffer = fs9.readFileSync(snapPath);
     let equal;
     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);
       equal = comparison.equal;