@pixerate/editor 0.246.0 → 0.249.0

package/dist/chunk-5RH3VXAK.js

@@ -0,0 +1,269 @@
+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/errors.ts
+var StickerError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "StickerError";
+  }
+  code;
+};
+
+// 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 };
+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 [find, describe];
+}
+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,
+  StickerError,
+  DEFAULT_STICKER_PAGE,
+  MAX_STICKER_PAGE,
+  EDITOR_STICKERS_ID,
+  checkStickerSearchOptions,
+  stickerPage,
+  parseStickerRef,
+  normalizeStickerRef,
+  editorStampOf,
+  stickerRefOf,
+  stickerIdFor,
+  closestStickerRefs,
+  StickersSlot,
+  stickerForAgent,
+  describeStickerRef,
+  createStickerTools,
+  createStickerToolProvider
+};

package/dist/{chunk-LDPLEZ5T.js → chunk-6BIDVPED.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-AKUI3SEJ.js").catch((error) => {
+  loading ??= import("./brushstrokeRender-T3JZST44.js").catch((error) => {
     loading = null;
     throw error;
   });

package/dist/{chunk-2ONK3ERD.cjs → chunk-75K3W4D6.cjs}

@@ -13,12 +13,12 @@ var _chunkBB6TR422cjs = require('./chunk-BB6TR422.cjs');
 
 
 
-var _chunkPQ3H2AANcjs = require('./chunk-PQ3H2AAN.cjs');
+var _chunkI7NJPHWVcjs = require('./chunk-I7NJPHWV.cjs');
 
 
 
 
-var _chunkOLNIPTB3cjs = require('./chunk-OLNIPTB3.cjs');
+var _chunk2VX55NFMcjs = require('./chunk-2VX55NFM.cjs');
 
 
 
@@ -367,9 +367,9 @@ function applyRetouchToTile(coverage, tileData, channels, tx, ty, paint, s, opti
         const g0 = rgb[1];
         const b0 = rgb[2];
         paint.tone(rgb);
-        _chunkPQ3H2AANcjs.put255.call(void 0, out, i, r0 + (rgb[0] - r0) * k);
-        _chunkPQ3H2AANcjs.put255.call(void 0, out, i + 1, g0 + (rgb[1] - g0) * k);
-        _chunkPQ3H2AANcjs.put255.call(void 0, out, i + 2, b0 + (rgb[2] - b0) * k);
+        _chunkI7NJPHWVcjs.put255.call(void 0, out, i, r0 + (rgb[0] - r0) * k);
+        _chunkI7NJPHWVcjs.put255.call(void 0, out, i + 1, g0 + (rgb[1] - g0) * k);
+        _chunkI7NJPHWVcjs.put255.call(void 0, out, i + 2, b0 + (rgb[2] - b0) * k);
         continue;
       }
       if (s.lockTransparency && a === 0) continue;
@@ -383,11 +383,11 @@ function applyRetouchToTile(coverage, tileData, channels, tx, ty, paint, s, opti
         cb[ch] = out[i + ch] / 255;
         cs[ch] = src[ch] / 255;
       }
-      const o = _chunkOLNIPTB3cjs.blendPixel.call(void 0, blend, cb, cs, k);
-      _chunkPQ3H2AANcjs.put255.call(void 0, out, i, o[0]);
-      _chunkPQ3H2AANcjs.put255.call(void 0, out, i + 1, o[1]);
-      _chunkPQ3H2AANcjs.put255.call(void 0, out, i + 2, o[2]);
-      if (!s.lockTransparency) _chunkPQ3H2AANcjs.put255.call(void 0, out, i + 3, o[3]);
+      const o = _chunk2VX55NFMcjs.blendPixel.call(void 0, blend, cb, cs, k);
+      _chunkI7NJPHWVcjs.put255.call(void 0, out, i, o[0]);
+      _chunkI7NJPHWVcjs.put255.call(void 0, out, i + 1, o[1]);
+      _chunkI7NJPHWVcjs.put255.call(void 0, out, i + 2, o[2]);
+      if (!s.lockTransparency) _chunkI7NJPHWVcjs.put255.call(void 0, out, i + 3, o[3]);
     }
   }
   return out;
@@ -443,14 +443,14 @@ function applyToneToDeepTile(coverage, samples, tx, ty, tone, s, options = {}) {
         const v = out[i + ch];
         if (linear) {
           excess[ch] = v > 1 ? v - 1 : 0;
-          rgb[ch] = _chunkOLNIPTB3cjs.srgbEncode.call(void 0, v > 1 ? 1 : v < 0 ? 0 : v);
+          rgb[ch] = _chunk2VX55NFMcjs.srgbEncode.call(void 0, v > 1 ? 1 : v < 0 ? 0 : v);
         } else rgb[ch] = v / 65535;
         before[ch] = rgb[ch];
       }
       tone(rgb);
       for (let ch = 0; ch < 3; ch++) {
         const e = before[ch] + (rgb[ch] - before[ch]) * k;
-        if (linear) out[i + ch] = _chunkOLNIPTB3cjs.srgbDecode.call(void 0, e) + excess[ch];
+        if (linear) out[i + ch] = _chunk2VX55NFMcjs.srgbDecode.call(void 0, e) + excess[ch];
         else out[i + ch] = e <= 0 ? 0 : e >= 1 ? 65535 : Math.round(e * 65535);
       }
     }
@@ -535,8 +535,8 @@ var RetouchDabStroke = (_class3 = class {
   constructor(brush, target, effect) {;_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);
     this.brush = brush;
     this.effect = effect;
-    this.walker = new (0, _chunkPQ3H2AANcjs.DabWalker)(brush);
-    this.medium = new (0, _chunkPQ3H2AANcjs.TileMedium)(target);
+    this.walker = new (0, _chunkI7NJPHWVcjs.DabWalker)(brush);
+    this.medium = new (0, _chunkI7NJPHWVcjs.TileMedium)(target);
   }
   
   
@@ -567,11 +567,11 @@ var RetouchDabStroke = (_class3 = class {
   paint(dabs) {
     const rects = [];
     for (const d of dabs) {
-      const rect = _chunkPQ3H2AANcjs.dabRect.call(void 0, d, this.brush.hardness);
+      const rect = _chunkI7NJPHWVcjs.dabRect.call(void 0, d, this.brush.hardness);
       const n = rect.width * rect.height;
       if (this.buf.length < n) this.buf = new Float32Array(n);
       const cov = this.buf.subarray(0, n);
-      _chunkPQ3H2AANcjs.rasterizeDab.call(void 0, { ...d, alpha: 1 }, this.brush.hardness, rect, cov);
+      _chunkI7NJPHWVcjs.rasterizeDab.call(void 0, { ...d, alpha: 1 }, this.brush.hardness, rect, cov);
       this.medium.reset();
       this.effect(this.medium, d, rect, cov);
       rects.push(rect);
@@ -583,7 +583,7 @@ var RetouchDabStroke = (_class3 = class {
 }, _class3);
 function smudgeEffect(brush, strength, mixing = "rgb") {
   const s = Math.min(1, Math.max(0, strength));
-  const tip = new (0, _chunkPQ3H2AANcjs.SmudgeTip)({ strength: s, length: s, mixing }, brush.size);
+  const tip = new (0, _chunkI7NJPHWVcjs.SmudgeTip)({ strength: s, length: s, mixing }, brush.size);
   return (medium, d, rect, cov) => tip.dab(medium, { x: d.x, y: d.y, radius: d.radius, opacity: d.opacity * d.alpha }, rect, cov);
 }
 function spongeEffect(brush, saturate, vibrance) {
@@ -606,9 +606,9 @@ function spongeEffect(brush, saturate, vibrance) {
         rgb[1] = px[i + 1] / 255;
         rgb[2] = px[i + 2] / 255;
         sponge(rgb, k, saturate, vibrance);
-        _chunkPQ3H2AANcjs.put255.call(void 0, px, i, rgb[0]);
-        _chunkPQ3H2AANcjs.put255.call(void 0, px, i + 1, rgb[1]);
-        _chunkPQ3H2AANcjs.put255.call(void 0, px, i + 2, rgb[2]);
+        _chunkI7NJPHWVcjs.put255.call(void 0, px, i, rgb[0]);
+        _chunkI7NJPHWVcjs.put255.call(void 0, px, i + 1, rgb[1]);
+        _chunkI7NJPHWVcjs.put255.call(void 0, px, i + 2, rgb[2]);
       }
     }
   };

package/dist/chunk-BOHDJJ2O.cjs

@@ -0,0 +1,192 @@
+"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 _chunkDPYAO5U6cjs = require('./chunk-DPYAO5U6.cjs');
+
+
+var _chunk2VX55NFMcjs = require('./chunk-2VX55NFM.cjs');
+
+// src/raster/effects/ui.ts
+function layerEffectsPanel(layer) {
+  const empty = { readOnly: true, enabled: true, scale: 1, rows: [] };
+  if (!layer) return { ...empty, available: false, reason: "Select a layer to add a layer style." };
+  if (layer.type === "adjustment") return { ...empty, available: false, reason: "Adjustment layers cannot have a layer style." };
+  const fx = layer.effects;
+  const readOnly = Boolean(_optionalChain([layer, 'access', _ => _.locks, 'optionalAccess', _2 => _2.all]));
+  return {
+    available: true,
+    readOnly,
+    reason: readOnly ? "The layer is locked; unlock it to change its layer style." : void 0,
+    enabled: _nullishCoalesce(_optionalChain([fx, 'optionalAccess', _3 => _3.enabled]), () => ( true)),
+    scale: _nullishCoalesce(_optionalChain([fx, 'optionalAccess', _4 => _4.scale]), () => ( 1)),
+    rows: (_nullishCoalesce(_optionalChain([fx, 'optionalAccess', _5 => _5.items]), () => ( []))).map((e) => ({ id: e.id, kind: e.kind, label: _chunkDPYAO5U6cjs.layerEffectLabel.call(void 0, e.kind), enabled: e.enabled }))
+  };
+}
+function layerEffectsBadge(layer) {
+  if (!_optionalChain([layer, 'access', _6 => _6.effects, 'optionalAccess', _7 => _7.items, 'access', _8 => _8.length])) return null;
+  return _chunkDPYAO5U6cjs.hasActiveEffects.call(void 0, layer.effects) ? "on" : "off";
+}
+var LAYER_EFFECT_MENU = _chunkDPYAO5U6cjs.LAYER_EFFECT_KINDS.map((kind) => ({ kind, label: _chunkDPYAO5U6cjs.layerEffectLabel.call(void 0, kind) }));
+var BLENDS = _chunk2VX55NFMcjs.BLEND_MODES.filter((m) => m.id !== "pigment").map((m) => ({ value: m.id, label: m.label }));
+var opt = (...pairs) => pairs.map(([value, label]) => ({ value, label }));
+function patternOptions(patterns) {
+  return [...patterns.map((p) => ({ value: p.id, label: p.name || p.id })), ..._chunkDPYAO5U6cjs.builtinPatternIds.call(void 0, ).map((id) => ({ value: id, label: _chunkDPYAO5U6cjs.builtinPattern.call(void 0, id).name }))];
+}
+function getPath(o, path) {
+  let v = o;
+  for (const p of path.split(".")) {
+    if (v === null || v === void 0) return void 0;
+    if (Array.isArray(v)) v = p === "last" ? v[v.length - 1] : v[Number(p)];
+    else v = v[p];
+  }
+  return v;
+}
+function setPath(o, parts, value) {
+  if (!parts.length) return value;
+  const [p, ...rest] = parts;
+  if (Array.isArray(o)) {
+    const i = p === "last" ? o.length - 1 : Number(p);
+    const out = [...o];
+    out[i] = setPath(o[i], rest, value);
+    return out;
+  }
+  const r = _nullishCoalesce(o, () => ( {}));
+  return { ...r, [p]: setPath(r[p], rest, value) };
+}
+function fillControls(f, allowPattern, patterns) {
+  const types = allowPattern ? opt(["color", "Color"], ["gradient", "Gradient"], ["pattern", "Pattern"]) : opt(["color", "Color"], ["gradient", "Gradient"]);
+  const out = [{ key: "fill.type", label: "Fill", type: "select", value: f.type, options: types }];
+  if (f.type === "color") out.push({ key: "fill.color", label: "Color", type: "color", value: f.color });
+  else if (f.type === "gradient") out.push(...gradientControls("fill.gradient", f.gradient));
+  else {
+    out.push(
+      { key: "fill.patternId", label: "Pattern", type: "select", value: f.patternId, options: patternOptions(patterns) },
+      { key: "fill.scale", label: "Scale", type: "range", min: 0.01, max: 10, step: 0.01, value: f.scale, percent: true, unit: "%" }
+    );
+  }
+  return out;
+}
+function gradientControls(prefix, g) {
+  return [
+    { key: `${prefix}.stops.0.color`, label: "Start colour", type: "color", value: _nullishCoalesce(_optionalChain([g, 'access', _9 => _9.stops, 'access', _10 => _10[0], 'optionalAccess', _11 => _11.color]), () => ( "#000000")) },
+    { key: `${prefix}.stops.last.color`, label: "End colour", type: "color", value: _nullishCoalesce(_optionalChain([g, 'access', _12 => _12.stops, 'access', _13 => _13[g.stops.length - 1], 'optionalAccess', _14 => _14.color]), () => ( "#ffffff")) },
+    { key: `${prefix}.style`, label: "Style", type: "select", value: g.style, options: opt(["linear", "Linear"], ["radial", "Radial"], ["angle", "Angle"], ["reflected", "Reflected"], ["diamond", "Diamond"]) },
+    { key: `${prefix}.angle`, label: "Angle", type: "range", min: -180, max: 180, step: 1, value: g.angle, unit: "\xB0" },
+    { key: `${prefix}.scale`, label: "Scale", type: "range", min: 0.1, max: 1.5, step: 0.01, value: g.scale, percent: true, unit: "%" },
+    { key: `${prefix}.reverse`, label: "Reverse", type: "checkbox", value: g.reverse },
+    { key: `${prefix}.align`, label: "Align with layer", type: "checkbox", value: g.align }
+  ];
+}
+var px = (key, label, value, max = 250) => ({ key, label, type: "range", min: 0, max, step: 1, value, unit: "px" });
+var pct = (key, label, value, min = 0, max = 1) => ({ key, label, type: "range", min, max, step: 0.01, value, percent: true, unit: "%" });
+var deg = (key, label, value, min = -180, max = 180) => ({ key, label, type: "range", min, max, step: 1, value, unit: "\xB0" });
+function layerEffectControls(e, patterns = []) {
+  const blended = e.kind === "bevel-emboss" ? [] : [
+    { key: "blend", label: "Blend mode", type: "select", value: e.blend, options: BLENDS },
+    pct("opacity", "Opacity", e.opacity)
+  ];
+  switch (e.kind) {
+    case "drop-shadow":
+    case "inner-shadow":
+      return [
+        ...blended,
+        { key: "color", label: "Color", type: "color", value: e.color },
+        { key: "useGlobalLight", label: "Use global light", type: "checkbox", value: e.useGlobalLight },
+        deg("angle", "Angle", e.angle),
+        px("distance", "Distance", e.distance, 500),
+        e.kind === "drop-shadow" ? pct("spread", "Spread", e.spread) : pct("choke", "Choke", e.choke),
+        px("size", "Size", e.size),
+        pct("noise", "Noise", e.noise),
+        ...e.kind === "drop-shadow" ? [{ key: "knocksOut", label: "Layer knocks out shadow", type: "checkbox", value: e.knocksOut }] : []
+      ];
+    case "outer-glow":
+    case "inner-glow":
+      return [
+        ...blended,
+        ...fillControls(e.fill, false, patterns),
+        { key: "technique", label: "Technique", type: "select", value: e.technique, options: opt(["softer", "Softer"], ["precise", "Precise"]) },
+        ...e.kind === "inner-glow" ? [{ key: "source", label: "Source", type: "select", value: e.source, options: opt(["edge", "Edge"], ["center", "Center"]) }] : [],
+        e.kind === "outer-glow" ? pct("spread", "Spread", e.spread) : pct("choke", "Choke", e.choke),
+        px("size", "Size", e.size),
+        pct("range", "Range", e.range, 0.01, 1),
+        pct("noise", "Noise", e.noise)
+      ];
+    case "bevel-emboss":
+      return [
+        { key: "style", label: "Style", type: "select", value: e.style, options: opt(["inner-bevel", "Inner Bevel"], ["outer-bevel", "Outer Bevel"], ["emboss", "Emboss"], ["pillow-emboss", "Pillow Emboss"], ["stroke-emboss", "Stroke Emboss"]) },
+        { key: "technique", label: "Technique", type: "select", value: e.technique, options: opt(["smooth", "Smooth"], ["chisel-hard", "Chisel Hard"], ["chisel-soft", "Chisel Soft"]) },
+        pct("depth", "Depth", e.depth, 0, 10),
+        { key: "direction", label: "Direction", type: "select", value: e.direction, options: opt(["up", "Up"], ["down", "Down"]) },
+        px("size", "Size", e.size),
+        px("soften", "Soften", e.soften, 16),
+        { key: "useGlobalLight", label: "Use global light", type: "checkbox", value: e.useGlobalLight },
+        deg("angle", "Angle", e.angle),
+        deg("altitude", "Altitude", e.altitude, 0, 90),
+        { key: "highlightColor", label: "Highlight", type: "color", value: e.highlightColor },
+        { key: "highlightBlend", label: "Highlight mode", type: "select", value: e.highlightBlend, options: BLENDS },
+        pct("highlightOpacity", "Highlight opacity", e.highlightOpacity),
+        { key: "shadowColor", label: "Shadow", type: "color", value: e.shadowColor },
+        { key: "shadowBlend", label: "Shadow mode", type: "select", value: e.shadowBlend, options: BLENDS },
+        pct("shadowOpacity", "Shadow opacity", e.shadowOpacity)
+      ];
+    case "satin":
+      return [
+        ...blended,
+        { key: "color", label: "Color", type: "color", value: e.color },
+        deg("angle", "Angle", e.angle),
+        px("distance", "Distance", e.distance),
+        px("size", "Size", e.size),
+        { key: "invert", label: "Invert", type: "checkbox", value: e.invert }
+      ];
+    case "color-overlay":
+      return [...blended, { key: "color", label: "Color", type: "color", value: e.color }];
+    case "gradient-overlay":
+      return [...blended, ...gradientControls("gradient", e.gradient)];
+    case "pattern-overlay":
+      return [
+        ...blended,
+        { key: "patternId", label: "Pattern", type: "select", value: e.patternId, options: patternOptions(patterns) },
+        pct("scale", "Scale", e.scale, 0.01, 10),
+        deg("angle", "Angle", _nullishCoalesce(e.angle, () => ( 0))),
+        { key: "link", label: "Link with layer", type: "checkbox", value: _nullishCoalesce(e.link, () => ( true)) }
+      ];
+    case "stroke":
+      return [
+        ...blended,
+        px("size", "Size", e.size),
+        { key: "position", label: "Position", type: "select", value: e.position, options: opt(["outside", "Outside"], ["inside", "Inside"], ["center", "Center"]) },
+        ...fillControls(e.fill, true, patterns)
+      ];
+  }
+}
+function fillOfType(current, type, patterns) {
+  if (type === "gradient") return { type: "gradient", gradient: _chunkDPYAO5U6cjs.defaultEffectGradient.call(void 0, ) };
+  if (type === "pattern") return { type: "pattern", patternId: _nullishCoalesce(_optionalChain([patterns, 'access', _15 => _15[0], 'optionalAccess', _16 => _16.id]), () => ( "checker")), scale: 1 };
+  return { type: "color", color: current.type === "color" ? current.color : "#000000" };
+}
+function effectControlChange(effect, key, value, patterns = []) {
+  const [top, ...rest] = key.split(".");
+  if (top === "fill" && rest[0] === "type") return { fill: fillOfType(effect.fill, String(value), patterns) };
+  if (top === "patternId" && !rest.length) {
+    const name = _optionalChain([patternOptions, 'call', _17 => _17(patterns), 'access', _18 => _18.find, 'call', _19 => _19((o) => o.value === value), 'optionalAccess', _20 => _20.label]);
+    return name ? { patternId: value, name } : { patternId: value };
+  }
+  if (!rest.length) return { [top]: value };
+  if (top === "fill" && rest[0] === "patternId") {
+    const name = _optionalChain([patternOptions, 'call', _21 => _21(patterns), 'access', _22 => _22.find, 'call', _23 => _23((o) => o.value === value), 'optionalAccess', _24 => _24.label]);
+    return { fill: { ...effect.fill, patternId: value, ...name ? { name } : {} } };
+  }
+  return { [top]: setPath(getPath(effect, top), rest, value) };
+}
+
+
+
+
+
+
+
+exports.layerEffectsPanel = layerEffectsPanel; exports.layerEffectsBadge = layerEffectsBadge; exports.LAYER_EFFECT_MENU = LAYER_EFFECT_MENU; exports.layerEffectControls = layerEffectControls; exports.effectControlChange = effectControlChange;