@pixerate/editor 0.214.0 → 0.216.0

package/dist/{chunk-W3TOZTL7.js → chunk-F7Z2MKY2.js}

@@ -2,12 +2,14 @@ import {
   parseCssColor
 } from "./chunk-3CI7FRMK.js";
 import {
+  boxMean,
   createSelectionMask,
   decodeSelectionRle,
+  decontaminateColors,
   encodeSelectionRle,
   hashMaskContent,
   resizeSelection
-} from "./chunk-L3G23N5Y.js";
+} from "./chunk-ZNA3IQZF.js";
 import {
   DEFAULT_GLOBAL_LIGHT,
   DeepCompositor,
@@ -43,7 +45,7 @@ import {
   validateEffectGradient,
   validateLayerEffects,
   warpSurface
-} from "./chunk-YBJXCQTR.js";
+} from "./chunk-QXY4YTRI.js";
 import {
   affineFromHomography,
   applyHomography,
@@ -3419,6 +3421,68 @@ function unionRect(a, b) {
   return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
 }
 
+// src/image-editor/layers/edge-color.ts
+var EDGE_COLOR_RADIUS = 8;
+function hasEdgeUnmix(edge) {
+  return Boolean(edge && ((edge.decontaminate ?? 0) > 0 || (edge.despill ?? 0) > 0));
+}
+function maskCoverageOverCanvas(mask, ox, oy, width, height) {
+  const bytes = readRegion(mask.surface, { x: -ox, y: -oy, width, height });
+  const feather = mask.feather ?? 0;
+  if (!(feather > 0)) return new Uint8ClampedArray(bytes.buffer, bytes.byteOffset, bytes.length);
+  const v = new Float32Array(bytes.length);
+  for (let i = 0; i < v.length; i++) v[i] = bytes[i];
+  const blurred = gaussianBlur(v, width, height, feather, "clamp");
+  return Uint8ClampedArray.from(blurred);
+}
+function hasSoftBand(coverage) {
+  for (let i = 0; i < coverage.length; i++) if (coverage[i] > 5 && coverage[i] < 250) return true;
+  return false;
+}
+function despillEdge(rgba, coverage, w, h, amount, radius = EDGE_COLOR_RADIUS) {
+  const k = Math.min(1, Math.max(0, amount));
+  if (!(k > 0)) return;
+  const n = w * h;
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) out[i] = coverage[i] <= 5 ? 1 : 0;
+  const weight = boxMean(out, w, h, radius);
+  const mean = [0, 1, 2].map((c) => {
+    const v = new Float32Array(n);
+    for (let i = 0; i < n; i++) v[i] = rgba[i * 4 + c] * out[i];
+    return boxMean(v, w, h, radius);
+  });
+  const luma = (r, g, b) => 0.2126 * r + 0.7152 * g + 0.0722 * b;
+  for (let i = 0; i < n; i++) {
+    const c = coverage[i];
+    if (c <= 5 || c >= 250 || weight[i] <= 1e-6) continue;
+    const br = mean[0][i] / weight[i];
+    const bg = mean[1][i] / weight[i];
+    const bb = mean[2][i] / weight[i];
+    const bl = luma(br, bg, bb);
+    let ux = br - bl;
+    let uy = bg - bl;
+    let uz = bb - bl;
+    const len = Math.hypot(ux, uy, uz);
+    if (len < 4) continue;
+    ux /= len;
+    uy /= len;
+    uz /= len;
+    const p = i * 4;
+    const l = luma(rgba[p], rgba[p + 1], rgba[p + 2]);
+    const along = (rgba[p] - l) * ux + (rgba[p + 1] - l) * uy + (rgba[p + 2] - l) * uz;
+    if (along <= 0) continue;
+    const s = k * Math.min(1, 2 * (1 - c / 255)) * along;
+    rgba[p] -= s * ux;
+    rgba[p + 1] -= s * uy;
+    rgba[p + 2] -= s * uz;
+  }
+}
+function applyEdgeUnmix(rgba, coverage, w, h, edge) {
+  const d = edge.decontaminate ?? 0;
+  if (d > 0) rgba.set(decontaminateColors(rgba, coverage, w, h, d, EDGE_COLOR_RADIUS));
+  despillEdge(rgba, coverage, w, h, edge.despill ?? 0);
+}
+
 // src/image-editor/layers/compositor.ts
 var legacyViewCache = /* @__PURE__ */ new WeakMap();
 function adjustmentNodeAsLayer(node) {
@@ -3496,6 +3560,31 @@ function filterReach(filters) {
   return r;
 }
 var filterSpecCache = /* @__PURE__ */ new WeakMap();
+var maskIds = /* @__PURE__ */ new WeakMap();
+var nextMaskId = 1;
+var edgeSpecCache = /* @__PURE__ */ new WeakMap();
+function edgeFilterSpec(layer) {
+  const edge = layer.edge;
+  const mask = layer.mask;
+  if (!hasEdgeUnmix(edge) || !mask || mask.enabled === false || mask.source) return pixelFilterSpec(layer);
+  const hit = edgeSpecCache.get(layer);
+  if (hit) return hit;
+  let id = maskIds.get(mask.surface);
+  if (id === void 0) maskIds.set(mask.surface, id = nextMaskId++);
+  const filters = pixelFilterSpec(layer);
+  const ox = layer.offset.x;
+  const oy = layer.offset.y;
+  const spec = {
+    key: `edge:${JSON.stringify([edge.decontaminate ?? 0, edge.despill ?? 0, id, ox, oy, mask.feather ?? 0])}|${filters?.key ?? ""}`,
+    spatial: true,
+    apply: (data, width, height) => {
+      filters?.apply(data, width, height);
+      applyEdgeUnmix(data, maskCoverageOverCanvas(mask, ox, oy, width, height), width, height, edge);
+    }
+  };
+  edgeSpecCache.set(layer, spec);
+  return spec;
+}
 function pixelFilterSpec(layer) {
   const list2 = layer.filters;
   if (!list2?.length) return null;
@@ -3523,7 +3612,7 @@ var PHOTO_PROFILE = {
   /** Annotation layers draw with their annotation's blend mode unless the layer sets one. */
   contentBlend: (l) => l.type === "annotation" && l.blend === "normal" && l.annotation.blend ? l.annotation.blend : l.blend,
   layerKey: (l) => l.type === "pixel" ? [l.filters ?? null, l.source ?? null] : l.type === "adjustment" ? [l.kind, l.params] : l.type === "annotation" ? l.annotation : void 0,
-  pixelFilters: (l) => l.type === "pixel" ? pixelFilterSpec(l) : null,
+  pixelFilters: (l) => l.type === "pixel" ? edgeFilterSpec(l) : null,
   /**
    * A smart object draws its rendered pixels (contents → placement → smart filters) like a pixel
    * layer, and a shape layer the pixels rendered from its paths.
@@ -3557,7 +3646,7 @@ function compositeDeep(layers, rect, sources, depth) {
   const deep = new DeepCompositor(new LayerCompositor(), PHOTO_PROFILE, {
     applyFilterRunDeep: (run, acc, _r, masks) => applyAdjustmentLayersFloat(acc, run.map(adjustmentNodeAsLayer), masks),
     pixelFiltersDeep: (l) => {
-      if (l.type !== "pixel") return null;
+      if (l.type !== "pixel" || hasEdgeUnmix(l.edge)) return null;
       const filters = (l.filters ?? []).filter(isActiveFilter);
       if (!filters.length) return null;
       return { reach: filterReach(filters), apply: (data, width, height, linear) => runLayerFiltersFloat(data, width, height, filters, linear) };
@@ -5136,8 +5225,21 @@ function baseFields(layer, ctx) {
   if (layer.vectorMask) out.vectorMask = serializeVectorMask(layer.vectorMask);
   if (layer.locks && Object.values(layer.locks).some(Boolean)) out.locks = { ...layer.locks };
   if (layer.effects) out.effects = serializeEffects(layer.effects);
+  if (layer.edge) out.edge = { ...layer.edge, ...layer.edge.ambientColor ? { ambientColor: [...layer.edge.ambientColor] } : {} };
   return out;
 }
+function readEdgeColor(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  const out = {};
+  for (const k of ["decontaminate", "despill", "ambient"]) {
+    const v = r[k];
+    if (typeof v === "number" && Number.isFinite(v) && v > 0) out[k] = Math.min(1, v);
+  }
+  const c = r.ambientColor;
+  if (Array.isArray(c) && c.length === 3 && c.every((v) => typeof v === "number" && Number.isFinite(v))) out.ambientColor = c.map((v) => Math.min(255, Math.max(0, Math.round(v))));
+  return out.decontaminate || out.despill || out.ambient || out.ambientColor ? out : void 0;
+}
 function serializeEffects(effects) {
   const out = { enabled: effects.enabled, items: JSON.parse(JSON.stringify(effects.items)) };
   if (effects.scale !== void 0 && effects.scale !== 1) out.scale = effects.scale;
@@ -5597,6 +5699,8 @@ function deserializeLayer(raw, ctx) {
     blend: normalizeBlendMode(r.blend)
   };
   if (r.clipped === true) base.clipped = true;
+  const edge = readEdgeColor(r.edge);
+  if (edge) base.edge = edge;
   const mask = readMask(r.mask, ctx, `Layer "${base.name || id}"`);
   if (mask) base.mask = mask;
   if (r.vectorMask && typeof r.vectorMask === "object" && r.type !== "shape") {
@@ -11551,6 +11655,12 @@ export {
   followLayerMove,
   vectorMaskBounds,
   vectorMaskThumbnail,
+  EDGE_COLOR_RADIUS,
+  hasEdgeUnmix,
+  maskCoverageOverCanvas,
+  hasSoftBand,
+  despillEdge,
+  applyEdgeUnmix,
   adjustmentNodeAsLayer,
   depthMaskAlpha,
   runLayerFilters,
@@ -11668,6 +11778,7 @@ export {
   encodeSurface,
   encodeDeepSurface,
   decodeDeepSurface,
+  readEdgeColor,
   serializeEffects,
   deserializeEffects,
   readShapeComponents,