@pixerate/editor 0.121.0 → 0.122.0

package/dist/{chunk-LL3RAN55.cjs → chunk-DFFBJV3U.cjs}

@@ -464,1884 +464,1972 @@ function stableStringify(v) {
   return JSON.stringify(v);
 }
 
-// src/raster/deep-compositor.ts
-var isGroup = (l) => l.type === "group";
-var DeepCompositor = class {
-  constructor(base, profile, deep, depth) {
-    this.base = base;
-    this.profile = profile;
-    this.deep = deep;
-    this.depth = depth;
-    this.linear = depth === 32;
-  }
-  
-  
-  
-  
-  
-  
-  /** The composite of `layers` over `rect` as float RGBA in the working space (`rect.width × rect.height × 4`). */
-  composite(layers, rect, sources) {
-    this.sources = sources;
-    const acc = new Float32Array(Math.max(0, rect.width * rect.height * 4));
-    if (rect.width > 0 && rect.height > 0) this.runSteps(this.buildSteps(layers), acc, true, rect);
-    return acc;
-  }
-  // --- Steps (as RasterCompositor.buildSteps) ------------------------------------
-  isPixel(l) {
-    return l.type === "pixel" || (_nullishCoalesce(_optionalChain([this, 'access', _2 => _2.profile, 'access', _3 => _3.isPixelLike, 'optionalCall', _4 => _4(l)]), () => ( false)));
+// 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);
   }
-  isFilter(l) {
-    return _nullishCoalesce(_optionalChain([this, 'access', _5 => _5.profile, 'access', _6 => _6.isFilterLayer, 'optionalCall', _7 => _7(l)]), () => ( false));
+  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;
   }
-  buildSteps(layers) {
-    const steps = [];
-    for (const layer of layers) {
-      const last = steps[steps.length - 1];
-      if (layer.clipped && last && (last.kind === "content" || last.kind === "group")) {
-        last.clipped.push(layer);
-        continue;
-      }
-      if (this.isFilter(layer)) {
-        if (last && last.kind === "adjust") last.layers.push(layer);
-        else steps.push({ kind: "adjust", layers: [layer] });
-      } else if (isGroup(layer)) steps.push({ kind: "group", layer, clipped: [], steps: this.buildSteps(_nullishCoalesce(layer.children, () => ( []))) });
-      else steps.push({ kind: "content", layer, clipped: [] });
+  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;
     }
-    return steps;
-  }
-  runSteps(steps, acc, empty, r) {
-    for (const s of steps) empty = this.runStep(s, acc, empty, r);
-    return empty;
+    for (let i = n - 2; i >= 1; i--) m2[i] = d[i] - c[i] * m2[i + 1];
   }
-  runStep(step, acc, empty, r) {
-    if (step.kind === "adjust") {
-      if (empty) return true;
-      this.applyFilterRun(step.layers, acc, r);
-      return false;
-    }
-    const layer = step.layer;
-    if (!layer.visible) return empty;
-    const clipped = step.clipped.filter((l) => l.visible);
-    const coverage = this.renderedAlone(layer) ? null : this.base.maskCoverage(layer, r, this.sources);
-    if (coverage && coverage.every((v) => v <= 0)) return empty;
-    if (step.kind === "group" && !this.renderedAlone(layer)) {
-      if (layer.blend === "pass-through" && !clipped.length) {
-        if (layer.opacity >= 1 && !coverage) return this.runSteps(step.steps, acc, empty, r);
-        const before = acc.slice();
-        const stillEmpty = this.runSteps(step.steps, acc, empty, r);
-        lerp(acc, before, layer.opacity, coverage);
-        return empty && stillEmpty;
-      }
-      const buf2 = new Float32Array(acc.length);
-      if (this.runSteps(step.steps, buf2, true, r)) return empty;
-      this.applyClipped(clipped, buf2, r);
-      const mode2 = layer.blend === "pass-through" ? "normal" : layer.blend;
-      this.blend(acc, buf2, mode2, layer.opacity, coverage);
-      return false;
+  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;
     }
-    const content = this.content(layer, r);
-    if (!content) return empty;
-    const alone = this.renderedAlone(layer);
-    const fill2 = !alone && this.isPixel(layer) ? _nullishCoalesce(layer.fillOpacity, () => ( 1)) : 1;
-    const mode = this.blendOf(layer);
-    if (!clipped.length) {
-      this.blend(acc, content, mode, layer.opacity * fill2, coverage);
-      return false;
+    if (xv >= x[n - 1]) {
+      out[k] = clamp01(y[n - 1]);
+      continue;
     }
-    const buf = new Float32Array(acc.length);
-    this.blend(buf, content, "normal", fill2, coverage);
-    this.applyClipped(clipped, buf, r);
-    this.blend(acc, buf, mode, layer.opacity, null);
-    return false;
+    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);
   }
-  applyClipped(clipped, buf, r) {
-    let run = [];
-    const flush = () => {
-      if (run.length) this.applyFilterRun(run, buf, r);
-      run = [];
-    };
-    for (const c of clipped) {
-      if (this.isFilter(c)) {
-        run.push(c);
-        continue;
-      }
-      flush();
-      const alone = this.renderedAlone(c);
-      const coverage = alone ? null : this.base.maskCoverage(c, r, this.sources);
-      let src;
-      if (isGroup(c) && !alone) {
-        src = new Float32Array(buf.length);
-        if (this.runSteps(this.buildSteps(_nullishCoalesce(c.children, () => ( []))), src, true, r)) continue;
-      } else src = this.content(c, r);
-      if (!src) continue;
-      const fill2 = !alone && this.isPixel(c) ? _nullishCoalesce(c.fillOpacity, () => ( 1)) : 1;
-      const keep = new Float32Array(buf.length >> 2);
-      for (let i = 3, p = 0; i < buf.length; i += 4, p++) keep[p] = buf[i];
-      this.blend(buf, src, c.blend === "pass-through" ? "normal" : this.blendOf(c), c.opacity * fill2, coverage);
-      for (let i = 3, p = 0; i < buf.length; i += 4, p++) buf[i] = keep[p];
+  return out;
+}
+
+// src/raster/effects/patterns.ts
+var PatternTile = class {
+  
+  
+  
+  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 = (_nullishCoalesce(p.data[i * 4 + 3], () => ( 0))) / 255;
+      this.px[i * 4] = (_nullishCoalesce(p.data[i * 4], () => ( 0))) / 255 * a;
+      this.px[i * 4 + 1] = (_nullishCoalesce(p.data[i * 4 + 1], () => ( 0))) / 255 * a;
+      this.px[i * 4 + 2] = (_nullishCoalesce(p.data[i * 4 + 2], () => ( 0))) / 255 * a;
+      this.px[i * 4 + 3] = a;
     }
-    flush();
   }
-  applyFilterRun(layers, acc, r) {
-    const visible = [];
-    let masks;
-    for (const node of layers) {
-      if (!node.visible) continue;
-      const cov = this.base.maskCoverage(node, r, this.sources);
-      if (cov) {
-        if (cov.every((v) => v <= 0)) continue;
-        (masks ??= /* @__PURE__ */ new Map()).set(node.id, cov);
+  /** 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 wy2 = dy ? fy : 1 - fy;
+      if (wy2 === 0) continue;
+      const yi = ((y0 + dy) % this.h + this.h) % this.h;
+      for (let dx = 0; dx < 2; dx++) {
+        const wx2 = dx ? fx : 1 - fx;
+        if (wx2 === 0) continue;
+        const xi = ((x0 + dx) % this.w + this.w) % this.w;
+        const k = wx2 * wy2;
+        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;
       }
-      visible.push(node);
     }
-    if (!visible.length) return;
-    if (this.deep.applyFilterRunDeep) {
-      if (this.linear) mapColour(acc, _chunk7ISPWEJAcjs.srgbEncode);
-      this.deep.applyFilterRunDeep(visible, acc, r, masks, this.sources);
-      if (this.linear) mapColour(acc, _chunk7ISPWEJAcjs.srgbDecode);
+    if (a <= 0) {
+      out[0] = out[1] = out[2] = out[3] = 0;
       return;
     }
-    const bytes = this.to8(acc);
-    _optionalChain([this, 'access', _8 => _8.profile, 'access', _9 => _9.applyFilterRun, 'optionalCall', _10 => _10(visible, bytes, r, masks, this.sources)]);
-    acc.set(this.from8(bytes));
+    out[0] = r / a;
+    out[1] = g / a;
+    out[2] = b / a;
+    out[3] = Math.min(1, a);
   }
-  // --- Layer content ---------------------------------------------------------------
-  /** Layers drawn by the 8-bit compositor alone (effects, pixel filters, content the editor draws). */
-  renderedAlone(layer) {
-    if (hasActiveEffects(layer.effects) && !this.isFilter(layer)) return true;
-    if (this.isPixel(layer)) return Boolean(_optionalChain([this, 'access', _11 => _11.profile, 'access', _12 => _12.pixelFilters, 'optionalCall', _13 => _13(layer)]));
-    return !isGroup(layer);
+};
+var PatternPlacement = class {
+  
+  
+  
+  
+  
+  /** `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);
   }
-  blendOf(layer) {
-    return _nullishCoalesce(_optionalChain([this, 'access', _14 => _14.profile, 'access', _15 => _15.contentBlend, 'optionalCall', _16 => _16(layer)]), () => ( layer.blend));
+  /** 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;
   }
-  /** A layer's float RGBA over `r` (straight alpha, working space), or `null` when it has none there. */
-  content(layer, r) {
-    if (this.renderedAlone(layer)) {
-      const solo = { ...layer, blend: isGroup(layer) && layer.blend === "pass-through" ? "pass-through" : "normal", opacity: 1, clipped: false };
-      const bytes = this.base.composite([solo], r, this.sources);
-      return this.from8(bytes);
-    }
-    const surface = this.sources.surfaceOf ? this.sources.surfaceOf(layer) : layer.surface;
-    if (!surface) return null;
-    const ox = _nullishCoalesce(_optionalChain([layer, 'access', _17 => _17.offset, 'optionalAccess', _18 => _18.x]), () => ( 0));
-    const oy = _nullishCoalesce(_optionalChain([layer, 'access', _19 => _19.offset, 'optionalAccess', _20 => _20.y]), () => ( 0));
-    const samples = _chunk7ISPWEJAcjs.readDeepRegion.call(void 0, surface, { x: r.x - ox, y: r.y - oy, width: r.width, height: r.height }, this.depth);
-    if (samples instanceof Float32Array) return samples;
-    const out = new Float32Array(samples.length);
-    for (let i = 0; i < samples.length; i++) out[i] = samples[i] / 65535;
-    return out;
-  }
-  /** 8-bit RGBA to the working space. */
-  from8(bytes) {
-    if (this.linear) return _chunk7ISPWEJAcjs.to32From8.call(void 0, bytes, 4);
-    const out = new Float32Array(bytes.length);
-    for (let i = 0; i < bytes.length; i++) out[i] = bytes[i] / 255;
-    return out;
-  }
-  /** The working space to 8-bit RGBA. */
-  to8(acc) {
-    const out = new Uint8ClampedArray(acc.length);
-    for (let i = 0; i < acc.length; i += 4) {
-      for (let c = 0; c < 3; c++) out[i + c] = Math.round((this.linear ? _chunk7ISPWEJAcjs.srgbEncode.call(void 0, acc[i + c]) : acc[i + c]) * 255);
-      out[i + 3] = Math.round(acc[i + 3] * 255);
+};
+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];
     }
-    return out;
-  }
-  // --- Blending --------------------------------------------------------------------
-  /** `src` over `dst` with `mode` at `alpha` × coverage (straight alpha, float), as `blendTile`. */
-  blend(dst, src, mode, alpha, coverage) {
-    if (!(alpha > 0)) return;
-    const normal = mode === "normal";
-    const pigment = mode === "pigment";
-    const cb = [0, 0, 0];
-    const cs = [0, 0, 0];
-    const mix = [0, 0, 0];
-    for (let i = 0, p = 0; i < dst.length; i += 4, p++) {
-      const sa = src[i + 3];
-      if (!(sa > 0)) continue;
-      const k = coverage ? alpha * coverage[p] : alpha;
-      if (!(k > 0)) continue;
-      const as = Math.min(1, sa * k);
-      const ab = dst[i + 3];
-      const ao = as + ab * (1 - as);
-      if (ao <= 0) {
-        dst[i] = dst[i + 1] = dst[i + 2] = dst[i + 3] = 0;
-        continue;
-      }
-      if (normal && as >= 1) {
-        dst[i] = src[i];
-        dst[i + 1] = src[i + 1];
-        dst[i + 2] = src[i + 2];
-        dst[i + 3] = 1;
-        continue;
-      }
-      for (let c = 0; c < 3; c++) {
-        cb[c] = dst[i + c];
-        cs[c] = src[i + c];
-      }
-      if (pigment) {
-        if (this.linear) for (let c = 0; c < 3; c++) cb[c] = _chunk7ISPWEJAcjs.srgbEncode.call(void 0, cb[c]), cs[c] = _chunk7ISPWEJAcjs.srgbEncode.call(void 0, cs[c]);
-        _chunk7ISPWEJAcjs.mixPigmentRgb.call(void 0, cb, cs, as / ao, mix);
-        for (let c = 0; c < 3; c++) dst[i + c] = this.linear ? _chunk7ISPWEJAcjs.srgbDecode.call(void 0, mix[c]) : mix[c];
-        dst[i + 3] = ao;
-        continue;
-      }
-      const m = normal ? cs : _chunk7ISPWEJAcjs.blendRgb.call(void 0, mode, cb, cs);
-      const wb = (1 - as) * ab;
-      const ws = (1 - ab) * as;
-      const wm = as * ab;
-      for (let c = 0; c < 3; c++) dst[i + c] = (wb * cb[c] + ws * cs[c] + wm * m[c]) / ao;
-      dst[i + 3] = ao;
+  },
+  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 lerp(dst, before, alpha, coverage) {
-  for (let i = 0, p = 0; i < dst.length; i += 4, p++) {
-    const k = coverage ? alpha * coverage[p] : alpha;
-    if (k >= 1) continue;
-    for (let c = 0; c < 4; c++) dst[i + c] = before[i + c] + (dst[i + c] - before[i + c]) * k;
-  }
+function builtinPatternIds() {
+  return Object.keys(BUILTINS);
 }
-function mapColour(data, f) {
-  for (let i = 0; i < data.length; i += 4) {
-    data[i] = f(data[i]);
-    data[i + 1] = f(data[i + 1]);
-    data[i + 2] = f(data[i + 2]);
+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 workingToSamples(data, depth) {
-  if (depth === 32) return data;
-  const out = new Uint16Array(data.length);
-  for (let i = 0; i < data.length; i++) {
-    const v = data[i];
-    out[i] = v > 0 ? v < 1 ? Math.round(v * 65535) : 65535 : 0;
-  }
-  return out;
+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/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;
+// 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;
+    }
   }
-  for (let i = 0; i < k.length; i++) k[i] /= s;
-  return k;
+  return out;
 }
-var DIRECT_GAUSSIAN_MAX_SIGMA = 8;
-function boxRadii(sigma) {
-  const n = 3;
-  const wIdeal = Math.sqrt(12 * sigma * sigma / n + 1);
-  let wl = Math.floor(wIdeal);
-  if (wl % 2 === 0) wl--;
-  const wu = wl + 2;
-  const mIdeal = (12 * sigma * sigma - n * wl * wl - 4 * n * wl - 3 * n) / (-4 * wl - 4);
-  const m = Math.round(mIdeal);
-  const sizes = [0, 1, 2].map((i) => i < m ? wl : wu);
-  return sizes.map((s) => (s - 1) / 2);
+function 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 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;
+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;
       }
-      a += src[off + x * stride] * k[j];
+      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;
     }
-    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];
+  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;
   }
-  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) {
+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++) {
-      pass(out, y * w, 1, w);
-      out.set(line.subarray(0, w), y * w);
+      gc[x * h + y] = o[y];
+      nc[x * h + y] = nr[y];
     }
   }
-  for (const pass of passes) {
+  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++) {
-      pass(out, x, w, h);
-      for (let y = 0; y < h; y++) out[y * w + x] = line[y];
+      d[y * w + x] = Math.sqrt(o[x]);
+      const px = nr[x];
+      near[y * w + x] = nc[px * h + y] * w + px;
     }
   }
-  return out;
+  return { d, near };
 }
-
-// src/raster/layers.ts
-var childrenOf = (l) => l.type === "group" ? _nullishCoalesce(l.children, () => ( null)) : null;
-function flattenLayers(layers) {
-  const out = [];
-  const walk = (list) => {
-    for (const l of list) {
-      out.push(l);
-      const c = childrenOf(l);
-      if (c) walk(c);
+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;
+      }
     }
-  };
-  walk(layers);
+  }
+  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 findLayer(layers, id) {
-  const walk = (list, parent, path) => {
-    for (let i = 0; i < list.length; i++) {
-      const l = list[i];
-      if (l.id === id) return { layer: l, parent, index: i, path };
-      const c = childrenOf(l);
-      if (c) {
-        const g = l;
-        const hit = walk(c, g, [...path, g]);
-        if (hit) return hit;
-      }
+function 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 null;
-  };
-  return walk(layers, null, []);
+  }
+  return out;
 }
-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;
+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 c = childrenOf(l);
-        if (c) {
-          const children = walk(c);
-          if (children !== c) next = { ...l, children };
+        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);
       }
-      if (next !== l) {
-        if (!out) out = list.slice(0, i);
-        if (next) out.push(next);
-      } else if (out) out.push(l);
+      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 _nullishCoalesce(out, () => ( list));
-  };
-  const result = walk(layers);
-  return changed ? result : layers;
+  }
+  return { din, dout };
 }
-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 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 isLayerLocked(layer, what) {
-  return Boolean(_optionalChain([layer, 'access', _21 => _21.locks, 'optionalAccess', _22 => _22.all]) || _optionalChain([layer, 'access', _23 => _23.locks, 'optionalAccess', _24 => _24[what]]));
+function boxWidth(w) {
+  return Number.isNaN(w) ? 1 : clamp(w, 1, MAX_EFFECT_REACH);
 }
-
-// src/raster/effects/patterns.ts
-var PatternTile = class {
-  
-  
-  
-  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 = (_nullishCoalesce(p.data[i * 4 + 3], () => ( 0))) / 255;
-      this.px[i * 4] = (_nullishCoalesce(p.data[i * 4], () => ( 0))) / 255 * a;
-      this.px[i * 4 + 1] = (_nullishCoalesce(p.data[i * 4 + 1], () => ( 0))) / 255 * a;
-      this.px[i * 4 + 2] = (_nullishCoalesce(p.data[i * 4 + 2], () => ( 0))) / 255 * a;
-      this.px[i * 4 + 3] = a;
-    }
+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;
   }
-  /** 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 wy2 = dy ? fy : 1 - fy;
-      if (wy2 === 0) continue;
-      const yi = ((y0 + dy) % this.h + this.h) % this.h;
-      for (let dx = 0; dx < 2; dx++) {
-        const wx2 = dx ? fx : 1 - fx;
-        if (wx2 === 0) continue;
-        const xi = ((x0 + dx) % this.w + this.w) % this.w;
-        const k = wx2 * wy2;
-        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);
+  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 PatternPlacement = class {
-  
-  
-  
-  
-  
-  /** `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);
+}
+var BLUR_EPS = 1e-7;
+var BLUR_FIX = 2 ** 32;
+function tentLine(src, dst, bw, mid) {
+  const [r] = boxGeom(bw);
+  const m = mid.subarray(0, src.length + 2 * r);
+  for (let i = 0; i < src.length; i++) src[i] = Math.round(src[i] * BLUR_FIX);
+  boxLine(src, -r, m, bw);
+  for (let i = 0; i < m.length; i++) m[i] = Math.round(m[i]);
+  boxLine(m, r, dst, bw);
+  for (let i = 0; i < dst.length; i++) {
+    const v = dst[i] / BLUR_FIX;
+    dst[i] = Math.abs(v) < BLUR_EPS ? 0 : v;
   }
-  /** 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;
+}
+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];
   }
-};
-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];
-    }
+  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 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);
+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);
     }
-    p = { id, name: def.name, width: def.size, height: def.size, data };
-    builtinCache.set(id, p);
   }
-  return p;
+  lutCache.set(c, lut);
+  return lut;
 }
-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;
+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);
 }
-
-// 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);
+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;
   }
-  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;
+  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);
+    }
   }
-  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 lightOffset(angle, distance) {
+  const a = angle * Math.PI / 180;
+  return [Math.round(-Math.cos(a) * distance), Math.round(Math.sin(a) * distance)];
 }
-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;
+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);
   }
-  return out;
+  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 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 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 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;
-    }
+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;
   }
-  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;
+  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 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];
-    }
+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);
   }
-  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;
+  if (b.contourElement) h = applyLut(h, _nullishCoalesce(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, _nullishCoalesce(t.link, () => ( true)), _nullishCoalesce(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);
+      }
     }
   }
-  return { d, near };
+  if (b.soften >= 1) tent(h, b.soften);
+  return h;
 }
-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;
+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 };
   }
-  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;
+  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;
-  }
-  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;
+  };
+  return { maps: [mix(hi, ho), mix(sh, so)], paint: "both" };
 }
-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 strokeWidths(s) {
+  return s.position === "outside" ? [0, s.size] : s.position === "inside" ? [s.size, 0] : [s.size / 2, s.size / 2];
 }
-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 activeEffectItems(effects) {
+  if (!hasActiveEffects(effects)) return [];
+  const s = effectsScale(effects);
+  return effects.items.filter((e) => e.enabled).map((e) => scaleLayerEffect(e, s));
 }
-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;
+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;
     }
-  }
-  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);
+  });
+}
+function shapeBounds(shape, rect) {
+  const { width: w, height: h } = rect;
+  const rowHit = (y) => {
+    for (let x = 0, i = y * w; x < w; x++, i++) if (shape[i] > INSIDE_EPS) return true;
+    return false;
+  };
+  let y0 = 0;
+  while (y0 < h && !rowHit(y0)) y0++;
+  if (y0 === h) return null;
+  let y1 = h - 1;
+  while (!rowHit(y1)) y1--;
+  let x0 = w;
+  let x1 = -1;
+  for (let y = y0; y <= y1; y++) {
+    const o = y * w;
+    for (let x = 0; x < x0; x++) {
+      if (shape[o + x] > INSIDE_EPS) {
+        x0 = x;
+        break;
+      }
+    }
+    for (let x = w - 1; x > x1; x--) {
+      if (shape[o + x] > INSIDE_EPS) {
+        x1 = x;
+        break;
       }
-      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;
-var BLUR_FIX = 2 ** 32;
-function tentLine(src, dst, bw, mid) {
-  const [r] = boxGeom(bw);
-  const m = mid.subarray(0, src.length + 2 * r);
-  for (let i = 0; i < src.length; i++) src[i] = Math.round(src[i] * BLUR_FIX);
-  boxLine(src, -r, m, bw);
-  for (let i = 0; i < m.length; i++) m[i] = Math.round(m[i]);
-  boxLine(m, r, dst, bw);
-  for (let i = 0; i < dst.length; i++) {
-    const v = dst[i] / BLUR_FIX;
-    dst[i] = Math.abs(v) < BLUR_EPS ? 0 : v;
-  }
+  return { x: rect.x + x0, y: rect.y + y0, width: x1 - x0 + 1, height: y1 - y0 + 1 };
 }
-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;
+function buildEffectMaps(items, shape, rect, ctx) {
+  const w = rect.width;
+  const h = rect.height;
+  const s = { w, h, v: shape };
+  const bounds = shapeBounds(shape, rect);
+  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;
       }
-      lut ??= curveLut(pts);
+      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;
     }
-  }
-  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);
+    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 };
 }
-function applyLut(m, l) {
-  return l ? mapped(m, (v) => lutAt(l, v)) : m;
+var rectArea = (r) => r.width * r.height;
+function clipRect(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: x1 - x0, height: y1 - y0 } : null;
 }
-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;
+var growRect = (r, m) => ({ x: r.x - m, y: r.y - m, width: r.width + 2 * m, height: r.height + 2 * m });
+function unionRect(a, b) {
+  const x0 = Math.min(a.x, b.x);
+  const y0 = Math.min(a.y, b.y);
+  return { x: x0, y: y0, width: Math.max(a.x + a.width, b.x + b.width) - x0, height: Math.max(a.y + a.height, b.y + b.height) - y0 };
 }
-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 rectMinus(r, cut) {
+  const i = clipRect(r, cut);
+  if (!i) return [r];
+  const parts = [
+    { x: r.x, y: r.y, width: r.width, height: i.y - r.y },
+    { x: r.x, y: i.y + i.height, width: r.width, height: r.y + r.height - (i.y + i.height) },
+    { x: r.x, y: i.y, width: i.x - r.x, height: i.height },
+    { x: i.x + i.width, y: i.y, width: r.x + r.width - (i.x + i.width), height: i.height }
+  ];
+  return parts.filter((p) => p.width > 0 && p.height > 0);
 }
-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 pasteMap(dst, to, src, from, a) {
+  for (let y = a.y; y < a.y + a.height; y++) {
+    const s = (y - from.y) * from.width + (a.x - from.x);
+    dst.set(src.subarray(s, s + a.width), (y - to.y) * to.width + (a.x - to.x));
   }
 }
-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);
+function patchEffectMaps(prev, items, rect, changed, margin, shapeOver, ctx) {
+  if (!effectsAreLocal(items) || rectArea(rect) <= 0) return null;
+  let areas = [];
+  for (const c of changed) {
+    const a = clipRect(growRect(c, margin), rect);
+    if (a) areas.push(a);
+  }
+  areas.push(...rectMinus(rect, prev.rect));
+  for (let merged = true; merged; ) {
+    merged = false;
+    for (let i = 0; i < areas.length && !merged; i++) {
+      for (let j = i + 1; j < areas.length; j++) {
+        if (clipRect(growRect(areas[i], 2 * margin), areas[j])) {
+          areas[i] = unionRect(areas[i], areas[j]);
+          areas.splice(j, 1);
+          merged = true;
+          break;
+        }
+      }
     }
-  } 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;
+  const windows = areas.map((a) => clipRect(growRect(a, margin), rect));
+  if (windows.reduce((n, w) => n + rectArea(w), 0) > rectArea(rect) / 2) return null;
+  const same = rect.x === prev.rect.x && rect.y === prev.rect.y && rect.width === prev.rect.width && rect.height === prev.rect.height;
+  const take = (v) => same ? v : crop(v, prev.rect, rect, 0);
+  const shape = take(prev.shape);
+  const per = prev.per.map((maps) => maps.map(take));
+  const din = prev.din && take(prev.din);
+  const dout = prev.dout && take(prev.dout);
+  const doutExact = prev.doutExact && take(prev.doutExact);
+  areas.forEach((a, k) => {
+    const w = windows[k];
+    const part = buildEffectMaps(items, shapeOver(w), w, ctx);
+    pasteMap(shape, rect, part.shape, w, a);
+    per.forEach((maps, i) => maps.forEach((m, j) => pasteMap(m, rect, part.per[i][j], w, a)));
+    if (din) pasteMap(din, rect, part.din, w, a);
+    if (dout) pasteMap(dout, rect, part.dout, w, a);
+    if (doutExact) pasteMap(doutExact, rect, part.doutExact, w, a);
+  });
+  let bytes = shape.byteLength;
+  for (const maps of per) for (const m of maps) bytes += m.byteLength;
+  for (const d of [din, dout, doutExact]) if (d) bytes += d.byteLength;
+  return { rect, items, bounds: shapeBounds(shape, rect), shape, per, bevelPaint: prev.bevelPaint, din, dout, doutExact, frames: /* @__PURE__ */ new Map(), bytes };
 }
-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;
+var rgbScratchB = [0, 0, 0];
+var rgbScratchS = [0, 0, 0];
+var rgbScratchM = [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;
   }
-  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);
+  const b0 = dst[i];
+  const b1 = dst[i + 1];
+  const b2 = dst[i + 2];
+  if (mode === "pigment") {
+    rgbScratchB[0] = b0;
+    rgbScratchB[1] = b1;
+    rgbScratchB[2] = b2;
+    rgbScratchS[0] = sr;
+    rgbScratchS[1] = sg;
+    rgbScratchS[2] = sb;
+    _chunk7ISPWEJAcjs.mixPigmentRgb.call(void 0, rgbScratchB, rgbScratchS, sa / ao, rgbScratchM);
+    dst[i] = rgbScratchM[0];
+    dst[i + 1] = rgbScratchM[1];
+    dst[i + 2] = rgbScratchM[2];
+    dst[i + 3] = ao;
+    return;
   }
-  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);
+  let m0;
+  let m1;
+  let m2;
+  if (mode === "normal") {
+    m0 = sr;
+    m1 = sg;
+    m2 = sb;
+  } else if (separable) {
+    m0 = _chunk7ISPWEJAcjs.blendChannel.call(void 0, mode, b0, sr);
+    m1 = _chunk7ISPWEJAcjs.blendChannel.call(void 0, mode, b1, sg);
+    m2 = _chunk7ISPWEJAcjs.blendChannel.call(void 0, mode, b2, sb);
   } 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, _nullishCoalesce(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, _nullishCoalesce(t.link, () => ( true)), _nullishCoalesce(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);
-      }
-    }
+    rgbScratchB[0] = b0;
+    rgbScratchB[1] = b1;
+    rgbScratchB[2] = b2;
+    rgbScratchS[0] = sr;
+    rgbScratchS[1] = sg;
+    rgbScratchS[2] = sb;
+    const m = _chunk7ISPWEJAcjs.blendRgb.call(void 0, mode, rgbScratchB, rgbScratchS);
+    m0 = m[0];
+    m1 = m[1];
+    m2 = m[2];
   }
-  if (b.soften >= 1) tent(h, b.soften);
-  return h;
+  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;
 }
-var identity = null;
-function identityLut() {
-  if (!identity) {
-    identity = new Float32Array(4096);
-    for (let k = 0; k < 4096; k++) identity[k] = k / 4095;
+function paint(dst, m, color2, mode, opacity) {
+  const sep = mode !== "normal" && _chunk7ISPWEJAcjs.isSeparableBlendMode.call(void 0, 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));
   }
-  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;
+function rgbOf(hex) {
+  return _nullishCoalesce(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 {
+  
+  
+  constructor(g) {
+    this.color = [...g.stops].sort((a, b) => a.position - b.position).map((s) => [s.position, ...rgbOf(s.color)]);
+    this.alpha = [..._nullishCoalesce(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];
       }
     }
-    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));
+    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;
+        }
+      }
     }
-    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 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 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 shapeBounds(shape, rect) {
-  const { width: w, height: h } = rect;
-  const rowHit = (y) => {
-    for (let x = 0, i = y * w; x < w; x++, i++) if (shape[i] > INSIDE_EPS) return true;
-    return false;
-  };
-  let y0 = 0;
-  while (y0 < h && !rowHit(y0)) y0++;
-  if (y0 === h) return null;
-  let y1 = h - 1;
-  while (!rowHit(y1)) y1--;
-  let x0 = w;
-  let x1 = -1;
-  for (let y = y0; y <= y1; y++) {
-    const o = y * w;
-    for (let x = 0; x < x0; x++) {
-      if (shape[o + x] > INSIDE_EPS) {
-        x0 = x;
-        break;
-      }
-    }
-    for (let x = w - 1; x > x1; x--) {
-      if (shape[o + x] > INSIDE_EPS) {
-        x1 = x;
-        break;
-      }
+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;
     }
   }
-  return { x: rect.x + x0, y: rect.y + y0, width: x1 - x0 + 1, height: y1 - y0 + 1 };
-}
-function buildEffectMaps(items, shape, rect, ctx) {
-  const w = rect.width;
-  const h = rect.height;
-  const s = { w, h, v: shape };
-  const bounds = shapeBounds(shape, rect);
-  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 };
+  t = clamp012(t);
+  return reverse ? 1 - t : t;
 }
-var rectArea = (r) => r.width * r.height;
-function clipRect(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: x1 - x0, height: y1 - y0 } : null;
+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 snap2 = (v2) => Math.floor(v2 + 1e-4);
+  const end = [snap2(cx + dx), snap2(cy + dy)];
+  let start;
+  let mid;
+  if (style === "reflected") {
+    start = [cx, cy];
+    mid = [cx, cy];
+  } else {
+    start = [snap2(cx - dx), snap2(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 }];
 }
-var growRect = (r, m) => ({ x: r.x - m, y: r.y - m, width: r.width + 2 * m, height: r.height + 2 * m });
-function unionRect(a, b) {
-  const x0 = Math.min(a.x, b.x);
-  const y0 = Math.min(a.y, b.y);
-  return { x: x0, y: y0, width: Math.max(a.x + a.width, b.x + b.width) - x0, height: Math.max(a.y + a.height, b.y + b.height) - y0 };
+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 rectMinus(r, cut) {
-  const i = clipRect(r, cut);
-  if (!i) return [r];
-  const parts = [
-    { x: r.x, y: r.y, width: r.width, height: i.y - r.y },
-    { x: r.x, y: i.y + i.height, width: r.width, height: r.y + r.height - (i.y + i.height) },
-    { x: r.x, y: i.y, width: i.x - r.x, height: i.height },
-    { x: i.x + i.width, y: i.y, width: r.x + r.width - (i.x + i.width), height: i.height }
-  ];
-  return parts.filter((p) => p.width > 0 && p.height > 0);
+function paintPattern(dst, m, p, env, mode, opacity) {
+  const tile = env.ctx.pattern(p.patternId);
+  if (!tile) return;
+  const place = new PatternPlacement(env.anchor, _nullishCoalesce(p.link, () => ( true)), _nullishCoalesce(p.phase, () => ( { x: 0, y: 0 })), p.scale, _nullishCoalesce(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 pasteMap(dst, to, src, from, a) {
-  for (let y = a.y; y < a.y + a.height; y++) {
-    const s = (y - from.y) * from.width + (a.x - from.x);
-    dst.set(src.subarray(s, s + a.width), (y - to.y) * to.width + (a.x - to.x));
-  }
+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 patchEffectMaps(prev, items, rect, changed, margin, shapeOver, ctx) {
-  if (!effectsAreLocal(items) || rectArea(rect) <= 0) return null;
-  let areas = [];
-  for (const c of changed) {
-    const a = clipRect(growRect(c, margin), rect);
-    if (a) areas.push(a);
+function effectFillColors(fill2, rect, frame, canvas, anchor, ctx) {
+  const n = rect.width * rect.height;
+  const out = new Float32Array(n * 4);
+  const c = [0, 0, 0, 1];
+  const { x: rx, y: ry, width: w } = rect;
+  if (fill2.type === "color") {
+    const [r, g, b] = rgbOf(fill2.color);
+    for (let i = 0; i < n * 4; i += 4) {
+      out[i] = r;
+      out[i + 1] = g;
+      out[i + 2] = b;
+      out[i + 3] = 1;
+    }
+    return out;
   }
-  areas.push(...rectMinus(rect, prev.rect));
-  for (let merged = true; merged; ) {
-    merged = false;
-    for (let i = 0; i < areas.length && !merged; i++) {
-      for (let j = i + 1; j < areas.length; j++) {
-        if (clipRect(growRect(areas[i], 2 * margin), areas[j])) {
-          areas[i] = unionRect(areas[i], areas[j]);
-          areas.splice(j, 1);
-          merged = true;
-          break;
-        }
-      }
+  if (fill2.type === "gradient") {
+    const gr = fill2.gradient;
+    const f = gr.align ? frame : canvas;
+    const prepared = new PreparedGradient(gr);
+    const [angle, scale, offset] = gradientLayout(gr.style, gr.angle, gr.scale, gr.offset, f);
+    for (let i = 0; i < n; i++) {
+      prepared.sample(gradientT(gr.style, angle, scale, gr.reverse, offset, f, rx + i % w + 0.5, ry + Math.floor(i / w) + 0.5), c);
+      out.set(c, i * 4);
     }
+    return out;
   }
-  const windows = areas.map((a) => clipRect(growRect(a, margin), rect));
-  if (windows.reduce((n, w) => n + rectArea(w), 0) > rectArea(rect) / 2) return null;
-  const same = rect.x === prev.rect.x && rect.y === prev.rect.y && rect.width === prev.rect.width && rect.height === prev.rect.height;
-  const take = (v) => same ? v : crop(v, prev.rect, rect, 0);
-  const shape = take(prev.shape);
-  const per = prev.per.map((maps) => maps.map(take));
-  const din = prev.din && take(prev.din);
-  const dout = prev.dout && take(prev.dout);
-  const doutExact = prev.doutExact && take(prev.doutExact);
-  areas.forEach((a, k) => {
-    const w = windows[k];
-    const part = buildEffectMaps(items, shapeOver(w), w, ctx);
-    pasteMap(shape, rect, part.shape, w, a);
-    per.forEach((maps, i) => maps.forEach((m, j) => pasteMap(m, rect, part.per[i][j], w, a)));
-    if (din) pasteMap(din, rect, part.din, w, a);
-    if (dout) pasteMap(dout, rect, part.dout, w, a);
-    if (doutExact) pasteMap(doutExact, rect, part.doutExact, w, a);
-  });
-  let bytes = shape.byteLength;
-  for (const maps of per) for (const m of maps) bytes += m.byteLength;
-  for (const d of [din, dout, doutExact]) if (d) bytes += d.byteLength;
-  return { rect, items, bounds: shapeBounds(shape, rect), shape, per, bevelPaint: prev.bevelPaint, din, dout, doutExact, frames: /* @__PURE__ */ new Map(), bytes };
+  const tile = ctx.pattern(fill2.patternId);
+  if (!tile) return out;
+  const place = new PatternPlacement(anchor, _nullishCoalesce(fill2.link, () => ( true)), _nullishCoalesce(fill2.phase, () => ( { x: 0, y: 0 })), fill2.scale, _nullishCoalesce(fill2.angle, () => ( 0)));
+  const uv = [0, 0];
+  for (let i = 0; i < n; i++) {
+    place.map(rx + i % w + 0.5, ry + Math.floor(i / w) + 0.5, uv);
+    tile.sample(uv[0], uv[1], c);
+    out.set(c, i * 4);
+  }
+  return out;
 }
-var rgbScratchB = [0, 0, 0];
-var rgbScratchS = [0, 0, 0];
-var rgbScratchM = [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;
+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));
   }
-  const b0 = dst[i];
-  const b1 = dst[i + 1];
-  const b2 = dst[i + 2];
-  if (mode === "pigment") {
-    rgbScratchB[0] = b0;
-    rgbScratchB[1] = b1;
-    rgbScratchB[2] = b2;
-    rgbScratchS[0] = sr;
-    rgbScratchS[1] = sg;
-    rgbScratchS[2] = sb;
-    _chunk7ISPWEJAcjs.mixPigmentRgb.call(void 0, rgbScratchB, rgbScratchS, sa / ao, rgbScratchM);
-    dst[i] = rgbScratchM[0];
-    dst[i + 1] = rgbScratchM[1];
-    dst[i + 2] = rgbScratchM[2];
-    dst[i + 3] = ao;
-    return;
+  return out;
+}
+function compositeLayerEffects(input) {
+  const { backdrop, content, rect, maps, ctx } = input;
+  const items = maps.items;
+  const n = rect.width * rect.height;
+  const cs = content instanceof Float32Array ? 1 : 1 / 255;
+  const bs = backdrop instanceof Float32Array ? 1 : 1 / 255;
+  const floatOut = backdrop instanceof Float32Array;
+  const shape = new Float32Array(n);
+  for (let i = 0; i < n; i++) shape[i] = content[i * 4 + 3] * cs;
+  const before = new Float32Array(n * 4);
+  for (let i = 0; i < n * 4; i++) before[i] = backdrop[i] * bs;
+  const work = new Float32Array(before);
+  const fx = (i, k) => crop(maps.per[i][k], maps.rect, rect, 0);
+  const bounds = _nullishCoalesce(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);
   }
-  let m0;
-  let m1;
-  let m2;
-  if (mode === "normal") {
-    m0 = sr;
-    m1 = sg;
-    m2 = sb;
-  } else if (separable) {
-    m0 = _chunk7ISPWEJAcjs.blendChannel.call(void 0, mode, b0, sr);
-    m1 = _chunk7ISPWEJAcjs.blendChannel.call(void 0, mode, b1, sg);
-    m2 = _chunk7ISPWEJAcjs.blendChannel.call(void 0, mode, b2, sb);
-  } else {
-    rgbScratchB[0] = b0;
-    rgbScratchB[1] = b1;
-    rgbScratchB[2] = b2;
-    rgbScratchS[0] = sr;
-    rgbScratchS[1] = sg;
-    rgbScratchS[2] = sb;
-    const m = _chunk7ISPWEJAcjs.blendRgb.call(void 0, mode, rgbScratchB, rgbScratchS);
-    m0 = m[0];
-    m1 = m[1];
-    m2 = m[2];
+  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 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" && _chunk7ISPWEJAcjs.isSeparableBlendMode.call(void 0, mode);
-  const c = [0, 0, 0, 1];
-  const n = m.length;
+  const lay = new Float32Array(n * 4);
   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));
+    lay[i * 4] = content[i * 4] * cs;
+    lay[i * 4 + 1] = content[i * 4 + 1] * cs;
+    lay[i * 4 + 2] = content[i * 4 + 2] * cs;
+    lay[i * 4 + 3] = inside(shape[i]) ? fill2 : 0;
+  }
+  const premerge = !normalLike;
+  if (premerge) {
+    const sep2 = _chunk7ISPWEJAcjs.isSeparableBlendMode.call(void 0, 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) => _nullishCoalesce(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 = _nullishCoalesce((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 = _chunk7ISPWEJAcjs.isSeparableBlendMode.call(void 0, mode);
+  for (let i = 0; i < n; i++) {
+    const p = i * 4;
+    if (lay[p + 3] > 0) compositeAt(work, p, mode, sep, lay[p], lay[p + 1], lay[p + 2], lay[p + 3]);
+  }
+  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;
+    }
+    if (floatOut) {
+      for (let c = 0; c < 3; c++) backdrop[p + c] = (before[p + c] * aa + (work[p + c] * ba - before[p + c] * aa) * op) / alpha;
+      backdrop[p + 3] = alpha;
+      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 rgbOf(hex) {
-  return _nullishCoalesce(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
-  );
+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: _nullishCoalesce(layer.fillOpacity, () => ( 1)),
+    canvas,
+    ctx
+  });
 }
-var PreparedGradient = class {
+
+// src/raster/deep-compositor.ts
+var isGroup = (l) => l.type === "group";
+var DeepCompositor = class {
+  constructor(base, profile, deep, depth) {
+    this.base = base;
+    this.profile = profile;
+    this.deep = deep;
+    this.depth = depth;
+    this.linear = depth === 32;
+  }
   
   
-  constructor(g) {
-    this.color = [...g.stops].sort((a, b) => a.position - b.position).map((s) => [s.position, ...rgbOf(s.color)]);
-    this.alpha = [..._nullishCoalesce(g.opacityStops, () => ( []))].sort((a, b) => a.position - b.position).map((s) => [s.position, s.opacity]);
+  
+  
+  
+  
+  /** The composite of `layers` over `rect` as float RGBA in the working space (`rect.width × rect.height × 4`). */
+  composite(layers, rect, sources) {
+    this.sources = sources;
+    const acc = new Float32Array(Math.max(0, rect.width * rect.height * 4));
+    if (rect.width > 0 && rect.height > 0) this.runSteps(this.buildSteps(layers), acc, true, rect);
+    return acc;
   }
-  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];
+  // --- Steps (as RasterCompositor.buildSteps) ------------------------------------
+  isPixel(l) {
+    return l.type === "pixel" || (_nullishCoalesce(_optionalChain([this, 'access', _2 => _2.profile, 'access', _3 => _3.isPixelLike, 'optionalCall', _4 => _4(l)]), () => ( false)));
+  }
+  isFilter(l) {
+    return _nullishCoalesce(_optionalChain([this, 'access', _5 => _5.profile, 'access', _6 => _6.isFilterLayer, 'optionalCall', _7 => _7(l)]), () => ( false));
+  }
+  buildSteps(layers) {
+    const steps = [];
+    for (const layer of layers) {
+      const last = steps[steps.length - 1];
+      if (layer.clipped && last && (last.kind === "content" || last.kind === "group")) {
+        last.clipped.push(layer);
+        continue;
       }
+      if (this.isFilter(layer)) {
+        if (last && last.kind === "adjust") last.layers.push(layer);
+        else steps.push({ kind: "adjust", layers: [layer] });
+      } else if (isGroup(layer)) steps.push({ kind: "group", layer, clipped: [], steps: this.buildSteps(_nullishCoalesce(layer.children, () => ( []))) });
+      else steps.push({ kind: "content", layer, clipped: [] });
     }
-    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;
-        }
+    return steps;
+  }
+  runSteps(steps, acc, empty, r) {
+    for (const s of steps) empty = this.runStep(s, acc, empty, r);
+    return empty;
+  }
+  runStep(step, acc, empty, r) {
+    if (step.kind === "adjust") {
+      if (empty) return true;
+      this.applyFilterRun(step.layers, acc, r);
+      return false;
+    }
+    const layer = step.layer;
+    if (!layer.visible) return empty;
+    const clipped = step.clipped.filter((l) => l.visible);
+    if (step.kind === "content" && this.deepEffects(layer)) return this.runEffects(layer, clipped, acc, r) ? false : empty;
+    const coverage = this.renderedAlone(layer) ? null : this.base.maskCoverage(layer, r, this.sources);
+    if (coverage && coverage.every((v) => v <= 0)) return empty;
+    if (step.kind === "group" && !this.renderedAlone(layer)) {
+      if (layer.blend === "pass-through" && !clipped.length) {
+        if (layer.opacity >= 1 && !coverage) return this.runSteps(step.steps, acc, empty, r);
+        const before = acc.slice();
+        const stillEmpty = this.runSteps(step.steps, acc, empty, r);
+        lerp(acc, before, layer.opacity, coverage);
+        return empty && stillEmpty;
       }
+      const buf2 = new Float32Array(acc.length);
+      if (this.runSteps(step.steps, buf2, true, r)) return empty;
+      this.applyClipped(clipped, buf2, r);
+      const mode2 = layer.blend === "pass-through" ? "normal" : layer.blend;
+      this.blend(acc, buf2, mode2, layer.opacity, coverage);
+      return false;
+    }
+    const content = this.content(layer, r);
+    if (!content) return empty;
+    const alone = this.renderedAlone(layer);
+    const fill2 = !alone && this.isPixel(layer) ? _nullishCoalesce(layer.fillOpacity, () => ( 1)) : 1;
+    const mode = this.blendOf(layer);
+    if (!clipped.length) {
+      this.blend(acc, content, mode, layer.opacity * fill2, coverage);
+      return false;
     }
+    const buf = new Float32Array(acc.length);
+    this.blend(buf, content, "normal", fill2, coverage);
+    this.applyClipped(clipped, buf, r);
+    this.blend(acc, buf, mode, layer.opacity, null);
+    return false;
   }
-};
-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;
+  /**
+   * A pixel layer with effects onto `acc` over `r`: its deep content (filters, mask, clipped
+   * layers) and the effects composited in float. Effect maps come from the 8-bit shape. At 32
+   * bits the effects composite in sRGB-encoded values (their colours and blends are defined
+   * there) and the result is decoded back. Returns whether anything was drawn.
+   */
+  runEffects(layer, clipped, acc, r) {
+    const fx = this.base.effectsInput(layer, r, this.sources);
+    if (!fx) return false;
+    const a = fx.rect;
+    const content = _nullishCoalesce(this.content(layer, a), () => ( new Float32Array(a.width * a.height * 4)));
+    const coverage = this.base.maskCoverage(layer, a, this.sources);
+    if (coverage) for (let i = 0; i < coverage.length; i++) content[i * 4 + 3] *= coverage[i];
+    if (clipped.length) this.applyClipped(clipped, content, a);
+    const sub = new Float32Array(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;
+      sub.set(acc.subarray(s, s + a.width * 4), y * a.width * 4);
     }
+    if (this.linear) {
+      encodeInPlace(sub);
+      encodeInPlace(content);
+    }
+    compositeLayerEffects({ ...fx, backdrop: sub, content });
+    if (this.linear) decodeInPlace(sub);
+    for (let y = 0; y < a.height; y++) acc.set(sub.subarray(y * a.width * 4, (y + 1) * a.width * 4), ((a.y - r.y + y) * r.width + (a.x - r.x)) * 4);
+    return true;
   }
-  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 snap2 = (v2) => Math.floor(v2 + 1e-4);
-  const end = [snap2(cx + dx), snap2(cy + dy)];
-  let start;
-  let mid;
-  if (style === "reflected") {
-    start = [cx, cy];
-    mid = [cx, cy];
-  } else {
-    start = [snap2(cx - dx), snap2(cy - dy)];
-    mid = [(start[0] + end[0]) / 2, (start[1] + end[1]) / 2];
+  applyClipped(clipped, buf, r) {
+    let run = [];
+    const flush = () => {
+      if (run.length) this.applyFilterRun(run, buf, r);
+      run = [];
+    };
+    for (const c of clipped) {
+      if (this.isFilter(c)) {
+        run.push(c);
+        continue;
+      }
+      flush();
+      const alone = this.renderedAlone(c);
+      const coverage = alone ? null : this.base.maskCoverage(c, r, this.sources);
+      let src;
+      if (isGroup(c) && !alone) {
+        src = new Float32Array(buf.length);
+        if (this.runSteps(this.buildSteps(_nullishCoalesce(c.children, () => ( []))), src, true, r)) continue;
+      } else src = this.content(c, r);
+      if (!src) continue;
+      const fill2 = !alone && this.isPixel(c) ? _nullishCoalesce(c.fillOpacity, () => ( 1)) : 1;
+      const keep = new Float32Array(buf.length >> 2);
+      for (let i = 3, p = 0; i < buf.length; i += 4, p++) keep[p] = buf[i];
+      this.blend(buf, src, c.blend === "pass-through" ? "normal" : this.blendOf(c), c.opacity * fill2, coverage);
+      for (let i = 3, p = 0; i < buf.length; i += 4, p++) buf[i] = keep[p];
+    }
+    flush();
   }
-  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, _nullishCoalesce(p.link, () => ( true)), _nullishCoalesce(p.phase, () => ( { x: 0, y: 0 })), p.scale, _nullishCoalesce(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 effectFillColors(fill2, rect, frame, canvas, anchor, ctx) {
-  const n = rect.width * rect.height;
-  const out = new Float32Array(n * 4);
-  const c = [0, 0, 0, 1];
-  const { x: rx, y: ry, width: w } = rect;
-  if (fill2.type === "color") {
-    const [r, g, b] = rgbOf(fill2.color);
-    for (let i = 0; i < n * 4; i += 4) {
-      out[i] = r;
-      out[i + 1] = g;
-      out[i + 2] = b;
-      out[i + 3] = 1;
+  applyFilterRun(layers, acc, r) {
+    const visible = [];
+    let masks;
+    for (const node of layers) {
+      if (!node.visible) continue;
+      const cov = this.base.maskCoverage(node, r, this.sources);
+      if (cov) {
+        if (cov.every((v) => v <= 0)) continue;
+        (masks ??= /* @__PURE__ */ new Map()).set(node.id, cov);
+      }
+      visible.push(node);
+    }
+    if (!visible.length) return;
+    if (this.deep.applyFilterRunDeep) {
+      if (this.linear) mapColour(acc, _chunk7ISPWEJAcjs.srgbEncode);
+      this.deep.applyFilterRunDeep(visible, acc, r, masks, this.sources);
+      if (this.linear) mapColour(acc, _chunk7ISPWEJAcjs.srgbDecode);
+      return;
+    }
+    const bytes = this.to8(acc);
+    _optionalChain([this, 'access', _8 => _8.profile, 'access', _9 => _9.applyFilterRun, 'optionalCall', _10 => _10(visible, bytes, r, masks, this.sources)]);
+    acc.set(this.from8(bytes));
+  }
+  // --- Layer content ---------------------------------------------------------------
+  /** Layers drawn by the 8-bit compositor alone (effects, pixel filters, content the editor draws). */
+  /** A pixel(-like) layer with effects: composited in float through `compositeLayerEffects`. */
+  deepEffects(layer) {
+    return hasActiveEffects(layer.effects) && !this.isFilter(layer) && this.isPixel(layer) && !isGroup(layer);
+  }
+  renderedAlone(layer) {
+    if (hasActiveEffects(layer.effects) && !this.isFilter(layer) && !this.deepEffects(layer)) return true;
+    if (this.isPixel(layer)) return Boolean(_optionalChain([this, 'access', _11 => _11.profile, 'access', _12 => _12.pixelFilters, 'optionalCall', _13 => _13(layer)])) && !_optionalChain([this, 'access', _14 => _14.deep, 'access', _15 => _15.pixelFiltersDeep, 'optionalCall', _16 => _16(layer)]);
+    return !isGroup(layer);
+  }
+  blendOf(layer) {
+    return _nullishCoalesce(_optionalChain([this, 'access', _17 => _17.profile, 'access', _18 => _18.contentBlend, 'optionalCall', _19 => _19(layer)]), () => ( layer.blend));
+  }
+  /** A layer's float RGBA over `r` (straight alpha, working space), or `null` when it has none there. */
+  content(layer, r) {
+    if (this.renderedAlone(layer)) {
+      const solo = { ...layer, blend: isGroup(layer) && layer.blend === "pass-through" ? "pass-through" : "normal", opacity: 1, clipped: false };
+      const bytes = this.base.composite([solo], r, this.sources);
+      return this.from8(bytes);
+    }
+    const surface = this.sources.surfaceOf ? this.sources.surfaceOf(layer) : layer.surface;
+    if (!surface) return null;
+    const ox = _nullishCoalesce(_optionalChain([layer, 'access', _20 => _20.offset, 'optionalAccess', _21 => _21.x]), () => ( 0));
+    const oy = _nullishCoalesce(_optionalChain([layer, 'access', _22 => _22.offset, 'optionalAccess', _23 => _23.y]), () => ( 0));
+    const filters = this.isPixel(layer) ? _nullishCoalesce(_optionalChain([this, 'access', _24 => _24.deep, 'access', _25 => _25.pixelFiltersDeep, 'optionalCall', _26 => _26(layer)]), () => ( null)) : null;
+    if (!filters) return this.samples(surface, { x: r.x - ox, y: r.y - oy, width: r.width, height: r.height });
+    const m = filters.reach;
+    const W = this.sources.width;
+    const H = this.sources.height;
+    const x0 = m ? Math.max(0, r.x - m) : r.x;
+    const y0 = m ? Math.max(0, r.y - m) : r.y;
+    const x1 = m ? Math.min(W, r.x + r.width + m) : r.x + r.width;
+    const y1 = m ? Math.min(H, r.y + r.height + m) : r.y + r.height;
+    if (x1 <= x0 || y1 <= y0) return new Float32Array(r.width * r.height * 4);
+    const big = { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+    const data = this.samples(surface, { ...big, x: big.x - ox, y: big.y - oy });
+    filters.apply(data, big.width, big.height, this.linear);
+    if (big.x === r.x && big.y === r.y && big.width === r.width && big.height === r.height) return data;
+    const out = new Float32Array(r.width * r.height * 4);
+    for (let y = 0; y < r.height; y++) {
+      const sy = r.y + y - big.y;
+      if (sy < 0 || sy >= big.height) continue;
+      for (let x = 0; x < r.width; x++) {
+        const sx = r.x + x - big.x;
+        if (sx < 0 || sx >= big.width) continue;
+        const s = (sy * big.width + sx) * 4;
+        const d = (y * r.width + x) * 4;
+        out[d] = data[s];
+        out[d + 1] = data[s + 1];
+        out[d + 2] = data[s + 2];
+        out[d + 3] = data[s + 3];
+      }
     }
     return out;
   }
-  if (fill2.type === "gradient") {
-    const gr = fill2.gradient;
-    const f = gr.align ? frame : canvas;
-    const prepared = new PreparedGradient(gr);
-    const [angle, scale, offset] = gradientLayout(gr.style, gr.angle, gr.scale, gr.offset, f);
-    for (let i = 0; i < n; i++) {
-      prepared.sample(gradientT(gr.style, angle, scale, gr.reverse, offset, f, rx + i % w + 0.5, ry + Math.floor(i / w) + 0.5), c);
-      out.set(c, i * 4);
+  /** A surface's samples over `rect` (layer space) in the working space. */
+  samples(surface, rect) {
+    const samples = _chunk7ISPWEJAcjs.readDeepRegion.call(void 0, surface, rect, this.depth);
+    if (samples instanceof Float32Array) return samples;
+    const out = new Float32Array(samples.length);
+    for (let i = 0; i < samples.length; i++) out[i] = samples[i] / 65535;
+    return out;
+  }
+  /** 8-bit RGBA to the working space. */
+  from8(bytes) {
+    if (this.linear) return _chunk7ISPWEJAcjs.to32From8.call(void 0, bytes, 4);
+    const out = new Float32Array(bytes.length);
+    for (let i = 0; i < bytes.length; i++) out[i] = bytes[i] / 255;
+    return out;
+  }
+  /** The working space to 8-bit RGBA. */
+  to8(acc) {
+    const out = new Uint8ClampedArray(acc.length);
+    for (let i = 0; i < acc.length; i += 4) {
+      for (let c = 0; c < 3; c++) out[i + c] = Math.round((this.linear ? _chunk7ISPWEJAcjs.srgbEncode.call(void 0, acc[i + c]) : acc[i + c]) * 255);
+      out[i + 3] = Math.round(acc[i + 3] * 255);
     }
     return out;
   }
-  const tile = ctx.pattern(fill2.patternId);
-  if (!tile) return out;
-  const place = new PatternPlacement(anchor, _nullishCoalesce(fill2.link, () => ( true)), _nullishCoalesce(fill2.phase, () => ( { x: 0, y: 0 })), fill2.scale, _nullishCoalesce(fill2.angle, () => ( 0)));
-  const uv = [0, 0];
-  for (let i = 0; i < n; i++) {
-    place.map(rx + i % w + 0.5, ry + Math.floor(i / w) + 0.5, uv);
-    tile.sample(uv[0], uv[1], c);
-    out.set(c, i * 4);
+  // --- Blending --------------------------------------------------------------------
+  /** `src` over `dst` with `mode` at `alpha` × coverage (straight alpha, float), as `blendTile`. */
+  blend(dst, src, mode, alpha, coverage) {
+    if (!(alpha > 0)) return;
+    const normal = mode === "normal";
+    const pigment = mode === "pigment";
+    const cb = [0, 0, 0];
+    const cs = [0, 0, 0];
+    const mix = [0, 0, 0];
+    for (let i = 0, p = 0; i < dst.length; i += 4, p++) {
+      const sa = src[i + 3];
+      if (!(sa > 0)) continue;
+      const k = coverage ? alpha * coverage[p] : alpha;
+      if (!(k > 0)) continue;
+      const as = Math.min(1, sa * k);
+      const ab = dst[i + 3];
+      const ao = as + ab * (1 - as);
+      if (ao <= 0) {
+        dst[i] = dst[i + 1] = dst[i + 2] = dst[i + 3] = 0;
+        continue;
+      }
+      if (normal && as >= 1) {
+        dst[i] = src[i];
+        dst[i + 1] = src[i + 1];
+        dst[i + 2] = src[i + 2];
+        dst[i + 3] = 1;
+        continue;
+      }
+      for (let c = 0; c < 3; c++) {
+        cb[c] = dst[i + c];
+        cs[c] = src[i + c];
+      }
+      if (pigment) {
+        if (this.linear) for (let c = 0; c < 3; c++) cb[c] = _chunk7ISPWEJAcjs.srgbEncode.call(void 0, cb[c]), cs[c] = _chunk7ISPWEJAcjs.srgbEncode.call(void 0, cs[c]);
+        _chunk7ISPWEJAcjs.mixPigmentRgb.call(void 0, cb, cs, as / ao, mix);
+        for (let c = 0; c < 3; c++) dst[i + c] = this.linear ? _chunk7ISPWEJAcjs.srgbDecode.call(void 0, mix[c]) : mix[c];
+        dst[i + 3] = ao;
+        continue;
+      }
+      const m = normal ? cs : _chunk7ISPWEJAcjs.blendRgb.call(void 0, mode, cb, cs);
+      const wb = (1 - as) * ab;
+      const ws = (1 - ab) * as;
+      const wm = as * ab;
+      for (let c = 0; c < 3; c++) dst[i + c] = (wb * cb[c] + ws * cs[c] + wm * m[c]) / ao;
+      dst[i + 3] = ao;
+    }
+  }
+};
+function lerp(dst, before, alpha, coverage) {
+  for (let i = 0, p = 0; i < dst.length; i += 4, p++) {
+    const k = coverage ? alpha * coverage[p] : alpha;
+    if (k >= 1) continue;
+    for (let c = 0; c < 4; c++) dst[i + c] = before[i + c] + (dst[i + c] - before[i + c]) * k;
   }
-  return out;
 }
-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 mapColour(data, f) {
+  for (let i = 0; i < data.length; i += 4) {
+    data[i] = f(data[i]);
+    data[i + 1] = f(data[i + 1]);
+    data[i + 2] = f(data[i + 2]);
+  }
 }
-function 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));
+function workingToSamples(data, depth) {
+  if (depth === 32) return data;
+  const out = new Uint16Array(data.length);
+  for (let i = 0; i < data.length; i++) {
+    const v = data[i];
+    out[i] = v > 0 ? v < 1 ? Math.round(v * 65535) : 65535 : 0;
   }
   return out;
 }
-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 = _nullishCoalesce(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;
+function encodeInPlace(d) {
+  for (let i = 0; i < d.length; i += 4) {
+    d[i] = _chunk7ISPWEJAcjs.srgbEncode.call(void 0, d[i]);
+    d[i + 1] = _chunk7ISPWEJAcjs.srgbEncode.call(void 0, d[i + 1]);
+    d[i + 2] = _chunk7ISPWEJAcjs.srgbEncode.call(void 0, d[i + 2]);
   }
-  const premerge = !normalLike;
-  if (premerge) {
-    const sep2 = _chunk7ISPWEJAcjs.isSeparableBlendMode.call(void 0, 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);
+}
+function decodeInPlace(d) {
+  for (let i = 0; i < d.length; i += 4) {
+    d[i] = _chunk7ISPWEJAcjs.srgbDecode.call(void 0, d[i]);
+    d[i + 1] = _chunk7ISPWEJAcjs.srgbDecode.call(void 0, d[i + 1]);
+    d[i + 2] = _chunk7ISPWEJAcjs.srgbDecode.call(void 0, d[i + 2]);
   }
-  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);
+}
+
+// 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 (const i of rev) {
-    const e = items[i];
-    if (e.kind === "color-overlay") paintColor(lay, full, e.color, e.blend, e.opacity);
+  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;
   }
-  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);
+}
+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];
   }
-  for (const i of rev) {
-    const e = items[i];
-    if (e.kind === "inner-glow") paintGlow(lay, rel(fx(i, 0)), e, env);
+  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 (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);
+  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));
   }
-  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) => _nullishCoalesce(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 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 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 (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];
+    }
   }
-  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 = _nullishCoalesce((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;
-      }
+  return out;
+}
+
+// src/raster/layers.ts
+var childrenOf = (l) => l.type === "group" ? _nullishCoalesce(l.children, () => ( null)) : null;
+function flattenLayers(layers) {
+  const out = [];
+  const walk = (list) => {
+    for (const l of list) {
+      out.push(l);
+      const c = childrenOf(l);
+      if (c) walk(c);
     }
-    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);
+  };
+  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;
       }
     }
-  }
-  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 = _chunk7ISPWEJAcjs.isSeparableBlendMode.call(void 0, mode);
-  for (let i = 0; i < n; i++) {
-    const p = i * 4;
-    if (lay[p + 3] > 0) compositeAt(work, p, mode, sep, lay[p], lay[p + 1], lay[p + 2], lay[p + 3]);
-  }
-  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;
+    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);
     }
-    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);
-  }
+    return _nullishCoalesce(out, () => ( list));
+  };
+  const result = walk(layers);
+  return changed ? result : layers;
 }
-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: _nullishCoalesce(layer.fillOpacity, () => ( 1)),
-    canvas,
-    ctx
+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(_optionalChain([layer, 'access', _27 => _27.locks, 'optionalAccess', _28 => _28.all]) || _optionalChain([layer, 'access', _29 => _29.locks, 'optionalAccess', _30 => _30[what]]));
+}
 
 // src/raster/compositor.ts
 var TILE_PIXELS = _chunk7ISPWEJAcjs.TILE * _chunk7ISPWEJAcjs.TILE;
@@ -2563,7 +2651,7 @@ var RasterCompositor = (_class = class {
     const dirty = grow > 0 ? options.dirty.map((d) => inflateRect(d, grow)) : options.dirty;
     for (const { tx, ty } of _chunk7ISPWEJAcjs.tilesInRect.call(void 0, rect)) {
       stats.tiles++;
-      const before = _optionalChain([this, 'access', _25 => _25.tiles, 'access', _26 => _26.get, 'call', _27 => _27(_chunk7ISPWEJAcjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _28 => _28.result]);
+      const before = _optionalChain([this, 'access', _31 => _31.tiles, 'access', _32 => _32.get, 'call', _33 => _33(_chunk7ISPWEJAcjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _34 => _34.result]);
       const data = this.compositeTile(layers, steps, tx, ty, stats, dirty ? dirtyInTile(dirty, tx, ty) : null);
       onTile(tx, ty, data, data !== before);
     }
@@ -2591,13 +2679,33 @@ var RasterCompositor = (_class = class {
     this.setSources(sources);
     return this.maskTile(layer, r);
   }
+  /**
+   * For the float compositor: everything `compositeLayerEffects` needs for `layer` over `r` but
+   * the pixels (the area its effects reach inside `r`, the effect maps built from its 8-bit
+   * shape, blend, opacities, canvas and context), or `null` when nothing reaches `r`.
+   */
+  effectsInput(layer, r, sources) {
+    this.setSources(sources);
+    const maps = this.effectMapsOf(layer);
+    const rect = this.effectArea(layer, maps, r);
+    if (!rect) return null;
+    return {
+      rect,
+      maps,
+      blend: isGroup2(layer) ? layer.blend === "pass-through" ? "normal" : layer.blend : this.contentBlend(layer),
+      opacity: layer.opacity,
+      fillOpacity: this.isPixel(layer) ? _nullishCoalesce(layer.fillOpacity, () => ( 1)) : 1,
+      canvas: { x: 0, y: 0, width: this.sources.width, height: this.sources.height },
+      ctx: this.effectContext()
+    };
+  }
   // --- Steps -------------------------------------------------------------------
   /** Pixel layers, and the layer kinds the profile composites like them. */
   isPixel(l) {
-    return l.type === "pixel" || (_nullishCoalesce(_optionalChain([this, 'access', _29 => _29.profile, 'access', _30 => _30.isPixelLike, 'optionalCall', _31 => _31(l)]), () => ( false)));
+    return l.type === "pixel" || (_nullishCoalesce(_optionalChain([this, 'access', _35 => _35.profile, 'access', _36 => _36.isPixelLike, 'optionalCall', _37 => _37(l)]), () => ( false)));
   }
   isFilter(l) {
-    return _nullishCoalesce(_optionalChain([this, 'access', _32 => _32.profile, 'access', _33 => _33.isFilterLayer, 'optionalCall', _34 => _34(l)]), () => ( false));
+    return _nullishCoalesce(_optionalChain([this, 'access', _38 => _38.profile, 'access', _39 => _39.isFilterLayer, 'optionalCall', _40 => _40(l)]), () => ( false));
   }
   /**
    * Groups a layer list into compositing steps: clipped layers join the nearest unclipped
@@ -2636,9 +2744,9 @@ var RasterCompositor = (_class = class {
     if (key !== void 0) return key;
     const mask = layer.mask ? [layer.mask.enabled !== false, _nullishCoalesce(layer.mask.density, () => ( 1)), _nullishCoalesce(layer.mask.feather, () => ( 0)), layer.mask.defaultValue, _nullishCoalesce(layer.mask.source, () => ( null))] : null;
     const base = [layer.type, layer.id, layer.visible, layer.opacity, layer.blend, Boolean(layer.clipped), mask];
-    if (this.isPixel(layer)) base.push(_nullishCoalesce(_optionalChain([layer, 'access', _35 => _35.offset, 'optionalAccess', _36 => _36.x]), () => ( 0)), _nullishCoalesce(_optionalChain([layer, 'access', _37 => _37.offset, 'optionalAccess', _38 => _38.y]), () => ( 0)), _nullishCoalesce(layer.fillOpacity, () => ( 1)));
+    if (this.isPixel(layer)) base.push(_nullishCoalesce(_optionalChain([layer, 'access', _41 => _41.offset, 'optionalAccess', _42 => _42.x]), () => ( 0)), _nullishCoalesce(_optionalChain([layer, 'access', _43 => _43.offset, 'optionalAccess', _44 => _44.y]), () => ( 0)), _nullishCoalesce(layer.fillOpacity, () => ( 1)));
     if (this.hasEffects(layer)) base.push(effectsFingerprint(layer.effects));
-    const extra = _optionalChain([this, 'access', _39 => _39.profile, 'access', _40 => _40.layerKey, 'optionalCall', _41 => _41(layer)]);
+    const extra = _optionalChain([this, 'access', _45 => _45.profile, 'access', _46 => _46.layerKey, 'optionalCall', _47 => _47(layer)]);
     if (extra !== void 0) base.push(extra);
     key = JSON.stringify(base);
     this.propsKeyCache.set(layer, key);
@@ -2805,7 +2913,7 @@ var RasterCompositor = (_class = class {
     const refs = [surface.defaultValue];
     const r = { x: tx * _chunk7ISPWEJAcjs.TILE - dx, y: ty * _chunk7ISPWEJAcjs.TILE - dy, width: _chunk7ISPWEJAcjs.TILE, height: _chunk7ISPWEJAcjs.TILE };
     for (const t of _chunk7ISPWEJAcjs.tilesInRect.call(void 0, r)) refs.push(_nullishCoalesce(surface.getTile(t.tx, t.ty), () => ( null)));
-    refs.push(...this.maskRefs(layer, tx, ty, _nullishCoalesce(_optionalChain([layer, 'access', _42 => _42.offset, 'optionalAccess', _43 => _43.x]), () => ( 0)), _nullishCoalesce(_optionalChain([layer, 'access', _44 => _44.offset, 'optionalAccess', _45 => _45.y]), () => ( 0))));
+    refs.push(...this.maskRefs(layer, tx, ty, _nullishCoalesce(_optionalChain([layer, 'access', _48 => _48.offset, 'optionalAccess', _49 => _49.x]), () => ( 0)), _nullishCoalesce(_optionalChain([layer, 'access', _50 => _50.offset, 'optionalAccess', _51 => _51.y]), () => ( 0))));
     return { key, refs };
   }
   // --- Layer effects ------------------------------------------------------------
@@ -2835,7 +2943,7 @@ var RasterCompositor = (_class = class {
     this.fxContext = {
       light: _nullishCoalesce(sources.globalLight, () => ( DEFAULT_GLOBAL_LIGHT)),
       pattern: (id) => {
-        const p = _nullishCoalesce(_optionalChain([sources, 'access', _46 => _46.pattern, 'optionalCall', _47 => _47(id)]), () => ( builtinPattern(id)));
+        const p = _nullishCoalesce(_optionalChain([sources, 'access', _52 => _52.pattern, 'optionalCall', _53 => _53(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) {
@@ -2963,7 +3071,7 @@ var RasterCompositor = (_class = class {
    * without filters or a feathered or parametric mask (those spread a change beyond it).
    */
   dirtyCoversShape(layer) {
-    if (!this.isPixel(layer) || _optionalChain([this, 'access', _48 => _48.profile, 'access', _49 => _49.pixelFilters, 'optionalCall', _50 => _50(layer)])) return false;
+    if (!this.isPixel(layer) || _optionalChain([this, 'access', _54 => _54.profile, 'access', _55 => _55.pixelFilters, 'optionalCall', _56 => _56(layer)])) return false;
     const mask = layer.mask;
     return !mask || mask.enabled === false || !mask.source && !((_nullishCoalesce(mask.feather, () => ( 0))) > 0);
   }
@@ -3051,10 +3159,10 @@ var RasterCompositor = (_class = class {
    */
   layerPixels(layer) {
     const raw = this.sources.surfaceOf ? this.sources.surfaceOf(layer) : layer.surface;
-    const ox = _nullishCoalesce(_optionalChain([layer, 'access', _51 => _51.offset, 'optionalAccess', _52 => _52.x]), () => ( 0));
-    const oy = _nullishCoalesce(_optionalChain([layer, 'access', _53 => _53.offset, 'optionalAccess', _54 => _54.y]), () => ( 0));
-    const filters = _nullishCoalesce(_optionalChain([this, 'access', _55 => _55.profile, 'access', _56 => _56.pixelFilters, 'optionalCall', _57 => _57(layer)]), () => ( null));
-    if (!_optionalChain([filters, 'optionalAccess', _58 => _58.spatial])) return { surface: raw, dx: ox, dy: oy, perPixel: filters };
+    const ox = _nullishCoalesce(_optionalChain([layer, 'access', _57 => _57.offset, 'optionalAccess', _58 => _58.x]), () => ( 0));
+    const oy = _nullishCoalesce(_optionalChain([layer, 'access', _59 => _59.offset, 'optionalAccess', _60 => _60.y]), () => ( 0));
+    const filters = _nullishCoalesce(_optionalChain([this, 'access', _61 => _61.profile, 'access', _62 => _62.pixelFilters, 'optionalCall', _63 => _63(layer)]), () => ( null));
+    if (!_optionalChain([filters, 'optionalAccess', _64 => _64.spatial])) return { surface: raw, dx: ox, dy: oy, perPixel: filters };
     const fkey = `${ox},${oy}:${filters.key}`;
     let byKey = this.filteredCache.get(raw);
     if (!byKey) {
@@ -3071,7 +3179,7 @@ var RasterCompositor = (_class = class {
   }
   /** RGBA of a content layer over `r` (document space, inside one tile), or `null` when it has nothing there. */
   contentTile(layer, r) {
-    if (!this.isPixel(layer)) return _nullishCoalesce(_optionalChain([this, 'access', _59 => _59.profile, 'access', _60 => _60.contentTile, 'optionalCall', _61 => _61(layer, r, this.sources)]), () => ( null));
+    if (!this.isPixel(layer)) return _nullishCoalesce(_optionalChain([this, 'access', _65 => _65.profile, 'access', _66 => _66.contentTile, 'optionalCall', _67 => _67(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 = _chunk7ISPWEJAcjs.tilesInRect.call(void 0, src).map((t) => surface.getTile(t.tx, t.ty));
@@ -3086,7 +3194,7 @@ var RasterCompositor = (_class = class {
     let byKey = this.contentCache.get(anchor);
     const refsKey = `${r.x},${r.y}:${fkey}`;
     if (aligned) {
-      const hit = _optionalChain([byKey, 'optionalAccess', _62 => _62.get, 'call', _63 => _63(refsKey)]);
+      const hit = _optionalChain([byKey, 'optionalAccess', _68 => _68.get, 'call', _69 => _69(refsKey)]);
       if (hit) return hit;
     }
     const data = _chunk7ISPWEJAcjs.readRegion.call(void 0, surface, src);
@@ -3124,7 +3232,7 @@ var RasterCompositor = (_class = class {
     const H = this.sources.height;
     let v = new Float32Array(W * H);
     if (mask.source) {
-      const generated = _nullishCoalesce(_optionalChain([this, 'access', _64 => _64.profile, 'access', _65 => _65.maskSourcePlane, 'optionalCall', _66 => _66(mask.source, W, H, this.sources)]), () => ( null));
+      const generated = _nullishCoalesce(_optionalChain([this, 'access', _70 => _70.profile, 'access', _71 => _71.maskSourcePlane, 'optionalCall', _72 => _72(mask.source, W, H, this.sources)]), () => ( null));
       if (!generated || generated.length !== W * H) v.fill(1);
       else v.set(generated);
     } else {
@@ -3143,8 +3251,8 @@ var RasterCompositor = (_class = class {
   maskTile(layer, r) {
     const mask = layer.mask;
     if (!mask || mask.enabled === false) return null;
-    const ox = this.isPixel(layer) ? _nullishCoalesce(_optionalChain([layer, 'access', _67 => _67.offset, 'optionalAccess', _68 => _68.x]), () => ( 0)) : 0;
-    const oy = this.isPixel(layer) ? _nullishCoalesce(_optionalChain([layer, 'access', _69 => _69.offset, 'optionalAccess', _70 => _70.y]), () => ( 0)) : 0;
+    const ox = this.isPixel(layer) ? _nullishCoalesce(_optionalChain([layer, 'access', _73 => _73.offset, 'optionalAccess', _74 => _74.x]), () => ( 0)) : 0;
+    const oy = this.isPixel(layer) ? _nullishCoalesce(_optionalChain([layer, 'access', _75 => _75.offset, 'optionalAccess', _76 => _76.y]), () => ( 0)) : 0;
     const n = r.width * r.height;
     const out = new Float32Array(n);
     const density = _nullishCoalesce(mask.density, () => ( 1));
@@ -3228,7 +3336,7 @@ var RasterCompositor = (_class = class {
     return empty;
   }
   contentBlend(layer) {
-    return _nullishCoalesce(_optionalChain([this, 'access', _71 => _71.profile, 'access', _72 => _72.contentBlend, 'optionalCall', _73 => _73(layer)]), () => ( layer.blend));
+    return _nullishCoalesce(_optionalChain([this, 'access', _77 => _77.profile, 'access', _78 => _78.contentBlend, 'optionalCall', _79 => _79(layer)]), () => ( layer.blend));
   }
   blendOnto(acc, src, empty, mode, alpha, coverage) {
     if (!(alpha > 0)) return empty;
@@ -3282,7 +3390,7 @@ var RasterCompositor = (_class = class {
       }
       visible.push(node);
     }
-    if (visible.length) _optionalChain([this, 'access', _74 => _74.profile, 'access', _75 => _75.applyFilterRun, 'optionalCall', _76 => _76(visible, acc, r, masks, this.sources)]);
+    if (visible.length) _optionalChain([this, 'access', _80 => _80.profile, 'access', _81 => _81.applyFilterRun, 'optionalCall', _82 => _82(visible, acc, r, masks, this.sources)]);
   }
 }, _class);
 function filterOverCanvas(surface, ox, oy, filters, width, height) {
@@ -4201,5 +4309,5 @@ function compositeSurfaceOver(base, top) {
 
 
 
-exports.DEFAULT_GLOBAL_LIGHT = DEFAULT_GLOBAL_LIGHT; exports.LAYER_EFFECT_KINDS = LAYER_EFFECT_KINDS; exports.layerEffectLabel = layerEffectLabel; exports.isLayerEffectKind = isLayerEffectKind; exports.defaultEffectGradient = defaultEffectGradient; exports.newEffectId = newEffectId; exports.defaultLayerEffect = defaultLayerEffect; exports.hasActiveEffects = hasActiveEffects; exports.MAX_EFFECT_REACH = MAX_EFFECT_REACH; exports.effectReach = effectReach; exports.effectsMargin = effectsMargin; exports.effectsScale = effectsScale; exports.scaleLayerEffect = scaleLayerEffect; exports.parseEffectColor = parseEffectColor; exports.effectColorHex = effectColorHex; exports.LayerEffectError = LayerEffectError; exports.validateEffectGradient = validateEffectGradient; exports.layerEffectFields = layerEffectFields; exports.validateLayerEffect = validateLayerEffect; exports.mergeLayerEffect = mergeLayerEffect; exports.validateLayerEffects = validateLayerEffects; exports.normalizeLayerEffects = normalizeLayerEffects; exports.effectsFingerprint = effectsFingerprint; exports.DeepCompositor = DeepCompositor; exports.workingToSamples = workingToSamples; exports.DIRECT_GAUSSIAN_MAX_SIGMA = DIRECT_GAUSSIAN_MAX_SIGMA; exports.gaussianBlur = gaussianBlur; exports.flattenLayers = flattenLayers; exports.findLayer = findLayer; exports.mapLayer = mapLayer; exports.insertLayer = insertLayer; exports.isLayerLocked = isLayerLocked; exports.PatternTile = PatternTile; exports.PatternPlacement = PatternPlacement; exports.builtinPatternIds = builtinPatternIds; exports.builtinPattern = builtinPattern; exports.hashNoise = hashNoise; exports.CURVE_LUT_SIZE = CURVE_LUT_SIZE; exports.curveLut = curveLut; exports.STROKE_CHAMFER_MAX = STROKE_CHAMFER_MAX; exports.contourLut = contourLut; exports.activeEffectItems = activeEffectItems; exports.effectsAreLocal = effectsAreLocal; exports.buildEffectMaps = buildEffectMaps; exports.patchEffectMaps = patchEffectMaps; exports.gradientT = gradientT; exports.effectFillColors = effectFillColors; exports.compositeLayerEffects = compositeLayerEffects; exports.renderLayerEffects = renderLayerEffects; exports.blendTile = blendTile; exports.RasterCompositor = RasterCompositor; exports.changedTiles = changedTiles; exports.INTERPOLATIONS = INTERPOLATIONS; exports.isInterpolation = isInterpolation; exports.MAX_TRANSFORM_PIXELS = MAX_TRANSFORM_PIXELS; exports.TransformTooLargeError = TransformTooLargeError; exports.keysWeight = keysWeight; exports.reduceSurface = reduceSurface; exports.transformedBounds = transformedBounds; exports.transformSurface = transformSurface; exports.warpSurface = warpSurface; exports.compositeSurfaceOver = compositeSurfaceOver;
-//# sourceMappingURL=chunk-LL3RAN55.cjs.map
+exports.DEFAULT_GLOBAL_LIGHT = DEFAULT_GLOBAL_LIGHT; exports.LAYER_EFFECT_KINDS = LAYER_EFFECT_KINDS; exports.layerEffectLabel = layerEffectLabel; exports.isLayerEffectKind = isLayerEffectKind; exports.defaultEffectGradient = defaultEffectGradient; exports.newEffectId = newEffectId; exports.defaultLayerEffect = defaultLayerEffect; exports.hasActiveEffects = hasActiveEffects; exports.MAX_EFFECT_REACH = MAX_EFFECT_REACH; exports.effectReach = effectReach; exports.effectsMargin = effectsMargin; exports.effectsScale = effectsScale; exports.scaleLayerEffect = scaleLayerEffect; exports.parseEffectColor = parseEffectColor; exports.effectColorHex = effectColorHex; exports.LayerEffectError = LayerEffectError; exports.validateEffectGradient = validateEffectGradient; exports.layerEffectFields = layerEffectFields; exports.validateLayerEffect = validateLayerEffect; exports.mergeLayerEffect = mergeLayerEffect; exports.validateLayerEffects = validateLayerEffects; exports.normalizeLayerEffects = normalizeLayerEffects; exports.effectsFingerprint = effectsFingerprint; exports.CURVE_LUT_SIZE = CURVE_LUT_SIZE; exports.curveLut = curveLut; exports.PatternTile = PatternTile; exports.PatternPlacement = PatternPlacement; exports.builtinPatternIds = builtinPatternIds; exports.builtinPattern = builtinPattern; exports.hashNoise = hashNoise; exports.STROKE_CHAMFER_MAX = STROKE_CHAMFER_MAX; exports.contourLut = contourLut; exports.activeEffectItems = activeEffectItems; exports.effectsAreLocal = effectsAreLocal; exports.buildEffectMaps = buildEffectMaps; exports.patchEffectMaps = patchEffectMaps; exports.gradientT = gradientT; exports.effectFillColors = effectFillColors; exports.compositeLayerEffects = compositeLayerEffects; exports.renderLayerEffects = renderLayerEffects; exports.DeepCompositor = DeepCompositor; exports.workingToSamples = workingToSamples; exports.DIRECT_GAUSSIAN_MAX_SIGMA = DIRECT_GAUSSIAN_MAX_SIGMA; exports.gaussianBlur = gaussianBlur; exports.flattenLayers = flattenLayers; exports.findLayer = findLayer; exports.mapLayer = mapLayer; exports.insertLayer = insertLayer; exports.isLayerLocked = isLayerLocked; exports.blendTile = blendTile; exports.RasterCompositor = RasterCompositor; exports.changedTiles = changedTiles; exports.INTERPOLATIONS = INTERPOLATIONS; exports.isInterpolation = isInterpolation; exports.MAX_TRANSFORM_PIXELS = MAX_TRANSFORM_PIXELS; exports.TransformTooLargeError = TransformTooLargeError; exports.keysWeight = keysWeight; exports.reduceSurface = reduceSurface; exports.transformedBounds = transformedBounds; exports.transformSurface = transformSurface; exports.warpSurface = warpSurface; exports.compositeSurfaceOver = compositeSurfaceOver;
+//# sourceMappingURL=chunk-DFFBJV3U.cjs.map