@pixerate/editor 0.112.0 → 0.114.0

package/dist/{chunk-POGBUYWE.cjs → chunk-ST7E3NEE.cjs}

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
 
 
 
@@ -26,178 +26,254 @@ var _chunkMUUXNRU4cjs = require('./chunk-MUUXNRU4.cjs');
 
 
 
-var _chunkXIOMMGPDcjs = require('./chunk-XIOMMGPD.cjs');
+var _chunkTFOPHZ3Ucjs = require('./chunk-TFOPHZ3U.cjs');
 
-// src/raster/blur.ts
-function gaussianKernel(sigma) {
-  const r = Math.ceil(sigma * 3);
-  const k = new Float32Array(2 * r + 1);
-  let s = 0;
-  for (let i = -r; i <= r; i++) {
-    const v = Math.exp(-(i * i) / (2 * sigma * sigma));
-    k[i + r] = v;
-    s += v;
-  }
-  for (let i = 0; i < k.length; i++) k[i] /= s;
-  return k;
+
+
+var _chunk643B2HKCcjs = require('./chunk-643B2HKC.cjs');
+
+// src/raster/deep.ts
+var BIT_DEPTHS = [8, 16, 32];
+var isBitDepth = (v) => v === 8 || v === 16 || v === 32;
+var TILE_PIXELS = _chunkTFOPHZ3Ucjs.TILE * _chunkTFOPHZ3Ucjs.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;
 }
-var DIRECT_GAUSSIAN_MAX_SIGMA = 8;
-function boxRadii(sigma) {
-  const n = 3;
-  const wIdeal = Math.sqrt(12 * sigma * sigma / n + 1);
-  let wl = Math.floor(wIdeal);
-  if (wl % 2 === 0) wl--;
-  const wu = wl + 2;
-  const mIdeal = (12 * sigma * sigma - n * wl * wl - 4 * n * wl - 3 * n) / (-4 * wl - 4);
-  const m = Math.round(mIdeal);
-  const sizes = [0, 1, 2].map((i) => i < m ? wl : wu);
-  return sizes.map((s) => (s - 1) / 2);
+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 convolveLine(src, off, stride, len, k, edge, dst) {
-  const r = (k.length - 1) / 2;
-  for (let i = 0; i < len; i++) {
-    let a = 0;
-    const lo = i - r;
-    for (let j = 0; j < k.length; j++) {
-      let x = lo + j;
-      if (x < 0 || x >= len) {
-        if (edge === "zero") continue;
-        x = x < 0 ? 0 : len - 1;
-      }
-      a += src[off + x * stride] * k[j];
-    }
-    dst[i] = a;
+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 boxesLine(src, off, stride, len, radii, edge, a, b, dst) {
-  const pad = radii.reduce((s, r) => s + r, 0);
-  const plen = len + 2 * pad;
-  for (let i = 0; i < plen; i++) {
-    const j = i - pad;
-    a[i] = j < 0 ? edge === "zero" ? 0 : src[off] : j >= len ? edge === "zero" ? 0 : src[off + (len - 1) * stride] : src[off + j * stride];
+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;
   }
-  let from = a;
-  let to = b;
-  for (const r of radii) {
-    let sum = 0;
-    for (let i = 0; i <= Math.min(r, plen - 1); i++) sum += from[i];
-    const k = 2 * r + 1;
-    for (let i = 0; i < plen; i++) {
-      to[i] = sum / k;
-      const add = i + r + 1;
-      const drop = i - r;
-      if (add < plen) sum += from[add];
-      if (drop >= 0) sum -= from[drop];
-    }
-    const t = from;
-    from = to;
-    to = t;
+  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]);
   }
-  for (let i = 0; i < len; i++) dst[i] = from[i + pad];
+  return out;
 }
-function gaussianBlur(src, w, h, sigma, edge = "zero") {
-  const out = Float32Array.from(src);
-  if (!(sigma >= 0.1) || w <= 0 || h <= 0) return out;
-  const s = Math.min(sigma, 4 * Math.max(w, h));
-  const line = new Float32Array(Math.max(w, h));
-  const passes = [];
-  if (s <= DIRECT_GAUSSIAN_MAX_SIGMA) {
-    const k = gaussianKernel(s);
-    passes.push((buf, off, stride, len) => convolveLine(buf, off, stride, len, k, edge, line));
-  } else {
-    const radii = boxRadii(s);
-    const plen = Math.max(w, h) + 2 * radii.reduce((a2, r) => a2 + r, 0);
-    const a = new Float32Array(plen);
-    const b = new Float32Array(plen);
-    passes.push((buf, off, stride, len) => boxesLine(buf, off, stride, len, radii, edge, a, b, line));
+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 (const pass of passes) {
-    for (let y = 0; y < h; y++) {
-      pass(out, y * w, 1, w);
-      out.set(line.subarray(0, w), y * w);
-    }
+  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);
   }
-  for (const pass of passes) {
-    for (let x = 0; x < w; x++) {
-      pass(out, x, w, h);
-      for (let y = 0; y < h; y++) out[y * w + x] = line[y];
+  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 _chunkTFOPHZ3Ucjs.finishTile.call(void 0, 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 = _optionalChain([tile, 'optionalAccess', _2 => _2.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 = _optionalChain([tile, 'optionalAccess', _3 => _3.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;
 }
-
-// src/raster/layers.ts
-var childrenOf = (l) => l.type === "group" ? _nullishCoalesce(l.children, () => ( null)) : null;
-function flattenLayers(layers) {
-  const out = [];
-  const walk = (list) => {
-    for (const l of list) {
-      out.push(l);
-      const c = childrenOf(l);
-      if (c) walk(c);
+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 _chunkTFOPHZ3Ucjs.tilesInRect.call(void 0, rect)) {
+    const tile = surface.tiles.get(_chunkTFOPHZ3Ucjs.tileKey.call(void 0, tx, ty));
+    if (!tile) continue;
+    const src = tileSamples(tile, ch, depth, surface.defaultValue);
+    const ox = tx * _chunkTFOPHZ3Ucjs.TILE;
+    const oy = ty * _chunkTFOPHZ3Ucjs.TILE;
+    const x0 = Math.max(rect.x, ox);
+    const y0 = Math.max(rect.y, oy);
+    const x1 = Math.min(rect.x + w, ox + _chunkTFOPHZ3Ucjs.TILE);
+    const y1 = Math.min(rect.y + h, oy + _chunkTFOPHZ3Ucjs.TILE);
+    const span = (x1 - x0) * ch;
+    for (let yy = y0; yy < y1; yy++) {
+      const s = ((yy - oy) * _chunkTFOPHZ3Ucjs.TILE + (x0 - ox)) * ch;
+      const d = ((yy - rect.y) * w + (x0 - rect.x)) * ch;
+      out.set(src.subarray(s, s + span), d);
     }
-  };
-  walk(layers);
+  }
   return out;
 }
-function findLayer(layers, id) {
-  const walk = (list, parent, path) => {
-    for (let i = 0; i < list.length; i++) {
-      const l = list[i];
-      if (l.id === id) return { layer: l, parent, index: i, path };
-      const c = childrenOf(l);
-      if (c) {
-        const g = l;
-        const hit = walk(c, g, [...path, g]);
-        if (hit) return hit;
-      }
+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 _chunkTFOPHZ3Ucjs.tilesInRect.call(void 0, rect)) {
+    const key = _chunkTFOPHZ3Ucjs.tileKey.call(void 0, tx, ty);
+    const ox = tx * _chunkTFOPHZ3Ucjs.TILE;
+    const oy = ty * _chunkTFOPHZ3Ucjs.TILE;
+    const x0 = Math.max(rect.x, ox);
+    const y0 = Math.max(rect.y, oy);
+    const x1 = Math.min(rect.x + w, ox + _chunkTFOPHZ3Ucjs.TILE);
+    const y1 = Math.min(rect.y + h, oy + _chunkTFOPHZ3Ucjs.TILE);
+    const full = x0 === ox && y0 === oy && x1 === ox + _chunkTFOPHZ3Ucjs.TILE && y1 === oy + _chunkTFOPHZ3Ucjs.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) * _chunkTFOPHZ3Ucjs.TILE + (x0 - ox)) * ch;
+      t.set(samples.subarray(s, s + span), d);
     }
-    return null;
-  };
-  return walk(layers, null, []);
+    const tile = deepTile(t, ch, surface.defaultValue);
+    if (tile) tiles.set(key, tile);
+    else tiles.delete(key);
+  }
+  return new (0, _chunkTFOPHZ3Ucjs.TiledSurface)(ch, tiles, surface.defaultValue);
 }
-function mapLayer(layers, id, fn) {
-  let changed = false;
-  const walk = (list) => {
-    let out = null;
-    for (let i = 0; i < list.length; i++) {
-      const l = list[i];
-      let next = l;
-      if (l.id === id) {
-        next = fn(l);
-        changed = true;
-      } else {
-        const c = childrenOf(l);
-        if (c) {
-          const children = walk(c);
-          if (children !== c) next = { ...l, children };
-        }
-      }
-      if (next !== l) {
-        if (!out) out = list.slice(0, i);
-        if (next) out.push(next);
-      } else if (out) out.push(l);
-    }
-    return _nullishCoalesce(out, () => ( list));
-  };
-  const result = walk(layers);
-  return changed ? result : layers;
+function surfaceFromDeepPixels(pixels, channels = 4, x = 0, y = 0, defaultValue = 0) {
+  return writeDeepRegion(_chunkTFOPHZ3Ucjs.emptySurface.call(void 0, channels, defaultValue), { x, y, width: pixels.width, height: pixels.height }, pixels.data);
 }
-function insertLayer(layers, layer, parentId, index) {
-  const put = (list) => {
-    const at = index === void 0 ? list.length : Math.max(0, Math.min(list.length, index));
-    const next = list.slice();
-    next.splice(at, 0, layer);
-    return next;
-  };
-  if (!parentId) return put(layers);
-  return mapLayer(layers, parentId, (g) => {
-    const c = childrenOf(g);
-    return c ? { ...g, children: put(c) } : g;
-  });
+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 = _chunkTFOPHZ3Ucjs.finishTile.call(void 0, 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 (0, _chunkTFOPHZ3Ucjs.TiledSurface)(ch, tiles, surface.defaultValue) : surface;
 }
-function isLayerLocked(layer, what) {
-  return Boolean(_optionalChain([layer, 'access', _2 => _2.locks, 'optionalAccess', _3 => _3.all]) || _optionalChain([layer, 'access', _4 => _4.locks, 'optionalAccess', _5 => _5[what]]));
+function deepBytes(surface) {
+  let n = 0;
+  for (const t of surface.tiles.values()) if (t.deep) n += t.deep.byteLength;
+  return n;
 }
 
 // src/raster/effects/model.ts
@@ -387,7 +463,7 @@ function oneOf(r, key, path, values) {
   if (typeof r[key] !== "string" || !values.includes(r[key])) fail(`${path}.${key}`, `must be one of ${values.join(", ")}.`);
 }
 function blend(r, key, path) {
-  if (!_chunkXIOMMGPDcjs.isBlendMode.call(void 0, r[key])) fail(`${path}.${key}`, `must be a blend mode such as normal, multiply or screen (got ${JSON.stringify(r[key])}).`);
+  if (!_chunkTFOPHZ3Ucjs.isBlendMode.call(void 0, r[key])) fail(`${path}.${key}`, `must be a blend mode such as normal, multiply or screen (got ${JSON.stringify(r[key])}).`);
   if (r[key] === "pigment") fail(`${path}.${key}`, "pigment is a layer blend mode only; effects cannot use it.");
 }
 function contour(v, path) {
@@ -559,73 +635,502 @@ function validateLayerEffect(v, path = "effect") {
       break;
   }
 }
-function mergeLayerEffect(effect, changes) {
-  if ("kind" in changes && changes.kind !== effect.kind) throw new LayerEffectError(`kind cannot change (${effect.kind}); remove the effect and add a new one.`);
-  if ("id" in changes && changes.id !== effect.id) throw new LayerEffectError("id cannot change.");
-  const next = { ...effect };
-  for (const [k, v] of Object.entries(changes)) {
-    if (v === null) delete next[k];
-    else next[k] = v;
+function mergeLayerEffect(effect, changes) {
+  if ("kind" in changes && changes.kind !== effect.kind) throw new LayerEffectError(`kind cannot change (${effect.kind}); remove the effect and add a new one.`);
+  if ("id" in changes && changes.id !== effect.id) throw new LayerEffectError("id cannot change.");
+  const next = { ...effect };
+  for (const [k, v] of Object.entries(changes)) {
+    if (v === null) delete next[k];
+    else next[k] = v;
+  }
+  validateLayerEffect(next);
+  return next;
+}
+function validateLayerEffects(v) {
+  if (!v || typeof v !== "object") fail("effects", "must be { enabled, items }.");
+  const r = v;
+  bool(r, "enabled", "effects");
+  if (r.scale !== void 0) num(r, "scale", "effects", 0.01, 10);
+  if (!Array.isArray(r.items)) fail("effects.items", "must be a list.");
+  const ids = /* @__PURE__ */ new Set();
+  r.items.forEach((e, i) => {
+    validateLayerEffect(e, `effects.items[${i}]`);
+    if (ids.has(e.id)) fail(`effects.items[${i}].id`, `duplicate id ${e.id}.`);
+    ids.add(e.id);
+  });
+}
+function normalizeLayerEffects(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  const items = [];
+  const ids = /* @__PURE__ */ new Set();
+  if (Array.isArray(r.items)) {
+    for (const it of r.items) {
+      if (!it || typeof it !== "object" || !isLayerEffectKind(it.kind)) continue;
+      const kind = it.kind;
+      const merged = { ...defaultLayerEffect(kind), ...it };
+      if (typeof merged.id !== "string" || !merged.id || ids.has(merged.id)) merged.id = newEffectId();
+      try {
+        validateLayerEffect(merged);
+      } catch (e2) {
+        continue;
+      }
+      ids.add(merged.id);
+      items.push(merged);
+    }
+  }
+  const out = { enabled: r.enabled !== false, items };
+  if (typeof r.scale === "number" && Number.isFinite(r.scale) && r.scale > 0 && r.scale !== 1) out.scale = r.scale;
+  if (r.psd && typeof r.psd === "object") {
+    const p = r.psd;
+    if (typeof p.key === "string" && p.data instanceof Uint8Array) out.psd = { key: p.key, data: p.data };
+  }
+  return items.length || out.psd ? out : void 0;
+}
+function effectsFingerprint(effects) {
+  if (!effects) return "";
+  const items = effects.items.map((e) => {
+    const { id: _id, ...rest } = e;
+    return rest;
+  });
+  return stableStringify([effects.enabled, effectsScale(effects), items]);
+}
+function stableStringify(v) {
+  if (Array.isArray(v)) return `[${v.map(stableStringify).join(",")}]`;
+  if (v && typeof v === "object") {
+    const keys = Object.keys(v).filter((k) => v[k] !== void 0).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(v[k])}`).join(",")}}`;
+  }
+  return JSON.stringify(v);
+}
+
+// src/raster/deep-compositor.ts
+var isGroup = (l) => l.type === "group";
+var DeepCompositor = class {
+  constructor(base, profile, deep, depth) {
+    this.base = base;
+    this.profile = profile;
+    this.deep = deep;
+    this.depth = depth;
+    this.linear = depth === 32;
+  }
+  
+  
+  
+  
+  
+  
+  /** The composite of `layers` over `rect` as float RGBA in the working space (`rect.width × rect.height × 4`). */
+  composite(layers, rect, sources) {
+    this.sources = sources;
+    const acc = new Float32Array(Math.max(0, rect.width * rect.height * 4));
+    if (rect.width > 0 && rect.height > 0) this.runSteps(this.buildSteps(layers), acc, true, rect);
+    return acc;
+  }
+  // --- Steps (as RasterCompositor.buildSteps) ------------------------------------
+  isPixel(l) {
+    return l.type === "pixel" || (_nullishCoalesce(_optionalChain([this, 'access', _4 => _4.profile, 'access', _5 => _5.isPixelLike, 'optionalCall', _6 => _6(l)]), () => ( false)));
+  }
+  isFilter(l) {
+    return _nullishCoalesce(_optionalChain([this, 'access', _7 => _7.profile, 'access', _8 => _8.isFilterLayer, 'optionalCall', _9 => _9(l)]), () => ( false));
+  }
+  buildSteps(layers) {
+    const steps = [];
+    for (const layer of layers) {
+      const last = steps[steps.length - 1];
+      if (layer.clipped && last && (last.kind === "content" || last.kind === "group")) {
+        last.clipped.push(layer);
+        continue;
+      }
+      if (this.isFilter(layer)) {
+        if (last && last.kind === "adjust") last.layers.push(layer);
+        else steps.push({ kind: "adjust", layers: [layer] });
+      } else if (isGroup(layer)) steps.push({ kind: "group", layer, clipped: [], steps: this.buildSteps(_nullishCoalesce(layer.children, () => ( []))) });
+      else steps.push({ kind: "content", layer, clipped: [] });
+    }
+    return steps;
+  }
+  runSteps(steps, acc, empty, r) {
+    for (const s of steps) empty = this.runStep(s, acc, empty, r);
+    return empty;
+  }
+  runStep(step, acc, empty, r) {
+    if (step.kind === "adjust") {
+      if (empty) return true;
+      this.applyFilterRun(step.layers, acc, r);
+      return false;
+    }
+    const layer = step.layer;
+    if (!layer.visible) return empty;
+    const clipped = step.clipped.filter((l) => l.visible);
+    const coverage = this.renderedAlone(layer) ? null : this.base.maskCoverage(layer, r, this.sources);
+    if (coverage && coverage.every((v) => v <= 0)) return empty;
+    if (step.kind === "group" && !this.renderedAlone(layer)) {
+      if (layer.blend === "pass-through" && !clipped.length) {
+        if (layer.opacity >= 1 && !coverage) return this.runSteps(step.steps, acc, empty, r);
+        const before = acc.slice();
+        const stillEmpty = this.runSteps(step.steps, acc, empty, r);
+        lerp(acc, before, layer.opacity, coverage);
+        return empty && stillEmpty;
+      }
+      const buf2 = new Float32Array(acc.length);
+      if (this.runSteps(step.steps, buf2, true, r)) return empty;
+      this.applyClipped(clipped, buf2, r);
+      const mode2 = layer.blend === "pass-through" ? "normal" : layer.blend;
+      this.blend(acc, buf2, mode2, layer.opacity, coverage);
+      return false;
+    }
+    const content = this.content(layer, r);
+    if (!content) return empty;
+    const alone = this.renderedAlone(layer);
+    const fill2 = !alone && this.isPixel(layer) ? _nullishCoalesce(layer.fillOpacity, () => ( 1)) : 1;
+    const mode = this.blendOf(layer);
+    if (!clipped.length) {
+      this.blend(acc, content, mode, layer.opacity * fill2, coverage);
+      return false;
+    }
+    const buf = new Float32Array(acc.length);
+    this.blend(buf, content, "normal", fill2, coverage);
+    this.applyClipped(clipped, buf, r);
+    this.blend(acc, buf, mode, layer.opacity, null);
+    return false;
+  }
+  applyClipped(clipped, buf, r) {
+    let run = [];
+    const flush = () => {
+      if (run.length) this.applyFilterRun(run, buf, r);
+      run = [];
+    };
+    for (const c of clipped) {
+      if (this.isFilter(c)) {
+        run.push(c);
+        continue;
+      }
+      flush();
+      const alone = this.renderedAlone(c);
+      const coverage = alone ? null : this.base.maskCoverage(c, r, this.sources);
+      let src;
+      if (isGroup(c) && !alone) {
+        src = new Float32Array(buf.length);
+        if (this.runSteps(this.buildSteps(_nullishCoalesce(c.children, () => ( []))), src, true, r)) continue;
+      } else src = this.content(c, r);
+      if (!src) continue;
+      const fill2 = !alone && this.isPixel(c) ? _nullishCoalesce(c.fillOpacity, () => ( 1)) : 1;
+      const keep = new Float32Array(buf.length >> 2);
+      for (let i = 3, p = 0; i < buf.length; i += 4, p++) keep[p] = buf[i];
+      this.blend(buf, src, c.blend === "pass-through" ? "normal" : this.blendOf(c), c.opacity * fill2, coverage);
+      for (let i = 3, p = 0; i < buf.length; i += 4, p++) buf[i] = keep[p];
+    }
+    flush();
+  }
+  applyFilterRun(layers, acc, r) {
+    const visible = [];
+    let masks;
+    for (const node of layers) {
+      if (!node.visible) continue;
+      const cov = this.base.maskCoverage(node, r, this.sources);
+      if (cov) {
+        if (cov.every((v) => v <= 0)) continue;
+        (masks ??= /* @__PURE__ */ new Map()).set(node.id, cov);
+      }
+      visible.push(node);
+    }
+    if (!visible.length) return;
+    if (this.deep.applyFilterRunDeep) {
+      if (this.linear) mapColour(acc, srgbEncode);
+      this.deep.applyFilterRunDeep(visible, acc, r, masks, this.sources);
+      if (this.linear) mapColour(acc, srgbDecode);
+      return;
+    }
+    const bytes = this.to8(acc);
+    _optionalChain([this, 'access', _10 => _10.profile, 'access', _11 => _11.applyFilterRun, 'optionalCall', _12 => _12(visible, bytes, r, masks, this.sources)]);
+    acc.set(this.from8(bytes));
+  }
+  // --- Layer content ---------------------------------------------------------------
+  /** Layers drawn by the 8-bit compositor alone (effects, pixel filters, content the editor draws). */
+  renderedAlone(layer) {
+    if (hasActiveEffects(layer.effects) && !this.isFilter(layer)) return true;
+    if (this.isPixel(layer)) return Boolean(_optionalChain([this, 'access', _13 => _13.profile, 'access', _14 => _14.pixelFilters, 'optionalCall', _15 => _15(layer)]));
+    return !isGroup(layer);
+  }
+  blendOf(layer) {
+    return _nullishCoalesce(_optionalChain([this, 'access', _16 => _16.profile, 'access', _17 => _17.contentBlend, 'optionalCall', _18 => _18(layer)]), () => ( layer.blend));
+  }
+  /** A layer's float RGBA over `r` (straight alpha, working space), or `null` when it has none there. */
+  content(layer, r) {
+    if (this.renderedAlone(layer)) {
+      const solo = { ...layer, blend: isGroup(layer) && layer.blend === "pass-through" ? "pass-through" : "normal", opacity: 1, clipped: false };
+      const bytes = this.base.composite([solo], r, this.sources);
+      return this.from8(bytes);
+    }
+    const surface = this.sources.surfaceOf ? this.sources.surfaceOf(layer) : layer.surface;
+    if (!surface) return null;
+    const ox = _nullishCoalesce(_optionalChain([layer, 'access', _19 => _19.offset, 'optionalAccess', _20 => _20.x]), () => ( 0));
+    const oy = _nullishCoalesce(_optionalChain([layer, 'access', _21 => _21.offset, 'optionalAccess', _22 => _22.y]), () => ( 0));
+    const samples = readDeepRegion(surface, { x: r.x - ox, y: r.y - oy, width: r.width, height: r.height }, this.depth);
+    if (samples instanceof Float32Array) return samples;
+    const out = new Float32Array(samples.length);
+    for (let i = 0; i < samples.length; i++) out[i] = samples[i] / 65535;
+    return out;
+  }
+  /** 8-bit RGBA to the working space. */
+  from8(bytes) {
+    if (this.linear) return to32From8(bytes, 4);
+    const out = new Float32Array(bytes.length);
+    for (let i = 0; i < bytes.length; i++) out[i] = bytes[i] / 255;
+    return out;
+  }
+  /** The working space to 8-bit RGBA. */
+  to8(acc) {
+    const out = new Uint8ClampedArray(acc.length);
+    for (let i = 0; i < acc.length; i += 4) {
+      for (let c = 0; c < 3; c++) out[i + c] = Math.round((this.linear ? srgbEncode(acc[i + c]) : acc[i + c]) * 255);
+      out[i + 3] = Math.round(acc[i + 3] * 255);
+    }
+    return out;
+  }
+  // --- Blending --------------------------------------------------------------------
+  /** `src` over `dst` with `mode` at `alpha` × coverage (straight alpha, float), as `blendTile`. */
+  blend(dst, src, mode, alpha, coverage) {
+    if (!(alpha > 0)) return;
+    const normal = mode === "normal";
+    const pigment = mode === "pigment";
+    const cb = [0, 0, 0];
+    const cs = [0, 0, 0];
+    const mix = [0, 0, 0];
+    for (let i = 0, p = 0; i < dst.length; i += 4, p++) {
+      const sa = src[i + 3];
+      if (!(sa > 0)) continue;
+      const k = coverage ? alpha * coverage[p] : alpha;
+      if (!(k > 0)) continue;
+      const as = Math.min(1, sa * k);
+      const ab = dst[i + 3];
+      const ao = as + ab * (1 - as);
+      if (ao <= 0) {
+        dst[i] = dst[i + 1] = dst[i + 2] = dst[i + 3] = 0;
+        continue;
+      }
+      if (normal && as >= 1) {
+        dst[i] = src[i];
+        dst[i + 1] = src[i + 1];
+        dst[i + 2] = src[i + 2];
+        dst[i + 3] = 1;
+        continue;
+      }
+      for (let c = 0; c < 3; c++) {
+        cb[c] = dst[i + c];
+        cs[c] = src[i + c];
+      }
+      if (pigment) {
+        if (this.linear) for (let c = 0; c < 3; c++) cb[c] = srgbEncode(cb[c]), cs[c] = srgbEncode(cs[c]);
+        _chunkTFOPHZ3Ucjs.mixPigmentRgb.call(void 0, cb, cs, as / ao, mix);
+        for (let c = 0; c < 3; c++) dst[i + c] = this.linear ? srgbDecode(mix[c]) : mix[c];
+        dst[i + 3] = ao;
+        continue;
+      }
+      const m = normal ? cs : _chunkTFOPHZ3Ucjs.blendRgb.call(void 0, mode, cb, cs);
+      const wb = (1 - as) * ab;
+      const ws = (1 - ab) * as;
+      const wm = as * ab;
+      for (let c = 0; c < 3; c++) dst[i + c] = (wb * cb[c] + ws * cs[c] + wm * m[c]) / ao;
+      dst[i + 3] = ao;
+    }
+  }
+};
+function lerp(dst, before, alpha, coverage) {
+  for (let i = 0, p = 0; i < dst.length; i += 4, p++) {
+    const k = coverage ? alpha * coverage[p] : alpha;
+    if (k >= 1) continue;
+    for (let c = 0; c < 4; c++) dst[i + c] = before[i + c] + (dst[i + c] - before[i + c]) * k;
+  }
+}
+function mapColour(data, f) {
+  for (let i = 0; i < data.length; i += 4) {
+    data[i] = f(data[i]);
+    data[i + 1] = f(data[i + 1]);
+    data[i + 2] = f(data[i + 2]);
+  }
+}
+function workingToSamples(data, depth) {
+  if (depth === 32) return data;
+  const out = new Uint16Array(data.length);
+  for (let i = 0; i < data.length; i++) {
+    const v = data[i];
+    out[i] = v > 0 ? v < 1 ? Math.round(v * 65535) : 65535 : 0;
+  }
+  return out;
+}
+
+// src/raster/blur.ts
+function gaussianKernel(sigma) {
+  const r = Math.ceil(sigma * 3);
+  const k = new Float32Array(2 * r + 1);
+  let s = 0;
+  for (let i = -r; i <= r; i++) {
+    const v = Math.exp(-(i * i) / (2 * sigma * sigma));
+    k[i + r] = v;
+    s += v;
+  }
+  for (let i = 0; i < k.length; i++) k[i] /= s;
+  return k;
+}
+var DIRECT_GAUSSIAN_MAX_SIGMA = 8;
+function boxRadii(sigma) {
+  const n = 3;
+  const wIdeal = Math.sqrt(12 * sigma * sigma / n + 1);
+  let wl = Math.floor(wIdeal);
+  if (wl % 2 === 0) wl--;
+  const wu = wl + 2;
+  const mIdeal = (12 * sigma * sigma - n * wl * wl - 4 * n * wl - 3 * n) / (-4 * wl - 4);
+  const m = Math.round(mIdeal);
+  const sizes = [0, 1, 2].map((i) => i < m ? wl : wu);
+  return sizes.map((s) => (s - 1) / 2);
+}
+function convolveLine(src, off, stride, len, k, edge, dst) {
+  const r = (k.length - 1) / 2;
+  for (let i = 0; i < len; i++) {
+    let a = 0;
+    const lo = i - r;
+    for (let j = 0; j < k.length; j++) {
+      let x = lo + j;
+      if (x < 0 || x >= len) {
+        if (edge === "zero") continue;
+        x = x < 0 ? 0 : len - 1;
+      }
+      a += src[off + x * stride] * k[j];
+    }
+    dst[i] = a;
+  }
+}
+function boxesLine(src, off, stride, len, radii, edge, a, b, dst) {
+  const pad = radii.reduce((s, r) => s + r, 0);
+  const plen = len + 2 * pad;
+  for (let i = 0; i < plen; i++) {
+    const j = i - pad;
+    a[i] = j < 0 ? edge === "zero" ? 0 : src[off] : j >= len ? edge === "zero" ? 0 : src[off + (len - 1) * stride] : src[off + j * stride];
+  }
+  let from = a;
+  let to = b;
+  for (const r of radii) {
+    let sum = 0;
+    for (let i = 0; i <= Math.min(r, plen - 1); i++) sum += from[i];
+    const k = 2 * r + 1;
+    for (let i = 0; i < plen; i++) {
+      to[i] = sum / k;
+      const add = i + r + 1;
+      const drop = i - r;
+      if (add < plen) sum += from[add];
+      if (drop >= 0) sum -= from[drop];
+    }
+    const t = from;
+    from = to;
+    to = t;
+  }
+  for (let i = 0; i < len; i++) dst[i] = from[i + pad];
+}
+function gaussianBlur(src, w, h, sigma, edge = "zero") {
+  const out = Float32Array.from(src);
+  if (!(sigma >= 0.1) || w <= 0 || h <= 0) return out;
+  const s = Math.min(sigma, 4 * Math.max(w, h));
+  const line = new Float32Array(Math.max(w, h));
+  const passes = [];
+  if (s <= DIRECT_GAUSSIAN_MAX_SIGMA) {
+    const k = gaussianKernel(s);
+    passes.push((buf, off, stride, len) => convolveLine(buf, off, stride, len, k, edge, line));
+  } else {
+    const radii = boxRadii(s);
+    const plen = Math.max(w, h) + 2 * radii.reduce((a2, r) => a2 + r, 0);
+    const a = new Float32Array(plen);
+    const b = new Float32Array(plen);
+    passes.push((buf, off, stride, len) => boxesLine(buf, off, stride, len, radii, edge, a, b, line));
   }
-  validateLayerEffect(next);
-  return next;
+  for (const pass of passes) {
+    for (let y = 0; y < h; y++) {
+      pass(out, y * w, 1, w);
+      out.set(line.subarray(0, w), y * w);
+    }
+  }
+  for (const pass of passes) {
+    for (let x = 0; x < w; x++) {
+      pass(out, x, w, h);
+      for (let y = 0; y < h; y++) out[y * w + x] = line[y];
+    }
+  }
+  return out;
 }
-function validateLayerEffects(v) {
-  if (!v || typeof v !== "object") fail("effects", "must be { enabled, items }.");
-  const r = v;
-  bool(r, "enabled", "effects");
-  if (r.scale !== void 0) num(r, "scale", "effects", 0.01, 10);
-  if (!Array.isArray(r.items)) fail("effects.items", "must be a list.");
-  const ids = /* @__PURE__ */ new Set();
-  r.items.forEach((e, i) => {
-    validateLayerEffect(e, `effects.items[${i}]`);
-    if (ids.has(e.id)) fail(`effects.items[${i}].id`, `duplicate id ${e.id}.`);
-    ids.add(e.id);
-  });
+
+// src/raster/layers.ts
+var childrenOf = (l) => l.type === "group" ? _nullishCoalesce(l.children, () => ( null)) : null;
+function flattenLayers(layers) {
+  const out = [];
+  const walk = (list) => {
+    for (const l of list) {
+      out.push(l);
+      const c = childrenOf(l);
+      if (c) walk(c);
+    }
+  };
+  walk(layers);
+  return out;
 }
-function normalizeLayerEffects(raw) {
-  if (!raw || typeof raw !== "object") return void 0;
-  const r = raw;
-  const items = [];
-  const ids = /* @__PURE__ */ new Set();
-  if (Array.isArray(r.items)) {
-    for (const it of r.items) {
-      if (!it || typeof it !== "object" || !isLayerEffectKind(it.kind)) continue;
-      const kind = it.kind;
-      const merged = { ...defaultLayerEffect(kind), ...it };
-      if (typeof merged.id !== "string" || !merged.id || ids.has(merged.id)) merged.id = newEffectId();
-      try {
-        validateLayerEffect(merged);
-      } catch (e2) {
-        continue;
+function findLayer(layers, id) {
+  const walk = (list, parent, path) => {
+    for (let i = 0; i < list.length; i++) {
+      const l = list[i];
+      if (l.id === id) return { layer: l, parent, index: i, path };
+      const c = childrenOf(l);
+      if (c) {
+        const g = l;
+        const hit = walk(c, g, [...path, g]);
+        if (hit) return hit;
       }
-      ids.add(merged.id);
-      items.push(merged);
     }
-  }
-  const out = { enabled: r.enabled !== false, items };
-  if (typeof r.scale === "number" && Number.isFinite(r.scale) && r.scale > 0 && r.scale !== 1) out.scale = r.scale;
-  if (r.psd && typeof r.psd === "object") {
-    const p = r.psd;
-    if (typeof p.key === "string" && p.data instanceof Uint8Array) out.psd = { key: p.key, data: p.data };
-  }
-  return items.length || out.psd ? out : void 0;
+    return null;
+  };
+  return walk(layers, null, []);
 }
-function effectsFingerprint(effects) {
-  if (!effects) return "";
-  const items = effects.items.map((e) => {
-    const { id: _id, ...rest } = e;
-    return rest;
+function mapLayer(layers, id, fn) {
+  let changed = false;
+  const walk = (list) => {
+    let out = null;
+    for (let i = 0; i < list.length; i++) {
+      const l = list[i];
+      let next = l;
+      if (l.id === id) {
+        next = fn(l);
+        changed = true;
+      } else {
+        const c = childrenOf(l);
+        if (c) {
+          const children = walk(c);
+          if (children !== c) next = { ...l, children };
+        }
+      }
+      if (next !== l) {
+        if (!out) out = list.slice(0, i);
+        if (next) out.push(next);
+      } else if (out) out.push(l);
+    }
+    return _nullishCoalesce(out, () => ( list));
+  };
+  const result = walk(layers);
+  return changed ? result : layers;
+}
+function insertLayer(layers, layer, parentId, index) {
+  const put = (list) => {
+    const at = index === void 0 ? list.length : Math.max(0, Math.min(list.length, index));
+    const next = list.slice();
+    next.splice(at, 0, layer);
+    return next;
+  };
+  if (!parentId) return put(layers);
+  return mapLayer(layers, parentId, (g) => {
+    const c = childrenOf(g);
+    return c ? { ...g, children: put(c) } : g;
   });
-  return stableStringify([effects.enabled, effectsScale(effects), items]);
 }
-function stableStringify(v) {
-  if (Array.isArray(v)) return `[${v.map(stableStringify).join(",")}]`;
-  if (v && typeof v === "object") {
-    const keys = Object.keys(v).filter((k) => v[k] !== void 0).sort();
-    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(v[k])}`).join(",")}}`;
-  }
-  return JSON.stringify(v);
+function isLayerLocked(layer, what) {
+  return Boolean(_optionalChain([layer, 'access', _23 => _23.locks, 'optionalAccess', _24 => _24.all]) || _optionalChain([layer, 'access', _25 => _25.locks, 'optionalAccess', _26 => _26[what]]));
 }
 
 // src/raster/effects/patterns.ts
@@ -1586,7 +2091,7 @@ function compositeAt(dst, i, mode, separable, sr, sg, sb, sa) {
     rgbScratchS[0] = sr;
     rgbScratchS[1] = sg;
     rgbScratchS[2] = sb;
-    _chunkXIOMMGPDcjs.mixPigmentRgb.call(void 0, rgbScratchB, rgbScratchS, sa / ao, rgbScratchM);
+    _chunkTFOPHZ3Ucjs.mixPigmentRgb.call(void 0, rgbScratchB, rgbScratchS, sa / ao, rgbScratchM);
     dst[i] = rgbScratchM[0];
     dst[i + 1] = rgbScratchM[1];
     dst[i + 2] = rgbScratchM[2];
@@ -1601,9 +2106,9 @@ function compositeAt(dst, i, mode, separable, sr, sg, sb, sa) {
     m1 = sg;
     m2 = sb;
   } else if (separable) {
-    m0 = _chunkXIOMMGPDcjs.blendChannel.call(void 0, mode, b0, sr);
-    m1 = _chunkXIOMMGPDcjs.blendChannel.call(void 0, mode, b1, sg);
-    m2 = _chunkXIOMMGPDcjs.blendChannel.call(void 0, mode, b2, sb);
+    m0 = _chunkTFOPHZ3Ucjs.blendChannel.call(void 0, mode, b0, sr);
+    m1 = _chunkTFOPHZ3Ucjs.blendChannel.call(void 0, mode, b1, sg);
+    m2 = _chunkTFOPHZ3Ucjs.blendChannel.call(void 0, mode, b2, sb);
   } else {
     rgbScratchB[0] = b0;
     rgbScratchB[1] = b1;
@@ -1611,7 +2116,7 @@ function compositeAt(dst, i, mode, separable, sr, sg, sb, sa) {
     rgbScratchS[0] = sr;
     rgbScratchS[1] = sg;
     rgbScratchS[2] = sb;
-    const m = _chunkXIOMMGPDcjs.blendRgb.call(void 0, mode, rgbScratchB, rgbScratchS);
+    const m = _chunkTFOPHZ3Ucjs.blendRgb.call(void 0, mode, rgbScratchB, rgbScratchS);
     m0 = m[0];
     m1 = m[1];
     m2 = m[2];
@@ -1625,7 +2130,7 @@ function compositeAt(dst, i, mode, separable, sr, sg, sb, sa) {
   dst[i + 3] = ao;
 }
 function paint(dst, m, color2, mode, opacity) {
-  const sep = mode !== "normal" && _chunkXIOMMGPDcjs.isSeparableBlendMode.call(void 0, mode);
+  const sep = mode !== "normal" && _chunkTFOPHZ3Ucjs.isSeparableBlendMode.call(void 0, mode);
   const c = [0, 0, 0, 1];
   const n = m.length;
   for (let i = 0; i < n; i++) {
@@ -1914,7 +2419,7 @@ function compositeLayerEffects(input) {
   }
   const premerge = !normalLike;
   if (premerge) {
-    const sep2 = _chunkXIOMMGPDcjs.isSeparableBlendMode.call(void 0, input.blend);
+    const sep2 = _chunkTFOPHZ3Ucjs.isSeparableBlendMode.call(void 0, input.blend);
     for (let i = 0; i < n; i++) {
       const p = i * 4;
       const sr = lay[p];
@@ -2034,7 +2539,7 @@ function compositeLayerEffects(input) {
     paintColor(work, fx(i, 1), e.shadowColor, e.shadowBlend, e.shadowOpacity);
   }
   const mode = premerge ? "normal" : input.blend;
-  const sep = _chunkXIOMMGPDcjs.isSeparableBlendMode.call(void 0, mode);
+  const sep = _chunkTFOPHZ3Ucjs.isSeparableBlendMode.call(void 0, mode);
   for (let i = 0; i < n; i++) {
     const p = i * 4;
     if (lay[p + 3] > 0) compositeAt(work, p, mode, sep, lay[p], lay[p + 1], lay[p + 2], lay[p + 3]);
@@ -2079,8 +2584,8 @@ function renderLayerEffects(effects, layer, backdrop, canvas, ctx) {
 }
 
 // src/raster/compositor.ts
-var TILE_PIXELS = _chunkXIOMMGPDcjs.TILE * _chunkXIOMMGPDcjs.TILE;
-var TILE_BYTES = TILE_PIXELS * 4;
+var TILE_PIXELS2 = _chunkTFOPHZ3Ucjs.TILE * _chunkTFOPHZ3Ucjs.TILE;
+var TILE_BYTES = TILE_PIXELS2 * 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;
@@ -2091,13 +2596,13 @@ function dirtyInTile(rects, tx, ty) {
   let y0 = Infinity;
   let x1 = -Infinity;
   let y1 = -Infinity;
-  const ox = tx * _chunkXIOMMGPDcjs.TILE;
-  const oy = ty * _chunkXIOMMGPDcjs.TILE;
+  const ox = tx * _chunkTFOPHZ3Ucjs.TILE;
+  const oy = ty * _chunkTFOPHZ3Ucjs.TILE;
   for (const r of rects) {
     const a = Math.max(ox, Math.floor(r.x));
     const b = Math.max(oy, Math.floor(r.y));
-    const c = Math.min(ox + _chunkXIOMMGPDcjs.TILE, Math.ceil(r.x + r.width));
-    const d = Math.min(oy + _chunkXIOMMGPDcjs.TILE, Math.ceil(r.y + r.height));
+    const c = Math.min(ox + _chunkTFOPHZ3Ucjs.TILE, Math.ceil(r.x + r.width));
+    const d = Math.min(oy + _chunkTFOPHZ3Ucjs.TILE, Math.ceil(r.y + r.height));
     if (c <= a || d <= b) continue;
     x0 = Math.min(x0, a);
     y0 = Math.min(y0, b);
@@ -2110,7 +2615,7 @@ function blendTile(dst, src, mode, alpha, coverage) {
   if (!(alpha > 0)) return;
   const normal = mode === "normal";
   const pigment = mode === "pigment";
-  const lut = !normal && _chunkXIOMMGPDcjs.isSeparableBlendMode.call(void 0, mode) ? separableLut(mode) : null;
+  const lut = !normal && _chunkTFOPHZ3Ucjs.isSeparableBlendMode.call(void 0, mode) ? separableLut(mode) : null;
   const cb = [0, 0, 0];
   const cs = [0, 0, 0];
   const n = dst.length;
@@ -2137,7 +2642,7 @@ function blendTile(dst, src, mode, alpha, coverage) {
     const d1 = dst[i + 1];
     const d2 = dst[i + 2];
     if (pigment) {
-      _chunkXIOMMGPDcjs.mixPigment8.call(void 0, d0, d1, d2, src[i], src[i + 1], src[i + 2], as / ao, cb);
+      _chunkTFOPHZ3Ucjs.mixPigment8.call(void 0, d0, d1, d2, src[i], src[i + 1], src[i + 2], as / ao, cb);
       dst[i] = Math.round(cb[0] * 255);
       dst[i + 1] = Math.round(cb[1] * 255);
       dst[i + 2] = Math.round(cb[2] * 255);
@@ -2168,7 +2673,7 @@ function blendTile(dst, src, mode, alpha, coverage) {
       cs[0] = s0;
       cs[1] = s1;
       cs[2] = s2;
-      const m = _chunkXIOMMGPDcjs.blendRgb.call(void 0, mode, cb, cs);
+      const m = _chunkTFOPHZ3Ucjs.blendRgb.call(void 0, mode, cb, cs);
       m0 = m[0];
       m1 = m[1];
       m2 = m[2];
@@ -2187,7 +2692,7 @@ function separableLut(mode) {
   let lut = separableLuts.get(mode);
   if (!lut) {
     lut = new Float64Array(65536);
-    for (let b = 0; b < 256; b++) for (let c = 0; c < 256; c++) lut[b << 8 | c] = _chunkXIOMMGPDcjs.blendChannel.call(void 0, mode, b / 255, c / 255);
+    for (let b = 0; b < 256; b++) for (let c = 0; c < 256; c++) lut[b << 8 | c] = _chunkTFOPHZ3Ucjs.blendChannel.call(void 0, mode, b / 255, c / 255);
     separableLuts.set(mode, lut);
   }
   return lut;
@@ -2206,7 +2711,7 @@ function lerpTile(dst, before, alpha, coverage) {
   }
 }
 var ZERO_TILE = new Uint8ClampedArray(TILE_BYTES);
-var isGroup = (l) => l.type === "group";
+var isGroup2 = (l) => l.type === "group";
 var RasterCompositor = (_class = class {
   constructor(profile = {}, options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);_class.prototype.__init10.call(this);_class.prototype.__init11.call(this);_class.prototype.__init12.call(this);_class.prototype.__init13.call(this);_class.prototype.__init14.call(this);_class.prototype.__init15.call(this);_class.prototype.__init16.call(this);_class.prototype.__init17.call(this);_class.prototype.__init18.call(this);_class.prototype.__init19.call(this);_class.prototype.__init20.call(this);_class.prototype.__init21.call(this);
     this.profile = profile;
@@ -2261,15 +2766,15 @@ var RasterCompositor = (_class = class {
   composite(layers, rect, sources, options = {}) {
     const out = new Uint8ClampedArray(Math.max(0, rect.width * rect.height * 4));
     this.compositeTiles(layers, rect, sources, (tx, ty, data) => {
-      const ox = tx * _chunkXIOMMGPDcjs.TILE;
-      const oy = ty * _chunkXIOMMGPDcjs.TILE;
+      const ox = tx * _chunkTFOPHZ3Ucjs.TILE;
+      const oy = ty * _chunkTFOPHZ3Ucjs.TILE;
       const x0 = Math.max(rect.x, ox);
       const y0 = Math.max(rect.y, oy);
-      const x1 = Math.min(rect.x + rect.width, ox + _chunkXIOMMGPDcjs.TILE);
-      const y1 = Math.min(rect.y + rect.height, oy + _chunkXIOMMGPDcjs.TILE);
+      const x1 = Math.min(rect.x + rect.width, ox + _chunkTFOPHZ3Ucjs.TILE);
+      const y1 = Math.min(rect.y + rect.height, oy + _chunkTFOPHZ3Ucjs.TILE);
       const span = (x1 - x0) * 4;
       for (let y = y0; y < y1; y++) {
-        const s = ((y - oy) * _chunkXIOMMGPDcjs.TILE + (x0 - ox)) * 4;
+        const s = ((y - oy) * _chunkTFOPHZ3Ucjs.TILE + (x0 - ox)) * 4;
         out.set(data.subarray(s, s + span), ((y - rect.y) * rect.width + (x0 - rect.x)) * 4);
       }
     }, options);
@@ -2290,9 +2795,9 @@ var RasterCompositor = (_class = class {
     this.callStats = stats;
     const grow = options.dirty ? this.effectsReach(layers) : 0;
     const dirty = grow > 0 ? options.dirty.map((d) => inflateRect(d, grow)) : options.dirty;
-    for (const { tx, ty } of _chunkXIOMMGPDcjs.tilesInRect.call(void 0, rect)) {
+    for (const { tx, ty } of _chunkTFOPHZ3Ucjs.tilesInRect.call(void 0, rect)) {
       stats.tiles++;
-      const before = _optionalChain([this, 'access', _6 => _6.tiles, 'access', _7 => _7.get, 'call', _8 => _8(_chunkXIOMMGPDcjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _9 => _9.result]);
+      const before = _optionalChain([this, 'access', _27 => _27.tiles, 'access', _28 => _28.get, 'call', _29 => _29(_chunkTFOPHZ3Ucjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _30 => _30.result]);
       const data = this.compositeTile(layers, steps, tx, ty, stats, dirty ? dirtyInTile(dirty, tx, ty) : null);
       onTile(tx, ty, data, data !== before);
     }
@@ -2323,10 +2828,10 @@ var RasterCompositor = (_class = class {
   // --- Steps -------------------------------------------------------------------
   /** Pixel layers, and the layer kinds the profile composites like them. */
   isPixel(l) {
-    return l.type === "pixel" || (_nullishCoalesce(_optionalChain([this, 'access', _10 => _10.profile, 'access', _11 => _11.isPixelLike, 'optionalCall', _12 => _12(l)]), () => ( false)));
+    return l.type === "pixel" || (_nullishCoalesce(_optionalChain([this, 'access', _31 => _31.profile, 'access', _32 => _32.isPixelLike, 'optionalCall', _33 => _33(l)]), () => ( false)));
   }
   isFilter(l) {
-    return _nullishCoalesce(_optionalChain([this, 'access', _13 => _13.profile, 'access', _14 => _14.isFilterLayer, 'optionalCall', _15 => _15(l)]), () => ( false));
+    return _nullishCoalesce(_optionalChain([this, 'access', _34 => _34.profile, 'access', _35 => _35.isFilterLayer, 'optionalCall', _36 => _36(l)]), () => ( false));
   }
   /**
    * Groups a layer list into compositing steps: clipped layers join the nearest unclipped
@@ -2345,7 +2850,7 @@ var RasterCompositor = (_class = class {
       if (this.isFilter(layer)) {
         if (last && last.kind === "adjust") last.layers.push(layer);
         else steps.push({ kind: "adjust", layers: [layer] });
-      } else if (isGroup(layer)) {
+      } else if (isGroup2(layer)) {
         steps.push({ kind: "group", layer, clipped: [], steps: this.buildSteps(_nullishCoalesce(layer.children, () => ( []))) });
       } else {
         steps.push({ kind: "content", layer, clipped: [] });
@@ -2356,7 +2861,7 @@ var RasterCompositor = (_class = class {
   }
   /** The index of the top-level step that holds layer `id` (searching groups and clipped layers), or -1. */
   stepIndexOf(steps, id) {
-    const holds = (l) => l.id === id || isGroup(l) && (_nullishCoalesce(l.children, () => ( []))).some(holds);
+    const holds = (l) => l.id === id || isGroup2(l) && (_nullishCoalesce(l.children, () => ( []))).some(holds);
     return steps.findIndex((s) => s.kind === "adjust" ? s.layers.some(holds) : holds(s.layer) || s.clipped.some(holds));
   }
   /** Properties of a layer that change pixels, minus its surfaces (memoised per object). */
@@ -2365,16 +2870,16 @@ var RasterCompositor = (_class = class {
     if (key !== void 0) return key;
     const mask = layer.mask ? [layer.mask.enabled !== false, _nullishCoalesce(layer.mask.density, () => ( 1)), _nullishCoalesce(layer.mask.feather, () => ( 0)), layer.mask.defaultValue, _nullishCoalesce(layer.mask.source, () => ( null))] : null;
     const base = [layer.type, layer.id, layer.visible, layer.opacity, layer.blend, Boolean(layer.clipped), mask];
-    if (this.isPixel(layer)) base.push(_nullishCoalesce(_optionalChain([layer, 'access', _16 => _16.offset, 'optionalAccess', _17 => _17.x]), () => ( 0)), _nullishCoalesce(_optionalChain([layer, 'access', _18 => _18.offset, 'optionalAccess', _19 => _19.y]), () => ( 0)), _nullishCoalesce(layer.fillOpacity, () => ( 1)));
+    if (this.isPixel(layer)) base.push(_nullishCoalesce(_optionalChain([layer, 'access', _37 => _37.offset, 'optionalAccess', _38 => _38.x]), () => ( 0)), _nullishCoalesce(_optionalChain([layer, 'access', _39 => _39.offset, 'optionalAccess', _40 => _40.y]), () => ( 0)), _nullishCoalesce(layer.fillOpacity, () => ( 1)));
     if (this.hasEffects(layer)) base.push(effectsFingerprint(layer.effects));
-    const extra = _optionalChain([this, 'access', _20 => _20.profile, 'access', _21 => _21.layerKey, 'optionalCall', _22 => _22(layer)]);
+    const extra = _optionalChain([this, 'access', _41 => _41.profile, 'access', _42 => _42.layerKey, 'optionalCall', _43 => _43(layer)]);
     if (extra !== void 0) base.push(extra);
     key = JSON.stringify(base);
     this.propsKeyCache.set(layer, key);
     return key;
   }
   compositeTile(root, steps, tx, ty, stats, dirty = null) {
-    const key = _chunkXIOMMGPDcjs.tileKey.call(void 0, tx, ty);
+    const key = _chunkTFOPHZ3Ucjs.tileKey.call(void 0, tx, ty);
     const entry = this.tiles.get(key);
     const sigs = steps.map((s) => this.stepSig(s, tx, ty));
     let first = 0;
@@ -2397,20 +2902,20 @@ var RasterCompositor = (_class = class {
         }
       }
     }
-    const tileRect = { x: tx * _chunkXIOMMGPDcjs.TILE, y: ty * _chunkXIOMMGPDcjs.TILE, width: _chunkXIOMMGPDcjs.TILE, height: _chunkXIOMMGPDcjs.TILE };
+    const tileRect = { x: tx * _chunkTFOPHZ3Ucjs.TILE, y: ty * _chunkTFOPHZ3Ucjs.TILE, width: _chunkTFOPHZ3Ucjs.TILE, height: _chunkTFOPHZ3Ucjs.TILE };
     const hint = this.hint;
     const checkpoints = /* @__PURE__ */ new Map();
     if (entry) {
       for (const [index, cp] of entry.checkpoints) if (index <= start) checkpoints.set(index, cp);
     }
     let result;
-    if (entry && dirty && (dirty.width < _chunkXIOMMGPDcjs.TILE || dirty.height < _chunkXIOMMGPDcjs.TILE)) {
+    if (entry && dirty && (dirty.width < _chunkTFOPHZ3Ucjs.TILE || dirty.height < _chunkTFOPHZ3Ucjs.TILE)) {
       const r = dirty;
       const sub = (data) => {
         const out = new Uint8ClampedArray(r.width * r.height * 4);
         if (!data) return out;
         for (let y = 0; y < r.height; y++) {
-          const s = ((r.y - tileRect.y + y) * _chunkXIOMMGPDcjs.TILE + (r.x - tileRect.x)) * 4;
+          const s = ((r.y - tileRect.y + y) * _chunkTFOPHZ3Ucjs.TILE + (r.x - tileRect.x)) * 4;
           out.set(data.subarray(s, s + r.width * 4), y * r.width * 4);
         }
         return out;
@@ -2423,7 +2928,7 @@ var RasterCompositor = (_class = class {
       }
       result = new Uint8ClampedArray(entry.result);
       for (let y = 0; y < r.height; y++) {
-        result.set(acc.subarray(y * r.width * 4, (y + 1) * r.width * 4), ((r.y - tileRect.y + y) * _chunkXIOMMGPDcjs.TILE + (r.x - tileRect.x)) * 4);
+        result.set(acc.subarray(y * r.width * 4, (y + 1) * r.width * 4), ((r.y - tileRect.y + y) * _chunkTFOPHZ3Ucjs.TILE + (r.x - tileRect.x)) * 4);
       }
     } else {
       const acc = base ? new Uint8ClampedArray(base.data) : new Uint8ClampedArray(TILE_BYTES);
@@ -2504,7 +3009,7 @@ var RasterCompositor = (_class = class {
   }
   layerSig(layer, tx, ty) {
     if (this.isFilter(layer)) return { key: this.propsKey(layer), refs: this.maskRefs(layer, tx, ty, 0, 0) };
-    if (isGroup(layer)) return this.groupSig(layer, this.buildSteps(_nullishCoalesce(layer.children, () => ( []))), tx, ty);
+    if (isGroup2(layer)) return this.groupSig(layer, this.buildSteps(_nullishCoalesce(layer.children, () => ( []))), tx, ty);
     return this.contentSig(layer, tx, ty);
   }
   groupSig(group, steps, tx, ty) {
@@ -2532,9 +3037,9 @@ var RasterCompositor = (_class = class {
     if (!this.isPixel(layer)) return { key, refs: this.maskRefs(layer, tx, ty, 0, 0) };
     const { surface, dx, dy } = this.layerPixels(layer);
     const refs = [surface.defaultValue];
-    const r = { x: tx * _chunkXIOMMGPDcjs.TILE - dx, y: ty * _chunkXIOMMGPDcjs.TILE - dy, width: _chunkXIOMMGPDcjs.TILE, height: _chunkXIOMMGPDcjs.TILE };
-    for (const t of _chunkXIOMMGPDcjs.tilesInRect.call(void 0, r)) refs.push(_nullishCoalesce(surface.getTile(t.tx, t.ty), () => ( null)));
-    refs.push(...this.maskRefs(layer, tx, ty, _nullishCoalesce(_optionalChain([layer, 'access', _23 => _23.offset, 'optionalAccess', _24 => _24.x]), () => ( 0)), _nullishCoalesce(_optionalChain([layer, 'access', _25 => _25.offset, 'optionalAccess', _26 => _26.y]), () => ( 0))));
+    const r = { x: tx * _chunkTFOPHZ3Ucjs.TILE - dx, y: ty * _chunkTFOPHZ3Ucjs.TILE - dy, width: _chunkTFOPHZ3Ucjs.TILE, height: _chunkTFOPHZ3Ucjs.TILE };
+    for (const t of _chunkTFOPHZ3Ucjs.tilesInRect.call(void 0, r)) refs.push(_nullishCoalesce(surface.getTile(t.tx, t.ty), () => ( null)));
+    refs.push(...this.maskRefs(layer, tx, ty, _nullishCoalesce(_optionalChain([layer, 'access', _44 => _44.offset, 'optionalAccess', _45 => _45.x]), () => ( 0)), _nullishCoalesce(_optionalChain([layer, 'access', _46 => _46.offset, 'optionalAccess', _47 => _47.y]), () => ( 0))));
     return { key, refs };
   }
   // --- Layer effects ------------------------------------------------------------
@@ -2564,7 +3069,7 @@ var RasterCompositor = (_class = class {
     this.fxContext = {
       light: _nullishCoalesce(sources.globalLight, () => ( DEFAULT_GLOBAL_LIGHT)),
       pattern: (id) => {
-        const p = _nullishCoalesce(_optionalChain([sources, 'access', _27 => _27.pattern, 'optionalCall', _28 => _28(id)]), () => ( builtinPattern(id)));
+        const p = _nullishCoalesce(_optionalChain([sources, 'access', _48 => _48.pattern, 'optionalCall', _49 => _49(id)]), () => ( builtinPattern(id)));
         if (!p || !(p.width > 0 && p.height > 0) || p.data.length < p.width * p.height * 4) return null;
         let t = tiles.get(p);
         if (!t) {
@@ -2594,9 +3099,9 @@ var RasterCompositor = (_class = class {
   shapeSigs(layer, region) {
     const sigs = /* @__PURE__ */ new Map();
     if (region.width <= 0 || region.height <= 0) return sigs;
-    const steps = isGroup(layer) ? this.buildSteps(_nullishCoalesce(layer.children, () => ( []))) : null;
-    for (const t of _chunkXIOMMGPDcjs.tilesInRect.call(void 0, region)) {
-      sigs.set(_chunkXIOMMGPDcjs.tileKey.call(void 0, t.tx, t.ty), steps ? this.plainGroupSig(layer, steps, t.tx, t.ty) : this.plainContentSig(layer, t.tx, t.ty));
+    const steps = isGroup2(layer) ? this.buildSteps(_nullishCoalesce(layer.children, () => ( []))) : null;
+    for (const t of _chunkTFOPHZ3Ucjs.tilesInRect.call(void 0, region)) {
+      sigs.set(_chunkTFOPHZ3Ucjs.tileKey.call(void 0, t.tx, t.ty), steps ? this.plainGroupSig(layer, steps, t.tx, t.ty) : this.plainContentSig(layer, t.tx, t.ty));
     }
     return sigs;
   }
@@ -2616,11 +3121,11 @@ var RasterCompositor = (_class = class {
    * laid out over the layer's bounds.
    */
   effectSig(layer, tx, ty) {
-    const key = (isGroup(layer) ? "Gfx" : "Cfx") + this.propsKey(layer) + this.lightKey();
+    const key = (isGroup2(layer) ? "Gfx" : "Cfx") + this.propsKey(layer) + this.lightKey();
     const region = this.effectRegion(layer);
     const m = effectsMargin(layer.effects);
     if (effectsAreLocal(activeEffectItems(layer.effects))) {
-      return { key, refs: this.shapeRefs(layer, intersectRect({ x: tx * _chunkXIOMMGPDcjs.TILE - m, y: ty * _chunkXIOMMGPDcjs.TILE - m, width: _chunkXIOMMGPDcjs.TILE + 2 * m, height: _chunkXIOMMGPDcjs.TILE + 2 * m }, region)) };
+      return { key, refs: this.shapeRefs(layer, intersectRect({ x: tx * _chunkTFOPHZ3Ucjs.TILE - m, y: ty * _chunkTFOPHZ3Ucjs.TILE - m, width: _chunkTFOPHZ3Ucjs.TILE + 2 * m, height: _chunkTFOPHZ3Ucjs.TILE + 2 * m }, region)) };
     }
     return { key, refs: [`${region.x},${region.y},${region.width},${region.height}`, ...this.shapeRefs(layer, region)] };
   }
@@ -2669,11 +3174,11 @@ var RasterCompositor = (_class = class {
    */
   shapeChanges(layer, prev, tiles, region) {
     const out = [];
-    for (const { tx, ty } of _chunkXIOMMGPDcjs.tilesInRect.call(void 0, region)) {
-      const sig = tiles.get(_chunkXIOMMGPDcjs.tileKey.call(void 0, tx, ty));
-      const old = prev.tiles.get(_chunkXIOMMGPDcjs.tileKey.call(void 0, tx, ty));
+    for (const { tx, ty } of _chunkTFOPHZ3Ucjs.tilesInRect.call(void 0, region)) {
+      const sig = tiles.get(_chunkTFOPHZ3Ucjs.tileKey.call(void 0, tx, ty));
+      const old = prev.tiles.get(_chunkTFOPHZ3Ucjs.tileKey.call(void 0, tx, ty));
       if (old ? sameSig(old, sig) : sig.refs.every((r2) => r2 === null || r2 === 0)) continue;
-      const r = intersectRect({ x: tx * _chunkXIOMMGPDcjs.TILE, y: ty * _chunkXIOMMGPDcjs.TILE, width: _chunkXIOMMGPDcjs.TILE, height: _chunkXIOMMGPDcjs.TILE }, region);
+      const r = intersectRect({ x: tx * _chunkTFOPHZ3Ucjs.TILE, y: ty * _chunkTFOPHZ3Ucjs.TILE, width: _chunkTFOPHZ3Ucjs.TILE, height: _chunkTFOPHZ3Ucjs.TILE }, region);
       if (r.width > 0 && r.height > 0) out.push(r);
     }
     const dirty = this.callDirty;
@@ -2692,7 +3197,7 @@ var RasterCompositor = (_class = class {
    * without filters or a feathered or parametric mask (those spread a change beyond it).
    */
   dirtyCoversShape(layer) {
-    if (!this.isPixel(layer) || _optionalChain([this, 'access', _29 => _29.profile, 'access', _30 => _30.pixelFilters, 'optionalCall', _31 => _31(layer)])) return false;
+    if (!this.isPixel(layer) || _optionalChain([this, 'access', _50 => _50.profile, 'access', _51 => _51.pixelFilters, 'optionalCall', _52 => _52(layer)])) return false;
     const mask = layer.mask;
     return !mask || mask.enabled === false || !mask.source && !((_nullishCoalesce(mask.feather, () => ( 0))) > 0);
   }
@@ -2709,7 +3214,7 @@ var RasterCompositor = (_class = class {
   /** A content or group layer's own pixels over `r` with its mask applied to alpha, or `null` when empty. */
   ownPixels(layer, r) {
     let rgba;
-    if (isGroup(layer)) {
+    if (isGroup2(layer)) {
       const buf = new Uint8ClampedArray(r.width * r.height * 4);
       rgba = this.runSteps(this.buildSteps(_nullishCoalesce(layer.children, () => ( []))), buf, true, r) ? null : buf;
     } else {
@@ -2743,7 +3248,7 @@ var RasterCompositor = (_class = class {
     const content = _nullishCoalesce(this.ownPixels(layer, a), () => ( new Uint8ClampedArray(a.width * a.height * 4)));
     if (clipped.length) this.applyClipped(clipped, content, a);
     const keep = keepAlpha ? sub.filter((_, i) => (i & 3) === 3) : null;
-    const blend2 = isGroup(layer) ? layer.blend === "pass-through" ? "normal" : layer.blend : this.contentBlend(layer);
+    const blend2 = isGroup2(layer) ? layer.blend === "pass-through" ? "normal" : layer.blend : this.contentBlend(layer);
     compositeLayerEffects({
       backdrop: sub,
       content,
@@ -2768,7 +3273,7 @@ var RasterCompositor = (_class = class {
     if (!mask || mask.enabled === false) return [];
     if (mask.source || (_nullishCoalesce(mask.feather, () => ( 0))) > 0) return [this.planeFor(mask, ox, oy)];
     const refs = [];
-    for (const t of _chunkXIOMMGPDcjs.tilesInRect.call(void 0, { x: tx * _chunkXIOMMGPDcjs.TILE - ox, y: ty * _chunkXIOMMGPDcjs.TILE - oy, width: _chunkXIOMMGPDcjs.TILE, height: _chunkXIOMMGPDcjs.TILE })) {
+    for (const t of _chunkTFOPHZ3Ucjs.tilesInRect.call(void 0, { x: tx * _chunkTFOPHZ3Ucjs.TILE - ox, y: ty * _chunkTFOPHZ3Ucjs.TILE - oy, width: _chunkTFOPHZ3Ucjs.TILE, height: _chunkTFOPHZ3Ucjs.TILE })) {
       refs.push(_nullishCoalesce(mask.surface.getTile(t.tx, t.ty), () => ( null)));
     }
     return refs;
@@ -2780,10 +3285,10 @@ var RasterCompositor = (_class = class {
    */
   layerPixels(layer) {
     const raw = this.sources.surfaceOf ? this.sources.surfaceOf(layer) : layer.surface;
-    const ox = _nullishCoalesce(_optionalChain([layer, 'access', _32 => _32.offset, 'optionalAccess', _33 => _33.x]), () => ( 0));
-    const oy = _nullishCoalesce(_optionalChain([layer, 'access', _34 => _34.offset, 'optionalAccess', _35 => _35.y]), () => ( 0));
-    const filters = _nullishCoalesce(_optionalChain([this, 'access', _36 => _36.profile, 'access', _37 => _37.pixelFilters, 'optionalCall', _38 => _38(layer)]), () => ( null));
-    if (!_optionalChain([filters, 'optionalAccess', _39 => _39.spatial])) return { surface: raw, dx: ox, dy: oy, perPixel: filters };
+    const ox = _nullishCoalesce(_optionalChain([layer, 'access', _53 => _53.offset, 'optionalAccess', _54 => _54.x]), () => ( 0));
+    const oy = _nullishCoalesce(_optionalChain([layer, 'access', _55 => _55.offset, 'optionalAccess', _56 => _56.y]), () => ( 0));
+    const filters = _nullishCoalesce(_optionalChain([this, 'access', _57 => _57.profile, 'access', _58 => _58.pixelFilters, 'optionalCall', _59 => _59(layer)]), () => ( null));
+    if (!_optionalChain([filters, 'optionalAccess', _60 => _60.spatial])) return { surface: raw, dx: ox, dy: oy, perPixel: filters };
     const fkey = `${ox},${oy}:${filters.key}`;
     let byKey = this.filteredCache.get(raw);
     if (!byKey) {
@@ -2800,25 +3305,25 @@ var RasterCompositor = (_class = class {
   }
   /** RGBA of a content layer over `r` (document space, inside one tile), or `null` when it has nothing there. */
   contentTile(layer, r) {
-    if (!this.isPixel(layer)) return _nullishCoalesce(_optionalChain([this, 'access', _40 => _40.profile, 'access', _41 => _41.contentTile, 'optionalCall', _42 => _42(layer, r, this.sources)]), () => ( null));
+    if (!this.isPixel(layer)) return _nullishCoalesce(_optionalChain([this, 'access', _61 => _61.profile, 'access', _62 => _62.contentTile, 'optionalCall', _63 => _63(layer, r, this.sources)]), () => ( null));
     const { surface, dx, dy, perPixel } = this.layerPixels(layer);
     const src = { x: r.x - dx, y: r.y - dy, width: r.width, height: r.height };
-    const covered = _chunkXIOMMGPDcjs.tilesInRect.call(void 0, src).map((t) => surface.getTile(t.tx, t.ty));
+    const covered = _chunkTFOPHZ3Ucjs.tilesInRect.call(void 0, src).map((t) => surface.getTile(t.tx, t.ty));
     if (surface.defaultValue === 0 && covered.every((t) => !t)) return null;
-    const aligned = r.width === _chunkXIOMMGPDcjs.TILE && r.height === _chunkXIOMMGPDcjs.TILE && src.x % _chunkXIOMMGPDcjs.TILE === 0 && src.y % _chunkXIOMMGPDcjs.TILE === 0;
+    const aligned = r.width === _chunkTFOPHZ3Ucjs.TILE && r.height === _chunkTFOPHZ3Ucjs.TILE && src.x % _chunkTFOPHZ3Ucjs.TILE === 0 && src.y % _chunkTFOPHZ3Ucjs.TILE === 0;
     if (!perPixel) {
       if (aligned && covered[0]) return covered[0].data;
-      return _chunkXIOMMGPDcjs.readRegion.call(void 0, surface, src);
+      return _chunkTFOPHZ3Ucjs.readRegion.call(void 0, surface, src);
     }
     const fkey = `${dx},${dy}:${perPixel.key}`;
     const anchor = _nullishCoalesce(covered.find(Boolean), () => ( surface));
     let byKey = this.contentCache.get(anchor);
     const refsKey = `${r.x},${r.y}:${fkey}`;
     if (aligned) {
-      const hit = _optionalChain([byKey, 'optionalAccess', _43 => _43.get, 'call', _44 => _44(refsKey)]);
+      const hit = _optionalChain([byKey, 'optionalAccess', _64 => _64.get, 'call', _65 => _65(refsKey)]);
       if (hit) return hit;
     }
-    const data = _chunkXIOMMGPDcjs.readRegion.call(void 0, surface, src);
+    const data = _chunkTFOPHZ3Ucjs.readRegion.call(void 0, surface, src);
     perPixel.apply(data, r.width, r.height);
     if (aligned) {
       if (!byKey) {
@@ -2853,11 +3358,11 @@ var RasterCompositor = (_class = class {
     const H = this.sources.height;
     let v = new Float32Array(W * H);
     if (mask.source) {
-      const generated = _nullishCoalesce(_optionalChain([this, 'access', _45 => _45.profile, 'access', _46 => _46.maskSourcePlane, 'optionalCall', _47 => _47(mask.source, W, H, this.sources)]), () => ( null));
+      const generated = _nullishCoalesce(_optionalChain([this, 'access', _66 => _66.profile, 'access', _67 => _67.maskSourcePlane, 'optionalCall', _68 => _68(mask.source, W, H, this.sources)]), () => ( null));
       if (!generated || generated.length !== W * H) v.fill(1);
       else v.set(generated);
     } else {
-      const bytes = _chunkXIOMMGPDcjs.readRegion.call(void 0, mask.surface, { x: -ox, y: -oy, width: W, height: H });
+      const bytes = _chunkTFOPHZ3Ucjs.readRegion.call(void 0, mask.surface, { x: -ox, y: -oy, width: W, height: H });
       for (let i = 0; i < v.length; i++) v[i] = bytes[i] / 255;
     }
     const feather = _nullishCoalesce(mask.feather, () => ( 0));
@@ -2872,8 +3377,8 @@ var RasterCompositor = (_class = class {
   maskTile(layer, r) {
     const mask = layer.mask;
     if (!mask || mask.enabled === false) return null;
-    const ox = this.isPixel(layer) ? _nullishCoalesce(_optionalChain([layer, 'access', _48 => _48.offset, 'optionalAccess', _49 => _49.x]), () => ( 0)) : 0;
-    const oy = this.isPixel(layer) ? _nullishCoalesce(_optionalChain([layer, 'access', _50 => _50.offset, 'optionalAccess', _51 => _51.y]), () => ( 0)) : 0;
+    const ox = this.isPixel(layer) ? _nullishCoalesce(_optionalChain([layer, 'access', _69 => _69.offset, 'optionalAccess', _70 => _70.x]), () => ( 0)) : 0;
+    const oy = this.isPixel(layer) ? _nullishCoalesce(_optionalChain([layer, 'access', _71 => _71.offset, 'optionalAccess', _72 => _72.y]), () => ( 0)) : 0;
     const n = r.width * r.height;
     const out = new Float32Array(n);
     const density = _nullishCoalesce(mask.density, () => ( 1));
@@ -2893,7 +3398,7 @@ var RasterCompositor = (_class = class {
         for (let x = x0; x < x1; x++) out[d + x] = plane.data[s + x];
       }
     } else {
-      const bytes = _chunkXIOMMGPDcjs.readRegion.call(void 0, mask.surface, { x: r.x - ox, y: r.y - oy, width: r.width, height: r.height });
+      const bytes = _chunkTFOPHZ3Ucjs.readRegion.call(void 0, mask.surface, { x: r.x - ox, y: r.y - oy, width: r.width, height: r.height });
       let all = true;
       for (let i = 0; i < n; i++) {
         out[i] = bytes[i] / 255;
@@ -2947,7 +3452,7 @@ var RasterCompositor = (_class = class {
     return empty;
   }
   contentBlend(layer) {
-    return _nullishCoalesce(_optionalChain([this, 'access', _52 => _52.profile, 'access', _53 => _53.contentBlend, 'optionalCall', _54 => _54(layer)]), () => ( layer.blend));
+    return _nullishCoalesce(_optionalChain([this, 'access', _73 => _73.profile, 'access', _74 => _74.contentBlend, 'optionalCall', _75 => _75(layer)]), () => ( layer.blend));
   }
   blendOnto(acc, src, empty, mode, alpha, coverage) {
     if (!(alpha > 0)) return empty;
@@ -2970,12 +3475,12 @@ var RasterCompositor = (_class = class {
         continue;
       }
       flush();
-      if (this.hasEffects(c) && !isGroup(c)) {
+      if (this.hasEffects(c) && !isGroup2(c)) {
         this.compositeEffects(c, [], buf, r, true);
         continue;
       }
       const coverage = this.maskTile(c, r);
-      if (isGroup(c)) {
+      if (isGroup2(c)) {
         const inner = new Uint8ClampedArray(buf.length);
         if (this.runSteps(this.buildSteps(_nullishCoalesce(c.children, () => ( []))), inner, true, r)) continue;
         const mode = c.blend === "pass-through" ? "normal" : c.blend;
@@ -3001,14 +3506,14 @@ var RasterCompositor = (_class = class {
       }
       visible.push(node);
     }
-    if (visible.length) _optionalChain([this, 'access', _55 => _55.profile, 'access', _56 => _56.applyFilterRun, 'optionalCall', _57 => _57(visible, acc, r, masks, this.sources)]);
+    if (visible.length) _optionalChain([this, 'access', _76 => _76.profile, 'access', _77 => _77.applyFilterRun, 'optionalCall', _78 => _78(visible, acc, r, masks, this.sources)]);
   }
 }, _class);
 function filterOverCanvas(surface, ox, oy, filters, width, height) {
-  if (width <= 0 || height <= 0) return _chunkXIOMMGPDcjs.emptySurface.call(void 0, 4);
-  const data = _chunkXIOMMGPDcjs.readRegion.call(void 0, surface, { x: -ox, y: -oy, width, height });
+  if (width <= 0 || height <= 0) return _chunkTFOPHZ3Ucjs.emptySurface.call(void 0, 4);
+  const data = _chunkTFOPHZ3Ucjs.readRegion.call(void 0, surface, { x: -ox, y: -oy, width, height });
   filters.apply(data, width, height);
-  return _chunkXIOMMGPDcjs.surfaceFromPixels.call(void 0, { width, height, data }, 4, 0, 0);
+  return _chunkTFOPHZ3Ucjs.surfaceFromPixels.call(void 0, { width, height, data }, 4, 0, 0);
 }
 function copyRect(data, r, a) {
   const out = new Uint8ClampedArray(a.width * a.height * 4);
@@ -3097,7 +3602,7 @@ function intersect(a, b) {
   return x1 > x && y1 > y ? { x, y, width: x1 - x, height: y1 - y } : null;
 }
 function hasTilesIn(src, r) {
-  for (const { tx, ty } of _chunkXIOMMGPDcjs.tilesInRect.call(void 0, r)) if (src.getTile(tx, ty)) return true;
+  for (const { tx, ty } of _chunkTFOPHZ3Ucjs.tilesInRect.call(void 0, r)) if (src.getTile(tx, ty)) return true;
   return false;
 }
 function readWindow(src, srcRect, rect) {
@@ -3106,7 +3611,7 @@ function readWindow(src, srcRect, rect) {
   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 = _chunkXIOMMGPDcjs.readRegion.call(void 0, src, r);
+  const px = _chunkTFOPHZ3Ucjs.readRegion.call(void 0, 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;
@@ -3248,13 +3753,13 @@ function boxReduce(src, srcRect, kx, ky) {
   const ry1 = Math.ceil((srcRect.y + srcRect.height) / ky);
   const rw = rx1 - rx0;
   const rect = { x: rx0, y: ry0, width: rw, height: ry1 - ry0 };
-  let out = _chunkXIOMMGPDcjs.emptySurface.call(void 0, ch, src.defaultValue);
-  const rowsPer = Math.max(1, Math.floor(_chunkXIOMMGPDcjs.TILE / ky));
+  let out = _chunkTFOPHZ3Ucjs.emptySurface.call(void 0, ch, src.defaultValue);
+  const rowsPer = Math.max(1, Math.floor(_chunkTFOPHZ3Ucjs.TILE / ky));
   const area = 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 = _chunkXIOMMGPDcjs.readRegion.call(void 0, src, strip);
+    const px = _chunkTFOPHZ3Ucjs.readRegion.call(void 0, src, strip);
     const red = new Uint8ClampedArray(rw * rows * ch);
     for (let j = 0; j < rows; j++) {
       for (let i = 0; i < rw; i++) {
@@ -3290,13 +3795,13 @@ function boxReduce(src, srcRect, kx, ky) {
         }
       }
     }
-    out = _chunkXIOMMGPDcjs.writeRegion.call(void 0, out, { x: rx0, y: ry, width: rw, height: rows }, red);
+    out = _chunkTFOPHZ3Ucjs.writeRegion.call(void 0, out, { x: rx0, y: ry, width: rw, height: rows }, red);
   }
   return { surface: out, rect };
 }
 function reduceSurface(src, factor) {
   const k = Math.max(1, Math.floor(factor));
-  const b = _chunkXIOMMGPDcjs.contentBounds.call(void 0, src);
+  const b = _chunkTFOPHZ3Ucjs.contentBounds.call(void 0, src);
   if (k === 1 || !b) return src;
   return boxReduce(src, b, k, k).surface;
 }
@@ -3324,7 +3829,7 @@ function checkBudget(dst, what = "result") {
   }
 }
 function assemble(src, tiles) {
-  return new (0, _chunkXIOMMGPDcjs.TiledSurface)(src.channels, tiles, src.defaultValue);
+  return new (0, _chunkTFOPHZ3Ucjs.TiledSurface)(src.channels, tiles, src.defaultValue);
 }
 function transformedBounds(source, h) {
   if (!(source.width > 0 && source.height > 0) || !_chunkMUUXNRU4cjs.invertHomography.call(void 0, h)) return null;
@@ -3336,16 +3841,16 @@ function transformSurface(src, h, options = {}) {
   const interp = _nullishCoalesce(options.interpolation, () => ( "bicubic"));
   const ch = src.channels;
   const def = src.defaultValue;
-  const empty = _chunkXIOMMGPDcjs.emptySurface.call(void 0, ch, def);
+  const empty = _chunkTFOPHZ3Ucjs.emptySurface.call(void 0, ch, def);
   const given = options.source;
   const step = normalizeStep(options.step);
   if (_chunkMUUXNRU4cjs.isIdentityHomography.call(void 0, h, 1e-12) && !given && !options.clip) return src;
   const dx = h[2] / h[8];
   const dy = h[5] / h[8];
   if (!given && !options.clip && _chunkMUUXNRU4cjs.isIdentityHomography.call(void 0, [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 _chunkXIOMMGPDcjs.translateSurface.call(void 0, src, Math.round(dx), Math.round(dy));
+    return _chunkTFOPHZ3Ucjs.translateSurface.call(void 0, src, Math.round(dx), Math.round(dy));
   }
-  let srcRect = given ? intersect(given, given) : _chunkXIOMMGPDcjs.contentBounds.call(void 0, src);
+  let srcRect = given ? intersect(given, given) : _chunkTFOPHZ3Ucjs.contentBounds.call(void 0, src);
   if (!srcRect) return empty;
   let H = h;
   let S = src;
@@ -3395,8 +3900,8 @@ function transformSurface(src, h, options = {}) {
   const sy0 = sr.y;
   const sx1 = sr.x + sr.width - 1;
   const sy1 = sr.y + sr.height - 1;
-  for (const { tx, ty } of _chunkXIOMMGPDcjs.tilesInRect.call(void 0, dst)) {
-    const t = intersect({ x: tx * _chunkXIOMMGPDcjs.TILE, y: ty * _chunkXIOMMGPDcjs.TILE, width: _chunkXIOMMGPDcjs.TILE, height: _chunkXIOMMGPDcjs.TILE }, dst);
+  for (const { tx, ty } of _chunkTFOPHZ3Ucjs.tilesInRect.call(void 0, dst)) {
+    const t = intersect({ x: tx * _chunkTFOPHZ3Ucjs.TILE, y: ty * _chunkTFOPHZ3Ucjs.TILE, width: _chunkTFOPHZ3Ucjs.TILE, height: _chunkTFOPHZ3Ucjs.TILE }, dst);
     if (!t) continue;
     const tc = [
       { x: t.x, y: t.y },
@@ -3442,11 +3947,11 @@ function transformSurface(src, h, options = {}) {
     const readable = intersect(foot, sr);
     if (!readable || !hasTilesIn(S, readable)) continue;
     const win = readWindow(S, sr, foot);
-    const out = new Uint8ClampedArray(_chunkXIOMMGPDcjs.TILE * _chunkXIOMMGPDcjs.TILE * ch);
+    const out = new Uint8ClampedArray(_chunkTFOPHZ3Ucjs.TILE * _chunkTFOPHZ3Ucjs.TILE * ch);
     if (def) out.fill(def);
     let any = false;
-    const ox = tx * _chunkXIOMMGPDcjs.TILE;
-    const oy = ty * _chunkXIOMMGPDcjs.TILE;
+    const ox = tx * _chunkTFOPHZ3Ucjs.TILE;
+    const oy = ty * _chunkTFOPHZ3Ucjs.TILE;
     let su = widen(su0);
     let sv = widen(sv0);
     const ystart = t.y - ((t.y - oy) % step + step) % step;
@@ -3482,7 +3987,7 @@ function transformSurface(src, h, options = {}) {
       const y0 = Math.max(y, t.y);
       const y1 = Math.min(y + step, t.y + t.height);
       for (let yy = y0; yy < y1; yy++) {
-        const row = (yy - oy) * _chunkXIOMMGPDcjs.TILE - ox;
+        const row = (yy - oy) * _chunkTFOPHZ3Ucjs.TILE - ox;
         for (let bi = 0, x = xstart; bi < blocks; bi++, x += step) {
           if (!rowSet[bi]) continue;
           const x0 = Math.max(x, t.x);
@@ -3494,8 +3999,8 @@ function transformSurface(src, h, options = {}) {
       }
     }
     if (!any) continue;
-    const tile = _chunkXIOMMGPDcjs.finishTile.call(void 0, out, ch, def);
-    if (tile) tiles.set(_chunkXIOMMGPDcjs.tileKey.call(void 0, tx, ty), tile);
+    const tile = _chunkTFOPHZ3Ucjs.finishTile.call(void 0, out, ch, def);
+    if (tile) tiles.set(_chunkTFOPHZ3Ucjs.tileKey.call(void 0, tx, ty), tile);
   }
   return assemble(src, tiles);
 }
@@ -3506,8 +4011,8 @@ function warpSurface(src, f, options = {}) {
   const interp = _nullishCoalesce(options.interpolation, () => ( "bicubic"));
   const ch = src.channels;
   const def = src.defaultValue;
-  const empty = _chunkXIOMMGPDcjs.emptySurface.call(void 0, ch, def);
-  const sr = options.source ? intersect(options.source, options.source) : _chunkXIOMMGPDcjs.contentBounds.call(void 0, src);
+  const empty = _chunkTFOPHZ3Ucjs.emptySurface.call(void 0, ch, def);
+  const sr = options.source ? intersect(options.source, options.source) : _chunkTFOPHZ3Ucjs.contentBounds.call(void 0, src);
   if (!sr) return empty;
   const step = normalizeStep(options.step);
   const nx = Math.min(MAX_CELLS, Math.max(1, Math.ceil(sr.width / CELL)));
@@ -3558,10 +4063,10 @@ function warpSurface(src, f, options = {}) {
       tris[t++] = a + w1;
     }
   }
-  const tx0 = Math.floor(dst.x / _chunkXIOMMGPDcjs.TILE);
-  const ty0 = Math.floor(dst.y / _chunkXIOMMGPDcjs.TILE);
-  const cols = Math.floor((dst.x + dst.width - 1) / _chunkXIOMMGPDcjs.TILE) - tx0 + 1;
-  const rows = Math.floor((dst.y + dst.height - 1) / _chunkXIOMMGPDcjs.TILE) - ty0 + 1;
+  const tx0 = Math.floor(dst.x / _chunkTFOPHZ3Ucjs.TILE);
+  const ty0 = Math.floor(dst.y / _chunkTFOPHZ3Ucjs.TILE);
+  const cols = Math.floor((dst.x + dst.width - 1) / _chunkTFOPHZ3Ucjs.TILE) - tx0 + 1;
+  const rows = Math.floor((dst.y + dst.height - 1) / _chunkTFOPHZ3Ucjs.TILE) - ty0 + 1;
   const bins = Array.from({ length: cols * rows }, () => []);
   for (let k = 0; k < triCount; k++) {
     const a = tris[3 * k];
@@ -3571,10 +4076,10 @@ function warpSurface(src, f, options = {}) {
     const tminy = Math.floor(Math.min(dvy[a], dvy[b], dvy[c]));
     const tmaxx = Math.ceil(Math.max(dvx[a], dvx[b], dvx[c]));
     const tmaxy = Math.ceil(Math.max(dvy[a], dvy[b], dvy[c]));
-    const cx0 = Math.max(0, Math.floor(Math.max(tminx, dst.x) / _chunkXIOMMGPDcjs.TILE) - tx0);
-    const cy0 = Math.max(0, Math.floor(Math.max(tminy, dst.y) / _chunkXIOMMGPDcjs.TILE) - ty0);
-    const cx1 = Math.min(cols - 1, Math.floor(Math.min(tmaxx, dst.x + dst.width - 1) / _chunkXIOMMGPDcjs.TILE) - tx0);
-    const cy1 = Math.min(rows - 1, Math.floor(Math.min(tmaxy, dst.y + dst.height - 1) / _chunkXIOMMGPDcjs.TILE) - ty0);
+    const cx0 = Math.max(0, Math.floor(Math.max(tminx, dst.x) / _chunkTFOPHZ3Ucjs.TILE) - tx0);
+    const cy0 = Math.max(0, Math.floor(Math.max(tminy, dst.y) / _chunkTFOPHZ3Ucjs.TILE) - ty0);
+    const cx1 = Math.min(cols - 1, Math.floor(Math.min(tmaxx, dst.x + dst.width - 1) / _chunkTFOPHZ3Ucjs.TILE) - tx0);
+    const cy1 = Math.min(rows - 1, Math.floor(Math.min(tmaxy, dst.y + dst.height - 1) / _chunkTFOPHZ3Ucjs.TILE) - ty0);
     for (let cy = cy0; cy <= cy1; cy++) for (let cx = cx0; cx <= cx1; cx++) bins[cy * cols + cx].push(k);
   }
   const tiles = /* @__PURE__ */ new Map();
@@ -3588,7 +4093,7 @@ function warpSurface(src, f, options = {}) {
       if (!list.length) continue;
       const ttx = tx0 + cx;
       const tty = ty0 + cy;
-      const t = intersect({ x: ttx * _chunkXIOMMGPDcjs.TILE, y: tty * _chunkXIOMMGPDcjs.TILE, width: _chunkXIOMMGPDcjs.TILE, height: _chunkXIOMMGPDcjs.TILE }, dst);
+      const t = intersect({ x: ttx * _chunkTFOPHZ3Ucjs.TILE, y: tty * _chunkTFOPHZ3Ucjs.TILE, width: _chunkTFOPHZ3Ucjs.TILE, height: _chunkTFOPHZ3Ucjs.TILE }, dst);
       if (!t) continue;
       const tw = t.width;
       const th = t.height;
@@ -3678,11 +4183,11 @@ function warpSurface(src, f, options = {}) {
       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 out = new Uint8ClampedArray(_chunkXIOMMGPDcjs.TILE * _chunkXIOMMGPDcjs.TILE * ch);
+      const out = new Uint8ClampedArray(_chunkTFOPHZ3Ucjs.TILE * _chunkTFOPHZ3Ucjs.TILE * ch);
       if (def) out.fill(def);
       let any = false;
-      const ox = ttx * _chunkXIOMMGPDcjs.TILE;
-      const oy = tty * _chunkXIOMMGPDcjs.TILE;
+      const ox = ttx * _chunkTFOPHZ3Ucjs.TILE;
+      const oy = tty * _chunkTFOPHZ3Ucjs.TILE;
       const pointAt = (o, into) => {
         const li = owner[o];
         const cnx = ssx[li];
@@ -3713,7 +4218,7 @@ 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) * _chunkXIOMMGPDcjs.TILE + (x - ox)) * ch, acc, ch, def)) any = true;
+          if (store(out, ((y - oy) * _chunkTFOPHZ3Ucjs.TILE + (x - ox)) * ch, acc, ch, def)) any = true;
         }
       } else {
         for (let by = 0; by < th; by += step) {
@@ -3721,19 +4226,19 @@ function warpSurface(src, f, options = {}) {
             const o = by * tw + bx;
             if (Number.isNaN(us[o])) continue;
             pointAt(o, acc);
-            const first = ((t.y + by - oy) * _chunkXIOMMGPDcjs.TILE + (t.x + bx - ox)) * ch;
+            const first = ((t.y + by - oy) * _chunkTFOPHZ3Ucjs.TILE + (t.x + bx - ox)) * ch;
             if (!store(out, first, acc, ch, def)) continue;
             any = true;
             for (let yy = by; yy < Math.min(th, by + step); yy++) {
-              const row = ((t.y + yy - oy) * _chunkXIOMMGPDcjs.TILE + (t.x - ox)) * ch;
+              const row = ((t.y + yy - oy) * _chunkTFOPHZ3Ucjs.TILE + (t.x - ox)) * ch;
               for (let xx = bx; xx < Math.min(tw, bx + step); xx++) for (let c = 0; c < ch; c++) out[row + xx * ch + c] = out[first + c];
             }
           }
         }
       }
       if (!any) continue;
-      const tile = _chunkXIOMMGPDcjs.finishTile.call(void 0, out, ch, def);
-      if (tile) tiles.set(_chunkXIOMMGPDcjs.tileKey.call(void 0, ttx, tty), tile);
+      const tile = _chunkTFOPHZ3Ucjs.finishTile.call(void 0, out, ch, def);
+      if (tile) tiles.set(_chunkTFOPHZ3Ucjs.tileKey.call(void 0, ttx, tty), tile);
     }
   }
   return assemble(src, tiles);
@@ -3749,7 +4254,7 @@ function compositeSurfaceOver(base, top) {
       tiles.set(key, t);
       continue;
     }
-    const d = new Uint8ClampedArray(_chunkXIOMMGPDcjs.TILE * _chunkXIOMMGPDcjs.TILE * ch);
+    const d = new Uint8ClampedArray(_chunkTFOPHZ3Ucjs.TILE * _chunkTFOPHZ3Ucjs.TILE * ch);
     if (under) d.set(under.data);
     else if (base.defaultValue) d.fill(base.defaultValue);
     const s = t.data;
@@ -3775,536 +4280,11 @@ function compositeSurfaceOver(base, top) {
         if (ta > 0) d[p] = s[i] * ta + d[p] * (1 - ta);
       }
     }
-    const tile = _chunkXIOMMGPDcjs.finishTile.call(void 0, d, ch, base.defaultValue);
+    const tile = _chunkTFOPHZ3Ucjs.finishTile.call(void 0, d, ch, base.defaultValue);
     if (tile) tiles.set(key, tile);
     else tiles.delete(key);
   }
-  return new (0, _chunkXIOMMGPDcjs.TiledSurface)(ch, tiles, base.defaultValue);
-}
-
-// src/raster/zlib.ts
-var LENGTH_BASE = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
-var LENGTH_EXTRA = [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];
-var DIST_BASE = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577];
-var DIST_EXTRA = [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];
-var CL_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
-var ZlibError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ZlibError";
-  }
-};
-function buildHuffman(lengths, n) {
-  const counts = new Uint16Array(16);
-  for (let i = 0; i < n; i++) counts[lengths[i]]++;
-  counts[0] = 0;
-  const offs = new Uint16Array(16);
-  for (let i = 1; i < 16; i++) offs[i] = offs[i - 1] + counts[i - 1];
-  const symbols = new Uint16Array(n);
-  for (let i = 0; i < n; i++) if (lengths[i]) symbols[offs[lengths[i]]++] = i;
-  return { counts, symbols };
-}
-var fixedLit = null;
-var fixedDist = null;
-function fixedTables() {
-  if (!fixedLit || !fixedDist) {
-    const l = new Uint8Array(288);
-    for (let i = 0; i < 144; i++) l[i] = 8;
-    for (let i = 144; i < 256; i++) l[i] = 9;
-    for (let i = 256; i < 280; i++) l[i] = 7;
-    for (let i = 280; i < 288; i++) l[i] = 8;
-    fixedLit = buildHuffman(l, 288);
-    const d = new Uint8Array(30).fill(5);
-    fixedDist = buildHuffman(d, 30);
-  }
-  return [fixedLit, fixedDist];
-}
-var BitReader = (_class2 = class {
-  constructor(data) {;_class2.prototype.__init22.call(this);_class2.prototype.__init23.call(this);_class2.prototype.__init24.call(this);
-    this.data = data;
-  }
-  
-  __init22() {this.pos = 0}
-  __init23() {this.bit = 0}
-  __init24() {this.bits = 0}
-  need(n) {
-    while (this.bits < n) {
-      if (this.pos >= this.data.length) throw new ZlibError("Unexpected end of compressed data");
-      this.bit |= this.data[this.pos++] << this.bits;
-      this.bits += 8;
-    }
-    const v = this.bit & (1 << n) - 1;
-    this.bit >>>= n;
-    this.bits -= n;
-    return v;
-  }
-  decode(h) {
-    let code = 0;
-    let first = 0;
-    let index = 0;
-    for (let len = 1; len < 16; len++) {
-      code |= this.need(1);
-      const count = h.counts[len];
-      if (code - count < first) return h.symbols[index + (code - first)];
-      index += count;
-      first += count;
-      first <<= 1;
-      code <<= 1;
-    }
-    throw new ZlibError("Invalid Huffman code");
-  }
-  align() {
-    this.bit = 0;
-    this.bits = 0;
-  }
-}, _class2);
-var Output = (_class3 = class {
-  constructor(hint, max) {;_class3.prototype.__init25.call(this);
-    this.max = max;
-    this.buf = new Uint8Array(Math.max(1024, Math.min(hint, max)));
-  }
-  
-  
-  __init25() {this.len = 0}
-  ensure(n) {
-    if (this.len + n > this.max) throw new ZlibError(`Decompressed data exceeds ${this.max} bytes`);
-    if (this.len + n <= this.buf.length) return;
-    let size = this.buf.length * 2;
-    while (size < this.len + n) size *= 2;
-    const next = new Uint8Array(Math.min(size, Math.max(this.max, this.len + n)));
-    next.set(this.buf.subarray(0, this.len));
-    this.buf = next;
-  }
-}, _class3);
-function inflateRaw(data, options = {}) {
-  const max = _nullishCoalesce(options.maxOutput, () => ( 512 * 1024 * 1024));
-  const out = new Output(_nullishCoalesce(options.sizeHint, () => ( data.length * 4)), max);
-  const br = new BitReader(data);
-  let final = 0;
-  while (!final) {
-    final = br.need(1);
-    const type = br.need(2);
-    if (type === 0) {
-      br.align();
-      if (br.pos + 4 > data.length) throw new ZlibError("Unexpected end of compressed data");
-      const len = data[br.pos] | data[br.pos + 1] << 8;
-      const nlen = data[br.pos + 2] | data[br.pos + 3] << 8;
-      br.pos += 4;
-      if ((len ^ 65535) !== nlen) throw new ZlibError("Stored block length mismatch");
-      if (br.pos + len > data.length) throw new ZlibError("Unexpected end of compressed data");
-      out.ensure(len);
-      out.buf.set(data.subarray(br.pos, br.pos + len), out.len);
-      out.len += len;
-      br.pos += len;
-      continue;
-    }
-    let lit;
-    let dist;
-    if (type === 1) [lit, dist] = fixedTables();
-    else if (type === 2) {
-      const hlit = br.need(5) + 257;
-      const hdist = br.need(5) + 1;
-      const hclen = br.need(4) + 4;
-      const cl = new Uint8Array(19);
-      for (let i2 = 0; i2 < hclen; i2++) cl[CL_ORDER[i2]] = br.need(3);
-      const clh = buildHuffman(cl, 19);
-      const lengths = new Uint8Array(hlit + hdist);
-      let i = 0;
-      while (i < hlit + hdist) {
-        const sym = br.decode(clh);
-        if (sym < 16) lengths[i++] = sym;
-        else {
-          let rep = 0;
-          let val = 0;
-          if (sym === 16) {
-            if (i === 0) throw new ZlibError("Repeat with no previous length");
-            val = lengths[i - 1];
-            rep = 3 + br.need(2);
-          } else if (sym === 17) rep = 3 + br.need(3);
-          else rep = 11 + br.need(7);
-          if (i + rep > hlit + hdist) throw new ZlibError("Too many code lengths");
-          while (rep--) lengths[i++] = val;
-        }
-      }
-      lit = buildHuffman(lengths.subarray(0, hlit), hlit);
-      dist = buildHuffman(lengths.subarray(hlit), hdist);
-    } else throw new ZlibError("Invalid block type");
-    for (; ; ) {
-      const sym = br.decode(lit);
-      if (sym < 256) {
-        out.ensure(1);
-        out.buf[out.len++] = sym;
-      } else if (sym === 256) break;
-      else {
-        const li = sym - 257;
-        if (li >= 29) throw new ZlibError("Invalid length symbol");
-        const len = LENGTH_BASE[li] + br.need(LENGTH_EXTRA[li]);
-        const di = br.decode(dist);
-        if (di >= 30) throw new ZlibError("Invalid distance symbol");
-        const d = DIST_BASE[di] + br.need(DIST_EXTRA[di]);
-        if (d > out.len) throw new ZlibError("Distance too far back");
-        out.ensure(len);
-        const buf = out.buf;
-        let p = out.len;
-        for (let k = 0; k < len; k++, p++) buf[p] = buf[p - d];
-        out.len = p;
-      }
-    }
-  }
-  return out.buf.slice(0, out.len);
-}
-function adler32(data) {
-  let a = 1;
-  let b = 0;
-  const n = data.length;
-  let i = 0;
-  while (i < n) {
-    const end = Math.min(n, i + 3800);
-    for (; i < end; i++) {
-      a += data[i];
-      b += a;
-    }
-    a %= 65521;
-    b %= 65521;
-  }
-  return (b << 16 | a) >>> 0;
-}
-function inflate(data, options = {}) {
-  if (data.length < 6) throw new ZlibError("Truncated zlib stream");
-  const cmf = data[0];
-  const flg = data[1];
-  if ((cmf & 15) !== 8 || (cmf << 8 | flg) % 31 !== 0) throw new ZlibError("Not a zlib stream");
-  if (flg & 32) throw new ZlibError("Preset dictionaries are not supported");
-  const out = inflateRaw(data.subarray(2), options);
-  if (options.verify !== false && data.length >= 6) {
-    const t = data.length - 4;
-    const want = (data[t] << 24 | data[t + 1] << 16 | data[t + 2] << 8 | data[t + 3]) >>> 0;
-    if (adler32(out) !== want) throw new ZlibError("Adler-32 mismatch");
-  }
-  return out;
-}
-var BitWriter = (_class4 = class {
-  
-  __init26() {this.len = 0}
-  __init27() {this.bit = 0}
-  __init28() {this.bits = 0}
-  constructor(hint) {;_class4.prototype.__init26.call(this);_class4.prototype.__init27.call(this);_class4.prototype.__init28.call(this);
-    this.buf = new Uint8Array(Math.max(1024, hint));
-  }
-  grow() {
-    const next = new Uint8Array(this.buf.length * 2);
-    next.set(this.buf);
-    this.buf = next;
-  }
-  write(value, n) {
-    this.bit |= value << this.bits;
-    this.bits += n;
-    while (this.bits >= 8) {
-      if (this.len >= this.buf.length) this.grow();
-      this.buf[this.len++] = this.bit & 255;
-      this.bit >>>= 8;
-      this.bits -= 8;
-    }
-  }
-  flush() {
-    if (this.bits > 0) {
-      if (this.len >= this.buf.length) this.grow();
-      this.buf[this.len++] = this.bit & 255;
-    }
-    this.bit = 0;
-    this.bits = 0;
-  }
-  bytes() {
-    return this.buf.slice(0, this.len);
-  }
-}, _class4);
-function codeLengths(freqs, maxBits) {
-  const n = freqs.length;
-  const lengths = new Uint8Array(n);
-  const f = Float64Array.from(freqs);
-  for (; ; ) {
-    const nodes = [];
-    for (let i = 0; i < n; i++) if (f[i] > 0) nodes.push({ w: f[i], sym: i });
-    lengths.fill(0);
-    if (nodes.length === 0) return lengths;
-    if (nodes.length === 1) {
-      lengths[nodes[0].sym] = 1;
-      return lengths;
-    }
-    const heap = nodes.map((_, i) => i);
-    const less = (a, b) => nodes[a].w < nodes[b].w || nodes[a].w === nodes[b].w && a < b;
-    const down = (i) => {
-      for (; ; ) {
-        const l = 2 * i + 1;
-        const r = l + 1;
-        let m = i;
-        if (l < heap.length && less(heap[l], heap[m])) m = l;
-        if (r < heap.length && less(heap[r], heap[m])) m = r;
-        if (m === i) return;
-        [heap[i], heap[m]] = [heap[m], heap[i]];
-        i = m;
-      }
-    };
-    const up = (i) => {
-      while (i > 0) {
-        const p = i - 1 >> 1;
-        if (!less(heap[i], heap[p])) return;
-        [heap[i], heap[p]] = [heap[p], heap[i]];
-        i = p;
-      }
-    };
-    for (let i = (heap.length >> 1) - 1; i >= 0; i--) down(i);
-    const pop = () => {
-      const top = heap[0];
-      const last = heap.pop();
-      if (heap.length) {
-        heap[0] = last;
-        down(0);
-      }
-      return top;
-    };
-    while (heap.length > 1) {
-      const a = pop();
-      const b = pop();
-      nodes.push({ w: nodes[a].w + nodes[b].w, sym: -1, left: a, right: b });
-      heap.push(nodes.length - 1);
-      up(heap.length - 1);
-    }
-    let maxLen = 0;
-    const stack = [[heap[0], 0]];
-    while (stack.length) {
-      const [i, d] = stack.pop();
-      const node = nodes[i];
-      if (node.sym >= 0) {
-        lengths[node.sym] = d;
-        if (d > maxLen) maxLen = d;
-      } else {
-        stack.push([node.left, d + 1], [node.right, d + 1]);
-      }
-    }
-    if (maxLen <= maxBits) return lengths;
-    for (let i = 0; i < n; i++) if (f[i] > 0) f[i] = Math.floor(f[i] / 2) + 1;
-  }
-}
-function canonicalCodes(lengths) {
-  const blCount = new Uint16Array(16);
-  for (const l of lengths) blCount[l]++;
-  blCount[0] = 0;
-  const next = new Uint16Array(16);
-  let code = 0;
-  for (let bits = 1; bits < 16; bits++) {
-    code = code + blCount[bits - 1] << 1;
-    next[bits] = code;
-  }
-  const codes = new Uint16Array(lengths.length);
-  for (let i = 0; i < lengths.length; i++) {
-    const len = lengths[i];
-    if (!len) continue;
-    let c = next[len]++;
-    let r = 0;
-    for (let k = 0; k < len; k++) {
-      r = r << 1 | c & 1;
-      c >>= 1;
-    }
-    codes[i] = r;
-  }
-  return codes;
-}
-function lengthSymbol(len) {
-  let i = 28;
-  while (LENGTH_BASE[i] > len) i--;
-  return i;
-}
-function distSymbol(d) {
-  let i = 29;
-  while (DIST_BASE[i] > d) i--;
-  return i;
-}
-var WINDOW = 32768;
-var HASH_BITS = 15;
-var HASH_SIZE = 1 << HASH_BITS;
-var MAX_CHAIN = 24;
-var MAX_MATCH = 258;
-var BLOCK_SYMBOLS = 65536;
-function deflateRaw(data, level = 1) {
-  const w = new BitWriter(Math.ceil(data.length / 2) + 64);
-  const n = data.length;
-  if (level === 0 || n === 0) {
-    let pos = 0;
-    do {
-      const len = Math.min(65535, n - pos);
-      const final = pos + len >= n ? 1 : 0;
-      w.write(final, 1);
-      w.write(0, 2);
-      w.flush();
-      w.write(len & 65535, 16);
-      w.write(~len & 65535, 16);
-      for (let i2 = 0; i2 < len; i2++) w.write(data[pos + i2], 8);
-      pos += len;
-    } while (pos < n);
-    return w.bytes();
-  }
-  const head = new Int32Array(HASH_SIZE).fill(-1);
-  const prev = new Int32Array(WINDOW);
-  const litLen = new Uint16Array(BLOCK_SYMBOLS);
-  const dists = new Uint16Array(BLOCK_SYMBOLS);
-  let count = 0;
-  const hash = (i2) => (data[i2] << 10 ^ data[i2 + 1] << 5 ^ data[i2 + 2]) * 2654435761 >>> 32 - HASH_BITS;
-  const insert = (i2) => {
-    if (i2 + 2 >= n) return;
-    const h = hash(i2);
-    prev[i2 & WINDOW - 1] = head[h];
-    head[h] = i2;
-  };
-  const flushBlock = (final) => {
-    const litFreq = new Uint32Array(286);
-    const distFreq = new Uint32Array(30);
-    for (let k = 0; k < count; k++) {
-      if (dists[k] === 0) litFreq[litLen[k]]++;
-      else {
-        litFreq[257 + lengthSymbol(litLen[k])]++;
-        distFreq[distSymbol(dists[k])]++;
-      }
-    }
-    litFreq[256] = 1;
-    let anyDist = false;
-    for (const v of distFreq) if (v) anyDist = true;
-    if (!anyDist) distFreq[0] = 1;
-    const litLengths = codeLengths(litFreq, 15);
-    const distLengths = codeLengths(distFreq, 15);
-    let hlit = 286;
-    while (hlit > 257 && !litLengths[hlit - 1]) hlit--;
-    let hdist = 30;
-    while (hdist > 1 && !distLengths[hdist - 1]) hdist--;
-    const all = new Uint8Array(hlit + hdist);
-    all.set(litLengths.subarray(0, hlit));
-    all.set(distLengths.subarray(0, hdist), hlit);
-    const clSyms = [];
-    const clExtra = [];
-    for (let i2 = 0; i2 < all.length; ) {
-      const v = all[i2];
-      let run = 1;
-      while (i2 + run < all.length && all[i2 + run] === v) run++;
-      if (v === 0 && run >= 3) {
-        const r = Math.min(run, 138);
-        if (r >= 11) {
-          clSyms.push(18);
-          clExtra.push(r - 11);
-        } else {
-          clSyms.push(17);
-          clExtra.push(r - 3);
-        }
-        i2 += r;
-      } else if (v !== 0 && run >= 4) {
-        clSyms.push(v);
-        clExtra.push(0);
-        const r = Math.min(run - 1, 6);
-        clSyms.push(16);
-        clExtra.push(r - 3);
-        i2 += r + 1;
-      } else {
-        clSyms.push(v);
-        clExtra.push(0);
-        i2++;
-      }
-    }
-    const clFreq = new Uint32Array(19);
-    for (const s of clSyms) clFreq[s]++;
-    const clLengths = codeLengths(clFreq, 7);
-    let hclen = 19;
-    while (hclen > 4 && !clLengths[CL_ORDER[hclen - 1]]) hclen--;
-    const clCodes = canonicalCodes(clLengths);
-    const litCodes = canonicalCodes(litLengths);
-    const distCodes = canonicalCodes(distLengths);
-    w.write(final ? 1 : 0, 1);
-    w.write(2, 2);
-    w.write(hlit - 257, 5);
-    w.write(hdist - 1, 5);
-    w.write(hclen - 4, 4);
-    for (let i2 = 0; i2 < hclen; i2++) w.write(clLengths[CL_ORDER[i2]], 3);
-    for (let i2 = 0; i2 < clSyms.length; i2++) {
-      const s = clSyms[i2];
-      w.write(clCodes[s], clLengths[s]);
-      if (s === 16) w.write(clExtra[i2], 2);
-      else if (s === 17) w.write(clExtra[i2], 3);
-      else if (s === 18) w.write(clExtra[i2], 7);
-    }
-    for (let k = 0; k < count; k++) {
-      const d = dists[k];
-      if (d === 0) {
-        const s = litLen[k];
-        w.write(litCodes[s], litLengths[s]);
-      } else {
-        const len = litLen[k];
-        const li = lengthSymbol(len);
-        w.write(litCodes[257 + li], litLengths[257 + li]);
-        if (LENGTH_EXTRA[li]) w.write(len - LENGTH_BASE[li], LENGTH_EXTRA[li]);
-        const di = distSymbol(d);
-        w.write(distCodes[di], distLengths[di]);
-        if (DIST_EXTRA[di]) w.write(d - DIST_BASE[di], DIST_EXTRA[di]);
-      }
-    }
-    w.write(litCodes[256], litLengths[256]);
-    count = 0;
-  };
-  let i = 0;
-  while (i < n) {
-    let bestLen = 0;
-    let bestDist = 0;
-    if (i + 2 < n) {
-      let cand = head[hash(i)];
-      let chain = MAX_CHAIN;
-      const limit = Math.min(MAX_MATCH, n - i);
-      while (cand >= 0 && i - cand <= WINDOW - 1 && chain-- > 0) {
-        if (data[cand + bestLen] === data[i + bestLen]) {
-          let l = 0;
-          while (l < limit && data[cand + l] === data[i + l]) l++;
-          if (l > bestLen) {
-            bestLen = l;
-            bestDist = i - cand;
-            if (l === limit) break;
-          }
-        }
-        const next = prev[cand & WINDOW - 1];
-        if (next >= cand) break;
-        cand = next;
-      }
-    }
-    if (bestLen >= 3) {
-      litLen[count] = bestLen;
-      dists[count] = bestDist;
-      count++;
-      const end = i + bestLen;
-      const insertEnd = bestLen > 64 ? i + 64 : end;
-      for (let k = i; k < insertEnd; k++) insert(k);
-      for (let k = Math.max(insertEnd, end - 3); k < end; k++) insert(k);
-      i = end;
-    } else {
-      litLen[count] = data[i];
-      dists[count] = 0;
-      count++;
-      insert(i);
-      i++;
-    }
-    if (count >= BLOCK_SYMBOLS - 1 && i < n) flushBlock(false);
-  }
-  flushBlock(true);
-  w.flush();
-  return w.bytes();
-}
-function deflate(data, level = 1) {
-  const raw = deflateRaw(data, level);
-  const out = new Uint8Array(raw.length + 6);
-  out[0] = 120;
-  out[1] = 1;
-  out.set(raw, 2);
-  const a = adler32(data);
-  const t = out.length - 4;
-  out[t] = a >>> 24;
-  out[t + 1] = a >>> 16 & 255;
-  out[t + 2] = a >>> 8 & 255;
-  out[t + 3] = a & 255;
-  return out;
+  return new (0, _chunkTFOPHZ3Ucjs.TiledSurface)(ch, tiles, base.defaultValue);
 }
 
 // src/raster/png.ts
@@ -4379,7 +4359,7 @@ function encodePng(width, height, data, channels = 4) {
     raw[o] = best;
     raw.set(cand[best], o + 1);
   }
-  const idat = deflate(raw);
+  const idat = _chunk643B2HKCcjs.deflate.call(void 0, raw);
   const chunks = [];
   const ihdr = new Uint8Array(13);
   writeU32(ihdr, 0, width);
@@ -4457,7 +4437,7 @@ function decodePng(bytes, options = {}) {
   }
   const bitsPerPixel = samples * depth;
   const stride = Math.ceil(width * bitsPerPixel / 8);
-  const raw = inflate(z, { maxOutput: (stride + 1) * height, sizeHint: (stride + 1) * height });
+  const raw = _chunk643B2HKCcjs.inflate.call(void 0, 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);
@@ -4689,5 +4669,23 @@ function pngDataUrl(width, height, data, channels = 4) {
 
 
 
-exports.DIRECT_GAUSSIAN_MAX_SIGMA = DIRECT_GAUSSIAN_MAX_SIGMA; exports.gaussianBlur = gaussianBlur; exports.flattenLayers = flattenLayers; exports.findLayer = findLayer; exports.mapLayer = mapLayer; exports.insertLayer = insertLayer; exports.isLayerLocked = isLayerLocked; exports.DEFAULT_GLOBAL_LIGHT = DEFAULT_GLOBAL_LIGHT; exports.LAYER_EFFECT_KINDS = LAYER_EFFECT_KINDS; exports.layerEffectLabel = layerEffectLabel; exports.isLayerEffectKind = isLayerEffectKind; exports.defaultEffectGradient = defaultEffectGradient; exports.newEffectId = newEffectId; exports.defaultLayerEffect = defaultLayerEffect; exports.hasActiveEffects = hasActiveEffects; exports.MAX_EFFECT_REACH = MAX_EFFECT_REACH; exports.effectReach = effectReach; exports.effectsMargin = effectsMargin; exports.effectsScale = effectsScale; exports.scaleLayerEffect = scaleLayerEffect; exports.parseEffectColor = parseEffectColor; exports.effectColorHex = effectColorHex; exports.LayerEffectError = LayerEffectError; exports.validateEffectGradient = validateEffectGradient; exports.layerEffectFields = layerEffectFields; exports.validateLayerEffect = validateLayerEffect; exports.mergeLayerEffect = mergeLayerEffect; exports.validateLayerEffects = validateLayerEffects; exports.normalizeLayerEffects = normalizeLayerEffects; exports.effectsFingerprint = effectsFingerprint; exports.PatternTile = PatternTile; exports.PatternPlacement = PatternPlacement; exports.builtinPatternIds = builtinPatternIds; exports.builtinPattern = builtinPattern; exports.hashNoise = hashNoise; exports.CURVE_LUT_SIZE = CURVE_LUT_SIZE; exports.curveLut = curveLut; exports.STROKE_CHAMFER_MAX = STROKE_CHAMFER_MAX; exports.contourLut = contourLut; exports.activeEffectItems = activeEffectItems; exports.effectsAreLocal = effectsAreLocal; exports.buildEffectMaps = buildEffectMaps; exports.patchEffectMaps = patchEffectMaps; exports.gradientT = gradientT; exports.effectFillColors = effectFillColors; exports.compositeLayerEffects = compositeLayerEffects; exports.renderLayerEffects = renderLayerEffects; exports.blendTile = blendTile; exports.RasterCompositor = RasterCompositor; exports.changedTiles = changedTiles; exports.INTERPOLATIONS = INTERPOLATIONS; exports.isInterpolation = isInterpolation; exports.MAX_TRANSFORM_PIXELS = MAX_TRANSFORM_PIXELS; exports.TransformTooLargeError = TransformTooLargeError; exports.keysWeight = keysWeight; exports.reduceSurface = reduceSurface; exports.transformedBounds = transformedBounds; exports.transformSurface = transformSurface; exports.warpSurface = warpSurface; exports.compositeSurfaceOver = compositeSurfaceOver; exports.ZlibError = ZlibError; exports.inflateRaw = inflateRaw; exports.adler32 = adler32; exports.inflate = inflate; exports.deflateRaw = deflateRaw; exports.deflate = deflate; exports.encodePng = encodePng; exports.isPng = isPng; exports.decodePng = decodePng; exports.bytesToBase64 = bytesToBase64; exports.base64ToBytes = base64ToBytes; exports.parseDataUrl = parseDataUrl; exports.pngDataUrl = pngDataUrl;
-//# sourceMappingURL=chunk-POGBUYWE.cjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.BIT_DEPTHS = BIT_DEPTHS; exports.isBitDepth = isBitDepth; exports.srgbDecode = srgbDecode; exports.srgbEncode = srgbEncode; exports.to16From8 = to16From8; exports.to32From8 = to32From8; exports.to32From16 = to32From16; exports.to16From32 = to16From32; exports.to8From16 = to8From16; exports.to8From32 = to8From32; exports.proxyOf = proxyOf; exports.depthOf = depthOf; exports.deepTile = deepTile; exports.tileSamples16 = tileSamples16; exports.tileSamples32 = tileSamples32; exports.tileSamples = tileSamples; exports.surfaceDepth = surfaceDepth; exports.readDeepRegion = readDeepRegion; exports.writeDeepRegion = writeDeepRegion; exports.surfaceFromDeepPixels = surfaceFromDeepPixels; exports.convertSurfaceDepth = convertSurfaceDepth; exports.deepBytes = deepBytes; exports.DEFAULT_GLOBAL_LIGHT = DEFAULT_GLOBAL_LIGHT; exports.LAYER_EFFECT_KINDS = LAYER_EFFECT_KINDS; exports.layerEffectLabel = layerEffectLabel; exports.isLayerEffectKind = isLayerEffectKind; exports.defaultEffectGradient = defaultEffectGradient; exports.newEffectId = newEffectId; exports.defaultLayerEffect = defaultLayerEffect; exports.hasActiveEffects = hasActiveEffects; exports.MAX_EFFECT_REACH = MAX_EFFECT_REACH; exports.effectReach = effectReach; exports.effectsMargin = effectsMargin; exports.effectsScale = effectsScale; exports.scaleLayerEffect = scaleLayerEffect; exports.parseEffectColor = parseEffectColor; exports.effectColorHex = effectColorHex; exports.LayerEffectError = LayerEffectError; exports.validateEffectGradient = validateEffectGradient; exports.layerEffectFields = layerEffectFields; exports.validateLayerEffect = validateLayerEffect; exports.mergeLayerEffect = mergeLayerEffect; exports.validateLayerEffects = validateLayerEffects; exports.normalizeLayerEffects = normalizeLayerEffects; exports.effectsFingerprint = effectsFingerprint; exports.DeepCompositor = DeepCompositor; exports.workingToSamples = workingToSamples; exports.DIRECT_GAUSSIAN_MAX_SIGMA = DIRECT_GAUSSIAN_MAX_SIGMA; exports.gaussianBlur = gaussianBlur; exports.flattenLayers = flattenLayers; exports.findLayer = findLayer; exports.mapLayer = mapLayer; exports.insertLayer = insertLayer; exports.isLayerLocked = isLayerLocked; exports.PatternTile = PatternTile; exports.PatternPlacement = PatternPlacement; exports.builtinPatternIds = builtinPatternIds; exports.builtinPattern = builtinPattern; exports.hashNoise = hashNoise; exports.CURVE_LUT_SIZE = CURVE_LUT_SIZE; exports.curveLut = curveLut; exports.STROKE_CHAMFER_MAX = STROKE_CHAMFER_MAX; exports.contourLut = contourLut; exports.activeEffectItems = activeEffectItems; exports.effectsAreLocal = effectsAreLocal; exports.buildEffectMaps = buildEffectMaps; exports.patchEffectMaps = patchEffectMaps; exports.gradientT = gradientT; exports.effectFillColors = effectFillColors; exports.compositeLayerEffects = compositeLayerEffects; exports.renderLayerEffects = renderLayerEffects; exports.blendTile = blendTile; exports.RasterCompositor = RasterCompositor; exports.changedTiles = changedTiles; exports.INTERPOLATIONS = INTERPOLATIONS; exports.isInterpolation = isInterpolation; exports.MAX_TRANSFORM_PIXELS = MAX_TRANSFORM_PIXELS; exports.TransformTooLargeError = TransformTooLargeError; exports.keysWeight = keysWeight; exports.reduceSurface = reduceSurface; exports.transformedBounds = transformedBounds; exports.transformSurface = transformSurface; exports.warpSurface = warpSurface; exports.compositeSurfaceOver = compositeSurfaceOver; exports.encodePng = encodePng; exports.isPng = isPng; exports.decodePng = decodePng; exports.bytesToBase64 = bytesToBase64; exports.base64ToBytes = base64ToBytes; exports.parseDataUrl = parseDataUrl; exports.pngDataUrl = pngDataUrl;
+//# sourceMappingURL=chunk-ST7E3NEE.cjs.map