@pixerate/editor 0.115.0 → 0.117.0

package/dist/{chunk-C6C5PDKU.js → chunk-VD2UDVF7.js}

@@ -7,274 +7,34 @@ import {
   invertHomography,
   isIdentityHomography,
   multiplyHomographies
-} from "./chunk-GX332W2C.js";
+} from "./chunk-N3467VD6.js";
 import {
   TILE,
   TiledSurface,
   blendChannel,
   blendRgb,
   contentBounds,
+  deepTile,
   emptySurface,
   finishTile,
   isBlendMode,
   isSeparableBlendMode,
   mixPigment8,
   mixPigmentRgb,
+  readDeepRegion,
   readRegion,
+  srgbDecode,
+  srgbEncode,
+  surfaceDepth,
   surfaceFromPixels,
   tileKey,
+  tileSamples,
   tilesInRect,
+  to32From8,
   translateSurface,
+  writeDeepRegion,
   writeRegion
-} from "./chunk-XK5LZKBD.js";
-import {
-  deflate,
-  inflate
-} from "./chunk-6FCKOS2B.js";
-
-// src/raster/deep.ts
-var BIT_DEPTHS = [8, 16, 32];
-var isBitDepth = (v) => v === 8 || v === 16 || v === 32;
-var TILE_PIXELS = TILE * TILE;
-function srgbDecode(v) {
-  return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
-}
-function srgbEncode(v) {
-  if (!(v > 0)) return 0;
-  return v <= 31308e-7 ? v * 12.92 : 1.055 * Math.pow(v, 1 / 2.4) - 0.055;
-}
-var LIN8 = null;
-var LIN16 = null;
-function lin8() {
-  if (!LIN8) {
-    LIN8 = new Float32Array(256);
-    for (let i = 0; i < 256; i++) LIN8[i] = srgbDecode(i / 255);
-  }
-  return LIN8;
-}
-function lin16() {
-  if (!LIN16) {
-    LIN16 = new Float32Array(65536);
-    for (let i = 0; i < 65536; i++) LIN16[i] = srgbDecode(i / 65535);
-  }
-  return LIN16;
-}
-function encode16(v) {
-  if (!(v > 0)) return 0;
-  if (v >= 1) return 65535;
-  return Math.round(srgbEncode(v) * 65535);
-}
-var ENC8 = null;
-function encode8(v) {
-  if (!(v > 0)) return 0;
-  if (v >= 1) return 255;
-  if (!ENC8) {
-    ENC8 = new Uint8Array(65536);
-    for (let i = 0; i < 65536; i++) ENC8[i] = Math.round(srgbEncode(i / 65535) * 255);
-  }
-  return ENC8[Math.round(v * 65535)];
-}
-function to16From8(data, out = new Uint16Array(data.length)) {
-  for (let i = 0; i < data.length; i++) out[i] = data[i] * 257;
-  return out;
-}
-function to32From8(data, channels, out = new Float32Array(data.length)) {
-  if (channels === 1) {
-    for (let i = 0; i < data.length; i++) out[i] = data[i] / 255;
-    return out;
-  }
-  const t = lin8();
-  for (let i = 0; i < data.length; i += 4) {
-    out[i] = t[data[i]];
-    out[i + 1] = t[data[i + 1]];
-    out[i + 2] = t[data[i + 2]];
-    out[i + 3] = data[i + 3] / 255;
-  }
-  return out;
-}
-function to32From16(data, channels, out = new Float32Array(data.length)) {
-  if (channels === 1) {
-    for (let i = 0; i < data.length; i++) out[i] = data[i] / 65535;
-    return out;
-  }
-  const t = lin16();
-  for (let i = 0; i < data.length; i += 4) {
-    out[i] = t[data[i]];
-    out[i + 1] = t[data[i + 1]];
-    out[i + 2] = t[data[i + 2]];
-    out[i + 3] = data[i + 3] / 65535;
-  }
-  return out;
-}
-function to16From32(data, channels, out = new Uint16Array(data.length)) {
-  const unit = (v) => v > 0 ? v < 1 ? Math.round(v * 65535) : 65535 : 0;
-  if (channels === 1) {
-    for (let i = 0; i < data.length; i++) out[i] = unit(data[i]);
-    return out;
-  }
-  for (let i = 0; i < data.length; i += 4) {
-    out[i] = encode16(data[i]);
-    out[i + 1] = encode16(data[i + 1]);
-    out[i + 2] = encode16(data[i + 2]);
-    out[i + 3] = unit(data[i + 3]);
-  }
-  return out;
-}
-function to8From16(data, out = new Uint8ClampedArray(data.length)) {
-  for (let i = 0; i < data.length; i++) out[i] = Math.round(data[i] / 257);
-  return out;
-}
-function to8From32(data, channels, out = new Uint8ClampedArray(data.length)) {
-  if (channels === 1) {
-    for (let i = 0; i < data.length; i++) out[i] = Math.round(data[i] * 255);
-    return out;
-  }
-  for (let i = 0; i < data.length; i += 4) {
-    out[i] = encode8(data[i]);
-    out[i + 1] = encode8(data[i + 1]);
-    out[i + 2] = encode8(data[i + 2]);
-    out[i + 3] = Math.round(Math.min(1, Math.max(0, data[i + 3])) * 255);
-  }
-  return out;
-}
-function proxyOf(deep, channels, out) {
-  return deep instanceof Uint16Array ? to8From16(deep, out) : to8From32(deep, channels, out);
-}
-var depthOf = (deep) => deep instanceof Uint16Array ? 16 : 32;
-function deepTile(deep, channels, defaultValue = 0) {
-  const data = proxyOf(deep, channels);
-  if (deep instanceof Uint16Array) {
-    let exact = true;
-    for (let i = 0; i < deep.length; i++) {
-      if (deep[i] % 257 !== 0) {
-        exact = false;
-        break;
-      }
-    }
-    if (exact) return finishTile(data, channels, defaultValue);
-  } else if (channels === 4 && defaultValue === 0) {
-    let empty = true;
-    for (let i = 3; i < deep.length; i += 4) {
-      if (deep[i] !== 0) {
-        empty = false;
-        break;
-      }
-    }
-    if (empty) return null;
-  }
-  return { data, uniform: null, deep };
-}
-function tileSamples16(tile, channels, defaultValue = 0) {
-  const deep = tile?.deep;
-  if (deep instanceof Uint16Array) return deep;
-  if (deep instanceof Float32Array) return to16From32(deep, channels);
-  if (tile) return to16From8(tile.data);
-  return new Uint16Array(TILE_PIXELS * channels).fill(defaultValue * 257);
-}
-function tileSamples32(tile, channels, defaultValue = 0) {
-  const deep = tile?.deep;
-  if (deep instanceof Float32Array) return deep;
-  if (deep instanceof Uint16Array) return to32From16(deep, channels);
-  if (tile) return to32From8(tile.data, channels);
-  const out = new Float32Array(TILE_PIXELS * channels);
-  if (defaultValue) {
-    if (channels === 1) out.fill(defaultValue / 255);
-    else to32From8(new Uint8ClampedArray(TILE_PIXELS * 4).fill(defaultValue), 4, out);
-  }
-  return out;
-}
-function tileSamples(tile, channels, depth, defaultValue = 0) {
-  return depth === 16 ? tileSamples16(tile, channels, defaultValue) : tileSamples32(tile, channels, defaultValue);
-}
-function surfaceDepth(surface) {
-  let d = 8;
-  for (const t of surface.tiles.values()) {
-    if (t.deep instanceof Float32Array) return 32;
-    if (t.deep) d = 16;
-  }
-  return d;
-}
-function readDeepRegion(surface, rect, depth) {
-  const ch = surface.channels;
-  const w = rect.width;
-  const h = rect.height;
-  const out = depth === 16 ? new Uint16Array(w * h * ch) : new Float32Array(w * h * ch);
-  const fill2 = tileSamples(void 0, ch, depth, surface.defaultValue);
-  if (surface.defaultValue) for (let i = 0; i < out.length; i += ch) for (let c = 0; c < ch; c++) out[i + c] = fill2[c];
-  for (const { tx, ty } of tilesInRect(rect)) {
-    const tile = surface.tiles.get(tileKey(tx, ty));
-    if (!tile) continue;
-    const src = tileSamples(tile, ch, depth, surface.defaultValue);
-    const ox = tx * TILE;
-    const oy = ty * TILE;
-    const x0 = Math.max(rect.x, ox);
-    const y0 = Math.max(rect.y, oy);
-    const x1 = Math.min(rect.x + w, ox + TILE);
-    const y1 = Math.min(rect.y + h, oy + TILE);
-    const span = (x1 - x0) * ch;
-    for (let yy = y0; yy < y1; yy++) {
-      const s = ((yy - oy) * TILE + (x0 - ox)) * ch;
-      const d = ((yy - rect.y) * w + (x0 - rect.x)) * ch;
-      out.set(src.subarray(s, s + span), d);
-    }
-  }
-  return out;
-}
-function writeDeepRegion(surface, rect, samples) {
-  const ch = surface.channels;
-  const w = rect.width;
-  const h = rect.height;
-  if (w <= 0 || h <= 0) return surface;
-  if (samples.length < w * h * ch) throw new Error(`writeDeepRegion: expected ${w * h * ch} samples, got ${samples.length}`);
-  const depth = depthOf(samples);
-  const tiles = new Map(surface.tiles);
-  for (const { tx, ty } of tilesInRect(rect)) {
-    const key = tileKey(tx, ty);
-    const ox = tx * TILE;
-    const oy = ty * TILE;
-    const x0 = Math.max(rect.x, ox);
-    const y0 = Math.max(rect.y, oy);
-    const x1 = Math.min(rect.x + w, ox + TILE);
-    const y1 = Math.min(rect.y + h, oy + TILE);
-    const full = x0 === ox && y0 === oy && x1 === ox + TILE && y1 === oy + TILE;
-    const base = full ? null : tileSamples(surface.tiles.get(key), ch, depth, surface.defaultValue);
-    const t = base ? base.slice() : depth === 16 ? new Uint16Array(TILE_PIXELS * ch) : new Float32Array(TILE_PIXELS * ch);
-    const span = (x1 - x0) * ch;
-    for (let yy = y0; yy < y1; yy++) {
-      const s = ((yy - rect.y) * w + (x0 - rect.x)) * ch;
-      const d = ((yy - oy) * TILE + (x0 - ox)) * ch;
-      t.set(samples.subarray(s, s + span), d);
-    }
-    const tile = deepTile(t, ch, surface.defaultValue);
-    if (tile) tiles.set(key, tile);
-    else tiles.delete(key);
-  }
-  return new TiledSurface(ch, tiles, surface.defaultValue);
-}
-function surfaceFromDeepPixels(pixels, channels = 4, x = 0, y = 0, defaultValue = 0) {
-  return writeDeepRegion(emptySurface(channels, defaultValue), { x, y, width: pixels.width, height: pixels.height }, pixels.data);
-}
-function convertSurfaceDepth(surface, depth) {
-  let changed = false;
-  const tiles = new Map(surface.tiles);
-  const ch = surface.channels;
-  for (const [key, tile] of surface.tiles) {
-    const deep = tile.deep;
-    if (!deep || depthOf(deep) === depth) continue;
-    changed = true;
-    let next;
-    if (depth === 8) next = finishTile(tile.data, ch, surface.defaultValue);
-    else next = deepTile(depth === 16 ? to16From32(deep, ch) : to32From16(deep, ch), ch, surface.defaultValue);
-    if (next) tiles.set(key, next);
-    else tiles.delete(key);
-  }
-  return changed ? new TiledSurface(ch, tiles, surface.defaultValue) : surface;
-}
-function deepBytes(surface) {
-  let n = 0;
-  for (const t of surface.tiles.values()) if (t.deep) n += t.deep.byteLength;
-  return n;
-}
+} from "./chunk-HKDTM6VC.js";
 
 // src/raster/effects/model.ts
 var DEFAULT_GLOBAL_LIGHT = { angle: 120, altitude: 30 };
@@ -2584,8 +2344,8 @@ function renderLayerEffects(effects, layer, backdrop, canvas, ctx) {
 }
 
 // src/raster/compositor.ts
-var TILE_PIXELS2 = TILE * TILE;
-var TILE_BYTES = TILE_PIXELS2 * 4;
+var TILE_PIXELS = TILE * TILE;
+var TILE_BYTES = TILE_PIXELS * 4;
 function sameSig(a, b) {
   if (!a || a.key !== b.key || a.refs.length !== b.refs.length) return false;
   for (let i = 0; i < a.refs.length; i++) if (a.refs[i] !== b.refs[i]) return false;
@@ -3605,13 +3365,13 @@ function hasTilesIn(src, r) {
   for (const { tx, ty } of tilesInRect(r)) if (src.getTile(tx, ty)) return true;
   return false;
 }
-function readWindow(src, srcRect, rect) {
+function readWindow(src, srcRect, rect, depth = null) {
   const n = src.channels === 4 ? 4 : 2;
   const data = new Float32Array(rect.width * rect.height * n);
   const win = { x: rect.x, y: rect.y, w: rect.width, h: rect.height, n, data };
   const r = intersect(rect, srcRect);
   if (!r) return win;
-  const px = readRegion(src, r);
+  const px = depth ? readScaled(src, r, depth) : readRegion(src, r);
   for (let y = 0; y < r.height; y++) {
     let s = y * r.width * src.channels;
     let d = ((r.y - rect.y + y) * rect.width + (r.x - rect.x)) * n;
@@ -3745,7 +3505,44 @@ function store(out, o, acc, ch, def) {
   out[o] = acc[0] + def * (1 - inside);
   return true;
 }
-function boxReduce(src, srcRect, kx, ky) {
+function resampleDepth(src, step) {
+  if (src.channels !== 4 || src.defaultValue !== 0 || step !== 1) return null;
+  const d = surfaceDepth(src);
+  return d === 8 ? null : d;
+}
+function readScaled(src, rect, depth) {
+  const d = readDeepRegion(src, rect, depth);
+  const out = new Float32Array(d.length);
+  const k = depth === 16 ? 1 / 257 : 255;
+  for (let i = 0; i < d.length; i++) out[i] = d[i] * k;
+  return out;
+}
+function fromScaled(v, depth) {
+  if (depth === 16) {
+    const out2 = new Uint16Array(v.length);
+    for (let i = 0; i < v.length; i++) {
+      const x = Math.round(v[i] * 257);
+      out2[i] = x <= 0 ? 0 : x >= 65535 ? 65535 : x;
+    }
+    return out2;
+  }
+  const out = new Float32Array(v.length);
+  for (let i = 0; i < v.length; i++) {
+    const x = v[i] / 255;
+    out[i] = (i & 3) === 3 ? x <= 0 ? 0 : x >= 1 ? 1 : x : x;
+  }
+  return out;
+}
+function storeScaled(out, o, acc) {
+  const al = acc[3] > 1 ? 1 : acc[3];
+  if (!(al > 1e-6)) return false;
+  out[o] = acc[0] / al;
+  out[o + 1] = acc[1] / al;
+  out[o + 2] = acc[2] / al;
+  out[o + 3] = al * 255;
+  return true;
+}
+function boxReduce(src, srcRect, kx, ky, depth = null) {
   const ch = src.channels;
   const rx0 = Math.floor(srcRect.x / kx);
   const ry0 = Math.floor(srcRect.y / ky);
@@ -3759,8 +3556,8 @@ function boxReduce(src, srcRect, kx, ky) {
   for (let ry = ry0; ry < ry1; ry += rowsPer) {
     const rows = Math.min(rowsPer, ry1 - ry);
     const strip = { x: rx0 * kx, y: ry * ky, width: rw * kx, height: rows * ky };
-    const px = readRegion(src, strip);
-    const red = new Uint8ClampedArray(rw * rows * ch);
+    const px = depth ? readScaled(src, strip, depth) : readRegion(src, strip);
+    const red = depth ? new Float32Array(rw * rows * ch) : new Uint8ClampedArray(rw * rows * ch);
     for (let j = 0; j < rows; j++) {
       for (let i = 0; i < rw; i++) {
         if (ch === 4) {
@@ -3795,7 +3592,8 @@ function boxReduce(src, srcRect, kx, ky) {
         }
       }
     }
-    out = writeRegion(out, { x: rx0, y: ry, width: rw, height: rows }, red);
+    const region = { x: rx0, y: ry, width: rw, height: rows };
+    out = depth ? writeDeepRegion(out, region, fromScaled(red, depth)) : writeRegion(out, region, red);
   }
   return { surface: out, rect };
 }
@@ -3844,11 +3642,18 @@ function transformSurface(src, h, options = {}) {
   const empty = emptySurface(ch, def);
   const given = options.source;
   const step = normalizeStep(options.step);
+  const depth = resampleDepth(src, step);
   if (isIdentityHomography(h, 1e-12) && !given && !options.clip) return src;
   const dx = h[2] / h[8];
   const dy = h[5] / h[8];
   if (!given && !options.clip && isIdentityHomography([h[0], h[1], 0, h[3], h[4], 0, h[6], h[7], h[8]], 1e-12) && Math.abs(dx - Math.round(dx)) < 1e-9 && Math.abs(dy - Math.round(dy)) < 1e-9) {
-    return translateSurface(src, Math.round(dx), Math.round(dy));
+    const mx = Math.round(dx);
+    const my = Math.round(dy);
+    const b = src.bounds;
+    if (depth && b && (mx % TILE !== 0 || my % TILE !== 0)) {
+      return writeDeepRegion(emptySurface(ch, def), { ...b, x: b.x + mx, y: b.y + my }, readDeepRegion(src, b, depth));
+    }
+    return translateSurface(src, mx, my);
   }
   let srcRect = given ? intersect(given, given) : contentBounds(src);
   if (!srcRect) return empty;
@@ -3862,7 +3667,7 @@ function transformSurface(src, h, options = {}) {
       const kx = reduction(su);
       const ky = reduction(sv);
       if (kx > 1 || ky > 1) {
-        const red = boxReduce(src, srcRect, kx, ky);
+        const red = boxReduce(src, srcRect, kx, ky, depth);
         S = red.surface;
         srcRect = red.rect;
         H = multiplyHomographies([kx, 0, 0, 0, ky, 0, 0, 0, 1], H);
@@ -3946,9 +3751,10 @@ function transformSurface(src, h, options = {}) {
     if (!foot) continue;
     const readable = intersect(foot, sr);
     if (!readable || !hasTilesIn(S, readable)) continue;
-    const win = readWindow(S, sr, foot);
+    const win = readWindow(S, sr, foot, depth);
     const out = new Uint8ClampedArray(TILE * TILE * ch);
     if (def) out.fill(def);
+    const deepOut = depth ? new Float32Array(TILE * TILE * 4) : null;
     let any = false;
     const ox = tx * TILE;
     const oy = ty * TILE;
@@ -3977,6 +3783,10 @@ function transformSurface(src, h, options = {}) {
           sv = widen(s[1]);
         }
         sample(win, interp, u, v, su, sv, acc);
+        if (deepOut) {
+          if (storeScaled(deepOut, ((y - oy) * TILE + (x - ox)) * 4, acc)) any = true;
+          continue;
+        }
         if (!store(scratch, 0, acc, ch, def)) continue;
         rowSet[bi] = 1;
         rowVals[bi] = ch === 4 ? scratchWord[0] : scratch[0];
@@ -3999,7 +3809,7 @@ function transformSurface(src, h, options = {}) {
       }
     }
     if (!any) continue;
-    const tile = finishTile(out, ch, def);
+    const tile = deepOut ? deepTile(fromScaled(deepOut, depth), 4, def) : finishTile(out, ch, def);
     if (tile) tiles.set(tileKey(tx, ty), tile);
   }
   return assemble(src, tiles);
@@ -4015,6 +3825,7 @@ function warpSurface(src, f, options = {}) {
   const sr = options.source ? intersect(options.source, options.source) : contentBounds(src);
   if (!sr) return empty;
   const step = normalizeStep(options.step);
+  const depth = resampleDepth(src, step);
   const nx = Math.min(MAX_CELLS, Math.max(1, Math.ceil(sr.width / CELL)));
   const ny = Math.min(MAX_CELLS, Math.max(1, Math.ceil(sr.height / CELL)));
   const w1 = nx + 1;
@@ -4182,9 +3993,10 @@ function warpSurface(src, f, options = {}) {
       if (fx0 > fx1) continue;
       const foot = intersect({ x: Math.floor(fx0) - 3, y: Math.floor(fy0) - 3, width: Math.ceil(fx1) - Math.floor(fx0) + 6, height: Math.ceil(fy1) - Math.floor(fy0) + 6 }, sr);
       if (!foot || !hasTilesIn(src, foot)) continue;
-      const win = readWindow(src, sr, foot);
+      const win = readWindow(src, sr, foot, depth);
       const out = new Uint8ClampedArray(TILE * TILE * ch);
       if (def) out.fill(def);
+      const deepOut = depth ? new Float32Array(TILE * TILE * 4) : null;
       let any = false;
       const ox = ttx * TILE;
       const oy = tty * TILE;
@@ -4218,7 +4030,8 @@ function warpSurface(src, f, options = {}) {
           pointAt(o, acc);
           const x = t.x + o % tw;
           const y = t.y + Math.floor(o / tw);
-          if (store(out, ((y - oy) * TILE + (x - ox)) * ch, acc, ch, def)) any = true;
+          const o4 = ((y - oy) * TILE + (x - ox)) * ch;
+          if (deepOut ? storeScaled(deepOut, o4, acc) : store(out, o4, acc, ch, def)) any = true;
         }
       } else {
         for (let by = 0; by < th; by += step) {
@@ -4237,7 +4050,7 @@ function warpSurface(src, f, options = {}) {
         }
       }
       if (!any) continue;
-      const tile = finishTile(out, ch, def);
+      const tile = deepOut ? deepTile(fromScaled(deepOut, depth), 4, def) : finishTile(out, ch, def);
       if (tile) tiles.set(tileKey(ttx, tty), tile);
     }
   }
@@ -4248,12 +4061,34 @@ function compositeSurfaceOver(base, top) {
   if (!top.tiles.size) return base;
   const ch = base.channels;
   const tiles = new Map(base.tiles);
+  const bd = ch === 4 && base.defaultValue === 0 ? Math.max(surfaceDepth(base), surfaceDepth(top)) : 8;
+  const depth = bd === 8 ? null : bd;
   for (const [key, t] of top.tiles) {
     const under = base.tiles.get(key);
     if (!under && ch === 4) {
       tiles.set(key, t);
       continue;
     }
+    if (depth) {
+      const k = depth === 16 ? 65535 : 1;
+      const d2 = tileSamples(under, 4, depth, 0).slice();
+      const sd = tileSamples(t, 4, depth, 0);
+      for (let i = 0; i < d2.length; i += 4) {
+        const ta = Math.min(1, sd[i + 3] / k);
+        if (ta <= 0) continue;
+        const da = d2[i + 3] / k;
+        const oa = ta + da * (1 - ta);
+        for (let c = 0; c < 3; c++) {
+          const v = (sd[i + c] * ta + d2[i + c] * da * (1 - ta)) / oa;
+          d2[i + c] = depth === 16 ? Math.round(v) : v;
+        }
+        d2[i + 3] = depth === 16 ? Math.round(oa * k) : oa;
+      }
+      const tile2 = deepTile(d2, 4, 0);
+      if (tile2) tiles.set(key, tile2);
+      else tiles.delete(key);
+      continue;
+    }
     const d = new Uint8ClampedArray(TILE * TILE * ch);
     if (under) d.set(under.data);
     else if (base.defaultValue) d.fill(base.defaultValue);
@@ -4287,337 +4122,7 @@ function compositeSurfaceOver(base, top) {
   return new TiledSurface(ch, tiles, base.defaultValue);
 }
 
-// src/raster/png.ts
-var SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
-var crcTable = null;
-function crc32(bytes, start, end) {
-  if (!crcTable) {
-    crcTable = new Uint32Array(256);
-    for (let n = 0; n < 256; n++) {
-      let c2 = n;
-      for (let k = 0; k < 8; k++) c2 = c2 & 1 ? 3988292384 ^ c2 >>> 1 : c2 >>> 1;
-      crcTable[n] = c2 >>> 0;
-    }
-  }
-  let c = 4294967295;
-  for (let i = start; i < end; i++) c = crcTable[(c ^ bytes[i]) & 255] ^ c >>> 8;
-  return (c ^ 4294967295) >>> 0;
-}
-function paeth(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);
-  return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
-}
-function encodePng(width, height, data, channels = 4) {
-  const stride = width * channels;
-  const raw = new Uint8Array((stride + 1) * height);
-  const bpp = channels;
-  const cand = [new Uint8Array(stride), new Uint8Array(stride), new Uint8Array(stride), new Uint8Array(stride), new Uint8Array(stride)];
-  for (let y = 0; y < height; y++) {
-    const row = y * stride;
-    const prevRow = (y - 1) * stride;
-    let best = 0;
-    let bestScore = Infinity;
-    for (let f = 0; f < 5; f++) {
-      const out2 = cand[f];
-      let score = 0;
-      for (let x = 0; x < stride; x++) {
-        const v = data[row + x];
-        const a = x >= bpp ? data[row + x - bpp] : 0;
-        const b = y > 0 ? data[prevRow + x] : 0;
-        const c = x >= bpp && y > 0 ? data[prevRow + x - bpp] : 0;
-        let r;
-        switch (f) {
-          case 0:
-            r = v;
-            break;
-          case 1:
-            r = v - a;
-            break;
-          case 2:
-            r = v - b;
-            break;
-          case 3:
-            r = v - (a + b >> 1);
-            break;
-          default:
-            r = v - paeth(a, b, c);
-        }
-        r &= 255;
-        out2[x] = r;
-        score += r < 128 ? r : 256 - r;
-        if (score >= bestScore) break;
-      }
-      if (score < bestScore) {
-        bestScore = score;
-        best = f;
-      }
-    }
-    const o = y * (stride + 1);
-    raw[o] = best;
-    raw.set(cand[best], o + 1);
-  }
-  const idat = deflate(raw);
-  const chunks = [];
-  const ihdr = new Uint8Array(13);
-  writeU32(ihdr, 0, width);
-  writeU32(ihdr, 4, height);
-  ihdr[8] = 8;
-  ihdr[9] = channels === 1 ? 0 : 6;
-  chunks.push(["IHDR", ihdr], ["IDAT", idat], ["IEND", new Uint8Array(0)]);
-  let size = 8;
-  for (const [, d] of chunks) size += 12 + d.length;
-  const out = new Uint8Array(size);
-  out.set(SIGNATURE, 0);
-  let p = 8;
-  for (const [type, d] of chunks) {
-    writeU32(out, p, d.length);
-    for (let i = 0; i < 4; i++) out[p + 4 + i] = type.charCodeAt(i);
-    out.set(d, p + 8);
-    writeU32(out, p + 8 + d.length, crc32(out, p + 4, p + 8 + d.length));
-    p += 12 + d.length;
-  }
-  return out;
-}
-function writeU32(b, o, v) {
-  b[o] = v >>> 24;
-  b[o + 1] = v >>> 16 & 255;
-  b[o + 2] = v >>> 8 & 255;
-  b[o + 3] = v & 255;
-}
-function readU32(b, o) {
-  return (b[o] << 24 | b[o + 1] << 16 | b[o + 2] << 8 | b[o + 3]) >>> 0;
-}
-function isPng(bytes) {
-  return bytes.length > 8 && SIGNATURE.every((v, i) => bytes[i] === v);
-}
-function decodePng(bytes, options = {}) {
-  if (!isPng(bytes)) throw new Error("Not a PNG image.");
-  let p = 8;
-  let width = 0;
-  let height = 0;
-  let depth = 0;
-  let type = 0;
-  let interlace = 0;
-  let palette = null;
-  let trns = null;
-  const idat = [];
-  while (p + 8 <= bytes.length) {
-    const len = readU32(bytes, p);
-    const t = String.fromCharCode(bytes[p + 4], bytes[p + 5], bytes[p + 6], bytes[p + 7]);
-    const body = bytes.subarray(p + 8, p + 8 + len);
-    if (p + 12 + len > bytes.length) throw new Error("Truncated PNG.");
-    if (t === "IHDR") {
-      width = readU32(body, 0);
-      height = readU32(body, 4);
-      depth = body[8];
-      type = body[9];
-      interlace = body[12];
-    } else if (t === "PLTE") palette = body;
-    else if (t === "tRNS") trns = body;
-    else if (t === "IDAT") idat.push(body);
-    else if (t === "IEND") break;
-    p += 12 + len;
-  }
-  if (!width || !height) throw new Error("PNG has no image header.");
-  if (interlace) throw new Error("Interlaced PNGs are not supported here; decode them with a canvas.");
-  const maxPixels = options.maxPixels ?? 1 << 28;
-  if (width * height > maxPixels) throw new Error(`PNG is too large (${width}\xD7${height}).`);
-  const samples = type === 0 ? 1 : type === 2 ? 3 : type === 3 ? 1 : type === 4 ? 2 : type === 6 ? 4 : 0;
-  if (!samples || ![1, 2, 4, 8, 16].includes(depth)) throw new Error(`Unsupported PNG format (type ${type}, depth ${depth}).`);
-  let total = 0;
-  for (const c of idat) total += c.length;
-  const z = new Uint8Array(total);
-  let o = 0;
-  for (const c of idat) {
-    z.set(c, o);
-    o += c.length;
-  }
-  const bitsPerPixel = samples * depth;
-  const stride = Math.ceil(width * bitsPerPixel / 8);
-  const raw = inflate(z, { maxOutput: (stride + 1) * height, sizeHint: (stride + 1) * height });
-  if (raw.length < (stride + 1) * height) throw new Error("PNG image data is truncated.");
-  const bpp = Math.max(1, bitsPerPixel >> 3);
-  const lines = new Uint8Array(stride * height);
-  for (let y = 0; y < height; y++) {
-    const f = raw[y * (stride + 1)];
-    const src = y * (stride + 1) + 1;
-    const dst = y * stride;
-    const up = dst - stride;
-    for (let x = 0; x < stride; x++) {
-      const v = raw[src + x];
-      const a = x >= bpp ? lines[dst + x - bpp] : 0;
-      const b = y > 0 ? lines[up + x] : 0;
-      const c = x >= bpp && y > 0 ? lines[up + x - bpp] : 0;
-      let r;
-      switch (f) {
-        case 0:
-          r = v;
-          break;
-        case 1:
-          r = v + a;
-          break;
-        case 2:
-          r = v + b;
-          break;
-        case 3:
-          r = v + (a + b >> 1);
-          break;
-        case 4:
-          r = v + paeth(a, b, c);
-          break;
-        default:
-          throw new Error(`Invalid PNG filter ${f}.`);
-      }
-      lines[dst + x] = r & 255;
-    }
-  }
-  const sample2 = (y, i) => {
-    const row = y * stride;
-    if (depth === 8) return lines[row + i];
-    if (depth === 16) return lines[row + i * 2];
-    const perByte = 8 / depth;
-    const byte = lines[row + Math.floor(i / perByte)];
-    const shift = 8 - depth * (i % perByte + 1);
-    const v = byte >> shift & (1 << depth) - 1;
-    return type === 3 ? v : Math.round(v * 255 / ((1 << depth) - 1));
-  };
-  const gray = options.keepGray && type === 0 && !trns;
-  const channels = gray ? 1 : 4;
-  const out = new Uint8ClampedArray(width * height * channels);
-  const trnsGray = trns && type === 0 ? depth === 16 ? trns[0] : sample16(trns, 0, depth) : -1;
-  const trnsRgb = trns && type === 2 ? [0, 1, 2].map((k) => depth === 16 ? trns[k * 2] : sample16(trns, k, depth)) : null;
-  for (let y = 0; y < height; y++) {
-    for (let x = 0; x < width; x++) {
-      const d = (y * width + x) * channels;
-      if (type === 0) {
-        const v = sample2(y, x);
-        if (gray) out[d] = v;
-        else {
-          out[d] = out[d + 1] = out[d + 2] = v;
-          out[d + 3] = v === trnsGray && trns ? 0 : 255;
-        }
-      } else if (type === 2) {
-        const r = sample2(y, x * 3);
-        const g = sample2(y, x * 3 + 1);
-        const b = sample2(y, x * 3 + 2);
-        out[d] = r;
-        out[d + 1] = g;
-        out[d + 2] = b;
-        out[d + 3] = trnsRgb && r === trnsRgb[0] && g === trnsRgb[1] && b === trnsRgb[2] ? 0 : 255;
-      } else if (type === 3) {
-        const i = sample2(y, x);
-        if (!palette || i * 3 + 2 >= palette.length) throw new Error("PNG palette index out of range.");
-        out[d] = palette[i * 3];
-        out[d + 1] = palette[i * 3 + 1];
-        out[d + 2] = palette[i * 3 + 2];
-        out[d + 3] = trns && i < trns.length ? trns[i] : 255;
-      } else if (type === 4) {
-        const v = sample2(y, x * 2);
-        out[d] = out[d + 1] = out[d + 2] = v;
-        out[d + 3] = sample2(y, x * 2 + 1);
-      } else {
-        out[d] = sample2(y, x * 4);
-        out[d + 1] = sample2(y, x * 4 + 1);
-        out[d + 2] = sample2(y, x * 4 + 2);
-        out[d + 3] = sample2(y, x * 4 + 3);
-      }
-    }
-  }
-  return { width, height, channels, data: out };
-}
-function sample16(trns, k, depth) {
-  const v = trns[k * 2] << 8 | trns[k * 2 + 1];
-  if (depth === 8) return v & 255;
-  return Math.round((v & (1 << depth) - 1) * 255 / ((1 << depth) - 1));
-}
-var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-var B64_INV = null;
-function bytesToBase64(bytes) {
-  const parts = [];
-  const CHUNK = 3 * 4096;
-  for (let start = 0; start < bytes.length; start += CHUNK) {
-    const end = Math.min(bytes.length, start + CHUNK);
-    let s = "";
-    let i = start;
-    for (; i + 2 < end; i += 3) {
-      const n = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
-      s += B64[n >> 18] + B64[n >> 12 & 63] + B64[n >> 6 & 63] + B64[n & 63];
-    }
-    if (i < end) {
-      const n = bytes[i] << 16 | (i + 1 < end ? bytes[i + 1] << 8 : 0);
-      s += B64[n >> 18] + B64[n >> 12 & 63] + (i + 1 < end ? B64[n >> 6 & 63] : "=") + "=";
-    }
-    parts.push(s);
-  }
-  return parts.join("");
-}
-function base64ToBytes(text) {
-  if (!B64_INV) {
-    B64_INV = new Int16Array(128).fill(-1);
-    for (let i = 0; i < 64; i++) B64_INV[B64.charCodeAt(i)] = i;
-    B64_INV["-".charCodeAt(0)] = 62;
-    B64_INV["_".charCodeAt(0)] = 63;
-  }
-  const inv = B64_INV;
-  const clean = text.replace(/[\s=]/g, "");
-  const out = new Uint8Array(Math.floor(clean.length * 3 / 4));
-  let bits = 0;
-  let acc = 0;
-  let o = 0;
-  for (let i = 0; i < clean.length; i++) {
-    const c = clean.charCodeAt(i);
-    const v = c < 128 ? inv[c] : -1;
-    if (v < 0) throw new Error("Invalid base64 data.");
-    acc = acc << 6 | v;
-    bits += 6;
-    if (bits >= 8) {
-      bits -= 8;
-      out[o++] = acc >> bits & 255;
-    }
-  }
-  return out.subarray(0, o);
-}
-function parseDataUrl(url) {
-  const m = /^data:([^;,]*)((?:;[^;,]*)*?),/i.exec(url);
-  if (!m) return null;
-  const body = url.slice(m[0].length);
-  const isBase64 = /;base64/i.test(m[2]);
-  if (isBase64) return { mime: m[1] || "text/plain", bytes: base64ToBytes(body) };
-  const text = decodeURIComponent(body);
-  const bytes = new Uint8Array(text.length);
-  for (let i = 0; i < text.length; i++) bytes[i] = text.charCodeAt(i) & 255;
-  return { mime: m[1] || "text/plain", bytes };
-}
-function pngDataUrl(width, height, data, channels = 4) {
-  return `data:image/png;base64,${bytesToBase64(encodePng(width, height, data, channels))}`;
-}
-
 export {
-  BIT_DEPTHS,
-  isBitDepth,
-  srgbDecode,
-  srgbEncode,
-  to16From8,
-  to32From8,
-  to32From16,
-  to16From32,
-  to8From16,
-  to8From32,
-  proxyOf,
-  depthOf,
-  deepTile,
-  tileSamples16,
-  tileSamples32,
-  tileSamples,
-  surfaceDepth,
-  readDeepRegion,
-  writeDeepRegion,
-  surfaceFromDeepPixels,
-  convertSurfaceDepth,
-  deepBytes,
   DEFAULT_GLOBAL_LIGHT,
   LAYER_EFFECT_KINDS,
   layerEffectLabel,
@@ -4679,13 +4184,6 @@ export {
   transformedBounds,
   transformSurface,
   warpSurface,
-  compositeSurfaceOver,
-  encodePng,
-  isPng,
-  decodePng,
-  bytesToBase64,
-  base64ToBytes,
-  parseDataUrl,
-  pngDataUrl
+  compositeSurfaceOver
 };
-//# sourceMappingURL=chunk-C6C5PDKU.js.map
+//# sourceMappingURL=chunk-VD2UDVF7.js.map