@pixerate/editor 0.92.0 → 0.94.0

package/dist/chunk-747CGOT2.js

@@ -0,0 +1,3685 @@
+import {
+  TILE,
+  blendChannel,
+  blendRgb,
+  emptySurface,
+  isBlendMode,
+  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/effects/model.ts
+var DEFAULT_GLOBAL_LIGHT = { angle: 120, altitude: 30 };
+var LAYER_EFFECT_KINDS = [
+  "bevel-emboss",
+  "stroke",
+  "inner-shadow",
+  "inner-glow",
+  "satin",
+  "color-overlay",
+  "gradient-overlay",
+  "pattern-overlay",
+  "outer-glow",
+  "drop-shadow"
+];
+var LABELS = {
+  "drop-shadow": "Drop Shadow",
+  "inner-shadow": "Inner Shadow",
+  "outer-glow": "Outer Glow",
+  "inner-glow": "Inner Glow",
+  "bevel-emboss": "Bevel & Emboss",
+  satin: "Satin",
+  "color-overlay": "Color Overlay",
+  "gradient-overlay": "Gradient Overlay",
+  "pattern-overlay": "Pattern Overlay",
+  stroke: "Stroke"
+};
+function layerEffectLabel(kind) {
+  return LABELS[kind];
+}
+function isLayerEffectKind(value) {
+  return typeof value === "string" && value in LABELS;
+}
+function defaultEffectGradient() {
+  return {
+    stops: [
+      { position: 0, color: "#000000" },
+      { position: 1, color: "#ffffff" }
+    ],
+    style: "linear",
+    angle: 90,
+    scale: 1,
+    reverse: false,
+    align: true,
+    offset: { x: 0, y: 0 }
+  };
+}
+var fxCounter = 0;
+function newEffectId() {
+  return `fx_${Date.now().toString(36)}_${(++fxCounter).toString(36)}`;
+}
+function defaultLayerEffect(kind, id = newEffectId()) {
+  const base = { id, enabled: true };
+  switch (kind) {
+    case "drop-shadow":
+      return { ...base, kind, blend: "multiply", opacity: 0.75, color: "#000000", angle: 120, useGlobalLight: true, distance: 5, spread: 0, size: 5, antiAlias: false, noise: 0, knocksOut: true };
+    case "inner-shadow":
+      return { ...base, kind, blend: "multiply", opacity: 0.75, color: "#000000", angle: 120, useGlobalLight: true, distance: 5, choke: 0, size: 5, antiAlias: false, noise: 0 };
+    case "outer-glow":
+      return { ...base, kind, blend: "screen", opacity: 0.75, fill: { type: "color", color: "#ffffbe" }, technique: "softer", spread: 0, size: 5, antiAlias: false, range: 0.5, jitter: 0, noise: 0 };
+    case "inner-glow":
+      return { ...base, kind, blend: "screen", opacity: 0.75, fill: { type: "color", color: "#ffffbe" }, technique: "softer", choke: 0, size: 5, antiAlias: false, range: 0.5, jitter: 0, noise: 0, source: "edge" };
+    case "bevel-emboss":
+      return {
+        ...base,
+        kind,
+        style: "inner-bevel",
+        technique: "smooth",
+        depth: 1,
+        direction: "up",
+        size: 5,
+        soften: 0,
+        angle: 120,
+        altitude: 30,
+        useGlobalLight: true,
+        highlightColor: "#ffffff",
+        highlightBlend: "screen",
+        highlightOpacity: 0.75,
+        shadowColor: "#000000",
+        shadowBlend: "multiply",
+        shadowOpacity: 0.75
+      };
+    case "satin":
+      return { ...base, kind, blend: "multiply", opacity: 0.5, color: "#000000", angle: 19, distance: 11, size: 14, antiAlias: true, invert: true };
+    case "color-overlay":
+      return { ...base, kind, blend: "normal", opacity: 1, color: "#ff0000" };
+    case "gradient-overlay":
+      return { ...base, kind, blend: "normal", opacity: 1, gradient: defaultEffectGradient(), dither: false };
+    case "pattern-overlay":
+      return { ...base, kind, blend: "normal", opacity: 1, patternId: "checker", name: "Checker", scale: 1, angle: 0, link: true, phase: { x: 0, y: 0 } };
+    case "stroke":
+      return { ...base, kind, blend: "normal", opacity: 1, size: 3, position: "outside", fill: { type: "color", color: "#000000" } };
+  }
+}
+function hasActiveEffects(effects) {
+  return Boolean(effects && effects.enabled && effects.items.some((e) => e.enabled));
+}
+var MAX_EFFECT_REACH = 512;
+function effectReach(e) {
+  switch (e.kind) {
+    case "drop-shadow":
+    case "inner-shadow":
+      return e.distance + e.size;
+    case "outer-glow":
+    case "inner-glow":
+      return e.size + 1;
+    case "stroke":
+      return e.size;
+    case "satin":
+      return Math.max(1, e.distance) + e.size;
+    case "bevel-emboss":
+      return e.size + e.soften + 1;
+    default:
+      return 0;
+  }
+}
+function effectsMargin(effects) {
+  if (!hasActiveEffects(effects)) return 0;
+  const scale = effectsScale(effects);
+  let m = 0;
+  for (const e of effects.items) {
+    if (!e.enabled) continue;
+    const r = effectReach(e) * scale;
+    if (Number.isFinite(r)) m = Math.max(m, r);
+  }
+  return Math.ceil(Math.min(Math.max(m, 0), MAX_EFFECT_REACH)) + 2;
+}
+function effectsScale(effects) {
+  const s = effects.scale;
+  return typeof s === "number" && Number.isFinite(s) && s > 0 ? s : 1;
+}
+function scaleLayerEffect(e, s) {
+  if (s === 1) return e;
+  const pattern = (p) => ({ ...p, scale: p.scale * s });
+  const fill2 = (f) => f.type === "pattern" ? pattern(f) : f;
+  switch (e.kind) {
+    case "drop-shadow":
+    case "inner-shadow":
+    case "satin":
+      return { ...e, distance: e.distance * s, size: e.size * s };
+    case "outer-glow":
+    case "inner-glow":
+      return { ...e, size: e.size * s };
+    case "stroke":
+      return { ...e, size: e.size * s, fill: fill2(e.fill) };
+    case "pattern-overlay":
+      return pattern(e);
+    case "bevel-emboss":
+      return { ...e, size: e.size * s, soften: e.soften * s, texture: e.texture ? pattern(e.texture) : void 0 };
+    default:
+      return e;
+  }
+}
+function parseEffectColor(value) {
+  if (typeof value !== "string") return null;
+  let h = value.trim().replace(/^#/, "");
+  if (/^[0-9a-f]{3}$/i.test(h)) h = h.replace(/./g, (c) => c + c);
+  if (!/^[0-9a-f]{6}$/i.test(h)) return null;
+  return [parseInt(h.slice(0, 2), 16) / 255, parseInt(h.slice(2, 4), 16) / 255, parseInt(h.slice(4, 6), 16) / 255];
+}
+function effectColorHex(rgb) {
+  const c = (v) => Math.round(Math.max(0, Math.min(1, v)) * 255).toString(16).padStart(2, "0");
+  return `#${c(rgb[0])}${c(rgb[1])}${c(rgb[2])}`;
+}
+var LayerEffectError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LayerEffectError";
+  }
+};
+function fail(path, msg) {
+  throw new LayerEffectError(`${path}: ${msg}`);
+}
+function num(r, key, path, min, max) {
+  const v = r[key];
+  if (typeof v !== "number" || !Number.isFinite(v)) fail(`${path}.${key}`, `must be a number from ${min} to ${max}.`);
+  if (v < min || v > max) fail(`${path}.${key}`, `${v} is out of range (${min} to ${max}).`);
+}
+function bool(r, key, path) {
+  if (typeof r[key] !== "boolean") fail(`${path}.${key}`, "must be true or false.");
+}
+function color(r, key, path) {
+  if (!parseEffectColor(r[key])) fail(`${path}.${key}`, `must be a colour like "#ff8800" (got ${JSON.stringify(r[key])}).`);
+}
+function oneOf(r, key, path, values) {
+  if (typeof r[key] !== "string" || !values.includes(r[key])) fail(`${path}.${key}`, `must be one of ${values.join(", ")}.`);
+}
+function blend(r, key, path) {
+  if (!isBlendMode(r[key])) fail(`${path}.${key}`, `must be a blend mode such as normal, multiply or screen (got ${JSON.stringify(r[key])}).`);
+}
+function contour(v, path) {
+  if (v === void 0) return;
+  if (!v || typeof v !== "object") fail(path, "must be an object { name, points }.");
+  const c = v;
+  if (typeof c.name !== "string") fail(`${path}.name`, "must be a string.");
+  if (!Array.isArray(c.points) || c.points.length < 2) fail(`${path}.points`, "needs at least 2 points { input, output } from 0 to 1.");
+  c.points.forEach((p, i) => {
+    if (!p || typeof p !== "object") fail(`${path}.points[${i}]`, "must be { input, output }.");
+    num(p, "input", `${path}.points[${i}]`, 0, 1);
+    num(p, "output", `${path}.points[${i}]`, 0, 1);
+    if (p.corner !== void 0) bool(p, "corner", `${path}.points[${i}]`);
+  });
+}
+function validateEffectGradient(v, path) {
+  if (!v || typeof v !== "object") fail(path, "must be a gradient object.");
+  const g = v;
+  if (!Array.isArray(g.stops) || g.stops.length < 1) fail(`${path}.stops`, "needs at least one stop { position, color }.");
+  g.stops.forEach((s, i) => {
+    num(s, "position", `${path}.stops[${i}]`, 0, 1);
+    color(s, "color", `${path}.stops[${i}]`);
+  });
+  if (g.opacityStops !== void 0) {
+    if (!Array.isArray(g.opacityStops)) fail(`${path}.opacityStops`, "must be a list of { position, opacity }.");
+    g.opacityStops.forEach((s, i) => {
+      num(s, "position", `${path}.opacityStops[${i}]`, 0, 1);
+      num(s, "opacity", `${path}.opacityStops[${i}]`, 0, 1);
+    });
+  }
+  oneOf(g, "style", path, ["linear", "radial", "angle", "reflected", "diamond"]);
+  num(g, "angle", path, -360, 360);
+  num(g, "scale", path, 0.1, 1.5);
+  bool(g, "reverse", path);
+  bool(g, "align", path);
+  const o = g.offset;
+  if (!o || typeof o !== "object") fail(`${path}.offset`, "must be { x, y } (fractions of the bounds).");
+  num(o, "x", `${path}.offset`, -1, 1);
+  num(o, "y", `${path}.offset`, -1, 1);
+}
+function patternRef(r, path) {
+  if (typeof r.patternId !== "string" || !r.patternId) fail(`${path}.patternId`, 'must be a pattern id (a built-in pattern such as "checker", or one from list_layer_effects.patterns).');
+  num(r, "scale", path, 0.01, 10);
+  if (r.angle !== void 0) num(r, "angle", path, -360, 360);
+  if (r.link !== void 0) bool(r, "link", path);
+  if (r.phase !== void 0) {
+    const p = r.phase;
+    if (!p || typeof p !== "object") fail(`${path}.phase`, "must be { x, y } in pixels.");
+    num(p, "x", `${path}.phase`, -1e6, 1e6);
+    num(p, "y", `${path}.phase`, -1e6, 1e6);
+  }
+}
+function fill(v, path, allowPattern) {
+  if (!v || typeof v !== "object") fail(path, 'must be { type: "color", color } or { type: "gradient", gradient }' + (allowPattern ? ' or { type: "pattern", patternId, scale }.' : "."));
+  const f = v;
+  if (f.type === "color") color(f, "color", path);
+  else if (f.type === "gradient") validateEffectGradient(f.gradient, `${path}.gradient`);
+  else if (f.type === "pattern" && allowPattern) patternRef(f, path);
+  else fail(`${path}.type`, allowPattern ? "must be color, gradient or pattern." : "must be color or gradient (glows cannot use a pattern).");
+}
+var OPTIONAL_FIELDS = {
+  "drop-shadow": ["contour"],
+  "inner-shadow": ["contour"],
+  "outer-glow": ["contour"],
+  "inner-glow": ["contour"],
+  satin: ["contour"],
+  "bevel-emboss": ["glossContour", "contourElement", "texture"]
+};
+function layerEffectFields(kind) {
+  return [...Object.keys(defaultLayerEffect(kind, "x")), ...OPTIONAL_FIELDS[kind] ?? []];
+}
+function validateLayerEffect(v, path = "effect") {
+  if (!v || typeof v !== "object") fail(path, "must be an object.");
+  const e = v;
+  if (!isLayerEffectKind(e.kind)) fail(`${path}.kind`, `must be one of ${LAYER_EFFECT_KINDS.join(", ")}.`);
+  if (typeof e.id !== "string" || !e.id) fail(`${path}.id`, "must be a non-empty string.");
+  bool(e, "enabled", path);
+  const kind = e.kind;
+  const allowed = layerEffectFields(kind);
+  for (const k of Object.keys(e)) {
+    if (e[k] !== void 0 && !allowed.includes(k)) fail(`${path}.${k}`, `not a setting of ${kind}. Its settings are ${allowed.filter((f) => f !== "id" && f !== "kind").join(", ")}.`);
+  }
+  if (kind !== "bevel-emboss") {
+    blend(e, "blend", path);
+    num(e, "opacity", path, 0, 1);
+  }
+  switch (kind) {
+    case "drop-shadow":
+    case "inner-shadow":
+      color(e, "color", path);
+      num(e, "angle", path, -360, 360);
+      bool(e, "useGlobalLight", path);
+      num(e, "distance", path, 0, 3e4);
+      num(e, kind === "drop-shadow" ? "spread" : "choke", path, 0, 1);
+      num(e, "size", path, 0, 250);
+      contour(e.contour, `${path}.contour`);
+      bool(e, "antiAlias", path);
+      num(e, "noise", path, 0, 1);
+      if (kind === "drop-shadow") bool(e, "knocksOut", path);
+      break;
+    case "outer-glow":
+    case "inner-glow":
+      fill(e.fill, `${path}.fill`, false);
+      oneOf(e, "technique", path, ["softer", "precise"]);
+      num(e, kind === "outer-glow" ? "spread" : "choke", path, 0, 1);
+      num(e, "size", path, 0, 250);
+      contour(e.contour, `${path}.contour`);
+      bool(e, "antiAlias", path);
+      num(e, "range", path, 0.01, 1);
+      num(e, "jitter", path, 0, 1);
+      num(e, "noise", path, 0, 1);
+      if (kind === "inner-glow") oneOf(e, "source", path, ["edge", "center"]);
+      break;
+    case "bevel-emboss":
+      oneOf(e, "style", path, ["inner-bevel", "outer-bevel", "emboss", "pillow-emboss", "stroke-emboss"]);
+      oneOf(e, "technique", path, ["smooth", "chisel-hard", "chisel-soft"]);
+      num(e, "depth", path, 0, 10);
+      oneOf(e, "direction", path, ["up", "down"]);
+      num(e, "size", path, 0, 250);
+      num(e, "soften", path, 0, 16);
+      num(e, "angle", path, -360, 360);
+      num(e, "altitude", path, 0, 90);
+      bool(e, "useGlobalLight", path);
+      contour(e.glossContour, `${path}.glossContour`);
+      color(e, "highlightColor", path);
+      blend(e, "highlightBlend", path);
+      num(e, "highlightOpacity", path, 0, 1);
+      color(e, "shadowColor", path);
+      blend(e, "shadowBlend", path);
+      num(e, "shadowOpacity", path, 0, 1);
+      if (e.contourElement !== void 0) {
+        const c = e.contourElement;
+        if (!c || typeof c !== "object") fail(`${path}.contourElement`, "must be { contour, range, antiAlias } or left out.");
+        contour(c.contour, `${path}.contourElement.contour`);
+        num(c, "range", `${path}.contourElement`, 0, 1);
+        bool(c, "antiAlias", `${path}.contourElement`);
+      }
+      if (e.texture !== void 0) {
+        const t = e.texture;
+        if (!t || typeof t !== "object") fail(`${path}.texture`, "must be { patternId, scale, depth, invert } or left out.");
+        patternRef(t, `${path}.texture`);
+        num(t, "depth", `${path}.texture`, -10, 10);
+        bool(t, "invert", `${path}.texture`);
+      }
+      break;
+    case "satin":
+      color(e, "color", path);
+      num(e, "angle", path, -360, 360);
+      num(e, "distance", path, 0, 250);
+      num(e, "size", path, 0, 250);
+      contour(e.contour, `${path}.contour`);
+      bool(e, "antiAlias", path);
+      bool(e, "invert", path);
+      break;
+    case "color-overlay":
+      color(e, "color", path);
+      break;
+    case "gradient-overlay":
+      validateEffectGradient(e.gradient, `${path}.gradient`);
+      bool(e, "dither", path);
+      break;
+    case "pattern-overlay":
+      patternRef(e, path);
+      break;
+    case "stroke":
+      num(e, "size", path, 0, 250);
+      oneOf(e, "position", path, ["outside", "inside", "center"]);
+      fill(e.fill, `${path}.fill`, true);
+      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;
+  }
+  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/effects/patterns.ts
+var PatternTile = class {
+  w;
+  h;
+  px;
+  constructor(p) {
+    this.w = Math.max(1, p.width | 0);
+    this.h = Math.max(1, p.height | 0);
+    const n = this.w * this.h;
+    this.px = new Float32Array(n * 4);
+    for (let i = 0; i < n; i++) {
+      const a = (p.data[i * 4 + 3] ?? 0) / 255;
+      this.px[i * 4] = (p.data[i * 4] ?? 0) / 255 * a;
+      this.px[i * 4 + 1] = (p.data[i * 4 + 1] ?? 0) / 255 * a;
+      this.px[i * 4 + 2] = (p.data[i * 4 + 2] ?? 0) / 255 * a;
+      this.px[i * 4 + 3] = a;
+    }
+  }
+  /** Bilinear wrapping sample at tile coordinates (pixel centres at `i + 0.5`), straight alpha into `out`. */
+  sample(u, v, out) {
+    u -= 0.5;
+    v -= 0.5;
+    const x0 = Math.floor(u);
+    const y0 = Math.floor(v);
+    const fx = u - x0;
+    const fy = v - y0;
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    let a = 0;
+    for (let dy = 0; dy < 2; dy++) {
+      const wy = dy ? fy : 1 - fy;
+      if (wy === 0) continue;
+      const yi = ((y0 + dy) % this.h + this.h) % this.h;
+      for (let dx = 0; dx < 2; dx++) {
+        const wx = dx ? fx : 1 - fx;
+        if (wx === 0) continue;
+        const xi = ((x0 + dx) % this.w + this.w) % this.w;
+        const k = wx * wy;
+        const i = (yi * this.w + xi) * 4;
+        r += this.px[i] * k;
+        g += this.px[i + 1] * k;
+        b += this.px[i + 2] * k;
+        a += this.px[i + 3] * k;
+      }
+    }
+    if (a <= 0) {
+      out[0] = out[1] = out[2] = out[3] = 0;
+      return;
+    }
+    out[0] = r / a;
+    out[1] = g / a;
+    out[2] = b / a;
+    out[3] = Math.min(1, a);
+  }
+};
+var PatternPlacement = class {
+  ox;
+  oy;
+  c;
+  s;
+  inv;
+  /** `anchor`: the layer's top-left (used when `link`); `phase` in px; `scale` a fraction; `angle` degrees counter-clockwise. */
+  constructor(anchor, link, phase, scale, angle) {
+    const bx = link ? anchor.x : 0;
+    const by = link ? anchor.y : 0;
+    this.ox = bx + phase.x;
+    this.oy = by + phase.y;
+    this.inv = Number.isFinite(scale) && scale > 1e-3 ? 1 / scale : 1;
+    const a = (Number.isFinite(angle) ? angle : 0) * Math.PI / 180;
+    this.c = Math.cos(a);
+    this.s = Math.sin(a);
+  }
+  /** Tile coordinates of the document point `(x, y)` into `out[0..1]`. */
+  map(x, y, out) {
+    const dx = x - this.ox;
+    const dy = y - this.oy;
+    out[0] = (dx * this.c - dy * this.s) * this.inv;
+    out[1] = (dx * this.s + dy * this.c) * this.inv;
+  }
+};
+var BUILTINS = {
+  checker: { name: "Checker", size: 16, paint: (x, y) => x < 8 !== y < 8 ? [204, 204, 204, 255] : [255, 255, 255, 255] },
+  stripes: { name: "Diagonal Stripes", size: 16, paint: (x, y) => (x + y) % 16 < 8 ? [40, 40, 40, 255] : [235, 235, 235, 255] },
+  dots: {
+    name: "Dots",
+    size: 12,
+    paint: (x, y) => {
+      const d = Math.hypot(x + 0.5 - 6, y + 0.5 - 6);
+      const a = Math.max(0, Math.min(1, 3.5 - d));
+      return [Math.round(255 - a * 215), Math.round(255 - a * 215), Math.round(255 - a * 215), 255];
+    }
+  },
+  grid: { name: "Grid", size: 16, paint: (x, y) => x === 0 || y === 0 ? [90, 90, 90, 255] : [250, 250, 250, 255] },
+  noise: {
+    name: "Noise",
+    size: 64,
+    paint: (x, y) => {
+      const v = Math.round(hashNoise(x, y) * 255);
+      return [v, v, v, 255];
+    }
+  }
+};
+function builtinPatternIds() {
+  return Object.keys(BUILTINS);
+}
+var builtinCache = /* @__PURE__ */ new Map();
+function builtinPattern(id) {
+  const def = BUILTINS[id];
+  if (!def) return null;
+  let p = builtinCache.get(id);
+  if (!p) {
+    const data = new Uint8ClampedArray(def.size * def.size * 4);
+    for (let y = 0; y < def.size; y++) {
+      for (let x = 0; x < def.size; x++) data.set(def.paint(x, y), (y * def.size + x) * 4);
+    }
+    p = { id, name: def.name, width: def.size, height: def.size, data };
+    builtinCache.set(id, p);
+  }
+  return p;
+}
+function hashNoise(x, y) {
+  let h = Math.imul(x | 0, 2376512323) ^ Math.imul(y | 0, 3625334849) ^ 2654435769;
+  h ^= h >>> 15;
+  h = Math.imul(h, 739982445);
+  h ^= h >>> 12;
+  return (h & 65535) / 65536;
+}
+
+// src/raster/curve.ts
+var CURVE_LUT_SIZE = 4096;
+var clamp01 = (v) => v <= 0 ? 0 : v >= 1 ? 1 : v;
+function curveLut(points, size = CURVE_LUT_SIZE) {
+  const pts = points.filter((p) => Number.isFinite(p.input) && Number.isFinite(p.output)).map((p) => [p.input, p.output]).sort((a, b) => a[0] - b[0]);
+  const dedup = [];
+  for (const p of pts) {
+    if (dedup.length && Math.abs(dedup[dedup.length - 1][0] - p[0]) < 1e-6) continue;
+    dedup.push(p);
+  }
+  const out = new Float32Array(size);
+  const n = dedup.length;
+  if (n < 2) {
+    for (let k = 0; k < size; k++) out[k] = k / (size - 1);
+    return out;
+  }
+  const x = dedup.map((p) => p[0]);
+  const y = dedup.map((p) => p[1]);
+  const m2 = new Float64Array(n);
+  if (n > 2) {
+    const c = new Float64Array(n);
+    const d = new Float64Array(n);
+    for (let i = 1; i < n - 1; i++) {
+      const h0 = x[i] - x[i - 1];
+      const h1 = x[i + 1] - x[i];
+      const a = h0 / 6;
+      const b = (h0 + h1) / 3;
+      const cc = h1 / 6;
+      const r = (y[i + 1] - y[i]) / h1 - (y[i] - y[i - 1]) / h0;
+      const denom = b - a * c[i - 1];
+      c[i] = cc / denom;
+      d[i] = (r - a * d[i - 1]) / denom;
+    }
+    for (let i = n - 2; i >= 1; i--) m2[i] = d[i] - c[i] * m2[i + 1];
+  }
+  let seg = 0;
+  for (let k = 0; k < size; k++) {
+    const xv = k / (size - 1);
+    if (xv <= x[0]) {
+      out[k] = clamp01(y[0]);
+      continue;
+    }
+    if (xv >= x[n - 1]) {
+      out[k] = clamp01(y[n - 1]);
+      continue;
+    }
+    while (seg < n - 2 && xv > x[seg + 1]) seg++;
+    const x0 = x[seg], x1 = x[seg + 1];
+    const h = x1 - x0;
+    const a = (x1 - xv) / h;
+    const b = (xv - x0) / h;
+    const v = a * y[seg] + b * y[seg + 1] + ((a * a * a - a) * m2[seg] + (b * b * b - b) * m2[seg + 1]) * (h * h) / 6;
+    out[k] = clamp01(v);
+  }
+  return out;
+}
+
+// src/raster/effects/render.ts
+var INSIDE_EPS = 0.5 / 255;
+var INF = 1e20;
+var FAR = 1e9;
+var STROKE_CHAMFER_MAX = 20;
+var BEVEL_H_EPS = 1e-5;
+var fmap = (w, h, fill2 = 0) => {
+  const v = new Float32Array(w * h);
+  if (fill2) v.fill(fill2);
+  return { w, h, v };
+};
+var clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+var clamp012 = (v) => v <= 0 ? 0 : v >= 1 ? 1 : v;
+function mapGet(m, x, y) {
+  return x < 0 || y < 0 || x >= m.w || y >= m.h ? 0 : m.v[y * m.w + x];
+}
+function shifted(m, dx, dy, outside) {
+  const reach = (d) => Number.isFinite(d) ? clamp(d, -1e9, 1e9) : 0;
+  dx = reach(dx);
+  dy = reach(dy);
+  const fx = Math.floor(dx);
+  const fy = Math.floor(dy);
+  const ax = dx - fx;
+  const ay = dy - fy;
+  const { w, h, v } = m;
+  const s = (x, y) => x < 0 || y < 0 || x >= w || y >= h ? outside : v[y * w + x];
+  const out = fmap(w, h);
+  for (let y = 0; y < h; y++) {
+    const sy = y - fy;
+    for (let x = 0; x < w; x++) {
+      const sx = x - fx;
+      const top = s(sx, sy) * (1 - ax) + s(sx - 1, sy) * ax;
+      const bot = s(sx, sy - 1) * (1 - ax) + s(sx - 1, sy - 1) * ax;
+      out.v[y * w + x] = top * (1 - ay) + bot * ay;
+    }
+  }
+  return out;
+}
+function mapped(m, f) {
+  const out = fmap(m.w, m.h);
+  for (let i = 0; i < m.v.length; i++) out.v[i] = f(m.v[i]);
+  return out;
+}
+function dt1(f, n, out, near, v, z) {
+  let k = 0;
+  v[0] = 0;
+  z[0] = -Infinity;
+  z[1] = Infinity;
+  for (let q = 1; q < n; q++) {
+    for (; ; ) {
+      const p = v[k];
+      const s = (f[q] + q * q - (f[p] + p * p)) / (2 * q - 2 * p);
+      if (s <= z[k] && k > 0) {
+        k--;
+        continue;
+      }
+      if (s <= z[k]) {
+        v[0] = q;
+        z[0] = -Infinity;
+        z[1] = Infinity;
+        break;
+      }
+      k++;
+      v[k] = q;
+      z[k] = s;
+      z[k + 1] = Infinity;
+      break;
+    }
+  }
+  k = 0;
+  for (let q = 0; q < n; q++) {
+    while (z[k + 1] < q) k++;
+    const p = v[k];
+    const d = q - p;
+    out[q] = d * d + f[p];
+    near[q] = p;
+  }
+}
+function edtNearest(inside, w, h) {
+  const total = w * h;
+  const n = Math.max(w, h);
+  const f = new Float64Array(n);
+  const o = new Float64Array(n);
+  const nr = new Int32Array(n);
+  const v = new Int32Array(n);
+  const z = new Float64Array(n + 1);
+  const gc = new Float64Array(total);
+  const nc = new Int32Array(total);
+  for (let x = 0; x < w; x++) {
+    for (let y = 0; y < h; y++) f[y] = inside[y * w + x] ? 0 : INF;
+    dt1(f, h, o, nr, v, z);
+    for (let y = 0; y < h; y++) {
+      gc[x * h + y] = o[y];
+      nc[x * h + y] = nr[y];
+    }
+  }
+  const d = new Float32Array(total);
+  const near = new Int32Array(total);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) f[x] = gc[x * h + y];
+    dt1(f, w, o, nr, v, z);
+    for (let x = 0; x < w; x++) {
+      d[y * w + x] = Math.sqrt(o[x]);
+      const px = nr[x];
+      near[y * w + x] = nc[px * h + y] * w + px;
+    }
+  }
+  return { d, near };
+}
+var S2 = Math.SQRT2;
+var S5 = 2.236068;
+var FWD = [
+  [-1, 0, 1],
+  [-1, -1, S2],
+  [0, -1, 1],
+  [1, -1, S2],
+  [-1, -2, S5],
+  [1, -2, S5],
+  [-2, -1, S5],
+  [2, -1, S5]
+];
+function chamferFrom(d, w, h) {
+  const ox = FWD.map((f) => f[0]);
+  const oy = FWD.map((f) => f[1]);
+  const wt = FWD.map((f) => f[2]);
+  const k = FWD.length;
+  for (let pass = 0; pass < 2; pass++) {
+    const sign = pass === 0 ? 1 : -1;
+    for (let yy = 0; yy < h; yy++) {
+      const y = pass === 0 ? yy : h - 1 - yy;
+      for (let xx = 0; xx < w; xx++) {
+        const x = pass === 0 ? xx : w - 1 - xx;
+        const i = y * w + x;
+        let best = d[i];
+        for (let j = 0; j < k; j++) {
+          const nx = x + ox[j] * sign;
+          const ny = y + oy[j] * sign;
+          if (nx < 0 || ny < 0 || nx >= w || ny >= h) continue;
+          const c = d[ny * w + nx] + wt[j];
+          if (c < best) best = c;
+        }
+        d[i] = best;
+      }
+    }
+  }
+  return d;
+}
+function distOutside(s, chamfer) {
+  const { w, h, v } = s;
+  const n = v.length;
+  const out = new Float32Array(n);
+  if (chamfer) {
+    const start = new Float32Array(n);
+    for (let i = 0; i < n; i++) start[i] = v[i] > INSIDE_EPS ? 1 - Math.min(v[i], 1) : INF;
+    const d2 = chamferFrom(start, w, h);
+    for (let i = 0; i < n; i++) out[i] = v[i] > INSIDE_EPS ? -0.5 : d2[i] - 0.5;
+    return out;
+  }
+  const inside = new Uint8Array(n);
+  for (let i = 0; i < n; i++) inside[i] = v[i] > INSIDE_EPS ? 1 : 0;
+  const { d, near } = edtNearest(inside, w, h);
+  for (let i = 0; i < n; i++) out[i] = inside[i] ? -0.5 : d[i] - 0.5 + (1 - Math.min(v[near[i]], 1));
+  return out;
+}
+function localCoverage(s) {
+  const out = { w: s.w, h: s.h, v: new Float32Array(s.v) };
+  for (let y = 0; y < s.h; y++) {
+    for (let x = 0; x < s.w; x++) {
+      const a = s.v[y * s.w + x];
+      if (a <= INSIDE_EPS) continue;
+      let mx = a;
+      for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) mx = Math.max(mx, mapGet(s, x + dx, y + dy));
+      out.v[y * s.w + x] = Math.min(a / mx, 1);
+    }
+  }
+  return out;
+}
+function distInside(s, chamfer) {
+  const { w, h, v } = s;
+  const n = v.length;
+  const out = new Float32Array(n);
+  if (chamfer) {
+    const cov = localCoverage(s);
+    const start = new Float32Array(n);
+    for (let i = 0; i < n; i++) start[i] = v[i] <= INSIDE_EPS ? 0 : cov.v[i] < 1 - INSIDE_EPS ? cov.v[i] : INF;
+    const d2 = chamferFrom(start, w, h);
+    for (let i = 0; i < n; i++) out[i] = v[i] <= INSIDE_EPS ? -0.5 : d2[i] - 0.5;
+    return out;
+  }
+  const outside = new Uint8Array(n);
+  for (let i = 0; i < n; i++) outside[i] = v[i] <= INSIDE_EPS ? 1 : 0;
+  const { d } = edtNearest(outside, w, h);
+  for (let i = 0; i < n; i++) out[i] = outside[i] ? -0.5 : d[i] - 0.5;
+  return out;
+}
+function edgeDistances(s, reach) {
+  const { w, h, v } = s;
+  const n = v.length;
+  const edge = new Uint8Array(n);
+  const inside = new Uint8Array(n);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const i = y * w + x;
+      const a = v[i];
+      if (a <= INSIDE_EPS) continue;
+      inside[i] = 1;
+      if (a < 1 - INSIDE_EPS || mapGet(s, x - 1, y) <= INSIDE_EPS || mapGet(s, x + 1, y) <= INSIDE_EPS || mapGet(s, x, y - 1) <= INSIDE_EPS || mapGet(s, x, y + 1) <= INSIDE_EPS) edge[i] = 1;
+    }
+  }
+  const { d, near } = edtNearest(edge, w, h);
+  const din = new Float32Array(n);
+  const dout = new Float32Array(n);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const i = y * w + x;
+      const q = near[i];
+      let sd;
+      if (d[i] > reach || d[i] >= INF / 2) {
+        sd = inside[i] ? -(d[i] + 0.5) : d[i] - 0.5;
+      } else {
+        const qx = q % w;
+        const qy = (q - qx) / w;
+        const g = (dx, dy) => mapGet(s, qx + dx, qy + dy);
+        let nx = -(g(1, -1) + 2 * g(1, 0) + g(1, 1) - g(-1, -1) - 2 * g(-1, 0) - g(-1, 1));
+        let ny = -(g(-1, 1) + 2 * g(0, 1) + g(1, 1) - g(-1, -1) - 2 * g(0, -1) - g(1, -1));
+        const len = Math.hypot(nx, ny);
+        if (len > 1e-6) {
+          nx /= len;
+          ny /= len;
+        } else if (d[i] > 0) {
+          nx = (x - qx) / d[i];
+          ny = (y - qy) / d[i];
+        } else {
+          nx = 1;
+          ny = 0;
+        }
+        sd = (x - qx) * nx + (y - qy) * ny - (Math.min(v[q], 1) - 0.5);
+      }
+      din[i] = inside[i] ? Math.max(-sd, inside[i] && !edge[i] ? 0.5 : -0.5) : -0.5;
+      dout[i] = inside[i] && !edge[i] ? -0.5 : Math.max(sd, -0.5);
+    }
+  }
+  return { din, dout };
+}
+function dilate(s, r) {
+  if (!(r > 0)) return s;
+  const d = distOutside(s, true);
+  const out = { w: s.w, h: s.h, v: new Float32Array(s.v) };
+  for (let i = 0; i < d.length; i++) {
+    const o = out.v[i];
+    out.v[i] = d[i] < 0 ? Math.min(o + r, 1) : Math.max(o, clamp012(r + 0.5 - d[i]));
+  }
+  return out;
+}
+function boxWidth(w) {
+  return Number.isNaN(w) ? 1 : clamp(w, 1, MAX_EFFECT_REACH);
+}
+function boxGeom(bw) {
+  bw = boxWidth(bw);
+  const half = bw / 2;
+  const r = Math.max(0, Math.ceil(half - 0.5));
+  const f = clamp012(half - (r - 0.5));
+  return [r, f, 1 / bw];
+}
+function boxLine(src, x0, dst, bw) {
+  const n = src.length;
+  const [r, f, norm] = boxGeom(bw);
+  const at = (i) => i >= 0 && i < n ? src[i] : 0;
+  if (r === 0) {
+    for (let k = 0; k < dst.length; k++) dst[k] = at(x0 + k);
+    return;
+  }
+  let inner = 0;
+  for (let i = x0 - (r - 1); i <= x0 + (r - 1); i++) inner += at(i);
+  for (let k = 0; k < dst.length; k++) {
+    const x = x0 + k;
+    dst[k] = (inner + f * (at(x - r) + at(x + r))) * norm;
+    inner += at(x + r) - at(x - r + 1);
+  }
+}
+var BLUR_EPS = 1e-7;
+function tentLine(src, dst, bw, mid) {
+  const [r] = boxGeom(bw);
+  boxLine(src, -r, mid.subarray(0, src.length + 2 * r), bw);
+  boxLine(mid.subarray(0, src.length + 2 * r), r, dst, bw);
+  for (let i = 0; i < dst.length; i++) if (Math.abs(dst[i]) < BLUR_EPS) dst[i] = 0;
+}
+function tent(m, w) {
+  if (!Number.isFinite(w) || m.v.length === 0) return;
+  if (boxGeom(w)[0] === 0) return;
+  const { w: mw, h: mh } = m;
+  const r = boxGeom(w)[0];
+  const mid = new Float64Array(Math.max(mw, mh) + 2 * r);
+  const row = new Float64Array(mw);
+  const rowOut = new Float64Array(mw);
+  for (let y = 0; y < mh; y++) {
+    for (let x = 0; x < mw; x++) row[x] = m.v[y * mw + x];
+    tentLine(row, rowOut, w, mid);
+    for (let x = 0; x < mw; x++) m.v[y * mw + x] = rowOut[x];
+  }
+  const col = new Float64Array(mh);
+  const colOut = new Float64Array(mh);
+  for (let x = 0; x < mw; x++) {
+    for (let y = 0; y < mh; y++) col[y] = m.v[y * mw + x];
+    tentLine(col, colOut, w, mid);
+    for (let y = 0; y < mh; y++) m.v[y * mw + x] = colOut[y];
+  }
+}
+function blur(m, size) {
+  if (Number.isFinite(size)) tent(m, size);
+}
+var lutCache = /* @__PURE__ */ new WeakMap();
+function contourLut(c) {
+  if (!c) return null;
+  const cached = lutCache.get(c);
+  if (cached !== void 0) return cached;
+  const pts = c.points;
+  const linear = pts.length === 2 && pts[0].input === 0 && pts[0].output === 0 && pts[1].input === 1 && pts[1].output === 1;
+  let lut = null;
+  if (pts.length >= 2 && !linear) {
+    if (!pts.some((p) => p.corner)) lut = curveLut(pts);
+    else {
+      const sorted = [...pts].sort((a, b) => a.input - b.input);
+      let start = 0;
+      for (let i = 1; i < sorted.length; i++) {
+        if (!(sorted[i].corner || i === sorted.length - 1)) continue;
+        const seg = sorted.slice(start, i + 1);
+        const from = seg[0].input;
+        const part = curveLut(seg);
+        if (!lut) lut = part;
+        else for (let k = 0; k < part.length; k++) if (k / (part.length - 1) >= from) lut[k] = part[k];
+        start = i;
+      }
+      lut ??= curveLut(pts);
+    }
+  }
+  lutCache.set(c, lut);
+  return lut;
+}
+function lutAt(l, v) {
+  const x = clamp012(v) * (l.length - 1);
+  const i = Math.floor(x);
+  const j = Math.min(i + 1, l.length - 1);
+  return l[i] + (l[j] - l[i]) * (x - i);
+}
+function applyLut(m, l) {
+  return l ? mapped(m, (v) => lutAt(l, v)) : m;
+}
+function rangedLut(c, range) {
+  const base = contourLut(c);
+  const r = Number.isFinite(range) ? clamp(range, 0.01, 1) : 1;
+  if (r >= 0.999) return base;
+  const n = 4096;
+  const out = new Float32Array(n);
+  for (let k = 0; k < n; k++) {
+    const v = Math.min(k / (n - 1) / r, 1);
+    out[k] = base ? lutAt(base, v) : v;
+  }
+  return out;
+}
+function satinLut(c) {
+  const lut = contourLut(c);
+  if (!lut) return null;
+  const end = lut[lut.length - 1];
+  const out = new Float32Array(lut.length);
+  for (let k = 0; k < lut.length; k++) out[k] = Math.abs(lut[lut.length - 1 - k] - end);
+  return out;
+}
+function noise(m, amount, x0, y0) {
+  if (!Number.isFinite(amount) || amount <= 0) return;
+  for (let y = 0; y < m.h; y++) {
+    for (let x = 0; x < m.w; x++) {
+      const i = y * m.w + x;
+      if (m.v[i] <= BLUR_EPS) continue;
+      m.v[i] = clamp012(m.v[i] + (hashNoise(x0 + x, y0 + y) - 0.5) * 2 * amount);
+    }
+  }
+}
+function lightOffset(angle, distance) {
+  const a = angle * Math.PI / 180;
+  return [Math.round(-Math.cos(a) * distance), Math.round(Math.sin(a) * distance)];
+}
+function spreadSplit(size, spread) {
+  return [Math.round(size * spread), size * (1 - spread)];
+}
+function shadowMap(shape, s, spread, light, inner, ox, oy) {
+  const angle = s.useGlobalLight ? light.angle : s.angle;
+  const [dx, dy] = lightOffset(angle, s.distance);
+  const src = inner ? mapped(shape, (a) => 1 - a) : shape;
+  let m = shifted(src, dx, dy, inner ? 1 : 0);
+  const [r, bw] = spreadSplit(s.size, spread);
+  m = dilate(m, r);
+  blur(m, bw);
+  m = applyLut(m, contourLut(s.contour));
+  noise(m, s.noise, ox, oy);
+  if (inner) for (let i = 0; i < m.v.length; i++) m.v[i] *= shape.v[i];
+  return m;
+}
+function glowMap(shape, g, ox, oy) {
+  const inner = g.kind === "inner-glow";
+  const spread = inner ? g.choke : g.spread;
+  const src = inner ? mapped(shape, (a) => 1 - a) : shape;
+  let m;
+  if (g.technique === "precise") {
+    const d = inner ? distInside(shape, false) : distOutside(src, false);
+    const solid = g.size * spread;
+    const soft = Math.max(g.size + 1 - solid, 1e-3);
+    m = fmap(shape.w, shape.h);
+    for (let i = 0; i < d.length; i++) {
+      const di = d[i] + 0.5;
+      m.v[i] = di <= solid ? 1 : 0.5 * clamp012(1 - (di - solid) / soft);
+    }
+  } else {
+    const [r, bw] = spreadSplit(g.size, spread);
+    m = dilate(src, r);
+    if (m === src || m === shape) m = { w: m.w, h: m.h, v: new Float32Array(m.v) };
+    blur(m, bw);
+  }
+  m = applyLut(m, rangedLut(g.contour, g.range));
+  if (inner && g.source === "center") m = mapped(m, (v) => 1 - v);
+  noise(m, g.noise, ox, oy);
+  if (inner) for (let i = 0; i < m.v.length; i++) m.v[i] *= shape.v[i];
+  return m;
+}
+function satinMap(shape, s) {
+  const [dx, dy] = lightOffset(s.angle, Math.max(1, s.distance));
+  const a = shifted(shape, dx, dy, 0);
+  const b = shifted(shape, -dx, -dy, 0);
+  tent(a, s.size);
+  tent(b, s.size);
+  let m = fmap(shape.w, shape.h);
+  for (let i = 0; i < m.v.length; i++) m.v[i] = Math.abs(a.v[i] - b.v[i]);
+  if (s.invert) m = mapped(m, (v) => 1 - v);
+  m = applyLut(m, satinLut(s.contour));
+  for (let i = 0; i < m.v.length; i++) m.v[i] *= shape.v[i];
+  return m;
+}
+function bevelGeom(b) {
+  const size = Math.max(b.size, 1);
+  const emboss = b.style === "emboss" || b.style === "pillow-emboss";
+  const paint2 = b.style === "outer-bevel" ? "outer" : emboss ? "both" : "inner";
+  const width = emboss ? Math.ceil(size / 2) : size;
+  const smooth = b.technique === "smooth";
+  const sign = b.direction === "up" ? 1 : -1;
+  return {
+    paint: paint2,
+    width,
+    depth: b.depth * (smooth ? width : size / 2) * sign,
+    pillow: b.style === "pillow-emboss",
+    chiselSoft: b.technique === "chisel-soft" ? Math.max(size / 4, 1) : 0
+  };
+}
+function bevelChiselH(paint2, size, din, dout, soft) {
+  const ramp = size + 1;
+  if (paint2 === "outer" && !soft) {
+    const top = (size + 2) / ramp;
+    return dout > 0 ? clamp((size + 1.5 - dout) / ramp, 0, top) : top;
+  }
+  if (paint2 === "outer") return dout > 0 ? 1 - clamp012((dout + 0.5) / ramp) : (size + 2) / ramp;
+  if (paint2 === "both") {
+    const half = size / 2 + 0.5;
+    return din > 0 ? 0.5 + 0.5 * clamp012(din / half) : 0.5 - 0.5 * clamp012(dout / half);
+  }
+  if (soft) return din > 0 ? clamp((din + 1.5) / ramp, 0, (size + 2) / ramp) : 0;
+  return din > 0 ? clamp012((din + 0.5) / ramp) : 0;
+}
+function bevelHeight(shape, b, g, rect, anchor, ctx) {
+  const size = Math.max(b.size, 1);
+  let h;
+  if (b.technique === "smooth") {
+    h = { w: shape.w, h: shape.h, v: new Float32Array(shape.v) };
+    tent(h, g.width);
+  } else {
+    const { din, dout } = edgeDistances(shape, size + 2);
+    h = fmap(shape.w, shape.h);
+    const soft = g.chiselSoft > 0;
+    for (let i = 0; i < h.v.length; i++) h.v[i] = bevelChiselH(g.paint, size, din[i], dout[i], soft);
+    if (soft && g.paint === "both") tent(h, g.chiselSoft);
+  }
+  if (b.contourElement) h = applyLut(h, contourLut(b.contourElement.contour) ?? identityLut());
+  const t = b.texture;
+  const tile = t ? ctx.pattern(t.patternId) : null;
+  if (t && tile) {
+    const unit = Math.abs(b.depth) > 1e-6 ? Math.max(Math.abs(g.depth / b.depth), 1e-3) : Math.max(g.width, 1);
+    const place = new PatternPlacement(anchor, t.link ?? true, t.phase ?? { x: 0, y: 0 }, t.scale, 0);
+    const k = t.depth / unit;
+    const uv = [0, 0];
+    const p = [0, 0, 0, 0];
+    for (let y = 0; y < h.h; y++) {
+      for (let x = 0; x < h.w; x++) {
+        place.map(rect.x + x + 0.5, rect.y + y + 0.5, uv);
+        tile.sample(uv[0], uv[1], p);
+        const l = (0.299 * p[0] + 0.587 * p[1] + 0.114 * p[2]) * p[3];
+        h.v[y * h.w + x] += k * (t.invert ? 1 - l : l);
+      }
+    }
+  }
+  if (b.soften >= 1) tent(h, b.soften);
+  return h;
+}
+var identity = null;
+function identityLut() {
+  if (!identity) {
+    identity = new Float32Array(4096);
+    for (let k = 0; k < 4096; k++) identity[k] = k / 4095;
+  }
+  return identity;
+}
+function bevelMaps(shape, b, rect, anchor, ctx) {
+  const g = bevelGeom(b);
+  const hmap = bevelHeight(shape, b, g, rect, anchor, ctx);
+  const angle = b.useGlobalLight ? ctx.light.angle : b.angle;
+  const altitude = b.useGlobalLight ? ctx.light.altitude : b.altitude;
+  const sa = Math.sin(angle * Math.PI / 180);
+  const ca = Math.cos(angle * Math.PI / 180);
+  const se = Math.sin(altitude * Math.PI / 180);
+  const ce = Math.cos(altitude * Math.PI / 180);
+  const lx = ca * ce;
+  const ly = -sa * ce;
+  const lz = se;
+  const reachPast = g.paint === "both" || g.paint === "outer" && b.technique !== "smooth";
+  const onBevel = (x, y) => mapGet(hmap, x, y) > BEVEL_H_EPS || reachPast && (mapGet(hmap, x + 1, y) > BEVEL_H_EPS || mapGet(hmap, x - 1, y) > BEVEL_H_EPS || mapGet(hmap, x, y + 1) > BEVEL_H_EPS || mapGet(hmap, x, y - 1) > BEVEL_H_EPS);
+  const gloss = contourLut(b.glossContour);
+  const shadeInto = (depth, outside) => {
+    const hi2 = fmap(shape.w, shape.h);
+    const sh2 = fmap(shape.w, shape.h);
+    for (let y = 0; y < shape.h; y++) {
+      for (let x = 0; x < shape.w; x++) {
+        const i = y * shape.w + x;
+        const gx = (mapGet(hmap, x + 1, y) - mapGet(hmap, x - 1, y)) * 0.5 * depth;
+        const gy = (mapGet(hmap, x, y + 1) - mapGet(hmap, x, y - 1)) * 0.5 * depth;
+        const len = Math.sqrt(gx * gx + gy * gy + 1);
+        const shade = (-gx * lx - gy * ly + lz) / len;
+        const region = outside ? shape.v[i] < 1 - INSIDE_EPS && onBevel(x, y) ? 1 : 0 : shape.v[i];
+        const k = shade - se;
+        if (k > 0) hi2.v[i] = clamp012(k / Math.max(1 - se, 1e-3)) * region;
+        else sh2.v[i] = clamp012(-k / Math.max(se, 1e-3)) * region;
+      }
+    }
+    return [applyLut(hi2, gloss), applyLut(sh2, gloss)];
+  };
+  if (g.paint !== "both") {
+    const [hi2, sh2] = shadeInto(g.depth, g.paint === "outer");
+    return { maps: [hi2, sh2], paint: g.paint };
+  }
+  const [hi, sh] = shadeInto(g.depth, false);
+  const [ho, so] = shadeInto(g.pillow ? -g.depth : g.depth, true);
+  const mix = (a, o) => {
+    const out = fmap(a.w, a.h);
+    for (let i = 0; i < out.v.length; i++) {
+      const s = shape.v[i];
+      out.v[i] = (s > INSIDE_EPS ? a.v[i] : 0) + o.v[i] * (1 - Math.min(s, 1));
+    }
+    return out;
+  };
+  return { maps: [mix(hi, ho), mix(sh, so)], paint: "both" };
+}
+function strokeWidths(s) {
+  return s.position === "outside" ? [0, s.size] : s.position === "inside" ? [s.size, 0] : [s.size / 2, s.size / 2];
+}
+function activeEffectItems(effects) {
+  if (!hasActiveEffects(effects)) return [];
+  const s = effectsScale(effects);
+  return effects.items.filter((e) => e.enabled).map((e) => scaleLayerEffect(e, s));
+}
+function effectsAreLocal(items) {
+  const linked = (p) => p.link !== false;
+  return items.every((e) => {
+    switch (e.kind) {
+      case "gradient-overlay":
+        return !e.gradient.align;
+      case "pattern-overlay":
+        return !linked(e);
+      case "stroke":
+        return e.fill.type === "color" || e.fill.type === "pattern" && !linked(e.fill);
+      case "drop-shadow":
+      case "inner-shadow":
+      case "outer-glow":
+      case "inner-glow":
+        return e.noise <= 0;
+      case "bevel-emboss":
+        return !e.texture || !linked(e.texture);
+      default:
+        return true;
+    }
+  });
+}
+function buildEffectMaps(items, shape, rect, ctx) {
+  const w = rect.width;
+  const h = rect.height;
+  const s = { w, h, v: shape };
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      if (shape[y * w + x] > INSIDE_EPS) {
+        if (x < x0) x0 = x;
+        if (x > x1) x1 = x;
+        if (y < y0) y0 = y;
+        if (y > y1) y1 = y;
+      }
+    }
+  }
+  const bounds = x0 === Infinity ? null : { x: rect.x + x0, y: rect.y + y0, width: x1 - x0 + 1, height: y1 - y0 + 1 };
+  const anchor = bounds ? { x: bounds.x, y: bounds.y } : { x: rect.x, y: rect.y };
+  const per = [];
+  const bevelPaint = [];
+  const frames = /* @__PURE__ */ new Map();
+  let bytes = shape.byteLength;
+  items.forEach((e, i) => {
+    let maps = [];
+    let paint2 = null;
+    switch (e.kind) {
+      case "drop-shadow":
+        maps = [shadowMap(s, e, e.spread, ctx.light, false, rect.x, rect.y)];
+        break;
+      case "inner-shadow":
+        maps = [shadowMap(s, e, e.choke, ctx.light, true, rect.x, rect.y)];
+        break;
+      case "outer-glow":
+      case "inner-glow":
+        maps = [glowMap(s, e, rect.x, rect.y)];
+        break;
+      case "satin":
+        maps = [satinMap(s, e)];
+        break;
+      case "bevel-emboss": {
+        const r = bevelMaps(s, e, rect, anchor, ctx);
+        maps = r.maps;
+        paint2 = r.paint;
+        break;
+      }
+      case "stroke":
+        if (e.fill.type === "gradient" && bounds) {
+          const grow = Math.max(0, Math.ceil(Math.min(strokeWidths(e)[1], MAX_EFFECT_REACH)) - 1);
+          frames.set(i, { x: bounds.x - grow, y: bounds.y - grow, width: bounds.width + 2 * grow, height: bounds.height + 2 * grow });
+        }
+        break;
+    }
+    per.push(maps.map((m) => m.v));
+    bevelPaint.push(paint2);
+    for (const m of maps) bytes += m.v.byteLength;
+  });
+  const strokes = items.filter((e) => e.kind === "stroke");
+  const outW = strokes.map((st) => strokeWidths(st)[1]).filter((x) => x > 0);
+  const din = strokes.length ? distInside(s, true) : null;
+  const dout = outW.some((x) => x < STROKE_CHAMFER_MAX) ? distOutside(s, true) : null;
+  const doutExact = outW.some((x) => x >= STROKE_CHAMFER_MAX) ? distOutside(s, false) : null;
+  for (const d of [din, dout, doutExact]) if (d) bytes += d.byteLength;
+  return { rect, items, bounds, shape, per, bevelPaint, din, dout, doutExact, frames, bytes };
+}
+var rgbScratchB = [0, 0, 0];
+var rgbScratchS = [0, 0, 0];
+function compositeAt(dst, i, mode, separable, sr, sg, sb, sa) {
+  if (!(sa > 0)) return;
+  const ab = dst[i + 3];
+  const ao = sa + ab * (1 - sa);
+  if (ao <= 0) {
+    dst[i] = dst[i + 1] = dst[i + 2] = dst[i + 3] = 0;
+    return;
+  }
+  const b0 = dst[i];
+  const b1 = dst[i + 1];
+  const b2 = dst[i + 2];
+  let m0;
+  let m1;
+  let m2;
+  if (mode === "normal") {
+    m0 = sr;
+    m1 = sg;
+    m2 = sb;
+  } else if (separable) {
+    m0 = blendChannel(mode, b0, sr);
+    m1 = blendChannel(mode, b1, sg);
+    m2 = blendChannel(mode, b2, sb);
+  } else {
+    rgbScratchB[0] = b0;
+    rgbScratchB[1] = b1;
+    rgbScratchB[2] = b2;
+    rgbScratchS[0] = sr;
+    rgbScratchS[1] = sg;
+    rgbScratchS[2] = sb;
+    const m = blendRgb(mode, rgbScratchB, rgbScratchS);
+    m0 = m[0];
+    m1 = m[1];
+    m2 = m[2];
+  }
+  const wb = (1 - sa) * ab;
+  const ws = (1 - ab) * sa;
+  const wm = sa * ab;
+  dst[i] = (wb * b0 + ws * sr + wm * m0) / ao;
+  dst[i + 1] = (wb * b1 + ws * sg + wm * m1) / ao;
+  dst[i + 2] = (wb * b2 + ws * sb + wm * m2) / ao;
+  dst[i + 3] = ao;
+}
+function paint(dst, m, color2, mode, opacity) {
+  const sep = mode !== "normal" && isSeparableBlendMode(mode);
+  const c = [0, 0, 0, 1];
+  const n = m.length;
+  for (let i = 0; i < n; i++) {
+    const a = m[i] * opacity;
+    if (!(a > 0)) continue;
+    color2(i, c);
+    compositeAt(dst, i * 4, mode, sep, c[0], c[1], c[2], c[3] * Math.min(a, 1));
+  }
+}
+function rgbOf(hex) {
+  return parseEffectColor(hex) ?? [0, 0, 0];
+}
+function paintColor(dst, m, hex, mode, opacity) {
+  const [r, g, b] = rgbOf(hex);
+  paint(
+    dst,
+    m,
+    (_i, c) => {
+      c[0] = r;
+      c[1] = g;
+      c[2] = b;
+      c[3] = 1;
+    },
+    mode,
+    opacity
+  );
+}
+var PreparedGradient = class {
+  color;
+  alpha;
+  constructor(g) {
+    this.color = [...g.stops].sort((a, b) => a.position - b.position).map((s) => [s.position, ...rgbOf(s.color)]);
+    this.alpha = [...g.opacityStops ?? []].sort((a, b) => a.position - b.position).map((s) => [s.position, s.opacity]);
+  }
+  sample(t, out) {
+    const c = this.color;
+    if (!c.length) {
+      out[0] = out[1] = out[2] = t;
+    } else if (c.length === 1 || t <= c[0][0]) {
+      out[0] = c[0][1];
+      out[1] = c[0][2];
+      out[2] = c[0][3];
+    } else {
+      let done = false;
+      for (let k = 0; k < c.length - 1; k++) {
+        const a2 = c[k];
+        const b = c[k + 1];
+        if (t <= b[0]) {
+          const f = b[0] > a2[0] ? (t - a2[0]) / (b[0] - a2[0]) : 0;
+          out[0] = a2[1] + (b[1] - a2[1]) * f;
+          out[1] = a2[2] + (b[2] - a2[2]) * f;
+          out[2] = a2[3] + (b[3] - a2[3]) * f;
+          done = true;
+          break;
+        }
+      }
+      if (!done) {
+        const l = c[c.length - 1];
+        out[0] = l[1];
+        out[1] = l[2];
+        out[2] = l[3];
+      }
+    }
+    const a = this.alpha;
+    if (!a.length) out[3] = 1;
+    else if (a.length === 1 || t <= a[0][0]) out[3] = a[0][1];
+    else {
+      out[3] = a[a.length - 1][1];
+      for (let k = 0; k < a.length - 1; k++) {
+        if (t <= a[k + 1][0]) {
+          const f = a[k + 1][0] > a[k][0] ? (t - a[k][0]) / (a[k + 1][0] - a[k][0]) : 0;
+          out[3] = a[k][1] + (a[k + 1][1] - a[k][1]) * f;
+          break;
+        }
+      }
+    }
+  }
+};
+function gradientUnits(angle, w, h) {
+  const a = angle * Math.PI / 180;
+  const s = Math.sin(a);
+  const c = Math.cos(a);
+  const len = Math.max(Math.sqrt((c * w) ** 2 + (s * h) ** 2), 1);
+  const chord = Math.max(Math.min(w / Math.max(Math.abs(c), 1e-6), h / Math.max(Math.abs(s), 1e-6)), 1);
+  return [chord, len];
+}
+function gradientT(style, angle, scale, reverse, offset, frame, x, y) {
+  const w = Math.max(frame.width, 1);
+  const h = Math.max(frame.height, 1);
+  const cx = frame.x + w / 2 + offset.x * w;
+  const cy = frame.y + h / 2 + offset.y * h;
+  const a = angle * Math.PI / 180;
+  const s = Math.sin(a);
+  const c = Math.cos(a);
+  const dx = x - cx;
+  const dy = y - cy;
+  const along = dx * c - dy * s;
+  const across = dx * s + dy * c;
+  let [chord, len] = gradientUnits(angle, w, h);
+  chord *= Math.max(scale, 1e-3);
+  len *= Math.max(scale, 1e-3);
+  const corner = 0.5 * (c - s);
+  let t;
+  switch (style) {
+    case "linear":
+      t = (along - corner) / chord + 0.5;
+      break;
+    case "reflected":
+      t = Math.abs((along - corner) / (chord / 2));
+      break;
+    case "radial":
+      t = Math.sqrt(dx * dx + dy * dy) / (len / 2);
+      break;
+    case "diamond":
+      t = (Math.abs(along) + Math.abs(across)) / (len / 2);
+      break;
+    case "angle": {
+      const turn = (a - Math.atan2(-dy, dx)) / (2 * Math.PI);
+      t = turn - Math.floor(turn);
+      break;
+    }
+  }
+  t = clamp012(t);
+  return reverse ? 1 - t : t;
+}
+function gradientLayout(style, angle, scale, offset, frame) {
+  const unchanged = [angle, scale, offset];
+  if (style !== "linear" && style !== "reflected" || ![angle, scale, offset.x, offset.y].every(Number.isFinite)) return unchanged;
+  const w = Math.max(frame.width, 1);
+  const h = Math.max(frame.height, 1);
+  const cx = frame.x + w / 2 + offset.x * w;
+  const cy = frame.y + h / 2 + offset.y * h;
+  const chordOf = (r) => Math.max(Math.min(w / Math.max(Math.abs(Math.cos(r)), 1e-6), h / Math.max(Math.abs(Math.sin(r)), 1e-6)), 1);
+  const a = angle * Math.PI / 180;
+  const half = chordOf(a) * Math.max(scale, 1e-3) / 2;
+  const dx = Math.cos(a) * half;
+  const dy = -Math.sin(a) * half;
+  const snap = (v2) => Math.floor(v2 + 1e-4);
+  const end = [snap(cx + dx), snap(cy + dy)];
+  let start;
+  let mid;
+  if (style === "reflected") {
+    start = [cx, cy];
+    mid = [cx, cy];
+  } else {
+    start = [snap(cx - dx), snap(cy - dy)];
+    mid = [(start[0] + end[0]) / 2, (start[1] + end[1]) / 2];
+  }
+  const v = [end[0] - start[0], end[1] - start[1]];
+  const len = Math.hypot(v[0], v[1]);
+  if (len < 0.5) return unchanged;
+  const a2 = Math.atan2(-v[1], v[0]);
+  const span = style === "reflected" ? 2 * len : len;
+  return [a2 * 180 / Math.PI, span / chordOf(a2), { x: offset.x + (mid[0] - cx) / w, y: offset.y + (mid[1] - cy) / h }];
+}
+function paintGradient(dst, m, g, frame, env, mode, opacity) {
+  const prepared = new PreparedGradient(g);
+  const [angle, scale, offset] = gradientLayout(g.style, g.angle, g.scale, g.offset, frame);
+  const { x: rx, y: ry, width: w } = env.rect;
+  paint(dst, m, (i, c) => prepared.sample(gradientT(g.style, angle, scale, g.reverse, offset, frame, rx + i % w + 0.5, ry + Math.floor(i / w) + 0.5), c), mode, opacity);
+}
+function paintPattern(dst, m, p, env, mode, opacity) {
+  const tile = env.ctx.pattern(p.patternId);
+  if (!tile) return;
+  const place = new PatternPlacement(env.anchor, p.link ?? true, p.phase ?? { x: 0, y: 0 }, p.scale, p.angle ?? 0);
+  const { x: rx, y: ry, width: w } = env.rect;
+  const uv = [0, 0];
+  paint(
+    dst,
+    m,
+    (i, c) => {
+      place.map(rx + i % w + 0.5, ry + Math.floor(i / w) + 0.5, uv);
+      tile.sample(uv[0], uv[1], c);
+    },
+    mode,
+    opacity
+  );
+}
+function paintFill(dst, m, f, frame, env, mode, opacity) {
+  if (f.type === "color") paintColor(dst, m, f.color, mode, opacity);
+  else if (f.type === "gradient") paintGradient(dst, m, f.gradient, f.gradient.align ? frame : env.canvas, env, mode, opacity);
+  else paintPattern(dst, m, f, env, mode, opacity);
+}
+function paintGlow(dst, m, g, env) {
+  if (g.fill.type === "color") return paintColor(dst, m, g.fill.color, g.blend, g.opacity);
+  const prepared = new PreparedGradient(g.fill.gradient);
+  const r = Number.isFinite(g.range) ? clamp(g.range, 0.01, 1) : 1;
+  const gain = 1 / (r * r);
+  const strength = new Float32Array(m.length);
+  for (let i = 0; i < m.length; i++) strength[i] = Math.min(m[i] * gain, 1);
+  paint(dst, strength, (i, c) => prepared.sample(1 - clamp012(m[i]), c), g.blend, g.opacity);
+}
+function crop(v, from, to, fill2) {
+  const out = new Float32Array(to.width * to.height);
+  if (fill2) out.fill(fill2);
+  const ix0 = Math.max(from.x, to.x);
+  const iy0 = Math.max(from.y, to.y);
+  const ix1 = Math.min(from.x + from.width, to.x + to.width);
+  const iy1 = Math.min(from.y + from.height, to.y + to.height);
+  if (ix1 <= ix0 || iy1 <= iy0) return out;
+  const n = ix1 - ix0;
+  for (let y = iy0; y < iy1; y++) {
+    const s = (y - from.y) * from.width + (ix0 - from.x);
+    out.set(v.subarray(s, s + n), (y - to.y) * to.width + (ix0 - to.x));
+  }
+  return out;
+}
+function compositeLayerEffects(input) {
+  const { backdrop, content, rect, maps, ctx } = input;
+  const items = maps.items;
+  const n = rect.width * rect.height;
+  const shape = new Float32Array(n);
+  for (let i = 0; i < n; i++) shape[i] = content[i * 4 + 3] / 255;
+  const before = new Float32Array(n * 4);
+  for (let i = 0; i < n * 4; i++) before[i] = backdrop[i] / 255;
+  const work = new Float32Array(before);
+  const fx = (i, k) => crop(maps.per[i][k], maps.rect, rect, 0);
+  const bounds = maps.bounds ?? rect;
+  const env = { rect, bounds, canvas: input.canvas, anchor: { x: bounds.x, y: bounds.y }, ctx };
+  const fill2 = clamp012(input.fillOpacity);
+  const inside = (a) => a > INSIDE_EPS;
+  const rev = [];
+  for (let i = items.length - 1; i >= 0; i--) rev.push(i);
+  const knockOut = (m, fillOpacity) => {
+    const seeThrough = 1 - clamp012(fillOpacity);
+    for (let i = 0; i < n; i++) m[i] *= 1 - shape[i] * seeThrough;
+  };
+  const normalLike = input.blend === "normal";
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind !== "drop-shadow") continue;
+    const m = fx(i, 0);
+    if (e.knocksOut) knockOut(m, normalLike ? fill2 : 0);
+    paintColor(work, m, e.color, e.blend, e.opacity);
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind !== "outer-glow") continue;
+    const m = fx(i, 0);
+    knockOut(m, fill2);
+    paintGlow(work, m, e, env);
+  }
+  const lay = new Float32Array(n * 4);
+  for (let i = 0; i < n; i++) {
+    lay[i * 4] = content[i * 4] / 255;
+    lay[i * 4 + 1] = content[i * 4 + 1] / 255;
+    lay[i * 4 + 2] = content[i * 4 + 2] / 255;
+    lay[i * 4 + 3] = inside(shape[i]) ? fill2 : 0;
+  }
+  const premerge = !normalLike;
+  if (premerge) {
+    const sep2 = isSeparableBlendMode(input.blend);
+    for (let i = 0; i < n; i++) {
+      const p = i * 4;
+      const sr = lay[p];
+      const sg = lay[p + 1];
+      const sb = lay[p + 2];
+      const sa = lay[p + 3];
+      lay[p] = work[p];
+      lay[p + 1] = work[p + 1];
+      lay[p + 2] = work[p + 2];
+      lay[p + 3] = work[p + 3];
+      compositeAt(lay, p, input.blend, sep2, sr, sg, sb, sa);
+    }
+  }
+  const rel = (m) => {
+    for (let i = 0; i < n; i++) m[i] = inside(shape[i]) ? Math.min(m[i] / shape[i], 1) : 0;
+    return m;
+  };
+  const full = new Float32Array(n);
+  for (let i = 0; i < n; i++) full[i] = inside(shape[i]) ? 1 : 0;
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind === "pattern-overlay") paintPattern(lay, full, e, env, e.blend, e.opacity);
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind === "gradient-overlay") paintGradient(lay, full, e.gradient, e.gradient.align ? bounds : input.canvas, env, e.blend, e.opacity);
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind === "color-overlay") paintColor(lay, full, e.color, e.blend, e.opacity);
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind === "satin") paintColor(lay, rel(fx(i, 0)), e.color, e.blend, e.opacity);
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind === "inner-glow") paintGlow(lay, rel(fx(i, 0)), e, env);
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind === "inner-shadow") paintColor(lay, rel(fx(i, 0)), e.color, e.blend, e.opacity);
+  }
+  const strokeIdx = items.map((e, i) => e.kind === "stroke" ? i : -1).filter((i) => i >= 0);
+  const din = strokeIdx.length && maps.din ? crop(maps.din, maps.rect, rect, 0) : null;
+  const frameOf = (i) => maps.frames.get(i) ?? bounds;
+  for (let k = strokeIdx.length - 1; k >= 0; k--) {
+    const st = items[strokeIdx[k]];
+    const [inW] = strokeWidths(st);
+    if (!(inW > 0) || !din) continue;
+    const m = new Float32Array(n);
+    for (let i = 0; i < n; i++) m[i] = inside(shape[i]) ? clamp012(inW + 0.5 - din[i]) : 0;
+    paintFill(lay, m, st.fill, frameOf(strokeIdx[k]), env, st.blend, st.opacity);
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind !== "bevel-emboss" || maps.bevelPaint[i] !== "inner") continue;
+    paintColor(lay, rel(fx(i, 0)), e.highlightColor, e.highlightBlend, e.highlightOpacity);
+    paintColor(lay, rel(fx(i, 1)), e.shadowColor, e.shadowBlend, e.shadowOpacity);
+  }
+  for (let i = 0; i < n; i++) lay[i * 4 + 3] *= Math.min(shape[i], 1);
+  const outside = strokeIdx.filter((i) => strokeWidths(items[i])[1] > 0);
+  if (outside.length) {
+    const dout = maps.dout ? crop(maps.dout, maps.rect, rect, FAR) : null;
+    const doutExact = maps.doutExact ? crop(maps.doutExact, maps.rect, rect, FAR) : null;
+    const base = new Float32Array(work);
+    const acc = new Float32Array(n * 4);
+    const cover = new Float32Array(n);
+    for (const si of outside) {
+      const st = items[si];
+      const outW = strokeWidths(st)[1];
+      const d = (outW >= STROKE_CHAMFER_MAX ? doutExact : dout) ?? new Float32Array(n).fill(FAR);
+      const share = new Float32Array(n);
+      const ones = new Float32Array(n);
+      for (let i = 0; i < n; i++) {
+        const band = clamp012(outW + 0.5 - d[i]);
+        let k;
+        if (inside(shape[i])) {
+          const c = clamp012(lay[i * 4 + 3]);
+          k = c >= 1 ? 1 : clamp012((1 - clamp012(shape[i])) / (1 - c));
+        } else k = band;
+        share[i] = k * st.opacity * (1 - cover[i]);
+        cover[i] += share[i];
+        ones[i] = share[i] > 0 ? 1 : 0;
+      }
+      const blended = new Float32Array(base);
+      paintFill(blended, ones, st.fill, frameOf(si), env, st.blend, 1);
+      for (let i = 0; i < n; i++) {
+        const s = share[i];
+        if (!(s > 0)) continue;
+        const p = i * 4;
+        const ba = blended[p + 3];
+        acc[p] += s * blended[p] * ba;
+        acc[p + 1] += s * blended[p + 1] * ba;
+        acc[p + 2] += s * blended[p + 2] * ba;
+        acc[p + 3] += s * ba;
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      const c = cover[i];
+      if (c <= 0) continue;
+      const p = i * 4;
+      const k = 1 - Math.min(c, 1);
+      const a = work[p + 3] * k + acc[p + 3];
+      if (a > 0) {
+        work[p] = (work[p] * work[p + 3] * k + acc[p]) / a;
+        work[p + 1] = (work[p + 1] * work[p + 3] * k + acc[p + 1]) / a;
+        work[p + 2] = (work[p + 2] * work[p + 3] * k + acc[p + 2]) / a;
+        work[p + 3] = Math.min(a, 1);
+      }
+    }
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind !== "bevel-emboss" || maps.bevelPaint[i] !== "outer") continue;
+    paintColor(work, fx(i, 0), e.highlightColor, e.highlightBlend, e.highlightOpacity);
+    paintColor(work, fx(i, 1), e.shadowColor, e.shadowBlend, e.shadowOpacity);
+  }
+  const mode = premerge ? "normal" : input.blend;
+  const sep = isSeparableBlendMode(mode);
+  for (let i = 0; i < n; i++) {
+    const p = i * 4;
+    if (lay[p + 3] > 0) compositeAt(work, p, mode, sep, lay[p], lay[p + 1], lay[p + 2], lay[p + 3]);
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind !== "bevel-emboss" || maps.bevelPaint[i] !== "both") continue;
+    paintColor(work, fx(i, 0), e.highlightColor, e.highlightBlend, e.highlightOpacity);
+    paintColor(work, fx(i, 1), e.shadowColor, e.shadowBlend, e.shadowOpacity);
+  }
+  const op = clamp012(input.opacity);
+  for (let i = 0; i < n; i++) {
+    const p = i * 4;
+    const aa = before[p + 3];
+    const ba = work[p + 3];
+    const alpha = aa + (ba - aa) * op;
+    if (alpha <= 0) {
+      backdrop[p] = backdrop[p + 1] = backdrop[p + 2] = backdrop[p + 3] = 0;
+      continue;
+    }
+    for (let c = 0; c < 3; c++) backdrop[p + c] = Math.round((before[p + c] * aa + (work[p + c] * ba - before[p + c] * aa) * op) / alpha * 255);
+    backdrop[p + 3] = Math.round(alpha * 255);
+  }
+}
+function renderLayerEffects(effects, layer, backdrop, canvas, ctx) {
+  const items = activeEffectItems(effects);
+  const n = layer.rect.width * layer.rect.height;
+  const shape = new Float32Array(n);
+  for (let i = 0; i < n; i++) shape[i] = layer.content[i * 4 + 3] / 255;
+  const maps = buildEffectMaps(items, shape, layer.rect, ctx);
+  compositeLayerEffects({
+    backdrop,
+    content: layer.content,
+    rect: layer.rect,
+    maps,
+    blend: layer.blend,
+    opacity: layer.opacity,
+    fillOpacity: layer.fillOpacity ?? 1,
+    canvas,
+    ctx
+  });
+}
+
+// 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();
+  /** Effect maps by layer id (see the module comment), least recently used first. */
+  effectCache = /* @__PURE__ */ new Map();
+  /** Effect maps already validated in this call, by layer object. */
+  effectMemo = /* @__PURE__ */ new WeakMap();
+  patternTiles = /* @__PURE__ */ new WeakMap();
+  reachCache = /* @__PURE__ */ new WeakMap();
+  fxContext = null;
+  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();
+    this.effectCache.clear();
+    this.effectMemo = /* @__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;
+    this.fxContext = null;
+  }
+  /** 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 };
+    const grow = options.dirty ? this.effectsReach(layers) : 0;
+    const dirty = grow > 0 ? options.dirty.map((d) => inflateRect(d, grow)) : options.dirty;
+    for (const { tx, ty } of tilesInRect(rect)) {
+      stats.tiles++;
+      const before = this.tiles.get(tileKey(tx, ty))?.result;
+      const data = this.compositeTile(layers, steps, tx, ty, stats, dirty ? dirtyInTile(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);
+    if (this.hasEffects(layer)) base.push(effectsFingerprint(layer.effects));
+    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) {
+    if (group.visible && this.hasEffects(group)) return this.effectSig(group, tx, ty);
+    return this.plainGroupSig(group, steps, tx, ty);
+  }
+  plainGroupSig(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) {
+    if (layer.visible && this.hasEffects(layer)) return this.effectSig(layer, tx, ty);
+    return this.plainContentSig(layer, tx, ty);
+  }
+  plainContentSig(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 };
+  }
+  // --- Layer effects ------------------------------------------------------------
+  hasEffects(layer) {
+    return hasActiveEffects(layer.effects) && !this.isFilter(layer);
+  }
+  /** The largest effects margin of any visible layer in the stack (memoised per root). */
+  effectsReach(layers) {
+    let m = this.reachCache.get(layers);
+    if (m !== void 0) return m;
+    m = 0;
+    const walk = (list) => {
+      for (const l of list) {
+        if (!l.visible) continue;
+        if (this.hasEffects(l)) m = Math.max(m, effectsMargin(l.effects));
+        if (l.children) walk(l.children);
+      }
+    };
+    walk(layers);
+    this.reachCache.set(layers, m);
+    return m;
+  }
+  effectContext() {
+    if (this.fxContext) return this.fxContext;
+    const sources = this.sources;
+    const tiles = this.patternTiles;
+    this.fxContext = {
+      light: sources.globalLight ?? DEFAULT_GLOBAL_LIGHT,
+      pattern: (id) => {
+        const p = sources.pattern?.(id) ?? builtinPattern(id);
+        if (!p || !(p.width > 0 && p.height > 0) || p.data.length < p.width * p.height * 4) return null;
+        let t = tiles.get(p);
+        if (!t) {
+          t = new PatternTile(p);
+          tiles.set(p, t);
+        }
+        return t;
+      }
+    };
+    return this.fxContext;
+  }
+  /**
+   * Where a layer's effect maps are built: its bounds (pixel layers; the canvas otherwise) grown by
+   * the effects' margin, within the canvas grown the same.
+   */
+  effectRegion(layer) {
+    const m = effectsMargin(layer.effects);
+    const canvas = { x: -m, y: -m, width: this.sources.width + 2 * m, height: this.sources.height + 2 * m };
+    if (!isPixel(layer)) return canvas;
+    const { surface, dx, dy } = this.layerPixels(layer);
+    if (surface.defaultValue !== 0) return canvas;
+    const b = surface.bounds;
+    if (!b) return { x: 0, y: 0, width: 0, height: 0 };
+    return intersectRect({ x: b.x + dx - m, y: b.y + dy - m, width: b.width + 2 * m, height: b.height + 2 * m }, canvas);
+  }
+  /** The surface tiles (and mask refs) a layer's shape reads over `region`. */
+  shapeRefs(layer, region) {
+    const refs = [];
+    if (region.width <= 0 || region.height <= 0) return refs;
+    for (const t of tilesInRect(region)) {
+      const sig = isGroup(layer) ? this.plainGroupSig(layer, this.buildSteps(layer.children ?? []), t.tx, t.ty) : this.plainContentSig(layer, t.tx, t.ty);
+      for (const r of sig.refs) refs.push(r);
+    }
+    return refs;
+  }
+  lightKey() {
+    const l = this.effectContext().light;
+    return `${l.angle},${l.altitude}`;
+  }
+  /**
+   * The signature of a layer with effects for tile (tx, ty): its properties and the tiles its shape
+   * reads within the effects' margin around the tile, or over its whole region when an effect is
+   * laid out over the layer's bounds.
+   */
+  effectSig(layer, tx, ty) {
+    const key = (isGroup(layer) ? "Gfx" : "Cfx") + this.propsKey(layer) + this.lightKey();
+    const region = this.effectRegion(layer);
+    const m = effectsMargin(layer.effects);
+    if (effectsAreLocal(activeEffectItems(layer.effects))) {
+      return { key, refs: this.shapeRefs(layer, intersectRect({ x: tx * TILE - m, y: ty * TILE - m, width: TILE + 2 * m, height: TILE + 2 * m }, region)) };
+    }
+    return { key, refs: [`${region.x},${region.y},${region.width},${region.height}`, ...this.shapeRefs(layer, region)] };
+  }
+  /** A layer's effect maps over its region (cached; see the module comment). */
+  effectMapsOf(layer) {
+    const memo = this.effectMemo.get(layer);
+    if (memo && memo.stamp === this.stamp) return memo.maps;
+    const region = this.effectRegion(layer);
+    const key = `${this.propsKey(layer)}${this.lightKey()}|${region.x},${region.y},${region.width},${region.height}`;
+    const refs = this.shapeRefs(layer, region);
+    const hit = this.effectCache.get(layer.id);
+    let maps;
+    if (hit && hit.key === key && sameSig({ key, refs: hit.refs }, { key, refs })) {
+      this.effectCache.delete(layer.id);
+      this.effectCache.set(layer.id, hit);
+      maps = hit.maps;
+    } else {
+      maps = buildEffectMaps(activeEffectItems(layer.effects), this.layerShape(layer, region), region, this.effectContext());
+      this.effectCache.delete(layer.id);
+      this.effectCache.set(layer.id, { key, refs, maps });
+      let bytes = 0;
+      for (const e of this.effectCache.values()) bytes += e.maps.bytes;
+      while (this.effectCache.size > 1 && (this.effectCache.size > 32 || bytes > this.maxCacheBytes / 2)) {
+        const [oldest, e] = this.effectCache.entries().next().value;
+        bytes -= e.maps.bytes;
+        this.effectCache.delete(oldest);
+      }
+    }
+    this.effectMemo.set(layer, { stamp: this.stamp, maps });
+    return maps;
+  }
+  /** A layer's alpha over `r` after its mask (0..1, quantised to bytes as tiles see it). */
+  layerShape(layer, r) {
+    const n = r.width * r.height;
+    const shape = new Float32Array(n);
+    if (n <= 0) return shape;
+    const rgba = this.ownPixels(layer, r);
+    if (!rgba) return shape;
+    for (let i = 0; i < n; i++) shape[i] = rgba[i * 4 + 3] / 255;
+    return shape;
+  }
+  /** 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)) {
+      const buf = new Uint8ClampedArray(r.width * r.height * 4);
+      rgba = this.runSteps(this.buildSteps(layer.children ?? []), buf, true, r) ? null : buf;
+    } else {
+      const content = this.contentTile(layer, r);
+      rgba = content ? new Uint8ClampedArray(content) : null;
+    }
+    if (!rgba) return null;
+    const cov = this.maskTile(layer, r);
+    if (cov) for (let i = 0, p = 3; i < cov.length; i++, p += 4) rgba[p] = Math.round(rgba[p] * cov[i]);
+    return rgba;
+  }
+  /**
+   * The part of `r` a layer with effects can change: its shape's bounds grown by the effects'
+   * margin. Beyond it the layer and every effect are transparent, so the backdrop stays as it is.
+   */
+  effectArea(layer, maps, r) {
+    if (!maps.bounds) return null;
+    const a = intersectRect(inflateRect(maps.bounds, effectsMargin(layer.effects)), r);
+    return a.width > 0 && a.height > 0 ? a : null;
+  }
+  /**
+   * Composites `layer`'s pixels (with `clipped` applied) and its effects onto `acc` (RGBA over `r`),
+   * only where they can reach. `keepAlpha`: clipped layers keep the base's alpha.
+   */
+  compositeEffects(layer, clipped, acc, r, keepAlpha) {
+    const maps = this.effectMapsOf(layer);
+    const a = this.effectArea(layer, maps, r);
+    if (!a) return false;
+    const whole = a.width === r.width && a.height === r.height;
+    const sub = whole ? acc : copyRect(acc, r, a);
+    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);
+    compositeLayerEffects({
+      backdrop: sub,
+      content,
+      rect: a,
+      maps,
+      blend: blend2,
+      opacity: layer.opacity,
+      fillOpacity: isPixel(layer) ? layer.fillOpacity ?? 1 : 1,
+      canvas: { x: 0, y: 0, width: this.sources.width, height: this.sources.height },
+      ctx: this.effectContext()
+    });
+    if (keep) for (let i = 0; i < keep.length; i++) sub[i * 4 + 3] = keep[i];
+    if (!whole) pasteRect(acc, r, sub, a);
+    return true;
+  }
+  /** Composites a layer with active effects onto `acc` over `r`; returns whether `acc` is still empty. */
+  runEffectStep(layer, clipped, acc, empty, r) {
+    return this.compositeEffects(layer, clipped, acc, r, false) ? false : empty;
+  }
+  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);
+    if (this.hasEffects(layer)) return this.runEffectStep(layer, clipped, acc, empty, r);
+    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 fill2 = isPixel(step.layer) ? step.layer.fillOpacity ?? 1 : 1;
+    const blend2 = this.contentBlend(step.layer);
+    if (!clipped.length) return this.blendOnto(acc, content, empty, blend2, layer.opacity * fill2, coverage);
+    const buf = new Uint8ClampedArray(acc.length);
+    blendTile(buf, content, "normal", fill2, coverage);
+    this.applyClipped(clipped, buf, r);
+    return this.blendOnto(acc, buf, empty, blend2, 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();
+      if (this.hasEffects(c) && !isGroup(c)) {
+        this.compositeEffects(c, [], buf, r, true);
+        continue;
+      }
+      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 fill2 = isPixel(c) ? c.fillOpacity ?? 1 : 1;
+      blendAtop(buf, content, this.contentBlend(c), c.opacity * fill2, 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 copyRect(data, r, a) {
+  const out = new Uint8ClampedArray(a.width * a.height * 4);
+  for (let y = 0; y < a.height; y++) {
+    const s = ((a.y - r.y + y) * r.width + (a.x - r.x)) * 4;
+    out.set(data.subarray(s, s + a.width * 4), y * a.width * 4);
+  }
+  return out;
+}
+function pasteRect(data, r, part, a) {
+  for (let y = 0; y < a.height; y++) data.set(part.subarray(y * a.width * 4, (y + 1) * a.width * 4), ((a.y - r.y + y) * r.width + (a.x - r.x)) * 4);
+}
+function inflateRect(r, m) {
+  return { x: r.x - m, y: r.y - m, width: r.width + 2 * m, height: r.height + 2 * m };
+}
+function intersectRect(a, b) {
+  const x0 = Math.max(a.x, b.x);
+  const y0 = Math.max(a.y, b.y);
+  const x1 = Math.min(a.x + a.width, b.x + b.width);
+  const y1 = Math.min(a.y + a.height, b.y + b.height);
+  return x1 <= x0 || y1 <= y0 ? { x: x0, y: y0, width: 0, height: 0 } : { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+}
+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,
+  DEFAULT_GLOBAL_LIGHT,
+  LAYER_EFFECT_KINDS,
+  layerEffectLabel,
+  isLayerEffectKind,
+  defaultEffectGradient,
+  newEffectId,
+  defaultLayerEffect,
+  hasActiveEffects,
+  MAX_EFFECT_REACH,
+  effectReach,
+  effectsMargin,
+  effectsScale,
+  scaleLayerEffect,
+  parseEffectColor,
+  effectColorHex,
+  LayerEffectError,
+  validateEffectGradient,
+  layerEffectFields,
+  validateLayerEffect,
+  mergeLayerEffect,
+  validateLayerEffects,
+  normalizeLayerEffects,
+  effectsFingerprint,
+  PatternTile,
+  PatternPlacement,
+  builtinPatternIds,
+  builtinPattern,
+  hashNoise,
+  CURVE_LUT_SIZE,
+  curveLut,
+  STROKE_CHAMFER_MAX,
+  contourLut,
+  activeEffectItems,
+  effectsAreLocal,
+  buildEffectMaps,
+  gradientT,
+  compositeLayerEffects,
+  renderLayerEffects,
+  blendTile,
+  RasterCompositor,
+  changedTiles,
+  ZlibError,
+  inflateRaw,
+  adler32,
+  inflate,
+  deflateRaw,
+  deflate,
+  encodePng,
+  isPng,
+  decodePng,
+  bytesToBase64,
+  base64ToBytes,
+  parseDataUrl,
+  pngDataUrl
+};
+//# sourceMappingURL=chunk-747CGOT2.js.map