@pixerate/editor 0.248.0 → 0.250.0

package/dist/chunk-WKH5ZAUA.js

@@ -0,0 +1,302 @@
+import {
+  StickerError
+} from "./chunk-SZTI6EER.js";
+import {
+  hash2
+} from "./chunk-4D6KP5BV.js";
+
+// src/stickers/stamps.ts
+var STAMP_KINDS = ["dot", "star", "heart", "leaf", "flower", "confetti", "splat", "sparkle", "ring"];
+function stampCoverage(kind, u, v, t) {
+  const r = Math.hypot(u, v);
+  const a = Math.atan2(v, u);
+  const edge = (d) => Math.min(1, Math.max(0, d * 24 + 0.5));
+  switch (kind) {
+    case "dot":
+      return edge(0.95 - r);
+    case "ring":
+      return edge(Math.min(0.95 - r, r - 0.6));
+    case "star": {
+      const f = (a + Math.PI / 2) * 5 / (2 * Math.PI) % 1;
+      const notch = Math.min(f < 0 ? f + 1 : f, 1 - (f < 0 ? f + 1 : f)) * 2;
+      return edge(0.95 - 0.55 * notch - r);
+    }
+    case "sparkle": {
+      const q = Math.pow(Math.abs(u) / 0.95, 0.6) + Math.pow(Math.abs(v) / 0.95, 0.6);
+      return edge((1 - q) * 0.4);
+    }
+    case "heart": {
+      const x = u * 1.1;
+      const y = -v * 1.1 + 0.15;
+      const q = x * x + y * y - 0.55;
+      return edge(-(q * q * q - x * x * y * y * y) * 3);
+    }
+    case "leaf": {
+      const w = 0.42 * Math.sqrt(Math.max(0, 1 - u * u));
+      const inside = edge(w - Math.abs(v + 0.15 * u * u));
+      const rib = Math.abs(v + 0.15 * u * u) < 0.03 && Math.abs(u) < 0.85 ? 0.65 : 1;
+      return inside * rib;
+    }
+    case "flower": {
+      const petals = 0.6 + 0.35 * Math.abs(Math.cos(2.5 * a));
+      const body = edge(petals - r);
+      return r < 0.22 ? Math.max(body, 1) * 0.85 : body;
+    }
+    case "confetti": {
+      return edge(Math.min(0.9 - Math.abs(u), 0.35 - Math.abs(v)));
+    }
+    case "splat": {
+      let rr = 0.55;
+      for (let k = 1; k <= 3; k++) rr += 0.08 * Math.sin(a * (k + 2) + hash2(k, 1, t) * 6.28) / k;
+      let c = edge(rr - r);
+      for (let k = 0; k < 4; k++) {
+        const ang = hash2(k, 7, t) * Math.PI * 2;
+        const dist = 0.72 + 0.2 * hash2(k, 9, t);
+        const dx = u - Math.cos(ang) * dist;
+        const dy = v - Math.sin(ang) * dist;
+        c = Math.max(c, edge(0.08 + 0.06 * hash2(k, 11, t) - Math.hypot(dx, dy)));
+      }
+      return c;
+    }
+  }
+}
+
+// src/stickers/helpers.ts
+var DEFAULT_STICKER_PAGE = 24;
+var MAX_STICKER_PAGE = 100;
+var EDITOR_STICKERS_ID = "editor";
+function checkStickerSearchOptions(options = {}) {
+  if (options.limit !== void 0 && !(Number.isInteger(options.limit) && options.limit >= 1 && options.limit <= MAX_STICKER_PAGE)) {
+    throw new StickerError("invalid_argument", `limit must be a whole number from 1 to ${MAX_STICKER_PAGE}, got ${options.limit}.`);
+  }
+  if (options.after !== void 0 && !/^\d+$/.test(options.after)) throw new StickerError("invalid_argument", `after "${options.after}" is not a cursor from this provider; pass the next value of the previous page.`);
+}
+var words = (s) => s.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+function stickerPage(items, options = {}, query = "") {
+  checkStickerSearchOptions(options);
+  const q = words(query);
+  const tags = (options.tags ?? []).map((t) => t.toLowerCase());
+  const matches = items.filter((s) => {
+    if (options.category && s.category !== options.category) return false;
+    if (tags.length && !tags.every((t) => (s.tags ?? []).some((x) => x.toLowerCase() === t))) return false;
+    if (options.licence?.commercial === true && !s.licence.commercial) return false;
+    if (!q.length) return true;
+    const text = new Set(words([s.name, s.category, s.description ?? "", ...s.tags ?? []].join(" ")));
+    return q.every((w) => [...text].some((t) => t.startsWith(w)));
+  });
+  const start = options.after ? Number(options.after) : 0;
+  const limit = options.limit ?? DEFAULT_STICKER_PAGE;
+  const page = matches.slice(start, start + limit);
+  return { items: page, total: matches.length, ...start + limit < matches.length ? { next: String(start + limit) } : {} };
+}
+function parseStickerRef(ref) {
+  if (typeof ref !== "string" || !ref) throw new StickerError("invalid_argument", 'A sticker ref is a "provider:id" string, e.g. "editor:star" (find_stickers lists them).');
+  const i = ref.indexOf(":");
+  if (i === -1) {
+    if (STAMP_KINDS.includes(ref)) return { provider: EDITOR_STICKERS_ID, id: ref };
+    throw new StickerError("invalid_argument", `"${ref}" is not a sticker ref; refs are "provider:id" (e.g. "editor:${STAMP_KINDS[1]}"); find_stickers lists them.`);
+  }
+  if (i === 0 || i === ref.length - 1) throw new StickerError("invalid_argument", `"${ref}" is not a sticker ref; refs are "provider:id".`);
+  return { provider: ref.slice(0, i), id: ref.slice(i + 1) };
+}
+function normalizeStickerRef(ref) {
+  const { provider, id } = parseStickerRef(ref);
+  return `${provider}:${id}`;
+}
+function editorStampOf(ref) {
+  const { provider, id } = parseStickerRef(ref);
+  return provider === EDITOR_STICKERS_ID && STAMP_KINDS.includes(id) ? id : null;
+}
+function stickerRefOf(provider, id) {
+  return provider.namespaced ? id : `${provider.id}:${id}`;
+}
+function stickerIdFor(provider, ref) {
+  const { provider: owner, id } = parseStickerRef(ref);
+  if (provider.namespaced) return `${owner}:${id}`;
+  return owner === provider.id ? id : null;
+}
+function closestStickerRefs(wanted, candidates, n = 3) {
+  const w = wanted.toLowerCase();
+  const dist = (a, b) => {
+    const d = Array.from({ length: b.length + 1 }, (_, j) => j);
+    for (let i = 1; i <= a.length; i++) {
+      let prev = d[0];
+      d[0] = i;
+      for (let j = 1; j <= b.length; j++) {
+        const tmp = d[j];
+        d[j] = Math.min(d[j] + 1, d[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+        prev = tmp;
+      }
+    }
+    return d[b.length];
+  };
+  return [...candidates].sort((a, b) => dist(w, a.toLowerCase()) - dist(w, b.toLowerCase()) || a.localeCompare(b)).slice(0, n);
+}
+var StickersSlot = class {
+  constructor(fallback) {
+    this.fallback = fallback;
+    this.current = fallback;
+  }
+  fallback;
+  current;
+  listeners = /* @__PURE__ */ new Set();
+  get provider() {
+    return this.current;
+  }
+  set(provider) {
+    const next = provider ?? this.fallback;
+    if (next === this.current) return;
+    this.current = next;
+    for (const l of [...this.listeners]) l(next);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+};
+
+// src/stickers/tools.ts
+var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+function stickerForAgent(provider, s) {
+  const { id, thumbnail: _thumbnail, ...rest } = s;
+  return { ref: stickerRefOf(provider, id), ...rest };
+}
+async function knownRefs(provider, cap = 500) {
+  const refs = [];
+  let after;
+  while (refs.length < cap) {
+    const page = await provider.list({ limit: MAX_STICKER_PAGE, ...after ? { after } : {} });
+    refs.push(...page.items.map((s) => stickerRefOf(provider, s.id)));
+    if (!page.next || !page.items.length) break;
+    after = page.next;
+  }
+  return refs;
+}
+async function describeStickerRef(provider, ref) {
+  parseStickerRef(ref);
+  const id = stickerIdFor(provider, ref);
+  const found = id === null ? void 0 : await provider.describe(id);
+  if (found) return found;
+  const near = closestStickerRefs(ref, await knownRefs(provider));
+  const owner = parseStickerRef(ref).provider;
+  const where = id === null && !provider.namespaced ? ` The sticker library is "${provider.id}", not "${owner}".` : "";
+  throw new StickerError("unknown_sticker", `No sticker "${ref}".${where} Closest: ${near.join(", ") || "none"}; find_stickers lists them.`);
+}
+function createStickerTools(options) {
+  const find = {
+    name: "find_stickers",
+    title: "Find stickers",
+    description: "Searches the sticker library (the editor's own stamps unless the host plugged in its own): words in the name, tags, category or description, filtered by category, tags and commercial licence, a small page at a time. Returns each sticker's ref (provider:id, for the tools that spray or place stickers), name, category, tags, natural width and height, formats, whether it is tintable (recoloured to the paint colour) and its licence, plus total and next (pass as after for the next page) and the categories. Changes nothing.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", maxLength: 200, description: "Words to match (default: list everything)." },
+        category: { type: "string", description: "Only this category (the result lists them)." },
+        tags: { type: "array", maxItems: 10, items: { type: "string", description: "A tag." }, description: "Only stickers with every one of these tags." },
+        commercial: { type: "boolean", description: "true: only stickers whose licence allows commercial use." },
+        limit: { type: "integer", minimum: 1, maximum: MAX_STICKER_PAGE, description: "Page size (default 24)." },
+        after: { type: "string", description: "next from the previous page." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Find stickers", ...READ },
+    handler: async ({ query, category, tags, commercial, limit, after }) => {
+      const p = options.provider();
+      const categories = await p.categories?.() ?? null;
+      if (category !== void 0 && categories && !categories.some((c) => c.id === category)) {
+        throw new StickerError("invalid_argument", `No category "${category}" in "${p.name}"; categories: ${categories.map((c) => c.id).join(", ")}.`);
+      }
+      const o = { ...category !== void 0 ? { category } : {}, ...tags ? { tags } : {}, ...commercial ? { licence: { commercial: true } } : {}, ...limit !== void 0 ? { limit } : {}, ...after !== void 0 ? { after } : {} };
+      const q = typeof query === "string" ? query.trim() : "";
+      if (q && !p.capabilities.supportsSearch) throw new StickerError("invalid_argument", `"${p.name}" can't search; leave query out and filter by category instead.`);
+      const page = q ? await p.search(q, o) : await p.list(o);
+      return { provider: p.id, items: page.items.map((s) => stickerForAgent(p, s)), total: page.total, ...page.next ? { next: page.next } : {}, ...categories ? { categories } : {} };
+    }
+  };
+  const describe = {
+    name: "describe_sticker",
+    title: "Describe a sticker",
+    description: "Everything about one sticker by ref (from find_stickers): name, category, tags, natural size, formats, tintable, licence (with any attribution it asks for), dominant colours, variants and its outline as SVG path data (silhouette). An unknown ref is refused with the closest refs. Changes nothing.",
+    inputSchema: { type: "object", properties: { ref: { type: "string", description: "Sticker ref provider:id from find_stickers (e.g. editor:star)." } }, required: ["ref"], additionalProperties: false },
+    annotations: { title: "Describe a sticker", ...READ },
+    handler: async ({ ref }) => {
+      const p = options.provider();
+      const d = await describeStickerRef(p, ref);
+      const { thumbnail: _thumbnail, id, ...rest } = d;
+      return { ref: stickerRefOf(p, id), ...rest };
+    }
+  };
+  return options.insert ? [find, describe, createInsertStickerTool(options.provider, options.insert)] : [find, describe];
+}
+async function loadForHost(provider, ref, d, host, colour, size) {
+  const id = stickerIdFor(provider, ref);
+  const format = d.formats.includes(host.format) ? host.format : d.formats[0] ?? host.format;
+  return provider.load(id, { format, ...format === "png" ? { size: Math.max(8, Math.min(provider.capabilities.maxSize ?? 1024, Math.round(size))) } : {}, ...colour && d.tintable ? { colour } : {} });
+}
+async function insertSticker(provider, host, options) {
+  const d = await describeStickerRef(provider, options.ref);
+  if (options.color !== void 0 && !d.tintable) throw new StickerError("invalid_argument", `"${options.ref}" is not tintable (its art has its own colours); leave color out, or pick a tintable sticker (find_stickers lists tintable).`);
+  if (options.width !== void 0 && !(options.width > 0)) throw new StickerError("invalid_argument", `width must be a positive size, got ${options.width}.`);
+  const w = options.width ?? d.width;
+  const h = w * d.height / d.width;
+  const centre = host.defaultCentre();
+  const asset = await loadForHost(provider, options.ref, d, host, options.color, Math.max(w, h));
+  const ref = stickerRefOf(provider, d.id);
+  const made = await host.insert({ ref, description: d, asset, x: options.x ?? centre.x, y: options.y ?? centre.y, width: w, height: h, ...options.color ? { colour: options.color.toLowerCase() } : {} });
+  return { ...made, ref, width: w, height: h, licence: d.licence };
+}
+function createInsertStickerTool(provider, host) {
+  return {
+    name: "insert_sticker",
+    title: "Insert a sticker",
+    description: `Puts one sticker from the sticker library (ref from find_stickers) into the document as a new ${host.noun}, centred at x, y and width wide (its natural aspect kept; default its natural size), tinted to color when the sticker is tintable. Its art is loaded first; an unknown ref is refused with the closest ones. One undo step. Returns the new ${host.noun}'s id (for the editor's own tools, such as effects on it), the ref and its licence (credit any attribution it asks for).`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        ref: { type: "string", minLength: 1, description: "Sticker ref provider:id from find_stickers (e.g. editor:star)." },
+        x: { type: "number", description: "Centre x in document units (default the middle of the view or document)." },
+        y: { type: "number", description: "Centre y in document units (default the middle of the view or document)." },
+        width: { type: "number", exclusiveMinimum: 0, maximum: 1e4, description: "Width in document units (default the natural width); the height follows the aspect." },
+        color: { type: "string", pattern: "^#[0-9a-fA-F]{6}$", description: "Tint #rrggbb for tintable stickers (default the sticker's own colour); refused for stickers that are not tintable." }
+      },
+      required: ["ref"],
+      additionalProperties: false
+    },
+    annotations: { title: "Insert a sticker", ...WRITE },
+    handler: ({ ref, x, y, width, color }) => insertSticker(provider(), host, { ref, x, y, width, color })
+  };
+}
+function createStickerToolProvider(options) {
+  return {
+    id: options.id ?? "stickers",
+    namespace: options.namespace,
+    title: "Stickers",
+    description: "Find and describe stickers from the sticker library, by ref (provider:id), for the editors that spray or place them.",
+    skill: "pixerate-stickers",
+    tools: createStickerTools(options)
+  };
+}
+
+export {
+  STAMP_KINDS,
+  stampCoverage,
+  DEFAULT_STICKER_PAGE,
+  MAX_STICKER_PAGE,
+  EDITOR_STICKERS_ID,
+  checkStickerSearchOptions,
+  stickerPage,
+  parseStickerRef,
+  normalizeStickerRef,
+  editorStampOf,
+  stickerRefOf,
+  stickerIdFor,
+  closestStickerRefs,
+  StickersSlot,
+  stickerForAgent,
+  describeStickerRef,
+  createStickerTools,
+  insertSticker,
+  createInsertStickerTool,
+  createStickerToolProvider
+};

package/dist/{chunk-L6REDLNB.cjs → chunk-WPUXGDH4.cjs}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
 
-var _chunk6G6ZDDDBcjs = require('./chunk-6G6ZDDDB.cjs');
+var _chunkGT77U7QGcjs = require('./chunk-GT77U7QG.cjs');
 
 
 var _chunkCVFAAZXEcjs = require('./chunk-CVFAAZXE.cjs');
@@ -47,7 +47,7 @@ var _chunkNM3G4VQTcjs = require('./chunk-NM3G4VQT.cjs');
 
 
 
-var _chunkPQ3H2AANcjs = require('./chunk-PQ3H2AAN.cjs');
+var _chunkI7NJPHWVcjs = require('./chunk-I7NJPHWV.cjs');
 
 
 
@@ -2527,7 +2527,7 @@ function vectorExtrudeFaces(path, params) {
 // src/vector/brushstroke.ts
 var VECTOR_BRUSHSTROKE_SCALE = 2;
 function vectorBrushstrokeBrushes() {
-  return _chunk6G6ZDDDBcjs.BUILTIN_BRUSHES.filter((b) => _chunkPQ3H2AANcjs.isBrushstrokeBrush.call(void 0, b));
+  return _chunkGT77U7QGcjs.BUILTIN_BRUSHES.filter((b) => _chunkI7NJPHWVcjs.isBrushstrokeBrush.call(void 0, b));
 }
 function vectorBrushstrokeBrush(id) {
   return _nullishCoalesce(vectorBrushstrokeBrushes().find((b) => b.id === id), () => ( null));
@@ -2558,7 +2558,7 @@ function sanitizeVectorBrushstrokePaper(value) {
   if (!value || typeof value !== "object") return null;
   const r = value;
   const out = {};
-  if (typeof r.pattern === "string" && _chunkPQ3H2AANcjs.GRAIN_PATTERNS.includes(r.pattern)) out.pattern = r.pattern;
+  if (typeof r.pattern === "string" && _chunkI7NJPHWVcjs.GRAIN_PATTERNS.includes(r.pattern)) out.pattern = r.pattern;
   const seed = sanitizeSeed(r.seed);
   if (seed !== void 0) out.seed = seed;
   if (finite2(r.scale) && r.scale > 0) out.scale = Math.min(8, Math.max(0.25, r.scale));
@@ -2573,7 +2573,7 @@ function vectorBrushstrokeCharacterError(brush) {
   const r = paper;
   const extra = Object.keys(r).filter((k) => !["pattern", "seed", "scale", "depth"].includes(k));
   if (extra.length) return `paper has unknown field ${extra.map((k) => `"${k}"`).join(", ")}: use pattern, seed, scale, depth.`;
-  if (r.pattern !== void 0 && !_chunkPQ3H2AANcjs.GRAIN_PATTERNS.includes(r.pattern)) return `Unknown paper pattern "${String(r.pattern)}": use one of ${_chunkPQ3H2AANcjs.GRAIN_PATTERNS.join(", ")}.`;
+  if (r.pattern !== void 0 && !_chunkI7NJPHWVcjs.GRAIN_PATTERNS.includes(r.pattern)) return `Unknown paper pattern "${String(r.pattern)}": use one of ${_chunkI7NJPHWVcjs.GRAIN_PATTERNS.join(", ")}.`;
   if (r.seed !== void 0 && !(Number.isInteger(r.seed) && r.seed >= 0 && r.seed <= VECTOR_BRUSHSTROKE_MAX_SEED)) return `paper.seed must be an integer from 0 to ${VECTOR_BRUSHSTROKE_MAX_SEED}.`;
   if (r.scale !== void 0 && !(finite2(r.scale) && r.scale >= 0.25 && r.scale <= 8)) return "paper.scale must be from 0.25 to 8 (1 is the pattern's natural size).";
   if (r.depth !== void 0 && !(finite2(r.depth) && r.depth >= 0 && r.depth <= 1)) return "paper.depth must be from 0 to 1.";
@@ -2589,7 +2589,7 @@ function vectorBrushstrokeReach(layer) {
   if (!isVectorBrushstrokeLayer(layer)) return 0;
   return (_nullishCoalesce(layer.brush.size, () => ( vectorBrushstrokeBrush(layer.brush.brushId).tip.size))) / 2;
 }
-var cache = new (0, _chunkPQ3H2AANcjs.BrushstrokeCache)(256);
+var cache = new (0, _chunkI7NJPHWVcjs.BrushstrokeCache)(256);
 var urls = /* @__PURE__ */ new WeakMap();
 var layerCache = /* @__PURE__ */ new WeakMap();
 function vectorBrushstrokeImages(node, layer) {
@@ -2614,7 +2614,7 @@ function vectorBrushstrokeImages(node, layer) {
       const stroke = cache.render({ points: ring.map(([x, y]) => ({ x, y })), ...layer.brush.pressure ? { pressure: layer.brush.pressure } : {} }, brush, { scale: VECTOR_BRUSHSTROKE_SCALE, color: color2, maxPixels: 2048 * 2048, ...character });
       if (!stroke.bounds) continue;
       let href = urls.get(stroke);
-      if (!href) urls.set(stroke, href = _chunkPQ3H2AANcjs.brushstrokeDataUrl.call(void 0, stroke));
+      if (!href) urls.set(stroke, href = _chunkI7NJPHWVcjs.brushstrokeDataUrl.call(void 0, stroke));
       out.push({ href, ...stroke.bounds });
     }
   }

package/dist/{chunk-P3NIPIKS.js → chunk-WQCNC4DK.js}

@@ -1,7 +1,7 @@
 import {
   createPigment,
   mixPigments
-} from "./chunk-42TWUPNJ.js";
+} from "./chunk-IRSTHLQQ.js";
 import {
   TILE,
   TiledSurface,

package/dist/{chunk-IBDU6EGZ.cjs → chunk-X7WRL5ZZ.cjs}

@@ -18,7 +18,7 @@
 
 
 
-var _chunkL6REDLNBcjs = require('./chunk-L6REDLNB.cjs');
+var _chunkWPUXGDH4cjs = require('./chunk-WPUXGDH4.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 = _chunkL6REDLNBcjs.IDENTITY_MATRIX) {
+function subpathToMorphContour(sp, m = _chunkWPUXGDH4cjs.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 = _chunkL6REDLNBcjs.IDENTITY_MATRIX, closed = c.closed) {
-  const pts = _chunkL6REDLNBcjs.isIdentityMatrix.call(void 0, m) ? c.pts : c.pts.map((p) => mapP(m, p));
+function morphContourToSubpath(c, m = _chunkWPUXGDH4cjs.IDENTITY_MATRIX, closed = c.closed) {
+  const pts = _chunkWPUXGDH4cjs.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 = _chunkL6REDLNBcjs.IDENTITY_MATRIX, closed
     anchors[(k + 1) % count].in = { x: p2[0], y: p2[1] };
   }
   for (const a of anchors) {
-    const type = _chunkL6REDLNBcjs.inferAnchorType.call(void 0, a);
+    const type = _chunkWPUXGDH4cjs.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 = _chunkL6REDLNBcjs.unionBounds.call(void 0, [boundsOfPoints(c.pts)]);
+  const b = _chunkWPUXGDH4cjs.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 = _chunkL6REDLNBcjs.sampleVectorGradient.call(void 0, g, offset);
+    const s = _chunkWPUXGDH4cjs.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 = _chunkL6REDLNBcjs.sortedVectorGradientStops.call(void 0, a);
-  let stopsB = _chunkL6REDLNBcjs.sortedVectorGradientStops.call(void 0, b);
+  let stopsA = _chunkWPUXGDH4cjs.sortedVectorGradientStops.call(void 0, a);
+  let stopsB = _chunkWPUXGDH4cjs.sortedVectorGradientStops.call(void 0, b);
   const resampled = stopsA.length !== stopsB.length || !sameColourModel(a, b);
   if (resampled) {
-    const offs = [..._chunkL6REDLNBcjs.expandVectorGradientStops.call(void 0, a), ..._chunkL6REDLNBcjs.expandVectorGradientStops.call(void 0, b), ...stopsA, ...stopsB].map((s) => s.offset).filter(Number.isFinite).sort((x, y) => x - y);
+    const offs = [..._chunkWPUXGDH4cjs.expandVectorGradientStops.call(void 0, a), ..._chunkWPUXGDH4cjs.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 = _chunkL6REDLNBcjs.hasExplicitGradientGeometry.call(void 0, a);
-  const eb = _chunkL6REDLNBcjs.hasExplicitGradientGeometry.call(void 0, b);
+  const ea = _chunkWPUXGDH4cjs.hasExplicitGradientGeometry.call(void 0, a);
+  const eb = _chunkWPUXGDH4cjs.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 = _chunkL6REDLNBcjs.vectorGradientPoints.call(void 0, a);
-  const pb = _chunkL6REDLNBcjs.vectorGradientPoints.call(void 0, b);
+  const pa = _chunkWPUXGDH4cjs.vectorGradientPoints.call(void 0, a);
+  const pb = _chunkWPUXGDH4cjs.vectorGradientPoints.call(void 0, b);
   if (pa.units !== pb.units) {
-    const src = _chunkL6REDLNBcjs.explicitVectorGradient.call(void 0, near);
+    const src = _chunkWPUXGDH4cjs.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 = _chunkL6REDLNBcjs.hasPaint.call(void 0, a);
-  const pb = _chunkL6REDLNBcjs.hasPaint.call(void 0, b);
+  const pa = _chunkWPUXGDH4cjs.hasPaint.call(void 0, a);
+  const pb = _chunkWPUXGDH4cjs.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 && _chunkL6REDLNBcjs.isVectorGradient.call(void 0, a) ? a : null;
-  const gb = pb && _chunkL6REDLNBcjs.isVectorGradient.call(void 0, b) ? b : null;
+  const ga = pa && _chunkWPUXGDH4cjs.isVectorGradient.call(void 0, a) ? a : null;
+  const gb = pb && _chunkWPUXGDH4cjs.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 = _chunkL6REDLNBcjs.widthProfileAt.call(void 0, a, pos);
-    const y = _chunkL6REDLNBcjs.widthProfileAt.call(void 0, b, pos);
+    const x = _chunkWPUXGDH4cjs.widthProfileAt.call(void 0, a, pos);
+    const y = _chunkWPUXGDH4cjs.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 = _chunkL6REDLNBcjs.reverseWidthProfile.call(void 0, s.strokeWidthProfile);
+  if (_optionalChain([s, 'access', _6 => _6.strokeWidthProfile, 'optionalAccess', _7 => _7.length])) out.strokeWidthProfile = _chunkWPUXGDH4cjs.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 _chunkL6REDLNBcjs.expandVectorCorners.call(void 0, node.subpaths).map((sp) => subpathToMorphContour(sp, m)).filter((c) => !!c);
+  return _chunkWPUXGDH4cjs.expandVectorCorners.call(void 0, node.subpaths).map((sp) => subpathToMorphContour(sp, m)).filter((c) => !!c);
 }
-function preparePathMorph(a, b, options, ma = _chunkL6REDLNBcjs.nodeMatrix.call(void 0, a), mb = _chunkL6REDLNBcjs.nodeMatrix.call(void 0, b)) {
+function preparePathMorph(a, b, options, ma = _chunkWPUXGDH4cjs.nodeMatrix.call(void 0, a), mb = _chunkWPUXGDH4cjs.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 = !_chunkL6REDLNBcjs.isIdentityMatrix.call(void 0, ma) || !_chunkL6REDLNBcjs.isIdentityMatrix.call(void 0, mb);
+  const rigid = !_chunkWPUXGDH4cjs.isIdentityMatrix.call(void 0, ma) || !_chunkWPUXGDH4cjs.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) : _chunkL6REDLNBcjs.IDENTITY_MATRIX;
-    const back = rigid ? _chunkL6REDLNBcjs.invertMatrix.call(void 0, m) : _chunkL6REDLNBcjs.IDENTITY_MATRIX;
+    const m = rigid ? interpolateRigidMatrix(ma, mb, t) : _chunkWPUXGDH4cjs.IDENTITY_MATRIX;
+    const back = rigid ? _chunkWPUXGDH4cjs.invertMatrix.call(void 0, m) : _chunkWPUXGDH4cjs.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 = _chunkL6REDLNBcjs.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 && !_chunkL6REDLNBcjs.isIdentityMatrix.call(void 0, m)) node.transform = m;
+    if (rigid && !_chunkWPUXGDH4cjs.isIdentityMatrix.call(void 0, m)) node.transform = m;
     return node;
   };
 }
-function flattenPaths(node, parent = _chunkL6REDLNBcjs.IDENTITY_MATRIX) {
-  const m = _chunkL6REDLNBcjs.multiplyMatrices.call(void 0, _chunkL6REDLNBcjs.nodeMatrix.call(void 0, node), parent);
+function flattenPaths(node, parent = _chunkWPUXGDH4cjs.IDENTITY_MATRIX) {
+  const m = _chunkWPUXGDH4cjs.multiplyMatrices.call(void 0, _chunkWPUXGDH4cjs.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(_chunkL6REDLNBcjs.expandVectorAppearance.call(void 0, node), parent);
+  if (node.type === "text" || node.type === "instance") return flattenPaths(_chunkWPUXGDH4cjs.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 = _chunkL6REDLNBcjs.unionBounds.call(void 0, pa.map((e) => placedBounds(e.path, e.m)));
-  const bb = _chunkL6REDLNBcjs.unionBounds.call(void 0, pb.map((e) => placedBounds(e.path, e.m)));
+  const ba = _chunkWPUXGDH4cjs.unionBounds.call(void 0, pa.map((e) => placedBounds(e.path, e.m)));
+  const bb = _chunkWPUXGDH4cjs.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, _chunkL6REDLNBcjs.IDENTITY_MATRIX));
+      parts.push(preparePathMorph(x.path, collapsedPath(x.path, x.m, ba, bb), sub, x.m, _chunkWPUXGDH4cjs.IDENTITY_MATRIX));
       opacities.push([x.opacity, x.opacity]);
     } else if (y) {
-      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub, _chunkL6REDLNBcjs.IDENTITY_MATRIX, y.m));
+      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub, _chunkWPUXGDH4cjs.IDENTITY_MATRIX, y.m));
       opacities.push([y.opacity, y.opacity]);
     }
   }