@pixerate/editor 0.87.0 → 0.89.0

package/dist/chunk-P5TPUNBZ.js

@@ -0,0 +1,1696 @@
+import {
+  TILE,
+  blendChannel,
+  blendRgb,
+  emptySurface,
+  isSeparableBlendMode,
+  readRegion,
+  surfaceFromPixels,
+  tileKey,
+  tilesInRect
+} from "./chunk-D4ZCU72J.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;
+}
+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));
+  }
+  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;
+}
+
+// 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 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;
+      }
+    }
+    return null;
+  };
+  return walk(layers, null, []);
+}
+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;
+  });
+}
+function isLayerLocked(layer, what) {
+  return Boolean(layer.locks?.all || layer.locks?.[what]);
+}
+
+// src/raster/compositor.ts
+var TILE_PIXELS = TILE * TILE;
+var TILE_BYTES = TILE_PIXELS * 4;
+function sameSig(a, b) {
+  if (!a || a.key !== b.key || a.refs.length !== b.refs.length) return false;
+  for (let i = 0; i < a.refs.length; i++) if (a.refs[i] !== b.refs[i]) return false;
+  return true;
+}
+function dirtyInTile(rects, tx, ty) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  const ox = tx * TILE;
+  const oy = ty * 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 + TILE, Math.ceil(r.x + r.width));
+    const d = Math.min(oy + TILE, Math.ceil(r.y + r.height));
+    if (c <= a || d <= b) continue;
+    x0 = Math.min(x0, a);
+    y0 = Math.min(y0, b);
+    x1 = Math.max(x1, c);
+    y1 = Math.max(y1, d);
+  }
+  return x0 === Infinity ? null : { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+}
+function blendTile(dst, src, mode, alpha, coverage) {
+  if (!(alpha > 0)) return;
+  const normal = mode === "normal";
+  const lut = !normal && isSeparableBlendMode(mode) ? separableLut(mode) : null;
+  const cb = [0, 0, 0];
+  const cs = [0, 0, 0];
+  const n = dst.length;
+  for (let i = 0, p = 0; i < n; i += 4, p++) {
+    const sa = src[i + 3];
+    if (sa === 0) continue;
+    const k = coverage ? alpha * coverage[p] : alpha;
+    if (!(k > 0)) continue;
+    if (normal && sa === 255 && k >= 1) {
+      dst[i] = src[i];
+      dst[i + 1] = src[i + 1];
+      dst[i + 2] = src[i + 2];
+      dst[i + 3] = 255;
+      continue;
+    }
+    const as = sa / 255 * k;
+    const ab = dst[i + 3] / 255;
+    const ao = as + ab * (1 - as);
+    if (ao <= 0) {
+      dst[i] = dst[i + 1] = dst[i + 2] = dst[i + 3] = 0;
+      continue;
+    }
+    const d0 = dst[i];
+    const d1 = dst[i + 1];
+    const d2 = dst[i + 2];
+    const b0 = d0 / 255;
+    const b1 = d1 / 255;
+    const b2 = d2 / 255;
+    const s0 = src[i] / 255;
+    const s1 = src[i + 1] / 255;
+    const s2 = src[i + 2] / 255;
+    let m0;
+    let m1;
+    let m2;
+    if (normal) {
+      m0 = s0;
+      m1 = s1;
+      m2 = s2;
+    } else if (lut) {
+      m0 = lut[d0 << 8 | src[i]];
+      m1 = lut[d1 << 8 | src[i + 1]];
+      m2 = lut[d2 << 8 | src[i + 2]];
+    } else {
+      cb[0] = b0;
+      cb[1] = b1;
+      cb[2] = b2;
+      cs[0] = s0;
+      cs[1] = s1;
+      cs[2] = s2;
+      const m = blendRgb(mode, cb, cs);
+      m0 = m[0];
+      m1 = m[1];
+      m2 = m[2];
+    }
+    const wb = (1 - as) * ab;
+    const ws = (1 - ab) * as;
+    const wm = as * ab;
+    dst[i] = Math.round((wb * b0 + ws * s0 + wm * m0) / ao * 255);
+    dst[i + 1] = Math.round((wb * b1 + ws * s1 + wm * m1) / ao * 255);
+    dst[i + 2] = Math.round((wb * b2 + ws * s2 + wm * m2) / ao * 255);
+    dst[i + 3] = Math.round(ao * 255);
+  }
+}
+var separableLuts = /* @__PURE__ */ new Map();
+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] = blendChannel(mode, b / 255, c / 255);
+    separableLuts.set(mode, lut);
+  }
+  return lut;
+}
+function blendAtop(dst, src, mode, alpha, coverage) {
+  const keep = new Uint8ClampedArray(dst.length >> 2);
+  for (let i = 3, p = 0; i < dst.length; i += 4, p++) keep[p] = dst[i];
+  blendTile(dst, src, mode, alpha, coverage);
+  for (let i = 3, p = 0; i < dst.length; i += 4, p++) dst[i] = keep[p];
+}
+function lerpTile(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] = Math.round(before[i + c] + (dst[i + c] - before[i + c]) * k);
+  }
+}
+var ZERO_TILE = new Uint8ClampedArray(TILE_BYTES);
+var isGroup = (l) => l.type === "group";
+var isPixel = (l) => l.type === "pixel";
+var RasterCompositor = class {
+  constructor(profile = {}, options = {}) {
+    this.profile = profile;
+    this.maxCacheBytes = options.maxCacheBytes ?? 256 * 1024 * 1024;
+  }
+  profile;
+  tiles = /* @__PURE__ */ new Map();
+  maxCacheBytes;
+  cacheBytes = 0;
+  stamp = 0;
+  sources = { width: 1, height: 1 };
+  sourcesVersion = void 0;
+  filteredCache = /* @__PURE__ */ new WeakMap();
+  planeCache = /* @__PURE__ */ new Map();
+  planeIds = /* @__PURE__ */ new WeakMap();
+  nextPlaneId = 1;
+  contentCache = /* @__PURE__ */ new WeakMap();
+  stepsCache = /* @__PURE__ */ new WeakMap();
+  propsKeyCache = /* @__PURE__ */ new WeakMap();
+  lastStats = { tiles: 0, cached: 0, stepsRun: 0 };
+  hint = -1;
+  /** Drops every cached tile and plane. */
+  clear() {
+    this.tiles.clear();
+    this.cacheBytes = 0;
+    this.planeCache.clear();
+    this.filteredCache = /* @__PURE__ */ new WeakMap();
+    this.contentCache = /* @__PURE__ */ new WeakMap();
+  }
+  setSources(sources) {
+    const version = `${sources.width}x${sources.height}:${sources.version ?? ""}`;
+    if (version !== this.sourcesVersion) {
+      this.clear();
+      this.sourcesVersion = version;
+    }
+    this.sources = sources;
+  }
+  /** The composite of `layers` over `rect` as `rect.width × rect.height` RGBA (straight alpha). */
+  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 * 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 + rect.width, ox + TILE);
+      const y1 = Math.min(rect.y + rect.height, oy + TILE);
+      const span = (x1 - x0) * 4;
+      for (let y = y0; y < y1; y++) {
+        const s = ((y - oy) * TILE + (x0 - ox)) * 4;
+        out.set(data.subarray(s, s + span), ((y - rect.y) * rect.width + (x0 - rect.x)) * 4);
+      }
+    }, options);
+    return out;
+  }
+  /**
+   * Composites every tile intersecting `rect` and calls `onTile` with each tile's RGBA buffer
+   * (TILE × TILE). A tile whose inputs did not change since the last call returns the same buffer
+   * object; never mutate it.
+   */
+  compositeTiles(layers, rect, sources, onTile, options = {}) {
+    this.setSources(sources);
+    const steps = this.buildSteps(layers);
+    this.hint = options.checkpointLayerId ? this.stepIndexOf(steps, options.checkpointLayerId) : -1;
+    this.stamp++;
+    const stats = { tiles: 0, cached: 0, stepsRun: 0 };
+    for (const { tx, ty } of tilesInRect(rect)) {
+      stats.tiles++;
+      const before = this.tiles.get(tileKey(tx, ty))?.result;
+      const data = this.compositeTile(layers, steps, tx, ty, stats, options.dirty ? dirtyInTile(options.dirty, tx, ty) : null);
+      onTile(tx, ty, data, data !== before);
+    }
+    this.lastStats = stats;
+    this.evict();
+  }
+  /** The composite of one tile (cached; do not mutate the result). */
+  tile(layers, tx, ty, sources) {
+    this.setSources(sources);
+    this.stamp++;
+    const stats = { tiles: 1, cached: 0, stepsRun: 0 };
+    this.hint = -1;
+    const data = this.compositeTile(layers, this.buildSteps(layers), tx, ty, stats);
+    this.lastStats = stats;
+    this.evict();
+    return data;
+  }
+  /**
+   * A layer's effective mask coverage (0..1, after density, feather or parametric evaluation)
+   * over `r` in document space, or `null` when it reveals all of `r`.
+   */
+  maskCoverage(layer, r, sources) {
+    this.setSources(sources);
+    return this.maskTile(layer, r);
+  }
+  // --- Steps -------------------------------------------------------------------
+  isFilter(l) {
+    return this.profile.isFilterLayer?.(l) ?? false;
+  }
+  /**
+   * Groups a layer list into compositing steps: clipped layers join the nearest unclipped
+   * content or group layer below; consecutive unclipped filter layers form one run.
+   */
+  buildSteps(layers) {
+    const cached = this.stepsCache.get(layers);
+    if (cached) return cached;
+    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: [] });
+      }
+    }
+    this.stepsCache.set(layers, steps);
+    return steps;
+  }
+  /** 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);
+    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). */
+  propsKey(layer) {
+    let key = this.propsKeyCache.get(layer);
+    if (key !== void 0) return key;
+    const mask = layer.mask ? [layer.mask.enabled !== false, layer.mask.density ?? 1, layer.mask.feather ?? 0, layer.mask.defaultValue, layer.mask.source ?? null] : null;
+    const base = [layer.type, layer.id, layer.visible, layer.opacity, layer.blend, Boolean(layer.clipped), mask];
+    if (isPixel(layer)) base.push(layer.offset?.x ?? 0, layer.offset?.y ?? 0, layer.fillOpacity ?? 1);
+    const extra = this.profile.layerKey?.(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 = tileKey(tx, ty);
+    const entry = this.tiles.get(key);
+    const sigs = steps.map((s) => this.stepSig(s, tx, ty));
+    let first = 0;
+    if (entry) {
+      while (first < sigs.length && first < entry.sigs.length && sameSig(entry.sigs[first], sigs[first])) first++;
+      if (first === sigs.length && first === entry.sigs.length) {
+        entry.stamp = this.stamp;
+        stats.cached++;
+        return entry.result;
+      }
+    }
+    let start = 0;
+    let base = null;
+    if (entry) {
+      for (const [index, cp] of entry.checkpoints) {
+        if (index <= first && index > start) {
+          start = index;
+          base = cp;
+        }
+      }
+    }
+    const tileRect = { x: tx * TILE, y: ty * TILE, width: TILE, height: 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 < TILE || dirty.height < 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) * TILE + (r.x - tileRect.x)) * 4;
+          out.set(data.subarray(s, s + r.width * 4), y * r.width * 4);
+        }
+        return out;
+      };
+      const acc = sub(base ? base.data : null);
+      let empty = base ? base.empty : true;
+      for (let i = start; i < steps.length; i++) {
+        empty = this.runStep(steps[i], acc, empty, r);
+        stats.stepsRun++;
+      }
+      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) * TILE + (r.x - tileRect.x)) * 4);
+      }
+    } else {
+      const acc = base ? new Uint8ClampedArray(base.data) : new Uint8ClampedArray(TILE_BYTES);
+      let empty = base ? base.empty : true;
+      for (let i = start; i < steps.length; i++) {
+        if ((i === first || i === hint) && i > 0 && !checkpoints.has(i)) checkpoints.set(i, { data: new Uint8ClampedArray(acc), empty });
+        empty = this.runStep(steps[i], acc, empty, tileRect);
+        stats.stepsRun++;
+      }
+      result = empty ? ZERO_TILE : acc;
+    }
+    if (checkpoints.size > 2) {
+      const keys = [...checkpoints.keys()].sort((a, b) => a - b);
+      const keep = /* @__PURE__ */ new Set([keys[keys.length - 1], first, hint]);
+      for (const k of keys) if (!keep.has(k)) checkpoints.delete(k);
+    }
+    const prevBytes = entry ? this.entryBytes(entry) : 0;
+    const next = { sigs, checkpoints, result, root, stamp: this.stamp };
+    this.tiles.set(key, next);
+    this.cacheBytes += this.entryBytes(next) - prevBytes;
+    return result;
+  }
+  entryBytes(e) {
+    let n = e.result === ZERO_TILE ? 0 : TILE_BYTES;
+    for (const cp of e.checkpoints.values()) n += cp.data.byteLength;
+    return n;
+  }
+  evict() {
+    if (this.cacheBytes <= this.maxCacheBytes) return;
+    const entries = [...this.tiles.entries()].sort((a, b) => a[1].stamp - b[1].stamp);
+    for (const [, e] of entries) {
+      if (this.cacheBytes <= this.maxCacheBytes) return;
+      for (const cp of e.checkpoints.values()) this.cacheBytes -= cp.data.byteLength;
+      e.checkpoints.clear();
+    }
+    for (const [k, e] of entries) {
+      if (this.cacheBytes <= this.maxCacheBytes) return;
+      if (e.stamp === this.stamp) continue;
+      this.cacheBytes -= this.entryBytes(e);
+      this.tiles.delete(k);
+    }
+  }
+  // --- Signatures -----------------------------------------------------------
+  stepSig(step, tx, ty) {
+    if (step.kind === "adjust") {
+      const refs2 = [];
+      let key2 = "A";
+      for (const l of step.layers) {
+        key2 += this.propsKey(l);
+        refs2.push(...this.maskRefs(l, tx, ty, 0, 0));
+      }
+      return { key: key2, refs: refs2 };
+    }
+    const own = step.kind === "content" ? this.contentSig(step.layer, tx, ty) : this.groupSig(step.layer, step.steps, tx, ty);
+    if (!step.clipped.length) return own;
+    const refs = [...own.refs];
+    let key = own.key;
+    for (const c of step.clipped) {
+      const s = this.layerSig(c, tx, ty);
+      key += "|" + s.key;
+      refs.push(...s.refs);
+    }
+    return { key, refs };
+  }
+  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);
+    return this.contentSig(layer, tx, ty);
+  }
+  groupSig(group, steps, tx, ty) {
+    let key = "G" + this.propsKey(group);
+    const refs = this.maskRefs(group, tx, ty, 0, 0);
+    if (!group.visible) return { key, refs };
+    for (const s of steps) {
+      const sig = this.stepSig(s, tx, ty);
+      key += "[" + sig.key + "]";
+      refs.push(...sig.refs);
+    }
+    return { key, refs };
+  }
+  contentSig(layer, tx, ty) {
+    const key = "C" + this.propsKey(layer);
+    if (!layer.visible) return { key, refs: [] };
+    if (!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 * TILE - dx, y: ty * TILE - dy, width: TILE, height: TILE };
+    for (const t of tilesInRect(r)) refs.push(surface.getTile(t.tx, t.ty) ?? null);
+    refs.push(...this.maskRefs(layer, tx, ty, layer.offset?.x ?? 0, layer.offset?.y ?? 0));
+    return { key, refs };
+  }
+  maskRefs(layer, tx, ty, ox, oy) {
+    const mask = layer.mask;
+    if (!mask || mask.enabled === false) return [];
+    if (mask.source || (mask.feather ?? 0) > 0) return [this.planeFor(mask, ox, oy)];
+    const refs = [];
+    for (const t of tilesInRect({ x: tx * TILE - ox, y: ty * TILE - oy, width: TILE, height: TILE })) {
+      refs.push(mask.surface.getTile(t.tx, t.ty) ?? null);
+    }
+    return refs;
+  }
+  // --- Layer pixels ------------------------------------------------------------
+  /**
+   * A pixel layer's pixels after spatial filters: the surface and the offset to apply. Layers
+   * with a spatial filter are filtered once over the canvas (in document space, offset 0).
+   */
+  layerPixels(layer) {
+    const raw = this.sources.surfaceOf ? this.sources.surfaceOf(layer) : layer.surface;
+    const ox = layer.offset?.x ?? 0;
+    const oy = layer.offset?.y ?? 0;
+    const filters = this.profile.pixelFilters?.(layer) ?? null;
+    if (!filters?.spatial) return { surface: raw, dx: ox, dy: oy, perPixel: filters };
+    const fkey = `${ox},${oy}:${filters.key}`;
+    let byKey = this.filteredCache.get(raw);
+    if (!byKey) {
+      byKey = /* @__PURE__ */ new Map();
+      this.filteredCache.set(raw, byKey);
+    }
+    let filtered = byKey.get(fkey);
+    if (!filtered) {
+      filtered = filterOverCanvas(raw, ox, oy, filters, this.sources.width, this.sources.height);
+      byKey.clear();
+      byKey.set(fkey, filtered);
+    }
+    return { surface: filtered, dx: 0, dy: 0, perPixel: null };
+  }
+  /** RGBA of a content layer over `r` (document space, inside one tile), or `null` when it has nothing there. */
+  contentTile(layer, r) {
+    if (!isPixel(layer)) return this.profile.contentTile?.(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 = tilesInRect(src).map((t) => surface.getTile(t.tx, t.ty));
+    if (surface.defaultValue === 0 && covered.every((t) => !t)) return null;
+    const aligned = r.width === TILE && r.height === TILE && src.x % TILE === 0 && src.y % TILE === 0;
+    if (!perPixel) {
+      if (aligned && covered[0]) return covered[0].data;
+      return readRegion(surface, src);
+    }
+    const fkey = `${dx},${dy}:${perPixel.key}`;
+    const anchor = covered.find(Boolean) ?? surface;
+    let byKey = this.contentCache.get(anchor);
+    const refsKey = `${r.x},${r.y}:${fkey}`;
+    if (aligned) {
+      const hit = byKey?.get(refsKey);
+      if (hit) return hit;
+    }
+    const data = readRegion(surface, src);
+    perPixel.apply(data, r.width, r.height);
+    if (aligned) {
+      if (!byKey) {
+        byKey = /* @__PURE__ */ new Map();
+        this.contentCache.set(anchor, byKey);
+      }
+      byKey.set(refsKey, data);
+    }
+    return data;
+  }
+  // --- Masks -------------------------------------------------------------------
+  planeKey(mask, ox, oy) {
+    const W = this.sources.width;
+    const H = this.sources.height;
+    let id = this.planeIds.get(mask.surface);
+    if (id === void 0) {
+      id = this.nextPlaneId++;
+      this.planeIds.set(mask.surface, id);
+    }
+    return `${id}:${ox},${oy}:${W}x${H}:${mask.feather ?? 0}:${mask.density ?? 1}:${mask.source ? JSON.stringify(mask.source) : ""}`;
+  }
+  /** Canvas-sized coverage of a feathered or parametric mask (cached). */
+  planeFor(mask, ox, oy) {
+    const key = this.planeKey(mask, ox, oy);
+    let plane = this.planeCache.get(key);
+    if (plane) {
+      this.planeCache.delete(key);
+      this.planeCache.set(key, plane);
+      return plane;
+    }
+    const W = this.sources.width;
+    const H = this.sources.height;
+    let v = new Float32Array(W * H);
+    if (mask.source) {
+      const generated = this.profile.maskSourcePlane?.(mask.source, W, H, this.sources) ?? null;
+      if (!generated || generated.length !== W * H) v.fill(1);
+      else v.set(generated);
+    } else {
+      const bytes = readRegion(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 = mask.feather ?? 0;
+    if (feather > 0) v = gaussianBlur(v, W, H, feather, "clamp");
+    const density = mask.density ?? 1;
+    if (density !== 1) for (let i = 0; i < v.length; i++) v[i] = 1 - density * (1 - v[i]);
+    plane = { data: v, width: W, height: H };
+    this.planeCache.set(key, plane);
+    while (this.planeCache.size > 8) this.planeCache.delete(this.planeCache.keys().next().value);
+    return plane;
+  }
+  maskTile(layer, r) {
+    const mask = layer.mask;
+    if (!mask || mask.enabled === false) return null;
+    const ox = isPixel(layer) ? layer.offset?.x ?? 0 : 0;
+    const oy = isPixel(layer) ? layer.offset?.y ?? 0 : 0;
+    const n = r.width * r.height;
+    const out = new Float32Array(n);
+    const density = mask.density ?? 1;
+    if (mask.source || (mask.feather ?? 0) > 0) {
+      const plane = this.planeFor(mask, ox, oy);
+      const W = plane.width;
+      const H = plane.height;
+      const outside = mask.source ? 1 : 1 - density * (1 - mask.defaultValue / 255);
+      out.fill(outside);
+      const x0 = Math.max(0, r.x);
+      const y0 = Math.max(0, r.y);
+      const x1 = Math.min(W, r.x + r.width);
+      const y1 = Math.min(H, r.y + r.height);
+      for (let y = y0; y < y1; y++) {
+        const s = y * W;
+        const d = (y - r.y) * r.width - r.x;
+        for (let x = x0; x < x1; x++) out[d + x] = plane.data[s + x];
+      }
+    } else {
+      const bytes = readRegion(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;
+        if (bytes[i] !== 255) all = false;
+      }
+      if (all) return null;
+      if (density !== 1) for (let i = 0; i < n; i++) out[i] = 1 - density * (1 - out[i]);
+    }
+    return out;
+  }
+  // --- Running steps ---------------------------------------------------------
+  /** Runs one step onto `acc`; returns whether `acc` is still 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.maskTile(layer, r);
+    if (coverage && coverage.every((v) => v <= 0)) return empty;
+    if (step.kind === "group") {
+      if (layer.blend === "pass-through" && !clipped.length) {
+        if (layer.opacity >= 1 && !coverage) return this.runSteps(step.steps, acc, empty, r);
+        const before = new Uint8ClampedArray(acc);
+        const stillEmpty = this.runSteps(step.steps, acc, empty, r);
+        lerpTile(acc, before, layer.opacity, coverage);
+        return empty && stillEmpty;
+      }
+      const buf2 = new Uint8ClampedArray(acc.length);
+      if (this.runSteps(step.steps, buf2, true, r)) return empty;
+      this.applyClipped(clipped, buf2, r);
+      const mode = layer.blend === "pass-through" ? "normal" : layer.blend;
+      return this.blendOnto(acc, buf2, empty, mode, layer.opacity, coverage);
+    }
+    const content = this.contentTile(step.layer, r);
+    if (!content) return empty;
+    const fill = isPixel(step.layer) ? step.layer.fillOpacity ?? 1 : 1;
+    const blend = this.contentBlend(step.layer);
+    if (!clipped.length) return this.blendOnto(acc, content, empty, blend, layer.opacity * fill, coverage);
+    const buf = new Uint8ClampedArray(acc.length);
+    blendTile(buf, content, "normal", fill, coverage);
+    this.applyClipped(clipped, buf, r);
+    return this.blendOnto(acc, buf, empty, blend, layer.opacity, null);
+  }
+  runSteps(steps, acc, empty, r) {
+    for (const s of steps) empty = this.runStep(s, acc, empty, r);
+    return empty;
+  }
+  contentBlend(layer) {
+    return this.profile.contentBlend?.(layer) ?? layer.blend;
+  }
+  blendOnto(acc, src, empty, mode, alpha, coverage) {
+    if (!(alpha > 0)) return empty;
+    if (empty && mode === "normal" && alpha >= 1 && !coverage) {
+      acc.set(src);
+      return false;
+    }
+    blendTile(acc, src, mode, alpha, coverage);
+    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 coverage = this.maskTile(c, r);
+      if (isGroup(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;
+        blendAtop(buf, inner, mode, c.opacity, coverage);
+        continue;
+      }
+      const content = this.contentTile(c, r);
+      if (!content) continue;
+      const fill = isPixel(c) ? c.fillOpacity ?? 1 : 1;
+      blendAtop(buf, content, this.contentBlend(c), c.opacity * fill, coverage);
+    }
+    flush();
+  }
+  applyFilterRun(layers, acc, r) {
+    const visible = [];
+    let masks;
+    for (const node of layers) {
+      if (!node.visible) continue;
+      const cov = this.maskTile(node, r);
+      if (cov) {
+        if (cov.every((v) => v <= 0)) continue;
+        (masks ??= /* @__PURE__ */ new Map()).set(node.id, cov);
+      }
+      visible.push(node);
+    }
+    if (visible.length) this.profile.applyFilterRun?.(visible, acc, r, masks, this.sources);
+  }
+};
+function filterOverCanvas(surface, ox, oy, filters, width, height) {
+  if (width <= 0 || height <= 0) return emptySurface(4);
+  const data = readRegion(surface, { x: -ox, y: -oy, width, height });
+  filters.apply(data, width, height);
+  return surfaceFromPixels({ width, height, data }, 4, 0, 0);
+}
+function changedTiles(a, b) {
+  const out = [];
+  for (const [k, t] of b.tiles) if (a.tiles.get(k) !== t) out.push(k);
+  for (const k of a.tiles.keys()) if (!b.tiles.has(k)) out.push(k);
+  return out;
+}
+
+// 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;
+function crc32(bytes, start, end) {
+  if (!crcTable) {
+    crcTable = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+      let c2 = n;
+      for (let k = 0; k < 8; k++) c2 = c2 & 1 ? 3988292384 ^ c2 >>> 1 : c2 >>> 1;
+      crcTable[n] = c2 >>> 0;
+    }
+  }
+  let c = 4294967295;
+  for (let i = start; i < end; i++) c = crcTable[(c ^ bytes[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function paeth(a, b, c) {
+  const p = a + b - c;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc = Math.abs(p - c);
+  return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+}
+function encodePng(width, height, data, channels = 4) {
+  const stride = width * channels;
+  const raw = new Uint8Array((stride + 1) * height);
+  const bpp = channels;
+  const cand = [new Uint8Array(stride), new Uint8Array(stride), new Uint8Array(stride), new Uint8Array(stride), new Uint8Array(stride)];
+  for (let y = 0; y < height; y++) {
+    const row = y * stride;
+    const prevRow = (y - 1) * stride;
+    let best = 0;
+    let bestScore = Infinity;
+    for (let f = 0; f < 5; f++) {
+      const out2 = cand[f];
+      let score = 0;
+      for (let x = 0; x < stride; x++) {
+        const v = data[row + x];
+        const a = x >= bpp ? data[row + x - bpp] : 0;
+        const b = y > 0 ? data[prevRow + x] : 0;
+        const c = x >= bpp && y > 0 ? data[prevRow + x - bpp] : 0;
+        let r;
+        switch (f) {
+          case 0:
+            r = v;
+            break;
+          case 1:
+            r = v - a;
+            break;
+          case 2:
+            r = v - b;
+            break;
+          case 3:
+            r = v - (a + b >> 1);
+            break;
+          default:
+            r = v - paeth(a, b, c);
+        }
+        r &= 255;
+        out2[x] = r;
+        score += r < 128 ? r : 256 - r;
+        if (score >= bestScore) break;
+      }
+      if (score < bestScore) {
+        bestScore = score;
+        best = f;
+      }
+    }
+    const o = y * (stride + 1);
+    raw[o] = best;
+    raw.set(cand[best], o + 1);
+  }
+  const idat = deflate(raw);
+  const chunks = [];
+  const ihdr = new Uint8Array(13);
+  writeU32(ihdr, 0, width);
+  writeU32(ihdr, 4, height);
+  ihdr[8] = 8;
+  ihdr[9] = channels === 1 ? 0 : 6;
+  chunks.push(["IHDR", ihdr], ["IDAT", idat], ["IEND", new Uint8Array(0)]);
+  let size = 8;
+  for (const [, d] of chunks) size += 12 + d.length;
+  const out = new Uint8Array(size);
+  out.set(SIGNATURE, 0);
+  let p = 8;
+  for (const [type, d] of chunks) {
+    writeU32(out, p, d.length);
+    for (let i = 0; i < 4; i++) out[p + 4 + i] = type.charCodeAt(i);
+    out.set(d, p + 8);
+    writeU32(out, p + 8 + d.length, crc32(out, p + 4, p + 8 + d.length));
+    p += 12 + d.length;
+  }
+  return out;
+}
+function writeU32(b, o, v) {
+  b[o] = v >>> 24;
+  b[o + 1] = v >>> 16 & 255;
+  b[o + 2] = v >>> 8 & 255;
+  b[o + 3] = v & 255;
+}
+function readU32(b, o) {
+  return (b[o] << 24 | b[o + 1] << 16 | b[o + 2] << 8 | b[o + 3]) >>> 0;
+}
+function isPng(bytes) {
+  return bytes.length > 8 && SIGNATURE.every((v, i) => bytes[i] === v);
+}
+function decodePng(bytes, options = {}) {
+  if (!isPng(bytes)) throw new Error("Not a PNG image.");
+  let p = 8;
+  let width = 0;
+  let height = 0;
+  let depth = 0;
+  let type = 0;
+  let interlace = 0;
+  let palette = null;
+  let trns = null;
+  const idat = [];
+  while (p + 8 <= bytes.length) {
+    const len = readU32(bytes, p);
+    const t = String.fromCharCode(bytes[p + 4], bytes[p + 5], bytes[p + 6], bytes[p + 7]);
+    const body = bytes.subarray(p + 8, p + 8 + len);
+    if (p + 12 + len > bytes.length) throw new Error("Truncated PNG.");
+    if (t === "IHDR") {
+      width = readU32(body, 0);
+      height = readU32(body, 4);
+      depth = body[8];
+      type = body[9];
+      interlace = body[12];
+    } else if (t === "PLTE") palette = body;
+    else if (t === "tRNS") trns = body;
+    else if (t === "IDAT") idat.push(body);
+    else if (t === "IEND") break;
+    p += 12 + len;
+  }
+  if (!width || !height) throw new Error("PNG has no image header.");
+  if (interlace) throw new Error("Interlaced PNGs are not supported here; decode them with a canvas.");
+  const maxPixels = options.maxPixels ?? 1 << 28;
+  if (width * height > maxPixels) throw new Error(`PNG is too large (${width}\xD7${height}).`);
+  const samples = type === 0 ? 1 : type === 2 ? 3 : type === 3 ? 1 : type === 4 ? 2 : type === 6 ? 4 : 0;
+  if (!samples || ![1, 2, 4, 8, 16].includes(depth)) throw new Error(`Unsupported PNG format (type ${type}, depth ${depth}).`);
+  let total = 0;
+  for (const c of idat) total += c.length;
+  const z = new Uint8Array(total);
+  let o = 0;
+  for (const c of idat) {
+    z.set(c, o);
+    o += c.length;
+  }
+  const bitsPerPixel = samples * depth;
+  const stride = Math.ceil(width * bitsPerPixel / 8);
+  const raw = inflate(z, { maxOutput: (stride + 1) * height, sizeHint: (stride + 1) * height });
+  if (raw.length < (stride + 1) * height) throw new Error("PNG image data is truncated.");
+  const bpp = Math.max(1, bitsPerPixel >> 3);
+  const lines = new Uint8Array(stride * height);
+  for (let y = 0; y < height; y++) {
+    const f = raw[y * (stride + 1)];
+    const src = y * (stride + 1) + 1;
+    const dst = y * stride;
+    const up = dst - stride;
+    for (let x = 0; x < stride; x++) {
+      const v = raw[src + x];
+      const a = x >= bpp ? lines[dst + x - bpp] : 0;
+      const b = y > 0 ? lines[up + x] : 0;
+      const c = x >= bpp && y > 0 ? lines[up + x - bpp] : 0;
+      let r;
+      switch (f) {
+        case 0:
+          r = v;
+          break;
+        case 1:
+          r = v + a;
+          break;
+        case 2:
+          r = v + b;
+          break;
+        case 3:
+          r = v + (a + b >> 1);
+          break;
+        case 4:
+          r = v + paeth(a, b, c);
+          break;
+        default:
+          throw new Error(`Invalid PNG filter ${f}.`);
+      }
+      lines[dst + x] = r & 255;
+    }
+  }
+  const sample = (y, i) => {
+    const row = y * stride;
+    if (depth === 8) return lines[row + i];
+    if (depth === 16) return lines[row + i * 2];
+    const perByte = 8 / depth;
+    const byte = lines[row + Math.floor(i / perByte)];
+    const shift = 8 - depth * (i % perByte + 1);
+    const v = byte >> shift & (1 << depth) - 1;
+    return type === 3 ? v : Math.round(v * 255 / ((1 << depth) - 1));
+  };
+  const gray = options.keepGray && type === 0 && !trns;
+  const channels = gray ? 1 : 4;
+  const out = new Uint8ClampedArray(width * height * channels);
+  const trnsGray = trns && type === 0 ? depth === 16 ? trns[0] : sample16(trns, 0, depth) : -1;
+  const trnsRgb = trns && type === 2 ? [0, 1, 2].map((k) => depth === 16 ? trns[k * 2] : sample16(trns, k, depth)) : null;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const d = (y * width + x) * channels;
+      if (type === 0) {
+        const v = sample(y, x);
+        if (gray) out[d] = v;
+        else {
+          out[d] = out[d + 1] = out[d + 2] = v;
+          out[d + 3] = v === trnsGray && trns ? 0 : 255;
+        }
+      } else if (type === 2) {
+        const r = sample(y, x * 3);
+        const g = sample(y, x * 3 + 1);
+        const b = sample(y, x * 3 + 2);
+        out[d] = r;
+        out[d + 1] = g;
+        out[d + 2] = b;
+        out[d + 3] = trnsRgb && r === trnsRgb[0] && g === trnsRgb[1] && b === trnsRgb[2] ? 0 : 255;
+      } else if (type === 3) {
+        const i = sample(y, x);
+        if (!palette || i * 3 + 2 >= palette.length) throw new Error("PNG palette index out of range.");
+        out[d] = palette[i * 3];
+        out[d + 1] = palette[i * 3 + 1];
+        out[d + 2] = palette[i * 3 + 2];
+        out[d + 3] = trns && i < trns.length ? trns[i] : 255;
+      } else if (type === 4) {
+        const v = sample(y, x * 2);
+        out[d] = out[d + 1] = out[d + 2] = v;
+        out[d + 3] = sample(y, x * 2 + 1);
+      } else {
+        out[d] = sample(y, x * 4);
+        out[d + 1] = sample(y, x * 4 + 1);
+        out[d + 2] = sample(y, x * 4 + 2);
+        out[d + 3] = sample(y, x * 4 + 3);
+      }
+    }
+  }
+  return { width, height, channels, data: out };
+}
+function sample16(trns, k, depth) {
+  const v = trns[k * 2] << 8 | trns[k * 2 + 1];
+  if (depth === 8) return v & 255;
+  return Math.round((v & (1 << depth) - 1) * 255 / ((1 << depth) - 1));
+}
+var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var B64_INV = null;
+function bytesToBase64(bytes) {
+  const parts = [];
+  const CHUNK = 3 * 4096;
+  for (let start = 0; start < bytes.length; start += CHUNK) {
+    const end = Math.min(bytes.length, start + CHUNK);
+    let s = "";
+    let i = start;
+    for (; i + 2 < end; i += 3) {
+      const n = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+      s += B64[n >> 18] + B64[n >> 12 & 63] + B64[n >> 6 & 63] + B64[n & 63];
+    }
+    if (i < end) {
+      const n = bytes[i] << 16 | (i + 1 < end ? bytes[i + 1] << 8 : 0);
+      s += B64[n >> 18] + B64[n >> 12 & 63] + (i + 1 < end ? B64[n >> 6 & 63] : "=") + "=";
+    }
+    parts.push(s);
+  }
+  return parts.join("");
+}
+function base64ToBytes(text) {
+  if (!B64_INV) {
+    B64_INV = new Int16Array(128).fill(-1);
+    for (let i = 0; i < 64; i++) B64_INV[B64.charCodeAt(i)] = i;
+    B64_INV["-".charCodeAt(0)] = 62;
+    B64_INV["_".charCodeAt(0)] = 63;
+  }
+  const inv = B64_INV;
+  const clean = text.replace(/[\s=]/g, "");
+  const out = new Uint8Array(Math.floor(clean.length * 3 / 4));
+  let bits = 0;
+  let acc = 0;
+  let o = 0;
+  for (let i = 0; i < clean.length; i++) {
+    const c = clean.charCodeAt(i);
+    const v = c < 128 ? inv[c] : -1;
+    if (v < 0) throw new Error("Invalid base64 data.");
+    acc = acc << 6 | v;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[o++] = acc >> bits & 255;
+    }
+  }
+  return out.subarray(0, o);
+}
+function parseDataUrl(url) {
+  const m = /^data:([^;,]*)((?:;[^;,]*)*?),/i.exec(url);
+  if (!m) return null;
+  const body = url.slice(m[0].length);
+  const isBase64 = /;base64/i.test(m[2]);
+  if (isBase64) return { mime: m[1] || "text/plain", bytes: base64ToBytes(body) };
+  const text = decodeURIComponent(body);
+  const bytes = new Uint8Array(text.length);
+  for (let i = 0; i < text.length; i++) bytes[i] = text.charCodeAt(i) & 255;
+  return { mime: m[1] || "text/plain", bytes };
+}
+function pngDataUrl(width, height, data, channels = 4) {
+  return `data:image/png;base64,${bytesToBase64(encodePng(width, height, data, channels))}`;
+}
+
+export {
+  DIRECT_GAUSSIAN_MAX_SIGMA,
+  gaussianBlur,
+  flattenLayers,
+  findLayer,
+  mapLayer,
+  insertLayer,
+  isLayerLocked,
+  blendTile,
+  RasterCompositor,
+  changedTiles,
+  ZlibError,
+  inflateRaw,
+  adler32,
+  inflate,
+  deflateRaw,
+  deflate,
+  encodePng,
+  isPng,
+  decodePng,
+  bytesToBase64,
+  base64ToBytes,
+  parseDataUrl,
+  pngDataUrl
+};
+//# sourceMappingURL=chunk-P5TPUNBZ.js.map