@pixerate/editor 0.96.0 → 0.98.0

package/dist/{chunk-KFTQ2PKP.js → chunk-WIR377F6.js}

@@ -1,8 +1,21 @@
+import {
+  applyHomography,
+  boxQuad,
+  cornerBounds,
+  homographyFrontSide,
+  homographyW,
+  invertHomography,
+  isIdentityHomography,
+  multiplyHomographies
+} from "./chunk-GX332W2C.js";
 import {
   TILE,
+  TiledSurface,
   blendChannel,
   blendRgb,
+  contentBounds,
   emptySurface,
+  finishTile,
   isBlendMode,
   isSeparableBlendMode,
   mixPigment8,
@@ -10,7 +23,9 @@ import {
   readRegion,
   surfaceFromPixels,
   tileKey,
-  tilesInRect
+  tilesInRect,
+  translateSurface,
+  writeRegion
 } from "./chunk-HEW6KDNI.js";
 
 // src/raster/blur.ts
@@ -644,14 +659,14 @@ var PatternTile = class {
     let b = 0;
     let a = 0;
     for (let dy = 0; dy < 2; dy++) {
-      const wy = dy ? fy : 1 - fy;
-      if (wy === 0) continue;
+      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 wx = dx ? fx : 1 - fx;
-        if (wx === 0) continue;
+        const wx2 = dx ? fx : 1 - fx;
+        if (wx2 === 0) continue;
         const xi = ((x0 + dx) % this.w + this.w) % this.w;
-        const k = wx * wy;
+        const k = wx2 * wy2;
         const i = (yi * this.w + xi) * 4;
         r += this.px[i] * k;
         g += this.px[i + 1] * k;
@@ -1080,11 +1095,18 @@ function boxLine(src, x0, dst, bw) {
   }
 }
 var BLUR_EPS = 1e-7;
+var BLUR_FIX = 2 ** 32;
 function tentLine(src, dst, bw, mid) {
   const [r] = boxGeom(bw);
-  boxLine(src, -r, mid.subarray(0, src.length + 2 * r), bw);
-  boxLine(mid.subarray(0, src.length + 2 * r), r, dst, bw);
-  for (let i = 0; i < dst.length; i++) if (Math.abs(dst[i]) < BLUR_EPS) dst[i] = 0;
+  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;
+  }
 }
 function tent(m, w) {
   if (!Number.isFinite(w) || m.v.length === 0) return;
@@ -1386,25 +1408,41 @@ function effectsAreLocal(items) {
     }
   });
 }
+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;
+      }
+    }
+  }
+  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 };
-  let x0 = Infinity;
-  let y0 = Infinity;
-  let x1 = -Infinity;
-  let y1 = -Infinity;
-  for (let y = 0; y < h; y++) {
-    for (let x = 0; x < w; x++) {
-      if (shape[y * w + x] > INSIDE_EPS) {
-        if (x < x0) x0 = x;
-        if (x > x1) x1 = x;
-        if (y < y0) y0 = y;
-        if (y > y1) y1 = y;
-      }
-    }
-  }
-  const bounds = x0 === Infinity ? null : { x: rect.x + x0, y: rect.y + y0, width: x1 - x0 + 1, height: y1 - y0 + 1 };
+  const bounds = shapeBounds(shape, rect);
   const anchor = bounds ? { x: bounds.x, y: bounds.y } : { x: rect.x, y: rect.y };
   const per = [];
   const bevelPaint = [];
@@ -1452,6 +1490,81 @@ function buildEffectMaps(items, shape, rect, ctx) {
   for (const d of [din, dout, doutExact]) if (d) bytes += d.byteLength;
   return { rect, items, bounds, shape, per, bevelPaint, din, dout, doutExact, frames, bytes };
 }
+var 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;
+}
+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 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 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 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;
+        }
+      }
+    }
+  }
+  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 };
+}
 var rgbScratchB = [0, 0, 0];
 var rgbScratchS = [0, 0, 0];
 var rgbScratchM = [0, 0, 0];
@@ -1650,15 +1763,15 @@ function gradientLayout(style, angle, scale, offset, frame) {
   const half = chordOf(a) * Math.max(scale, 1e-3) / 2;
   const dx = Math.cos(a) * half;
   const dy = -Math.sin(a) * half;
-  const snap = (v2) => Math.floor(v2 + 1e-4);
-  const end = [snap(cx + dx), snap(cy + dy)];
+  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 = [snap(cx - dx), snap(cy - dy)];
+    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]];
@@ -2084,8 +2197,11 @@ var RasterCompositor = class {
   patternTiles = /* @__PURE__ */ new WeakMap();
   reachCache = /* @__PURE__ */ new WeakMap();
   fxContext = null;
-  lastStats = { tiles: 0, cached: 0, stepsRun: 0 };
+  lastStats = { tiles: 0, cached: 0, stepsRun: 0, effectsBuilt: 0, effectsPatched: 0 };
   hint = -1;
+  /** The `dirty` rectangles of the current call, as passed. */
+  callDirty = null;
+  callStats = this.lastStats;
   /** Drops every cached tile and plane. */
   clear() {
     this.tiles.clear();
@@ -2133,7 +2249,9 @@ var RasterCompositor = class {
     const steps = this.buildSteps(layers);
     this.hint = options.checkpointLayerId ? this.stepIndexOf(steps, options.checkpointLayerId) : -1;
     this.stamp++;
-    const stats = { tiles: 0, cached: 0, stepsRun: 0 };
+    this.callDirty = options.dirty ?? null;
+    const stats = { tiles: 0, cached: 0, stepsRun: 0, effectsBuilt: 0, effectsPatched: 0 };
+    this.callStats = stats;
     const grow = options.dirty ? this.effectsReach(layers) : 0;
     const dirty = grow > 0 ? options.dirty.map((d) => inflateRect(d, grow)) : options.dirty;
     for (const { tx, ty } of tilesInRect(rect)) {
@@ -2149,8 +2267,10 @@ var RasterCompositor = class {
   tile(layers, tx, ty, sources) {
     this.setSources(sources);
     this.stamp++;
-    const stats = { tiles: 1, cached: 0, stepsRun: 0 };
+    const stats = { tiles: 1, cached: 0, stepsRun: 0, effectsBuilt: 0, effectsPatched: 0 };
+    this.callStats = stats;
     this.hint = -1;
+    this.callDirty = null;
     const data = this.compositeTile(layers, this.buildSteps(layers), tx, ty, stats);
     this.lastStats = stats;
     this.evict();
@@ -2220,7 +2340,8 @@ var RasterCompositor = class {
     let first = 0;
     if (entry) {
       while (first < sigs.length && first < entry.sigs.length && sameSig(entry.sigs[first], sigs[first])) first++;
-      if (first === sigs.length && first === entry.sigs.length) {
+      if (first === sigs.length && first === entry.sigs.length || this.changedOnlyNearby(steps, sigs, entry, dirty)) {
+        entry.sigs = sigs;
         entry.stamp = this.stamp;
         stats.cached++;
         return entry.result;
@@ -2285,6 +2406,20 @@ var RasterCompositor = class {
     this.cacheBytes += this.entryBytes(next) - prevBytes;
     return result;
   }
+  /**
+   * Whether a tile with no part in this call's (grown) `dirty` rectangles changed only in what local
+   * effects read beyond it: every changed step is a pixel layer with local effects whose changes stay
+   * inside `dirty` (and so are farther than its margin), which leaves the tile's pixels as they were.
+   */
+  changedOnlyNearby(steps, sigs, entry, dirty) {
+    if (this.callDirty === null || dirty || entry.stamp !== this.stamp - 1 || sigs.length !== entry.sigs.length) return false;
+    return steps.every((step, i) => {
+      if (sameSig(entry.sigs[i], sigs[i])) return true;
+      if (step.kind !== "content" || entry.sigs[i].key !== sigs[i].key) return false;
+      const { layer, clipped } = step;
+      return this.hasEffects(layer) && effectsAreLocal(activeEffectItems(layer.effects)) && this.dirtyCoversShape(layer) && clipped.every((c) => this.dirtyCoversShape(c));
+    });
+  }
   entryBytes(e) {
     let n = e.result === ZERO_TILE ? 0 : TILE_BYTES;
     for (const cp of e.checkpoints.values()) n += cp.data.byteLength;
@@ -2415,14 +2550,20 @@ var RasterCompositor = class {
     if (!b) return { x: 0, y: 0, width: 0, height: 0 };
     return intersectRect({ x: b.x + dx - m, y: b.y + dy - m, width: b.width + 2 * m, height: b.height + 2 * m }, canvas);
   }
+  /** The signature of a layer's shape (its surface tiles and mask refs) per tile of `region`. */
+  shapeSigs(layer, region) {
+    const sigs = /* @__PURE__ */ new Map();
+    if (region.width <= 0 || region.height <= 0) return sigs;
+    const steps = isGroup(layer) ? this.buildSteps(layer.children ?? []) : null;
+    for (const t of tilesInRect(region)) {
+      sigs.set(tileKey(t.tx, t.ty), steps ? this.plainGroupSig(layer, steps, t.tx, t.ty) : this.plainContentSig(layer, t.tx, t.ty));
+    }
+    return sigs;
+  }
   /** The surface tiles (and mask refs) a layer's shape reads over `region`. */
   shapeRefs(layer, region) {
     const refs = [];
-    if (region.width <= 0 || region.height <= 0) return refs;
-    for (const t of tilesInRect(region)) {
-      const sig = isGroup(layer) ? this.plainGroupSig(layer, this.buildSteps(layer.children ?? []), t.tx, t.ty) : this.plainContentSig(layer, t.tx, t.ty);
-      for (const r of sig.refs) refs.push(r);
-    }
+    for (const sig of this.shapeSigs(layer, region).values()) for (const r of sig.refs) refs.push(r);
     return refs;
   }
   lightKey() {
@@ -2448,18 +2589,28 @@ var RasterCompositor = class {
     const memo = this.effectMemo.get(layer);
     if (memo && memo.stamp === this.stamp) return memo.maps;
     const region = this.effectRegion(layer);
-    const key = `${this.propsKey(layer)}${this.lightKey()}|${region.x},${region.y},${region.width},${region.height}`;
-    const refs = this.shapeRefs(layer, region);
+    const key = this.propsKey(layer) + this.lightKey();
+    const tiles = this.shapeSigs(layer, region);
     const hit = this.effectCache.get(layer.id);
-    let maps;
-    if (hit && hit.key === key && sameSig({ key, refs: hit.refs }, { key, refs })) {
-      this.effectCache.delete(layer.id);
-      this.effectCache.set(layer.id, hit);
-      maps = hit.maps;
+    this.effectCache.delete(layer.id);
+    let entry;
+    if (hit && hit.key === key && sameRect(hit.region, region) && [...tiles].every(([k, sig]) => sameSig(hit.tiles.get(k), sig))) {
+      entry = hit;
     } else {
-      maps = buildEffectMaps(activeEffectItems(layer.effects), this.layerShape(layer, region), region, this.effectContext());
-      this.effectCache.delete(layer.id);
-      this.effectCache.set(layer.id, { key, refs, maps });
+      const items = activeEffectItems(layer.effects);
+      const ctx = this.effectContext();
+      let maps = null;
+      if (hit && hit.key === key && items.every((e) => effectReach(e) <= MAX_EFFECT_REACH)) {
+        const changed = this.shapeChanges(layer, hit, tiles, region);
+        maps = patchEffectMaps(hit.maps, items, region, changed, effectsMargin(layer.effects), (r) => this.layerShape(layer, r), ctx);
+      }
+      if (maps) this.callStats.effectsPatched++;
+      else this.callStats.effectsBuilt++;
+      entry = { key, region, tiles, maps: maps ?? buildEffectMaps(items, this.layerShape(layer, region), region, ctx), stamp: 0 };
+    }
+    entry.stamp = this.stamp;
+    this.effectCache.set(layer.id, entry);
+    if (entry !== hit) {
       let bytes = 0;
       for (const e of this.effectCache.values()) bytes += e.maps.bytes;
       while (this.effectCache.size > 1 && (this.effectCache.size > 32 || bytes > this.maxCacheBytes / 2)) {
@@ -2468,8 +2619,42 @@ var RasterCompositor = class {
         this.effectCache.delete(oldest);
       }
     }
-    this.effectMemo.set(layer, { stamp: this.stamp, maps });
-    return maps;
+    this.effectMemo.set(layer, { stamp: this.stamp, maps: entry.maps });
+    return entry.maps;
+  }
+  /**
+   * Where a layer's shape may differ from the one `prev` was built from: the tiles whose signature
+   * changed (a tile new to the region that reads nothing did not), narrowed to this call's `dirty`
+   * rectangles when `prev` is from the previous call and they cover every change of the shape.
+   */
+  shapeChanges(layer, prev, tiles, region) {
+    const out = [];
+    for (const { tx, ty } of tilesInRect(region)) {
+      const sig = tiles.get(tileKey(tx, ty));
+      const old = prev.tiles.get(tileKey(tx, ty));
+      if (old ? sameSig(old, sig) : sig.refs.every((r2) => r2 === null || r2 === 0)) continue;
+      const r = intersectRect({ x: tx * TILE, y: ty * TILE, width: TILE, height: TILE }, region);
+      if (r.width > 0 && r.height > 0) out.push(r);
+    }
+    const dirty = this.callDirty;
+    if (!dirty || prev.stamp !== this.stamp - 1 || !this.dirtyCoversShape(layer)) return out;
+    const narrowed = [];
+    for (const r of out) {
+      for (const d of dirty) {
+        const a = intersectRect(r, { x: Math.floor(d.x), y: Math.floor(d.y), width: Math.ceil(d.x + d.width) - Math.floor(d.x), height: Math.ceil(d.y + d.height) - Math.floor(d.y) });
+        if (a.width > 0 && a.height > 0) narrowed.push(a);
+      }
+    }
+    return narrowed;
+  }
+  /**
+   * Whether a change to a layer stays inside the `dirty` rectangles that name it: a pixel layer
+   * without filters or a feathered or parametric mask (those spread a change beyond it).
+   */
+  dirtyCoversShape(layer) {
+    if (!isPixel(layer) || this.profile.pixelFilters?.(layer)) return false;
+    const mask = layer.mask;
+    return !mask || mask.enabled === false || !mask.source && !((mask.feather ?? 0) > 0);
   }
   /** A layer's alpha over `r` after its mask (0..1, quantised to bytes as tiles see it). */
   layerShape(layer, r) {
@@ -2796,6 +2981,9 @@ function copyRect(data, r, a) {
 function pasteRect(data, r, part, a) {
   for (let y = 0; y < a.height; y++) data.set(part.subarray(y * a.width * 4, (y + 1) * a.width * 4), ((a.y - r.y + y) * r.width + (a.x - r.x)) * 4);
 }
+function sameRect(a, b) {
+  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
 function inflateRect(r, m) {
   return { x: r.x - m, y: r.y - m, width: r.width + 2 * m, height: r.height + 2 * m };
 }
@@ -2813,6 +3001,747 @@ function changedTiles(a, b) {
   return out;
 }
 
+// src/raster/transform.ts
+var INTERPOLATIONS = ["nearest", "bilinear", "bicubic"];
+function isInterpolation(value) {
+  return typeof value === "string" && INTERPOLATIONS.includes(value);
+}
+var MAX_TRANSFORM_PIXELS = 1 << 27;
+var TransformTooLargeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TransformTooLargeError";
+  }
+};
+var KEYS_A = -0.75;
+function keysWeight(x) {
+  x = Math.abs(x);
+  if (x < 1) return ((KEYS_A + 2) * x - (KEYS_A + 3)) * x * x + 1;
+  if (x < 2) return KEYS_A * (((x - 5) * x + 8) * x - 4);
+  return 0;
+}
+var snap = (t) => Math.abs(t - Math.round(t)) < 1e-7 ? Math.round(t) : t;
+var MAX_TAPS = 20;
+var tapI0 = 0;
+var tapN = 0;
+function cubicTaps(u, s, w) {
+  if (s <= 1.0001) {
+    const f = Math.floor(u);
+    const t = u - f;
+    w[0] = keysWeight(1 + t);
+    w[1] = keysWeight(t);
+    w[2] = keysWeight(1 - t);
+    w[3] = keysWeight(2 - t);
+    tapI0 = f - 1;
+    tapN = 4;
+    return;
+  }
+  const r = 2 * s;
+  const i0 = Math.ceil(u - r);
+  const n = Math.min(MAX_TAPS, Math.floor(u + r) - i0 + 1);
+  let sum = 0;
+  for (let k = 0; k < n; k++) {
+    const v = keysWeight((i0 + k - u) / s);
+    w[k] = v;
+    sum += v;
+  }
+  if (sum !== 0) for (let k = 0; k < n; k++) w[k] /= sum;
+  tapI0 = i0;
+  tapN = n;
+}
+function intersect(a, b) {
+  const x = Math.max(a.x, b.x);
+  const y = 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 > x && y1 > y ? { x, y, width: x1 - x, height: y1 - y } : null;
+}
+function hasTilesIn(src, r) {
+  for (const { tx, ty } of tilesInRect(r)) if (src.getTile(tx, ty)) return true;
+  return false;
+}
+function readWindow(src, srcRect, rect) {
+  const n = src.channels === 4 ? 4 : 2;
+  const data = new Float32Array(rect.width * rect.height * n);
+  const win = { x: rect.x, y: rect.y, w: rect.width, h: rect.height, n, data };
+  const r = intersect(rect, srcRect);
+  if (!r) return win;
+  const px = readRegion(src, r);
+  for (let y = 0; y < r.height; y++) {
+    let s = y * r.width * src.channels;
+    let d = ((r.y - rect.y + y) * rect.width + (r.x - rect.x)) * n;
+    if (n === 4) {
+      for (let x = 0; x < r.width; x++, s += 4, d += 4) {
+        const a = px[s + 3] / 255;
+        data[d] = px[s] * a;
+        data[d + 1] = px[s + 1] * a;
+        data[d + 2] = px[s + 2] * a;
+        data[d + 3] = a;
+      }
+    } else {
+      for (let x = 0; x < r.width; x++, s++, d += 2) {
+        data[d] = px[s];
+        data[d + 1] = 1;
+      }
+    }
+  }
+  return win;
+}
+var scratch = new Uint8ClampedArray(4);
+var scratchWord = new Uint32Array(scratch.buffer);
+var wx = new Float64Array(MAX_TAPS);
+var wy = new Float64Array(MAX_TAPS);
+function sample(win, interp, u, v, su, sv, acc) {
+  const n = win.n;
+  const d = win.data;
+  for (let c = 0; c < n; c++) acc[c] = 0;
+  if (interp === "nearest") {
+    const ix = Math.floor(u + 0.5) - win.x;
+    const iy = Math.floor(v + 0.5) - win.y;
+    if (ix < 0 || iy < 0 || ix >= win.w || iy >= win.h) return;
+    const o = (iy * win.w + ix) * n;
+    for (let c = 0; c < n; c++) acc[c] = d[o + c];
+    return;
+  }
+  if (interp === "bilinear") {
+    const fx = Math.floor(u);
+    const fy = Math.floor(v);
+    const tx = u - fx;
+    const ty = v - fy;
+    for (let j = 0; j < 2; j++) {
+      const iy = fy + j - win.y;
+      if (iy < 0 || iy >= win.h) continue;
+      const kyw = j ? ty : 1 - ty;
+      if (!kyw) continue;
+      for (let i = 0; i < 2; i++) {
+        const ix = fx + i - win.x;
+        if (ix < 0 || ix >= win.w) continue;
+        const k = (i ? tx : 1 - tx) * kyw;
+        if (!k) continue;
+        const o = (iy * win.w + ix) * n;
+        for (let c = 0; c < n; c++) acc[c] += d[o + c] * k;
+      }
+    }
+    return;
+  }
+  u = snap(u);
+  v = snap(v);
+  cubicTaps(u, su, wx);
+  const x0 = tapI0 - win.x;
+  const nu = tapN;
+  cubicTaps(v, sv, wy);
+  const y0 = tapI0 - win.y;
+  const nv = tapN;
+  const W = win.w;
+  if (n === 4 && nu === 4 && nv === 4 && x0 >= 0 && y0 >= 0 && x0 + 4 <= W && y0 + 4 <= win.h) {
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    let a = 0;
+    const w0 = wx[0];
+    const w1 = wx[1];
+    const w2 = wx[2];
+    const w3 = wx[3];
+    for (let j = 0; j < 4; j++) {
+      const kyw = wy[j];
+      if (kyw === 0) continue;
+      let o = ((y0 + j) * W + x0) * 4;
+      const r0 = d[o] * w0 + d[o + 4] * w1 + d[o + 8] * w2 + d[o + 12] * w3;
+      const g0 = d[o + 1] * w0 + d[o + 5] * w1 + d[o + 9] * w2 + d[o + 13] * w3;
+      const b0 = d[o + 2] * w0 + d[o + 6] * w1 + d[o + 10] * w2 + d[o + 14] * w3;
+      const a0 = d[o + 3] * w0 + d[o + 7] * w1 + d[o + 11] * w2 + d[o + 15] * w3;
+      r += r0 * kyw;
+      g += g0 * kyw;
+      b += b0 * kyw;
+      a += a0 * kyw;
+    }
+    acc[0] = r;
+    acc[1] = g;
+    acc[2] = b;
+    acc[3] = a;
+    return;
+  }
+  for (let j = 0; j < nv; j++) {
+    const kyw = wy[j];
+    if (kyw === 0) continue;
+    const iy = y0 + j;
+    if (iy < 0 || iy >= win.h) continue;
+    const row = iy * W;
+    for (let i = 0; i < nu; i++) {
+      const k = wx[i] * kyw;
+      if (k === 0) continue;
+      const ix = x0 + i;
+      if (ix < 0 || ix >= W) continue;
+      const o = (row + ix) * n;
+      if (n === 4) {
+        acc[0] += d[o] * k;
+        acc[1] += d[o + 1] * k;
+        acc[2] += d[o + 2] * k;
+        acc[3] += d[o + 3] * k;
+      } else {
+        acc[0] += d[o] * k;
+        acc[1] += d[o + 1] * k;
+      }
+    }
+  }
+}
+function store(out, o, acc, ch, def) {
+  if (ch === 4) {
+    const al = acc[3] > 1 ? 1 : acc[3];
+    if (!(al > 1e-6)) return false;
+    out[o] = acc[0] / al;
+    out[o + 1] = acc[1] / al;
+    out[o + 2] = acc[2] / al;
+    out[o + 3] = al * 255;
+    return true;
+  }
+  const inside = acc[1] > 1 ? 1 : acc[1];
+  if (!(inside > 1e-6)) return false;
+  out[o] = acc[0] + def * (1 - inside);
+  return true;
+}
+function boxReduce(src, srcRect, kx, ky) {
+  const ch = src.channels;
+  const rx0 = Math.floor(srcRect.x / kx);
+  const ry0 = Math.floor(srcRect.y / ky);
+  const rx1 = Math.ceil((srcRect.x + srcRect.width) / kx);
+  const ry1 = Math.ceil((srcRect.y + srcRect.height) / ky);
+  const rw = rx1 - rx0;
+  const rect = { x: rx0, y: ry0, width: rw, height: ry1 - ry0 };
+  let out = emptySurface(ch, src.defaultValue);
+  const rowsPer = Math.max(1, Math.floor(TILE / ky));
+  const area = kx * ky;
+  for (let ry = ry0; ry < ry1; ry += rowsPer) {
+    const rows = Math.min(rowsPer, ry1 - ry);
+    const strip = { x: rx0 * kx, y: ry * ky, width: rw * kx, height: rows * ky };
+    const px = readRegion(src, strip);
+    const red = new Uint8ClampedArray(rw * rows * ch);
+    for (let j = 0; j < rows; j++) {
+      for (let i = 0; i < rw; i++) {
+        if (ch === 4) {
+          let a = 0;
+          let r = 0;
+          let g = 0;
+          let b = 0;
+          for (let y = 0; y < ky; y++) {
+            let s = ((j * ky + y) * strip.width + i * kx) * 4;
+            for (let x = 0; x < kx; x++, s += 4) {
+              const al = px[s + 3];
+              a += al;
+              r += px[s] * al;
+              g += px[s + 1] * al;
+              b += px[s + 2] * al;
+            }
+          }
+          const o = (j * rw + i) * 4;
+          if (a > 0) {
+            red[o] = r / a;
+            red[o + 1] = g / a;
+            red[o + 2] = b / a;
+            red[o + 3] = a / area;
+          }
+        } else {
+          let v = 0;
+          for (let y = 0; y < ky; y++) {
+            const s = (j * ky + y) * strip.width + i * kx;
+            for (let x = 0; x < kx; x++) v += px[s + x];
+          }
+          red[j * rw + i] = v / area;
+        }
+      }
+    }
+    out = writeRegion(out, { x: rx0, y: ry, width: rw, height: rows }, red);
+  }
+  return { surface: out, rect };
+}
+function reduceSurface(src, factor) {
+  const k = Math.max(1, Math.floor(factor));
+  const b = contentBounds(src);
+  if (k === 1 || !b) return src;
+  return boxReduce(src, b, k, k).surface;
+}
+function inverseStretch(inv, X, Y) {
+  const w = inv[6] * X + inv[7] * Y + inv[8];
+  if (!(Math.abs(w) > 1e-12)) return [1, 1];
+  const U = (inv[0] * X + inv[1] * Y + inv[2]) / w;
+  const V = (inv[3] * X + inv[4] * Y + inv[5]) / w;
+  const ux = (inv[0] - U * inv[6]) / w;
+  const uy = (inv[1] - U * inv[7]) / w;
+  const vx = (inv[3] - V * inv[6]) / w;
+  const vy = (inv[4] - V * inv[7]) / w;
+  return [Math.hypot(ux, uy), Math.hypot(vx, vy)];
+}
+var reduction = (s) => s >= 2 && Number.isFinite(s) ? Math.min(64, 2 ** Math.floor(Math.log2(s))) : 1;
+function normalizeStep(step) {
+  if (!step || !(step > 1)) return 1;
+  return Math.min(64, 2 ** Math.floor(Math.log2(step)));
+}
+function checkBudget(dst, what = "result") {
+  if (dst.width * dst.height > MAX_TRANSFORM_PIXELS) {
+    throw new TransformTooLargeError(
+      `The transformed ${what} would be ${dst.width} \xD7 ${dst.height} px, more than the ${MAX_TRANSFORM_PIXELS} px limit; use a smaller scale.`
+    );
+  }
+}
+function assemble(src, tiles) {
+  return new TiledSurface(src.channels, tiles, src.defaultValue);
+}
+function transformedBounds(source, h) {
+  if (!(source.width > 0 && source.height > 0) || !invertHomography(h)) return null;
+  const pts = boxQuad(source).map((p) => applyHomography(h, p));
+  if (pts.some((p) => !p)) return null;
+  return cornerBounds(pts);
+}
+function transformSurface(src, h, options = {}) {
+  const interp = options.interpolation ?? "bicubic";
+  const ch = src.channels;
+  const def = src.defaultValue;
+  const empty = emptySurface(ch, def);
+  const given = options.source;
+  const step = normalizeStep(options.step);
+  if (isIdentityHomography(h, 1e-12) && !given && !options.clip) return src;
+  const dx = h[2] / h[8];
+  const dy = h[5] / h[8];
+  if (!given && !options.clip && isIdentityHomography([h[0], h[1], 0, h[3], h[4], 0, h[6], h[7], h[8]], 1e-12) && Math.abs(dx - Math.round(dx)) < 1e-9 && Math.abs(dy - Math.round(dy)) < 1e-9) {
+    return translateSurface(src, Math.round(dx), Math.round(dy));
+  }
+  let srcRect = given ? intersect(given, given) : contentBounds(src);
+  if (!srcRect) return empty;
+  let H = h;
+  let S = src;
+  if (interp === "bicubic") {
+    const inv0 = invertHomography(H);
+    const c = applyHomography(H, { x: srcRect.x + srcRect.width / 2, y: srcRect.y + srcRect.height / 2 });
+    if (inv0 && c) {
+      const [su, sv] = inverseStretch(inv0, c.x, c.y);
+      const kx = reduction(su);
+      const ky = reduction(sv);
+      if (kx > 1 || ky > 1) {
+        const red = boxReduce(src, srcRect, kx, ky);
+        S = red.surface;
+        srcRect = red.rect;
+        H = multiplyHomographies([kx, 0, 0, 0, ky, 0, 0, 0, 1], H);
+      }
+    }
+  }
+  const inv = invertHomography(H);
+  if (!inv) return empty;
+  const sr = srcRect;
+  const fwd = [
+    { x: sr.x - 1, y: sr.y - 1 },
+    { x: sr.x + sr.width + 1, y: sr.y - 1 },
+    { x: sr.x + sr.width + 1, y: sr.y + sr.height + 1 },
+    { x: sr.x - 1, y: sr.y + sr.height + 1 }
+  ].map((p) => homographyW(H, p));
+  const side = fwd.every((w) => w > 0) ? 1 : fwd.every((w) => w < 0) ? -1 : 0;
+  const wLo = 1 / fwd.reduce((m, w) => Math.max(m, Math.abs(w)), 0);
+  const front = side === 0 ? homographyFrontSide(H, sr) : 0;
+  const corners = boxQuad(sr).map((p) => applyHomography(H, p));
+  const bounds = corners.every(Boolean) ? cornerBounds(corners) : null;
+  let dst;
+  if (options.clip && bounds && side !== 0) dst = intersect(bounds, options.clip);
+  else dst = options.clip ?? bounds;
+  if (!dst) return empty;
+  if (!options.clip) checkBudget(dst);
+  const affine = Math.abs(inv[6]) < 1e-15 && Math.abs(inv[7]) < 1e-15;
+  const [su0, sv0] = inverseStretch(inv, dst.x + dst.width / 2, dst.y + dst.height / 2);
+  const widen = (s) => interp === "bicubic" ? Math.min(4, Math.max(1, s)) : 1;
+  const maxWiden = interp === "bicubic" ? 4 : 1;
+  const pad = 3 + Math.ceil(2 * maxWiden);
+  const margin = interp === "bicubic" ? Math.max(1, widen(su0), widen(sv0)) : 1;
+  const tiles = /* @__PURE__ */ new Map();
+  const acc = new Float64Array(4);
+  const sx0 = sr.x;
+  const sy0 = sr.y;
+  const sx1 = sr.x + sr.width - 1;
+  const sy1 = sr.y + sr.height - 1;
+  for (const { tx, ty } of tilesInRect(dst)) {
+    const t = intersect({ x: tx * TILE, y: ty * TILE, width: TILE, height: TILE }, dst);
+    if (!t) continue;
+    const tc = [
+      { x: t.x, y: t.y },
+      { x: t.x + t.width, y: t.y },
+      { x: t.x + t.width, y: t.y + t.height },
+      { x: t.x, y: t.y + t.height }
+    ];
+    const wc = tc.map((p) => homographyW(inv, p));
+    let poly = tc;
+    if (side !== 0) {
+      const dd = wc.map((w) => side * w - wLo);
+      poly = [];
+      for (let i = 0; i < 4; i++) {
+        const p = tc[i];
+        const q = tc[(i + 1) % 4];
+        const dp = dd[i];
+        const dq = dd[(i + 1) % 4];
+        if (dp >= 0) poly.push(p);
+        if (dp >= 0 !== dq >= 0) {
+          const k = dp / (dp - dq);
+          poly.push({ x: p.x + (q.x - p.x) * k, y: p.y + (q.y - p.y) * k });
+        }
+      }
+    }
+    if (!poly.length) continue;
+    const straddles = side === 0 && wc.some((w) => w <= 0) && wc.some((w) => w >= 0);
+    let foot;
+    if (straddles) foot = sr;
+    else {
+      const fp = poly.map((p) => applyHomography(inv, p));
+      if (fp.some((p) => !p)) foot = sr;
+      else {
+        const xs = fp.map((p) => p.x);
+        const ys = fp.map((p) => p.y);
+        const fx0 = Math.floor(Math.min(...xs)) - pad;
+        const fy0 = Math.floor(Math.min(...ys)) - pad;
+        const fx1 = Math.ceil(Math.max(...xs)) + pad;
+        const fy1 = Math.ceil(Math.max(...ys)) + pad;
+        foot = intersect({ x: fx0, y: fy0, width: fx1 - fx0, height: fy1 - fy0 }, { x: sr.x - pad, y: sr.y - pad, width: sr.width + 2 * pad, height: sr.height + 2 * pad });
+      }
+    }
+    if (!foot) continue;
+    const readable = intersect(foot, sr);
+    if (!readable || !hasTilesIn(S, readable)) continue;
+    const win = readWindow(S, sr, foot);
+    const out = new Uint8ClampedArray(TILE * TILE * ch);
+    if (def) out.fill(def);
+    let any = false;
+    const ox = tx * TILE;
+    const oy = ty * TILE;
+    let su = widen(su0);
+    let sv = widen(sv0);
+    const ystart = t.y - ((t.y - oy) % step + step) % step;
+    const xstart = t.x - ((t.x - ox) % step + step) % step;
+    const blocks = Math.ceil((t.x + t.width - xstart) / step);
+    const words = ch === 4 ? new Uint32Array(out.buffer) : null;
+    const rowVals = new Float64Array(blocks);
+    const rowSet = new Uint8Array(blocks);
+    for (let y = ystart; y < t.y + t.height; y += step) {
+      const Y = y + step / 2;
+      let anyInRow = false;
+      for (let bi = 0, x = xstart; bi < blocks; bi++, x += step) {
+        rowSet[bi] = 0;
+        const X = x + step / 2;
+        const w = inv[6] * X + inv[7] * Y + inv[8];
+        if (front !== 0 && front * w <= 0) continue;
+        const u = (inv[0] * X + inv[1] * Y + inv[2]) / w - 0.5;
+        const v = (inv[3] * X + inv[4] * Y + inv[5]) / w - 0.5;
+        if (!(u >= sx0 - margin && v >= sy0 - margin && u <= sx1 + margin && v <= sy1 + margin)) continue;
+        if (!affine && interp === "bicubic") {
+          const s = inverseStretch(inv, X, Y);
+          su = widen(s[0]);
+          sv = widen(s[1]);
+        }
+        sample(win, interp, u, v, su, sv, acc);
+        if (!store(scratch, 0, acc, ch, def)) continue;
+        rowSet[bi] = 1;
+        rowVals[bi] = ch === 4 ? scratchWord[0] : scratch[0];
+        anyInRow = true;
+      }
+      if (!anyInRow) continue;
+      any = true;
+      const y0 = Math.max(y, t.y);
+      const y1 = Math.min(y + step, t.y + t.height);
+      for (let yy = y0; yy < y1; yy++) {
+        const row = (yy - oy) * TILE - ox;
+        for (let bi = 0, x = xstart; bi < blocks; bi++, x += step) {
+          if (!rowSet[bi]) continue;
+          const x0 = Math.max(x, t.x);
+          const x1 = Math.min(x + step, t.x + t.width);
+          const val = rowVals[bi];
+          if (words) for (let xx = x0; xx < x1; xx++) words[row + xx] = val;
+          else for (let xx = x0; xx < x1; xx++) out[row + xx] = val;
+        }
+      }
+    }
+    if (!any) continue;
+    const tile = finishTile(out, ch, def);
+    if (tile) tiles.set(tileKey(tx, ty), tile);
+  }
+  return assemble(src, tiles);
+}
+var CELL = 4;
+var MAX_CELLS = 512;
+var MAX_SS = 8;
+function warpSurface(src, f, options = {}) {
+  const interp = options.interpolation ?? "bicubic";
+  const ch = src.channels;
+  const def = src.defaultValue;
+  const empty = emptySurface(ch, def);
+  const sr = options.source ? intersect(options.source, options.source) : contentBounds(src);
+  if (!sr) return empty;
+  const step = normalizeStep(options.step);
+  const nx = Math.min(MAX_CELLS, Math.max(1, Math.ceil(sr.width / CELL)));
+  const ny = Math.min(MAX_CELLS, Math.max(1, Math.ceil(sr.height / CELL)));
+  const w1 = nx + 1;
+  const dvx = new Float64Array(w1 * (ny + 1));
+  const dvy = new Float64Array(w1 * (ny + 1));
+  const svx = new Float64Array(w1 * (ny + 1));
+  const svy = new Float64Array(w1 * (ny + 1));
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (let j = 0; j <= ny; j++) {
+    for (let i = 0; i <= nx; i++) {
+      const k = j * w1 + i;
+      const sx = sr.x + sr.width * i / nx;
+      const sy = sr.y + sr.height * j / ny;
+      const d = f({ x: sx, y: sy });
+      if (!d || !Number.isFinite(d.x) || !Number.isFinite(d.y)) return empty;
+      dvx[k] = d.x;
+      dvy[k] = d.y;
+      svx[k] = sx;
+      svy[k] = sy;
+      if (d.x < x0) x0 = d.x;
+      if (d.y < y0) y0 = d.y;
+      if (d.x > x1) x1 = d.x;
+      if (d.y > y1) y1 = d.y;
+    }
+  }
+  const lim = 1 << 20;
+  const bx0 = Math.floor(Math.max(-lim, x0)) - 1;
+  const by0 = Math.floor(Math.max(-lim, y0)) - 1;
+  const full = { x: bx0, y: by0, width: Math.ceil(Math.min(lim, x1)) + 1 - bx0, height: Math.ceil(Math.min(lim, y1)) + 1 - by0 };
+  const dst = options.clip ? intersect(full, options.clip) : full;
+  if (!dst) return empty;
+  if (!options.clip) checkBudget(dst);
+  const triCount = nx * ny * 2;
+  const tris = new Int32Array(triCount * 3);
+  for (let j = 0, t = 0; j < ny; j++) {
+    for (let i = 0; i < nx; i++) {
+      const a = j * w1 + i;
+      tris[t++] = a;
+      tris[t++] = a + 1;
+      tris[t++] = a + w1 + 1;
+      tris[t++] = a;
+      tris[t++] = a + w1 + 1;
+      tris[t++] = a + w1;
+    }
+  }
+  const tx0 = Math.floor(dst.x / TILE);
+  const ty0 = Math.floor(dst.y / TILE);
+  const cols = Math.floor((dst.x + dst.width - 1) / TILE) - tx0 + 1;
+  const rows = Math.floor((dst.y + dst.height - 1) / TILE) - ty0 + 1;
+  const bins = Array.from({ length: cols * rows }, () => []);
+  for (let k = 0; k < triCount; k++) {
+    const a = tris[3 * k];
+    const b = tris[3 * k + 1];
+    const c = tris[3 * k + 2];
+    const tminx = Math.floor(Math.min(dvx[a], dvx[b], dvx[c]));
+    const tminy = Math.floor(Math.min(dvy[a], dvy[b], dvy[c]));
+    const tmaxx = Math.ceil(Math.max(dvx[a], dvx[b], dvx[c]));
+    const tmaxy = Math.ceil(Math.max(dvy[a], dvy[b], dvy[c]));
+    const cx0 = Math.max(0, Math.floor(Math.max(tminx, dst.x) / TILE) - tx0);
+    const cy0 = Math.max(0, Math.floor(Math.max(tminy, dst.y) / TILE) - ty0);
+    const cx1 = Math.min(cols - 1, Math.floor(Math.min(tmaxx, dst.x + dst.width - 1) / TILE) - tx0);
+    const cy1 = Math.min(rows - 1, Math.floor(Math.min(tmaxy, dst.y + dst.height - 1) / TILE) - ty0);
+    for (let cy = cy0; cy <= cy1; cy++) for (let cx = cx0; cx <= cx1; cx++) bins[cy * cols + cx].push(k);
+  }
+  const tiles = /* @__PURE__ */ new Map();
+  const acc = new Float64Array(4);
+  const one = new Float64Array(4);
+  const n = ch === 4 ? 4 : 2;
+  const count = (jx, jy) => interp === "nearest" ? 1 : Math.min(MAX_SS, Math.max(1, Math.round(Math.hypot(jx, jy))));
+  for (let cy = 0; cy < rows; cy++) {
+    for (let cx = 0; cx < cols; cx++) {
+      const list = bins[cy * cols + cx];
+      if (!list.length) continue;
+      const ttx = tx0 + cx;
+      const tty = ty0 + cy;
+      const t = intersect({ x: ttx * TILE, y: tty * TILE, width: TILE, height: TILE }, dst);
+      if (!t) continue;
+      const tw = t.width;
+      const th = t.height;
+      const us = new Float64Array(tw * th).fill(NaN);
+      const vs = new Float64Array(tw * th);
+      const owner = new Int32Array(tw * th);
+      const jac = new Float64Array(list.length * 4);
+      const ssx = new Int32Array(list.length);
+      const ssy = new Int32Array(list.length);
+      for (let li = 0; li < list.length; li++) {
+        const k = list[li];
+        const a = tris[3 * k];
+        const b = tris[3 * k + 1];
+        const c = tris[3 * k + 2];
+        const p0x = dvx[a];
+        const p0y = dvy[a];
+        const p1x = dvx[b];
+        const p1y = dvy[b];
+        const p2x = dvx[c];
+        const p2y = dvy[c];
+        const det = (p1x - p0x) * (p2y - p0y) - (p2x - p0x) * (p1y - p0y);
+        ssx[li] = 1;
+        ssy[li] = 1;
+        if (Math.abs(det) < 1e-12) continue;
+        const d1x = svx[b] - svx[a];
+        const d1y = svy[b] - svy[a];
+        const d2x = svx[c] - svx[a];
+        const d2y = svy[c] - svy[a];
+        const l1x = (p2y - p0y) / det;
+        const l1y = (p0x - p2x) / det;
+        const l2x = (p0y - p1y) / det;
+        const l2y = (p1x - p0x) / det;
+        const cap = (vx, vy) => {
+          const l = Math.hypot(vx, vy);
+          return l > MAX_SS ? [vx * MAX_SS / l, vy * MAX_SS / l] : [vx, vy];
+        };
+        const jx = cap(l1x * d1x + l2x * d2x, l1x * d1y + l2x * d2y);
+        const jy = cap(l1y * d1x + l2y * d2x, l1y * d1y + l2y * d2y);
+        const cnx = count(jx[0], jx[1]);
+        const cny = count(jy[0], jy[1]);
+        if (cnx * cny > 1) {
+          jac[li * 4] = jx[0];
+          jac[li * 4 + 1] = jx[1];
+          jac[li * 4 + 2] = jy[0];
+          jac[li * 4 + 3] = jy[1];
+          ssx[li] = cnx;
+          ssy[li] = cny;
+        }
+        const rx0 = Math.max(t.x, Math.floor(Math.min(p0x, p1x, p2x) - 0.5));
+        const ry0 = Math.max(t.y, Math.floor(Math.min(p0y, p1y, p2y) - 0.5));
+        const rx1 = Math.min(t.x + tw, Math.ceil(Math.max(p0x, p1x, p2x) + 0.5));
+        const ry1 = Math.min(t.y + th, Math.ceil(Math.max(p0y, p1y, p2y) + 0.5));
+        const eps = -1e-9;
+        const ay0 = step === 1 ? ry0 : ry0 + ((t.y - ry0) % step + step) % step;
+        const ax0 = step === 1 ? rx0 : rx0 + ((t.x - rx0) % step + step) % step;
+        for (let y = ay0; y < ry1; y += step) {
+          const py = y + 0.5;
+          for (let x = ax0; x < rx1; x += step) {
+            const px = x + 0.5;
+            const l1 = ((px - p0x) * (p2y - p0y) - (p2x - p0x) * (py - p0y)) / det;
+            const l2 = ((p1x - p0x) * (py - p0y) - (px - p0x) * (p1y - p0y)) / det;
+            const l0 = 1 - l1 - l2;
+            if (l0 < eps || l1 < eps || l2 < eps) continue;
+            const o = (y - t.y) * tw + (x - t.x);
+            us[o] = l0 * svx[a] + l1 * svx[b] + l2 * svx[c];
+            vs[o] = l0 * svy[a] + l1 * svy[b] + l2 * svy[c];
+            owner[o] = li;
+          }
+        }
+      }
+      let fx0 = Infinity;
+      let fy0 = Infinity;
+      let fx1 = -Infinity;
+      let fy1 = -Infinity;
+      for (let o = 0; o < us.length; o++) {
+        const u = us[o];
+        if (Number.isNaN(u)) continue;
+        const li = owner[o];
+        const ex = 0.5 * (Math.abs(jac[li * 4]) + Math.abs(jac[li * 4 + 2]));
+        const ey = 0.5 * (Math.abs(jac[li * 4 + 1]) + Math.abs(jac[li * 4 + 3]));
+        if (u - ex < fx0) fx0 = u - ex;
+        if (vs[o] - ey < fy0) fy0 = vs[o] - ey;
+        if (u + ex > fx1) fx1 = u + ex;
+        if (vs[o] + ey > fy1) fy1 = vs[o] + ey;
+      }
+      if (fx0 > fx1) continue;
+      const foot = intersect({ x: Math.floor(fx0) - 3, y: Math.floor(fy0) - 3, width: Math.ceil(fx1) - Math.floor(fx0) + 6, height: Math.ceil(fy1) - Math.floor(fy0) + 6 }, sr);
+      if (!foot || !hasTilesIn(src, foot)) continue;
+      const win = readWindow(src, sr, foot);
+      const out = new Uint8ClampedArray(TILE * TILE * ch);
+      if (def) out.fill(def);
+      let any = false;
+      const ox = ttx * TILE;
+      const oy = tty * TILE;
+      const pointAt = (o, into) => {
+        const li = owner[o];
+        const cnx = ssx[li];
+        const cny = ssy[li];
+        if (cnx * cny === 1) {
+          sample(win, interp, us[o] - 0.5, vs[o] - 0.5, 1, 1, into);
+          return;
+        }
+        for (let c = 0; c < n; c++) into[c] = 0;
+        const j0 = jac[li * 4];
+        const j1 = jac[li * 4 + 1];
+        const j2 = jac[li * 4 + 2];
+        const j3 = jac[li * 4 + 3];
+        for (let sy = 0; sy < cny; sy++) {
+          const tt = (sy + 0.5) / cny - 0.5;
+          for (let sx = 0; sx < cnx; sx++) {
+            const s = (sx + 0.5) / cnx - 0.5;
+            sample(win, "bilinear", us[o] + s * j0 + tt * j2 - 0.5, vs[o] + s * j1 + tt * j3 - 0.5, 1, 1, one);
+            for (let c = 0; c < n; c++) into[c] += one[c];
+          }
+        }
+        const k = 1 / (cnx * cny);
+        for (let c = 0; c < n; c++) into[c] *= k;
+      };
+      if (step === 1) {
+        for (let o = 0; o < us.length; o++) {
+          if (Number.isNaN(us[o])) continue;
+          pointAt(o, acc);
+          const x = t.x + o % tw;
+          const y = t.y + Math.floor(o / tw);
+          if (store(out, ((y - oy) * TILE + (x - ox)) * ch, acc, ch, def)) any = true;
+        }
+      } else {
+        for (let by = 0; by < th; by += step) {
+          for (let bx = 0; bx < tw; bx += step) {
+            const o = by * tw + bx;
+            if (Number.isNaN(us[o])) continue;
+            pointAt(o, acc);
+            const first = ((t.y + by - oy) * TILE + (t.x + bx - ox)) * ch;
+            if (!store(out, first, acc, ch, def)) continue;
+            any = true;
+            for (let yy = by; yy < Math.min(th, by + step); yy++) {
+              const row = ((t.y + yy - oy) * TILE + (t.x - ox)) * ch;
+              for (let xx = bx; xx < Math.min(tw, bx + step); xx++) for (let c = 0; c < ch; c++) out[row + xx * ch + c] = out[first + c];
+            }
+          }
+        }
+      }
+      if (!any) continue;
+      const tile = finishTile(out, ch, def);
+      if (tile) tiles.set(tileKey(ttx, tty), tile);
+    }
+  }
+  return assemble(src, tiles);
+}
+function compositeSurfaceOver(base, top) {
+  if (top.channels !== 4) throw new Error("compositeSurfaceOver: top must be RGBA");
+  if (!top.tiles.size) return base;
+  const ch = base.channels;
+  const tiles = new Map(base.tiles);
+  for (const [key, t] of top.tiles) {
+    const under = base.tiles.get(key);
+    if (!under && ch === 4) {
+      tiles.set(key, t);
+      continue;
+    }
+    const d = new Uint8ClampedArray(TILE * TILE * ch);
+    if (under) d.set(under.data);
+    else if (base.defaultValue) d.fill(base.defaultValue);
+    const s = t.data;
+    if (ch === 4) {
+      for (let i = 0; i < d.length; i += 4) {
+        const ta = s[i + 3] / 255;
+        if (ta <= 0) continue;
+        if (ta >= 1) {
+          d[i] = s[i];
+          d[i + 1] = s[i + 1];
+          d[i + 2] = s[i + 2];
+          d[i + 3] = 255;
+          continue;
+        }
+        const da = d[i + 3] / 255;
+        const oa = ta + da * (1 - ta);
+        for (let c = 0; c < 3; c++) d[i + c] = (s[i + c] * ta + d[i + c] * da * (1 - ta)) / oa;
+        d[i + 3] = oa * 255;
+      }
+    } else {
+      for (let p = 0, i = 0; p < d.length; p++, i += 4) {
+        const ta = s[i + 3] / 255;
+        if (ta > 0) d[p] = s[i] * ta + d[p] * (1 - ta);
+      }
+    }
+    const tile = finishTile(d, ch, base.defaultValue);
+    if (tile) tiles.set(key, tile);
+    else tiles.delete(key);
+  }
+  return new TiledSurface(ch, tiles, base.defaultValue);
+}
+
 // src/raster/zlib.ts
 var LENGTH_BASE = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
 var LENGTH_EXTRA = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
@@ -3525,7 +4454,7 @@ function decodePng(bytes, options = {}) {
       lines[dst + x] = r & 255;
     }
   }
-  const sample = (y, i) => {
+  const sample2 = (y, i) => {
     const row = y * stride;
     if (depth === 8) return lines[row + i];
     if (depth === 16) return lines[row + i * 2];
@@ -3544,36 +4473,36 @@ function decodePng(bytes, options = {}) {
     for (let x = 0; x < width; x++) {
       const d = (y * width + x) * channels;
       if (type === 0) {
-        const v = sample(y, x);
+        const v = sample2(y, x);
         if (gray) out[d] = v;
         else {
           out[d] = out[d + 1] = out[d + 2] = v;
           out[d + 3] = v === trnsGray && trns ? 0 : 255;
         }
       } else if (type === 2) {
-        const r = sample(y, x * 3);
-        const g = sample(y, x * 3 + 1);
-        const b = sample(y, x * 3 + 2);
+        const r = sample2(y, x * 3);
+        const g = sample2(y, x * 3 + 1);
+        const b = sample2(y, x * 3 + 2);
         out[d] = r;
         out[d + 1] = g;
         out[d + 2] = b;
         out[d + 3] = trnsRgb && r === trnsRgb[0] && g === trnsRgb[1] && b === trnsRgb[2] ? 0 : 255;
       } else if (type === 3) {
-        const i = sample(y, x);
+        const i = sample2(y, x);
         if (!palette || i * 3 + 2 >= palette.length) throw new Error("PNG palette index out of range.");
         out[d] = palette[i * 3];
         out[d + 1] = palette[i * 3 + 1];
         out[d + 2] = palette[i * 3 + 2];
         out[d + 3] = trns && i < trns.length ? trns[i] : 255;
       } else if (type === 4) {
-        const v = sample(y, x * 2);
+        const v = sample2(y, x * 2);
         out[d] = out[d + 1] = out[d + 2] = v;
-        out[d + 3] = sample(y, x * 2 + 1);
+        out[d + 3] = sample2(y, x * 2 + 1);
       } else {
-        out[d] = sample(y, x * 4);
-        out[d + 1] = sample(y, x * 4 + 1);
-        out[d + 2] = sample(y, x * 4 + 2);
-        out[d + 3] = sample(y, x * 4 + 3);
+        out[d] = sample2(y, x * 4);
+        out[d + 1] = sample2(y, x * 4 + 1);
+        out[d + 2] = sample2(y, x * 4 + 2);
+        out[d + 3] = sample2(y, x * 4 + 3);
       }
     }
   }
@@ -3689,12 +4618,23 @@ export {
   activeEffectItems,
   effectsAreLocal,
   buildEffectMaps,
+  patchEffectMaps,
   gradientT,
   compositeLayerEffects,
   renderLayerEffects,
   blendTile,
   RasterCompositor,
   changedTiles,
+  INTERPOLATIONS,
+  isInterpolation,
+  MAX_TRANSFORM_PIXELS,
+  TransformTooLargeError,
+  keysWeight,
+  reduceSurface,
+  transformedBounds,
+  transformSurface,
+  warpSurface,
+  compositeSurfaceOver,
   ZlibError,
   inflateRaw,
   adler32,
@@ -3709,4 +4649,4 @@ export {
   parseDataUrl,
   pngDataUrl
 };
-//# sourceMappingURL=chunk-KFTQ2PKP.js.map
+//# sourceMappingURL=chunk-WIR377F6.js.map