@pixerate/editor 0.206.0 → 0.208.0

package/dist/{chunk-YXKLVD56.js → chunk-F7YA3MMC.js}

@@ -20,13 +20,13 @@ import {
   randSigned,
   rasterizeDab,
   readPaintSource
-} from "./chunk-2N2QPO3H.js";
+} from "./chunk-2PBZBRP5.js";
 import {
   TILE,
   TiledSurface,
   finishTile,
   tileKey
-} from "./chunk-H367YTXI.js";
+} from "./chunk-HVVR5PZW.js";
 
 // src/paint-editor/paper.ts
 var PAPER_FAMILIES = ["watercolor", "drawing", "pastel", "canvas", "panel", "smooth"];

package/dist/{chunk-ZZGPYNS2.js → chunk-G4E6RUPC.js}

@@ -74,7 +74,7 @@ function profileAlongPolyline(points, values, count = 32) {
 var round3 = (v) => Math.round(v * 1e3) / 1e3;
 var loading = null;
 function loadCanvasBrushstrokeRenderer() {
-  loading ??= import("./brushstrokeRender-7LXCU7PD.js").catch((error) => {
+  loading ??= import("./brushstrokeRender-C3UU6GVC.js").catch((error) => {
     loading = null;
     throw error;
   });

package/dist/chunk-HVVR5PZW.js

@@ -0,0 +1,384 @@
+// src/raster/surface.ts
+var TILE = 256;
+var TILE_SHIFT = 8;
+var TILE_PIXELS = TILE * TILE;
+var KEY_OFFSET = 1 << 15;
+var KEY_SPAN = 1 << 16;
+function tileKey(tx, ty) {
+  return (ty + KEY_OFFSET) * KEY_SPAN + (tx + KEY_OFFSET);
+}
+function tileCoord(key) {
+  return { tx: key % KEY_SPAN - KEY_OFFSET, ty: Math.floor(key / KEY_SPAN) - KEY_OFFSET };
+}
+function tileRect(tx, ty) {
+  return { x: tx * TILE, y: ty * TILE, width: TILE, height: TILE };
+}
+var nextSurfaceId = 1;
+var TiledSurface = class {
+  constructor(channels, tiles, defaultValue = 0) {
+    this.channels = channels;
+    this.tiles = tiles;
+    this.defaultValue = defaultValue;
+  }
+  channels;
+  tiles;
+  defaultValue;
+  /** Unique per instance: a cache key that changes whenever the pixels can have changed. */
+  id = nextSurfaceId++;
+  boundsCache;
+  /** Bounds of the stored (non-default) tiles, tile-aligned; `null` when there are none. */
+  get bounds() {
+    if (this.boundsCache === void 0) this.boundsCache = tileUnion(this.tiles.keys());
+    return this.boundsCache;
+  }
+  get tileCount() {
+    return this.tiles.size;
+  }
+  getTile(tx, ty) {
+    return this.tiles.get(tileKey(tx, ty));
+  }
+};
+function tileUnion(keys) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const key of keys) {
+    const { tx, ty } = tileCoord(key);
+    if (tx < x0) x0 = tx;
+    if (ty < y0) y0 = ty;
+    if (tx > x1) x1 = tx;
+    if (ty > y1) y1 = ty;
+  }
+  if (x0 === Infinity) return null;
+  return { x: x0 * TILE, y: y0 * TILE, width: (x1 - x0 + 1) * TILE, height: (y1 - y0 + 1) * TILE };
+}
+var uniformTiles = /* @__PURE__ */ new Map();
+var UNIFORM_LIMIT = 64;
+function packPixel(data, offset, channels) {
+  return channels === 1 ? data[offset] : (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
+}
+function uniformTile(channels, value) {
+  const key = `${channels}:${value}`;
+  let tile = uniformTiles.get(key);
+  if (tile) return tile;
+  const data = new Uint8ClampedArray(TILE_PIXELS * channels);
+  if (channels === 1) data.fill(value);
+  else if (value !== 0) {
+    const r = value >>> 24;
+    const g = value >>> 16 & 255;
+    const b = value >>> 8 & 255;
+    const a = value & 255;
+    for (let i = 0; i < data.length; i += 4) {
+      data[i] = r;
+      data[i + 1] = g;
+      data[i + 2] = b;
+      data[i + 3] = a;
+    }
+  }
+  tile = { data, uniform: value };
+  if (uniformTiles.size >= UNIFORM_LIMIT) uniformTiles.delete(uniformTiles.keys().next().value);
+  uniformTiles.set(key, tile);
+  return tile;
+}
+function packRgba(r, g, b, a) {
+  return (r << 24 | g << 16 | b << 8 | a) >>> 0;
+}
+function defaultPacked(channels, defaultValue) {
+  return channels === 1 ? defaultValue : packRgba(defaultValue, defaultValue, defaultValue, defaultValue);
+}
+function uniformValue(data, channels) {
+  if (channels === 1) {
+    const v = data[0];
+    for (let i = 1; i < data.length; i++) if (data[i] !== v) return null;
+    return v;
+  }
+  const words = new Uint32Array(data.buffer, data.byteOffset, data.length >> 2);
+  const w = words[0];
+  for (let i = 1; i < words.length; i++) if (words[i] !== w) return null;
+  return packPixel(data, 0, 4);
+}
+function finishTile(data, channels, defaultValue) {
+  const u = uniformValue(data, channels);
+  if (u === null) return { data, uniform: null };
+  if (u === defaultPacked(channels, defaultValue)) return null;
+  return uniformTile(channels, u);
+}
+function emptySurface(channels = 4, defaultValue = 0) {
+  return new TiledSurface(channels, /* @__PURE__ */ new Map(), defaultValue);
+}
+function solidSurface(channels, rect, value, defaultValue = 0) {
+  const bytes = new Uint8ClampedArray(channels);
+  if (channels === 1) bytes[0] = value;
+  else {
+    bytes[0] = value >>> 24;
+    bytes[1] = value >>> 16 & 255;
+    bytes[2] = value >>> 8 & 255;
+    bytes[3] = value & 255;
+  }
+  return fillRect(emptySurface(channels, defaultValue), rect, bytes);
+}
+function surfaceFromPixels(pixels, channels = 4, x = 0, y = 0, defaultValue = 0) {
+  return writeRegion(emptySurface(channels, defaultValue), { x, y, width: pixels.width, height: pixels.height }, pixels.data);
+}
+function tilesInRect(rect) {
+  const out = [];
+  if (rect.width <= 0 || rect.height <= 0) return out;
+  const tx0 = Math.floor(rect.x / TILE);
+  const ty0 = Math.floor(rect.y / TILE);
+  const tx1 = Math.floor((rect.x + rect.width - 1) / TILE);
+  const ty1 = Math.floor((rect.y + rect.height - 1) / TILE);
+  for (let ty = ty0; ty <= ty1; ty++) for (let tx = tx0; tx <= tx1; tx++) out.push({ tx, ty });
+  return out;
+}
+function readRegion(surface, rect, out) {
+  const ch = surface.channels;
+  const w = rect.width;
+  const h = rect.height;
+  const dst = out ?? new Uint8ClampedArray(w * h * ch);
+  if (surface.defaultValue !== 0) dst.fill(surface.defaultValue);
+  else if (out) dst.fill(0);
+  for (const { tx, ty } of tilesInRect(rect)) {
+    const tile = surface.getTile(tx, ty);
+    if (!tile) continue;
+    const ox = tx * TILE;
+    const oy = ty * TILE;
+    const x0 = Math.max(rect.x, ox);
+    const y0 = Math.max(rect.y, oy);
+    const x1 = Math.min(rect.x + w, ox + TILE);
+    const y1 = Math.min(rect.y + h, oy + TILE);
+    const span = (x1 - x0) * ch;
+    for (let yy = y0; yy < y1; yy++) {
+      const s = ((yy - oy) * TILE + (x0 - ox)) * ch;
+      const d = ((yy - rect.y) * w + (x0 - rect.x)) * ch;
+      dst.set(tile.data.subarray(s, s + span), d);
+    }
+  }
+  return dst;
+}
+function readPixel(surface, x, y) {
+  const tile = surface.getTile(Math.floor(x / TILE), Math.floor(y / TILE));
+  const ch = surface.channels;
+  if (!tile) return new Array(ch).fill(surface.defaultValue);
+  const i = ((y & TILE - 1) * TILE + (x & TILE - 1)) * ch;
+  return Array.from(tile.data.subarray(i, i + ch));
+}
+function contentBounds(surface) {
+  const ch = surface.channels;
+  const def = surface.defaultValue;
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const [key, tile] of surface.tiles) {
+    const { tx, ty } = tileCoord(key);
+    const ox = tx * TILE;
+    const oy = ty * TILE;
+    if (tile.uniform !== null) {
+      if (ox < x0) x0 = ox;
+      if (oy < y0) y0 = oy;
+      if (ox + TILE - 1 > x1) x1 = ox + TILE - 1;
+      if (oy + TILE - 1 > y1) y1 = oy + TILE - 1;
+      continue;
+    }
+    const d = tile.data;
+    for (let y = 0; y < TILE; y++) {
+      let first = -1;
+      let last = -1;
+      const row = y * TILE * ch;
+      for (let x = 0; x < TILE; x++) {
+        const i = row + x * ch;
+        let differs = false;
+        for (let c = 0; c < ch; c++) if (d[i + c] !== def) differs = true;
+        if (differs) {
+          if (first < 0) first = x;
+          last = x;
+        }
+      }
+      if (first < 0) continue;
+      if (ox + first < x0) x0 = ox + first;
+      if (ox + last > x1) x1 = ox + last;
+      if (oy + y < y0) y0 = oy + y;
+      if (oy + y > y1) y1 = oy + y;
+    }
+  }
+  if (x0 === Infinity) return null;
+  return { x: x0, y: y0, width: x1 - x0 + 1, height: y1 - y0 + 1 };
+}
+var SurfaceDraft = class {
+  constructor(base) {
+    this.base = base;
+  }
+  base;
+  copies = /* @__PURE__ */ new Map();
+  get channels() {
+    return this.base.channels;
+  }
+  /** The writable data of tile (tx, ty), copied from the base on first use. */
+  tile(tx, ty) {
+    const key = tileKey(tx, ty);
+    let data = this.copies.get(key);
+    if (data) return data;
+    const src = this.base.tiles.get(key);
+    if (src) data = new Uint8ClampedArray(src.data);
+    else {
+      data = new Uint8ClampedArray(TILE_PIXELS * this.base.channels);
+      if (this.base.defaultValue !== 0) data.fill(this.base.defaultValue);
+    }
+    this.copies.set(key, data);
+    return data;
+  }
+  /** Replaces a whole tile with `data` (owned by the draft from now on). */
+  replace(tx, ty, data) {
+    this.copies.set(tileKey(tx, ty), data);
+  }
+  /** The current data of a tile without copying it (base tile, draft copy or `null` for default). */
+  peek(tx, ty) {
+    const key = tileKey(tx, ty);
+    return this.copies.get(key) ?? this.base.tiles.get(key)?.data ?? null;
+  }
+  /** Keys of the tiles changed so far. */
+  get touched() {
+    return [...this.copies.keys()];
+  }
+  /** A new surface with the draft's tiles; the draft must not be used afterwards. */
+  commit() {
+    if (!this.copies.size) return this.base;
+    const tiles = new Map(this.base.tiles);
+    const { channels, defaultValue } = this.base;
+    for (const [key, data] of this.copies) {
+      const tile = finishTile(data, channels, defaultValue);
+      if (tile) tiles.set(key, tile);
+      else tiles.delete(key);
+    }
+    return new TiledSurface(channels, tiles, defaultValue);
+  }
+};
+function writeRegion(surface, rect, data) {
+  const ch = surface.channels;
+  const w = rect.width;
+  const h = rect.height;
+  if (w <= 0 || h <= 0) return surface;
+  if (data.length < w * h * ch) throw new Error(`writeRegion: expected ${w * h * ch} bytes, got ${data.length}`);
+  const draft = new SurfaceDraft(surface);
+  const src = data;
+  const canSubarray = typeof src.subarray === "function";
+  for (const { tx, ty } of tilesInRect(rect)) {
+    const ox = tx * TILE;
+    const oy = ty * TILE;
+    const x0 = Math.max(rect.x, ox);
+    const y0 = Math.max(rect.y, oy);
+    const x1 = Math.min(rect.x + w, ox + TILE);
+    const y1 = Math.min(rect.y + h, oy + TILE);
+    const full = x0 === ox && y0 === oy && x1 === ox + TILE && y1 === oy + TILE;
+    const t = full ? new Uint8ClampedArray(TILE_PIXELS * ch) : draft.tile(tx, ty);
+    const span = (x1 - x0) * ch;
+    for (let yy = y0; yy < y1; yy++) {
+      const s = ((yy - rect.y) * w + (x0 - rect.x)) * ch;
+      const d = ((yy - oy) * TILE + (x0 - ox)) * ch;
+      if (canSubarray) t.set(src.subarray(s, s + span), d);
+      else for (let k = 0; k < span; k++) t[d + k] = src[s + k];
+    }
+    if (full) draft.replace(tx, ty, t);
+  }
+  return draft.commit();
+}
+function fillRect(surface, rect, bytes) {
+  const ch = surface.channels;
+  if (rect.width <= 0 || rect.height <= 0) return surface;
+  const tiles = new Map(surface.tiles);
+  const draft = new SurfaceDraft(surface);
+  const value = packPixel(bytes, 0, ch);
+  const isDefault = value === defaultPacked(ch, surface.defaultValue);
+  for (const { tx, ty } of tilesInRect(rect)) {
+    const ox = tx * TILE;
+    const oy = ty * TILE;
+    const x0 = Math.max(rect.x, ox);
+    const y0 = Math.max(rect.y, oy);
+    const x1 = Math.min(rect.x + rect.width, ox + TILE);
+    const y1 = Math.min(rect.y + rect.height, oy + TILE);
+    const key = tileKey(tx, ty);
+    if (x0 === ox && y0 === oy && x1 === ox + TILE && y1 === oy + TILE) {
+      if (isDefault) tiles.delete(key);
+      else tiles.set(key, uniformTile(ch, value));
+      continue;
+    }
+    const t = draft.tile(tx, ty);
+    for (let yy = y0; yy < y1; yy++) {
+      let d = ((yy - oy) * TILE + (x0 - ox)) * ch;
+      for (let xx = x0; xx < x1; xx++, d += ch) for (let c = 0; c < ch; c++) t[d + c] = bytes[c];
+    }
+    const tile = finishTile(t, ch, surface.defaultValue);
+    if (tile) tiles.set(key, tile);
+    else tiles.delete(key);
+  }
+  return new TiledSurface(ch, tiles, surface.defaultValue);
+}
+function translateSurface(surface, dx, dy) {
+  dx = Math.round(dx);
+  dy = Math.round(dy);
+  if (!dx && !dy) return surface;
+  if (dx % TILE === 0 && dy % TILE === 0) {
+    const tiles = /* @__PURE__ */ new Map();
+    for (const [key, tile] of surface.tiles) {
+      const { tx, ty } = tileCoord(key);
+      tiles.set(tileKey(tx + dx / TILE, ty + dy / TILE), tile);
+    }
+    return new TiledSurface(surface.channels, tiles, surface.defaultValue);
+  }
+  const b = surface.bounds;
+  if (!b) return surface;
+  const data = readRegion(surface, b);
+  return writeRegion(emptySurface(surface.channels, surface.defaultValue), { ...b, x: b.x + dx, y: b.y + dy }, data);
+}
+function surfaceBytes(surface) {
+  let n = 0;
+  for (const tile of surface.tiles.values()) if (tile.uniform === null) n += tile.data.byteLength;
+  return n;
+}
+function collectTiles(surface, into) {
+  for (const tile of surface.tiles.values()) if (tile.uniform === null) into.add(tile);
+}
+function surfacesEqual(a, b) {
+  if (a === b) return true;
+  if (a.channels !== b.channels || a.defaultValue !== b.defaultValue || a.tiles.size !== b.tiles.size) return false;
+  for (const [key, ta] of a.tiles) {
+    const tb = b.tiles.get(key);
+    if (!tb) return false;
+    if (ta === tb) continue;
+    if (ta.uniform !== null || tb.uniform !== null) {
+      if (ta.uniform !== tb.uniform) return false;
+      continue;
+    }
+    const x = ta.data;
+    const y = tb.data;
+    for (let i = 0; i < x.length; i++) if (x[i] !== y[i]) return false;
+  }
+  return true;
+}
+
+export {
+  TILE,
+  TILE_SHIFT,
+  tileKey,
+  tileCoord,
+  tileRect,
+  TiledSurface,
+  uniformTile,
+  packRgba,
+  finishTile,
+  emptySurface,
+  solidSurface,
+  surfaceFromPixels,
+  tilesInRect,
+  readRegion,
+  readPixel,
+  contentBounds,
+  SurfaceDraft,
+  writeRegion,
+  fillRect,
+  translateSurface,
+  surfaceBytes,
+  collectTiles,
+  surfacesEqual
+};

package/dist/{chunk-FR2Q2LVF.cjs → chunk-I7G3RSUJ.cjs}

@@ -18,7 +18,7 @@
 
 
 
-var _chunkBRKVNXDZcjs = require('./chunk-BRKVNXDZ.cjs');
+var _chunkQAUIZPYIcjs = require('./chunk-QAUIZPYI.cjs');
 
 
 
@@ -37,7 +37,7 @@ var lerpP = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
 var toP = (v) => [v.x, v.y];
 var mapP = (m, p) => [m[0] * p[0] + m[2] * p[1] + m[4], m[1] * p[0] + m[3] * p[1] + m[5]];
 var curvesOf = (c) => Math.max(0, (c.pts.length - 1) / 3) | 0;
-function subpathToMorphContour(sp, m = _chunkBRKVNXDZcjs.IDENTITY_MATRIX) {
+function subpathToMorphContour(sp, m = _chunkQAUIZPYIcjs.IDENTITY_MATRIX) {
   const n = sp.anchors.length;
   if (!n) return null;
   const first = mapP(m, toP(sp.anchors[0]));
@@ -67,8 +67,8 @@ function isStraight(p0, p1, p2, p3) {
   const u2 = along(p2);
   return off(p1) < tol && off(p2) < tol && u1 >= -1e-9 && u1 <= 1 + 1e-9 && u2 >= -1e-9 && u2 <= 1 + 1e-9;
 }
-function morphContourToSubpath(c, m = _chunkBRKVNXDZcjs.IDENTITY_MATRIX, closed = c.closed) {
-  const pts = _chunkBRKVNXDZcjs.isIdentityMatrix.call(void 0, m) ? c.pts : c.pts.map((p) => mapP(m, p));
+function morphContourToSubpath(c, m = _chunkQAUIZPYIcjs.IDENTITY_MATRIX, closed = c.closed) {
+  const pts = _chunkQAUIZPYIcjs.isIdentityMatrix.call(void 0, m) ? c.pts : c.pts.map((p) => mapP(m, p));
   const curves = curvesOf(c);
   const dropLast = closed && c.closed && curves > 0;
   const count = dropLast ? curves : curves + 1;
@@ -84,7 +84,7 @@ function morphContourToSubpath(c, m = _chunkBRKVNXDZcjs.IDENTITY_MATRIX, closed
     anchors[(k + 1) % count].in = { x: p2[0], y: p2[1] };
   }
   for (const a of anchors) {
-    const type = _chunkBRKVNXDZcjs.inferAnchorType.call(void 0, a);
+    const type = _chunkQAUIZPYIcjs.inferAnchorType.call(void 0, a);
     if (type !== "corner") a.type = type;
   }
   const isClosed = closed && curves > 0;
@@ -267,7 +267,7 @@ function bestStart(fixed, free, useShapeContext) {
   return best;
 }
 function placeIn(c, from, to) {
-  const b = _chunkBRKVNXDZcjs.unionBounds.call(void 0, [boundsOfPoints(c.pts)]);
+  const b = _chunkQAUIZPYIcjs.unionBounds.call(void 0, [boundsOfPoints(c.pts)]);
   const p = b ? [b.x + b.width / 2, b.y + b.height / 2] : c.pts[0];
   if (!from || !to) return p;
   const fx = from.width > 0 ? (p[0] - from.x) / from.width : 0.5;
@@ -456,7 +456,7 @@ function interpolateVectorColor(a, b, t) {
 }
 function resampleGradientStops(g, offsets) {
   return offsets.map((offset) => {
-    const s = _chunkBRKVNXDZcjs.sampleVectorGradient.call(void 0, g, offset);
+    const s = _chunkQAUIZPYIcjs.sampleVectorGradient.call(void 0, g, offset);
     return s.opacity < 1 ? { offset, color: s.color, opacity: Math.round(s.opacity * 1e4) / 1e4 } : { offset, color: s.color };
   });
 }
@@ -467,11 +467,11 @@ function lerpAngle(a, b, t) {
 var lerpPoint = (a, b, t) => ({ x: lerpN(a.x, b.x, t), y: lerpN(a.y, b.y, t) });
 var sameColourModel = (a, b) => (_nullishCoalesce(a.interpolation, () => ( "srgb"))) === (_nullishCoalesce(b.interpolation, () => ( "srgb"))) && (_nullishCoalesce(a.smoothness, () => ( 0))) === (_nullishCoalesce(b.smoothness, () => ( 0)));
 function lerpStops(a, b, t) {
-  let stopsA = _chunkBRKVNXDZcjs.sortedVectorGradientStops.call(void 0, a);
-  let stopsB = _chunkBRKVNXDZcjs.sortedVectorGradientStops.call(void 0, b);
+  let stopsA = _chunkQAUIZPYIcjs.sortedVectorGradientStops.call(void 0, a);
+  let stopsB = _chunkQAUIZPYIcjs.sortedVectorGradientStops.call(void 0, b);
   const resampled = stopsA.length !== stopsB.length || !sameColourModel(a, b);
   if (resampled) {
-    const offs = [..._chunkBRKVNXDZcjs.expandVectorGradientStops.call(void 0, a), ..._chunkBRKVNXDZcjs.expandVectorGradientStops.call(void 0, b), ...stopsA, ...stopsB].map((s) => s.offset).filter(Number.isFinite).sort((x, y) => x - y);
+    const offs = [..._chunkQAUIZPYIcjs.expandVectorGradientStops.call(void 0, a), ..._chunkQAUIZPYIcjs.expandVectorGradientStops.call(void 0, b), ...stopsA, ...stopsB].map((s) => s.offset).filter(Number.isFinite).sort((x, y) => x - y);
     const common = offs.filter((o, i) => i === 0 || o - offs[i - 1] > 1e-4);
     stopsA = resampleGradientStops(a, common);
     stopsB = resampleGradientStops(b, common);
@@ -498,8 +498,8 @@ function lerpGradient(a, b, t) {
   }
   if (near.spread && near.spread !== "pad") out.spread = near.spread;
   if (near.strokeMode && near.strokeMode !== "within") out.strokeMode = near.strokeMode;
-  const ea = _chunkBRKVNXDZcjs.hasExplicitGradientGeometry.call(void 0, a);
-  const eb = _chunkBRKVNXDZcjs.hasExplicitGradientGeometry.call(void 0, b);
+  const ea = _chunkQAUIZPYIcjs.hasExplicitGradientGeometry.call(void 0, a);
+  const eb = _chunkQAUIZPYIcjs.hasExplicitGradientGeometry.call(void 0, b);
   if (!ea && !eb) {
     if (a.angle !== void 0 || b.angle !== void 0 || a.type === "linear" || a.type === "reflected") {
       const fallback = a.type === "linear" || a.type === "reflected" ? 180 : 90;
@@ -512,10 +512,10 @@ function lerpGradient(a, b, t) {
     }
     return out;
   }
-  const pa = _chunkBRKVNXDZcjs.vectorGradientPoints.call(void 0, a);
-  const pb = _chunkBRKVNXDZcjs.vectorGradientPoints.call(void 0, b);
+  const pa = _chunkQAUIZPYIcjs.vectorGradientPoints.call(void 0, a);
+  const pb = _chunkQAUIZPYIcjs.vectorGradientPoints.call(void 0, b);
   if (pa.units !== pb.units) {
-    const src = _chunkBRKVNXDZcjs.explicitVectorGradient.call(void 0, near);
+    const src = _chunkQAUIZPYIcjs.explicitVectorGradient.call(void 0, near);
     return { ...src, stops: out.stops, ...out.interpolation ? { interpolation: out.interpolation } : {}, ...out.smoothness ? { smoothness: out.smoothness } : {} };
   }
   out.start = lerpPoint(pa.start, pb.start, t);
@@ -535,14 +535,14 @@ function solidLike(color, like) {
 function interpolateVectorPaint(a, b, t) {
   if (t <= 0) return a;
   if (t >= 1) return b;
-  const pa = _chunkBRKVNXDZcjs.hasPaint.call(void 0, a);
-  const pb = _chunkBRKVNXDZcjs.hasPaint.call(void 0, b);
+  const pa = _chunkQAUIZPYIcjs.hasPaint.call(void 0, a);
+  const pb = _chunkQAUIZPYIcjs.hasPaint.call(void 0, b);
   if (!pa && !pb) return t < 0.5 ? a : b;
   if (typeof a === "string" && pa && typeof b === "string" && pb) return interpolateVectorColor(a, b, t);
   if (!pa && typeof b === "string") return interpolateVectorColor("transparent", b, t);
   if (!pb && typeof a === "string") return interpolateVectorColor(a, "transparent", t);
-  const ga = pa && _chunkBRKVNXDZcjs.isVectorGradient.call(void 0, a) ? a : null;
-  const gb = pb && _chunkBRKVNXDZcjs.isVectorGradient.call(void 0, b) ? b : null;
+  const ga = pa && _chunkQAUIZPYIcjs.isVectorGradient.call(void 0, a) ? a : null;
+  const gb = pb && _chunkQAUIZPYIcjs.isVectorGradient.call(void 0, b) ? b : null;
   if (ga && gb) return _nullishCoalesce(lerpGradient(ga, gb, t), () => ( (t < 0.5 ? a : b)));
   if (gb) return _nullishCoalesce(lerpGradient(solidLike(pa ? a : null, gb), gb, t), () => ( b));
   if (ga) return _nullishCoalesce(lerpGradient(ga, solidLike(pb ? b : null, ga), t), () => ( a));
@@ -553,8 +553,8 @@ function interpolateWidthProfiles(a, b, t) {
   const at = [..._nullishCoalesce(a, () => ( [])), ..._nullishCoalesce(b, () => ( [])), { t: 0 }, { t: 1 }].map((p) => p.t).sort((x, y) => x - y);
   const ts = at.filter((v, i) => i === 0 || v - at[i - 1] > 1e-6);
   return ts.map((pos) => {
-    const x = _chunkBRKVNXDZcjs.widthProfileAt.call(void 0, a, pos);
-    const y = _chunkBRKVNXDZcjs.widthProfileAt.call(void 0, b, pos);
+    const x = _chunkQAUIZPYIcjs.widthProfileAt.call(void 0, a, pos);
+    const y = _chunkQAUIZPYIcjs.widthProfileAt.call(void 0, b, pos);
     return { t: pos, left: lerpN(x.left, y.left, t), right: lerpN(x.right, y.right, t) };
   });
 }
@@ -597,7 +597,7 @@ function reversedStyle(s) {
   out.endArrow = s.startArrow;
   out.startArrowScale = s.endArrowScale;
   out.endArrowScale = s.startArrowScale;
-  if (_optionalChain([s, 'access', _6 => _6.strokeWidthProfile, 'optionalAccess', _7 => _7.length])) out.strokeWidthProfile = _chunkBRKVNXDZcjs.reverseWidthProfile.call(void 0, s.strokeWidthProfile);
+  if (_optionalChain([s, 'access', _6 => _6.strokeWidthProfile, 'optionalAccess', _7 => _7.length])) out.strokeWidthProfile = _chunkQAUIZPYIcjs.reverseWidthProfile.call(void 0, s.strokeWidthProfile);
   for (const k of ["startArrow", "endArrow", "startArrowScale", "endArrowScale"]) if (out[k] === void 0) delete out[k];
   return out;
 }
@@ -623,19 +623,19 @@ function styleOf(n) {
   return out;
 }
 function contoursOf(node, m) {
-  return _chunkBRKVNXDZcjs.expandVectorCorners.call(void 0, node.subpaths).map((sp) => subpathToMorphContour(sp, m)).filter((c) => !!c);
+  return _chunkQAUIZPYIcjs.expandVectorCorners.call(void 0, node.subpaths).map((sp) => subpathToMorphContour(sp, m)).filter((c) => !!c);
 }
-function preparePathMorph(a, b, options, ma = _chunkBRKVNXDZcjs.nodeMatrix.call(void 0, a), mb = _chunkBRKVNXDZcjs.nodeMatrix.call(void 0, b)) {
+function preparePathMorph(a, b, options, ma = _chunkQAUIZPYIcjs.nodeMatrix.call(void 0, a), mb = _chunkQAUIZPYIcjs.nodeMatrix.call(void 0, b)) {
   const corr = correspondMorphContours(contoursOf(a, ma), contoursOf(b, mb), options);
   const sim = procrustes(corr.a, corr.b);
   const styleA = styleOf(a);
   const styleB = corr.reversed ? reversedStyle(styleOf(b)) : styleOf(b);
-  const rigid = !_chunkBRKVNXDZcjs.isIdentityMatrix.call(void 0, ma) || !_chunkBRKVNXDZcjs.isIdentityMatrix.call(void 0, mb);
+  const rigid = !_chunkQAUIZPYIcjs.isIdentityMatrix.call(void 0, ma) || !_chunkQAUIZPYIcjs.isIdentityMatrix.call(void 0, mb);
   const id = _nullishCoalesce(options.id, () => ( a.id));
   return (t) => {
     const contours = interpolateMorphContours(corr.a, corr.b, t, { linear: options.linear, rigidity: options.rigidity, similarity: sim });
-    const m = rigid ? interpolateRigidMatrix(ma, mb, t) : _chunkBRKVNXDZcjs.IDENTITY_MATRIX;
-    const back = rigid ? _chunkBRKVNXDZcjs.invertMatrix.call(void 0, m) : _chunkBRKVNXDZcjs.IDENTITY_MATRIX;
+    const m = rigid ? interpolateRigidMatrix(ma, mb, t) : _chunkQAUIZPYIcjs.IDENTITY_MATRIX;
+    const back = rigid ? _chunkQAUIZPYIcjs.invertMatrix.call(void 0, m) : _chunkQAUIZPYIcjs.IDENTITY_MATRIX;
     const subpaths = contours.map((c, k) => {
       const closed = t <= 0 ? corr.a[k].closed : t >= 1 ? corr.b[k].closed : corr.a[k].closed && corr.b[k].closed;
       return morphContourToSubpath({ closed: corr.a[k].closed && corr.b[k].closed, pts: c.pts }, back, closed);
@@ -643,14 +643,14 @@ function preparePathMorph(a, b, options, ma = _chunkBRKVNXDZcjs.nodeMatrix.call(
     const node = { id, type: "path", subpaths, ...interpolateVectorStyle(styleA, styleB, t) };
     const opacity = lerpN(_nullishCoalesce(a.opacity, () => ( 1)), _nullishCoalesce(b.opacity, () => ( 1)), t);
     if (opacity < 1) node.opacity = opacity;
-    if (rigid && !_chunkBRKVNXDZcjs.isIdentityMatrix.call(void 0, m)) node.transform = m;
+    if (rigid && !_chunkQAUIZPYIcjs.isIdentityMatrix.call(void 0, m)) node.transform = m;
     return node;
   };
 }
-function flattenPaths(node, parent = _chunkBRKVNXDZcjs.IDENTITY_MATRIX) {
-  const m = _chunkBRKVNXDZcjs.multiplyMatrices.call(void 0, _chunkBRKVNXDZcjs.nodeMatrix.call(void 0, node), parent);
+function flattenPaths(node, parent = _chunkQAUIZPYIcjs.IDENTITY_MATRIX) {
+  const m = _chunkQAUIZPYIcjs.multiplyMatrices.call(void 0, _chunkQAUIZPYIcjs.nodeMatrix.call(void 0, node), parent);
   if (node.type === "path") return [{ path: node, m, opacity: 1 }];
-  if (node.type === "text" || node.type === "instance") return flattenPaths(_chunkBRKVNXDZcjs.expandVectorAppearance.call(void 0, node), parent);
+  if (node.type === "text" || node.type === "instance") return flattenPaths(_chunkQAUIZPYIcjs.expandVectorAppearance.call(void 0, node), parent);
   const o = _nullishCoalesce(node.opacity, () => ( 1));
   return node.children.filter((c) => c.visible !== false).flatMap((c) => flattenPaths(c, m)).map((e) => ({ ...e, opacity: e.opacity * o }));
 }
@@ -672,8 +672,8 @@ function createVectorMorph(a, b, options = {}) {
   }
   const pa = flattenPaths(a);
   const pb = flattenPaths(b);
-  const ba = _chunkBRKVNXDZcjs.unionBounds.call(void 0, pa.map((e) => placedBounds(e.path, e.m)));
-  const bb = _chunkBRKVNXDZcjs.unionBounds.call(void 0, pb.map((e) => placedBounds(e.path, e.m)));
+  const ba = _chunkQAUIZPYIcjs.unionBounds.call(void 0, pa.map((e) => placedBounds(e.path, e.m)));
+  const bb = _chunkQAUIZPYIcjs.unionBounds.call(void 0, pb.map((e) => placedBounds(e.path, e.m)));
   const id = _nullishCoalesce(options.id, () => ( a.id));
   const parts = [];
   const opacities = [];
@@ -685,10 +685,10 @@ function createVectorMorph(a, b, options = {}) {
       parts.push(preparePathMorph(x.path, y.path, sub, x.m, y.m));
       opacities.push([x.opacity, y.opacity]);
     } else if (x) {
-      parts.push(preparePathMorph(x.path, collapsedPath(x.path, x.m, ba, bb), sub, x.m, _chunkBRKVNXDZcjs.IDENTITY_MATRIX));
+      parts.push(preparePathMorph(x.path, collapsedPath(x.path, x.m, ba, bb), sub, x.m, _chunkQAUIZPYIcjs.IDENTITY_MATRIX));
       opacities.push([x.opacity, x.opacity]);
     } else if (y) {
-      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub, _chunkBRKVNXDZcjs.IDENTITY_MATRIX, y.m));
+      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub, _chunkQAUIZPYIcjs.IDENTITY_MATRIX, y.m));
       opacities.push([y.opacity, y.opacity]);
     }
   }