@pixerate/editor 0.113.0 → 0.114.0

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

@@ -26,178 +26,254 @@ import {
   tilesInRect,
   translateSurface,
   writeRegion
-} from "./chunk-HNS7UHCM.js";
+} from "./chunk-XK5LZKBD.js";
+import {
+  deflate,
+  inflate
+} from "./chunk-6FCKOS2B.js";
 
-// 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;
+// src/raster/deep.ts
+var BIT_DEPTHS = [8, 16, 32];
+var isBitDepth = (v) => v === 8 || v === 16 || v === 32;
+var TILE_PIXELS = TILE * TILE;
+function srgbDecode(v) {
+  return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+}
+function srgbEncode(v) {
+  if (!(v > 0)) return 0;
+  return v <= 31308e-7 ? v * 12.92 : 1.055 * Math.pow(v, 1 / 2.4) - 0.055;
+}
+var LIN8 = null;
+var LIN16 = null;
+function lin8() {
+  if (!LIN8) {
+    LIN8 = new Float32Array(256);
+    for (let i = 0; i < 256; i++) LIN8[i] = srgbDecode(i / 255);
+  }
+  return LIN8;
+}
+function lin16() {
+  if (!LIN16) {
+    LIN16 = new Float32Array(65536);
+    for (let i = 0; i < 65536; i++) LIN16[i] = srgbDecode(i / 65535);
+  }
+  return LIN16;
+}
+function encode16(v) {
+  if (!(v > 0)) return 0;
+  if (v >= 1) return 65535;
+  return Math.round(srgbEncode(v) * 65535);
+}
+var ENC8 = null;
+function encode8(v) {
+  if (!(v > 0)) return 0;
+  if (v >= 1) return 255;
+  if (!ENC8) {
+    ENC8 = new Uint8Array(65536);
+    for (let i = 0; i < 65536; i++) ENC8[i] = Math.round(srgbEncode(i / 65535) * 255);
+  }
+  return ENC8[Math.round(v * 65535)];
+}
+function to16From8(data, out = new Uint16Array(data.length)) {
+  for (let i = 0; i < data.length; i++) out[i] = data[i] * 257;
+  return out;
 }
-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 finishTile(data, channels, defaultValue);
+  } else if (channels === 4 && defaultValue === 0) {
+    let empty = true;
+    for (let i = 3; i < deep.length; i += 4) {
+      if (deep[i] !== 0) {
+        empty = false;
+        break;
+      }
     }
+    if (empty) return null;
+  }
+  return { data, uniform: null, deep };
+}
+function tileSamples16(tile, channels, defaultValue = 0) {
+  const deep = tile?.deep;
+  if (deep instanceof Uint16Array) return deep;
+  if (deep instanceof Float32Array) return to16From32(deep, channels);
+  if (tile) return to16From8(tile.data);
+  return new Uint16Array(TILE_PIXELS * channels).fill(defaultValue * 257);
+}
+function tileSamples32(tile, channels, defaultValue = 0) {
+  const deep = tile?.deep;
+  if (deep instanceof Float32Array) return deep;
+  if (deep instanceof Uint16Array) return to32From16(deep, channels);
+  if (tile) return to32From8(tile.data, channels);
+  const out = new Float32Array(TILE_PIXELS * channels);
+  if (defaultValue) {
+    if (channels === 1) out.fill(defaultValue / 255);
+    else to32From8(new Uint8ClampedArray(TILE_PIXELS * 4).fill(defaultValue), 4, out);
   }
   return out;
 }
-
-// src/raster/layers.ts
-var childrenOf = (l) => l.type === "group" ? 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 tilesInRect(rect)) {
+    const tile = surface.tiles.get(tileKey(tx, ty));
+    if (!tile) continue;
+    const src = tileSamples(tile, ch, depth, surface.defaultValue);
+    const ox = tx * TILE;
+    const oy = ty * TILE;
+    const x0 = Math.max(rect.x, ox);
+    const y0 = Math.max(rect.y, oy);
+    const x1 = Math.min(rect.x + w, ox + TILE);
+    const y1 = Math.min(rect.y + h, oy + TILE);
+    const span = (x1 - x0) * ch;
+    for (let yy = y0; yy < y1; yy++) {
+      const s = ((yy - oy) * TILE + (x0 - ox)) * ch;
+      const d = ((yy - rect.y) * w + (x0 - rect.x)) * ch;
+      out.set(src.subarray(s, s + span), d);
     }
-  };
-  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 tilesInRect(rect)) {
+    const key = tileKey(tx, ty);
+    const ox = tx * TILE;
+    const oy = ty * TILE;
+    const x0 = Math.max(rect.x, ox);
+    const y0 = Math.max(rect.y, oy);
+    const x1 = Math.min(rect.x + w, ox + TILE);
+    const y1 = Math.min(rect.y + h, oy + TILE);
+    const full = x0 === ox && y0 === oy && x1 === ox + TILE && y1 === oy + TILE;
+    const base = full ? null : tileSamples(surface.tiles.get(key), ch, depth, surface.defaultValue);
+    const t = base ? base.slice() : depth === 16 ? new Uint16Array(TILE_PIXELS * ch) : new Float32Array(TILE_PIXELS * ch);
+    const span = (x1 - x0) * ch;
+    for (let yy = y0; yy < y1; yy++) {
+      const s = ((yy - rect.y) * w + (x0 - rect.x)) * ch;
+      const d = ((yy - oy) * TILE + (x0 - ox)) * ch;
+      t.set(samples.subarray(s, s + span), d);
     }
-    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 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 out ?? list;
-  };
-  const result = walk(layers);
-  return changed ? result : layers;
+function surfaceFromDeepPixels(pixels, channels = 4, x = 0, y = 0, defaultValue = 0) {
+  return writeDeepRegion(emptySurface(channels, defaultValue), { x, y, width: pixels.width, height: pixels.height }, pixels.data);
 }
-function 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 = finishTile(tile.data, ch, surface.defaultValue);
+    else next = deepTile(depth === 16 ? to16From32(deep, ch) : to32From16(deep, ch), ch, surface.defaultValue);
+    if (next) tiles.set(key, next);
+    else tiles.delete(key);
+  }
+  return changed ? new TiledSurface(ch, tiles, surface.defaultValue) : surface;
 }
-function isLayerLocked(layer, what) {
-  return Boolean(layer.locks?.all || layer.locks?.[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
@@ -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 {
+        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;
+  }
+  base;
+  profile;
+  deep;
+  depth;
+  sources;
+  linear;
+  /** 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" || (this.profile.isPixelLike?.(l) ?? false);
+  }
+  isFilter(l) {
+    return this.profile.isFilterLayer?.(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(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) ? 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(c.children ?? []), src, true, r)) continue;
+      } else src = this.content(c, r);
+      if (!src) continue;
+      const fill2 = !alone && this.isPixel(c) ? 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);
+    this.profile.applyFilterRun?.(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(this.profile.pixelFilters?.(layer));
+    return !isGroup(layer);
+  }
+  blendOf(layer) {
+    return this.profile.contentBlend?.(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 = layer.offset?.x ?? 0;
+    const oy = layer.offset?.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]);
+        mixPigmentRgb(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 : blendRgb(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" ? 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 {
-        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 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(layer.locks?.all || layer.locks?.[what]);
 }
 
 // src/raster/effects/patterns.ts
@@ -2079,8 +2584,8 @@ function renderLayerEffects(effects, layer, backdrop, canvas, ctx) {
 }
 
 // src/raster/compositor.ts
-var TILE_PIXELS = TILE * TILE;
-var TILE_BYTES = TILE_PIXELS * 4;
+var TILE_PIXELS2 = TILE * 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;
@@ -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 {
   constructor(profile = {}, options = {}) {
     this.profile = profile;
@@ -2345,7 +2850,7 @@ var RasterCompositor = 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(layer.children ?? []) });
       } else {
         steps.push({ kind: "content", layer, clipped: [] });
@@ -2356,7 +2861,7 @@ var RasterCompositor = 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) && (l.children ?? []).some(holds);
+    const holds = (l) => l.id === id || isGroup2(l) && (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). */
@@ -2504,7 +3009,7 @@ var RasterCompositor = 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(layer.children ?? []), tx, ty);
+    if (isGroup2(layer)) return this.groupSig(layer, this.buildSteps(layer.children ?? []), tx, ty);
     return this.contentSig(layer, tx, ty);
   }
   groupSig(group, steps, tx, ty) {
@@ -2594,7 +3099,7 @@ var RasterCompositor = class {
   shapeSigs(layer, region) {
     const sigs = /* @__PURE__ */ new Map();
     if (region.width <= 0 || region.height <= 0) return sigs;
-    const steps = isGroup(layer) ? this.buildSteps(layer.children ?? []) : null;
+    const steps = isGroup2(layer) ? this.buildSteps(layer.children ?? []) : null;
     for (const t of tilesInRect(region)) {
       sigs.set(tileKey(t.tx, t.ty), steps ? this.plainGroupSig(layer, steps, t.tx, t.ty) : this.plainContentSig(layer, t.tx, t.ty));
     }
@@ -2616,7 +3121,7 @@ var RasterCompositor = 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))) {
@@ -2709,7 +3214,7 @@ var RasterCompositor = 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(layer.children ?? []), buf, true, r) ? null : buf;
     } else {
@@ -2743,7 +3248,7 @@ var RasterCompositor = class {
     const content = 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,
@@ -2970,12 +3475,12 @@ var RasterCompositor = 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(c.children ?? []), inner, true, r)) continue;
         const mode = c.blend === "pass-through" ? "normal" : c.blend;
@@ -3782,531 +4287,6 @@ function compositeSurfaceOver(base, top) {
   return new 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 = class {
-  constructor(data) {
-    this.data = data;
-  }
-  data;
-  pos = 0;
-  bit = 0;
-  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;
-  }
-};
-var Output = class {
-  constructor(hint, max) {
-    this.max = max;
-    this.buf = new Uint8Array(Math.max(1024, Math.min(hint, max)));
-  }
-  max;
-  buf;
-  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;
-  }
-};
-function inflateRaw(data, options = {}) {
-  const max = options.maxOutput ?? 512 * 1024 * 1024;
-  const out = new Output(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 = class {
-  buf;
-  len = 0;
-  bit = 0;
-  bits = 0;
-  constructor(hint) {
-    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);
-  }
-};
-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;
-}
-
 // src/raster/png.ts
 var SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
 var crcTable = null;
@@ -4616,13 +4596,28 @@ function pngDataUrl(width, height, data, channels = 4) {
 }
 
 export {
-  DIRECT_GAUSSIAN_MAX_SIGMA,
-  gaussianBlur,
-  flattenLayers,
-  findLayer,
-  mapLayer,
-  insertLayer,
-  isLayerLocked,
+  BIT_DEPTHS,
+  isBitDepth,
+  srgbDecode,
+  srgbEncode,
+  to16From8,
+  to32From8,
+  to32From16,
+  to16From32,
+  to8From16,
+  to8From32,
+  proxyOf,
+  depthOf,
+  deepTile,
+  tileSamples16,
+  tileSamples32,
+  tileSamples,
+  surfaceDepth,
+  readDeepRegion,
+  writeDeepRegion,
+  surfaceFromDeepPixels,
+  convertSurfaceDepth,
+  deepBytes,
   DEFAULT_GLOBAL_LIGHT,
   LAYER_EFFECT_KINDS,
   layerEffectLabel,
@@ -4646,6 +4641,15 @@ export {
   validateLayerEffects,
   normalizeLayerEffects,
   effectsFingerprint,
+  DeepCompositor,
+  workingToSamples,
+  DIRECT_GAUSSIAN_MAX_SIGMA,
+  gaussianBlur,
+  flattenLayers,
+  findLayer,
+  mapLayer,
+  insertLayer,
+  isLayerLocked,
   PatternTile,
   PatternPlacement,
   builtinPatternIds,
@@ -4676,12 +4680,6 @@ export {
   transformSurface,
   warpSurface,
   compositeSurfaceOver,
-  ZlibError,
-  inflateRaw,
-  adler32,
-  inflate,
-  deflateRaw,
-  deflate,
   encodePng,
   isPng,
   decodePng,
@@ -4690,4 +4688,4 @@ export {
   parseDataUrl,
   pngDataUrl
 };
-//# sourceMappingURL=chunk-LQEEDHOP.js.map
+//# sourceMappingURL=chunk-C6C5PDKU.js.map