@pixerate/editor 0.212.0 → 0.214.0

package/dist/vector/index.js

@@ -10,13 +10,23 @@ import {
 } from "../chunk-65MDXWA7.js";
 import {
   VECTOR_TRACE_MAX_PIXELS,
+  bendSegment,
+  curvatureMoveAnchor,
+  cutSubpathAt,
+  joinSubpaths,
   loadOpenTypeFont,
   parseOpenTypeFont,
   quantizeVectorTraceColors,
+  removeAnchorKeepingShape,
+  removeAnchorsKeepingShape,
+  removeRedundantPoints,
+  smoothSubpath,
+  splitSubpathAt,
+  subpathPointAt,
   traceField,
   traceVectorImage,
   vectorTraceContours
-} from "../chunk-5OC22IEO.js";
+} from "../chunk-DJBYJOHM.js";
 import {
   applyHomography,
   homographyFromPoints,
@@ -540,7 +550,6 @@ import {
   transformBezierPath
 } from "../chunk-WEIK3UYB.js";
 import {
-  fitCubicWithTangents,
   fitCubics,
   parseSvgPath
 } from "../chunk-PWBZH3FK.js";
@@ -1032,8 +1041,8 @@ function vectorBlendStepCount(a, b, options, length) {
     if (cd > 1 / 255) return Math.min(VECTOR_BLEND_MAX_SMOOTH_STEPS, Math.max(1, Math.ceil(cd * 255 / 2)));
     const ba = vectorNodeBounds(a);
     const bb = vectorNodeBounds(b);
-    const dist4 = ba && bb ? Math.max(Math.abs(ba.x - bb.x), Math.abs(ba.y - bb.y), Math.abs(ba.x + ba.width - bb.x - bb.width), Math.abs(ba.y + ba.height - bb.y - bb.height)) : length;
-    return Math.min(VECTOR_BLEND_MAX_SMOOTH_STEPS, Math.max(1, Math.ceil(dist4 / 2)));
+    const dist3 = ba && bb ? Math.max(Math.abs(ba.x - bb.x), Math.abs(ba.y - bb.y), Math.abs(ba.x + ba.width - bb.x - bb.width), Math.abs(ba.y + ba.height - bb.y - bb.height)) : length;
+    return Math.min(VECTOR_BLEND_MAX_SMOOTH_STEPS, Math.max(1, Math.ceil(dist3 / 2)));
   }
   return Math.min(VECTOR_BLEND_MAX_STEPS, Math.max(1, Math.round(Number.isFinite(o.steps) ? o.steps : DEFAULT_VECTOR_BLEND_STEPS)));
 }
@@ -2539,7 +2548,7 @@ function vectorConstraintActions(doc, selection) {
   const act = (kind, refs) => ({ kind, label: VECTOR_CONSTRAINT_LABELS[kind], refs, dimensional: VECTOR_DIMENSIONAL_KINDS.has(kind) });
   const anchors = selection.anchors.filter((r) => located.get(r.nodeId)?.node.subpaths[r.subpath]?.anchors[r.index]);
   if (anchors.length) {
-    const neighbours2 = (a, b) => {
+    const neighbours = (a, b) => {
       if (a.nodeId !== b.nodeId || a.subpath !== b.subpath) return null;
       const sp = located.get(a.nodeId).node.subpaths[a.subpath];
       const n2 = sp.anchors.length;
@@ -2551,14 +2560,14 @@ function vectorConstraintActions(doc, selection) {
     const segRef = (r) => ({ ...pointRef(r), segment: true });
     if (anchors.length === 1) return [act("fix", [pointRef(anchors[0])]), act("tangent", [pointRef(anchors[0])]), act("smooth", [pointRef(anchors[0])])];
     if (anchors.length === 2) {
-      const start = neighbours2(anchors[0], anchors[1]);
+      const start = neighbours(anchors[0], anchors[1]);
       if (start) return ["horizontal", "vertical", "distance", "fix"].map((k) => act(k, [segRef(start)]));
       return ["coincident", "horizontal", "vertical", "distance"].map((k) => act(k, anchors.map(pointRef)));
     }
     if (anchors.length === 3) {
       for (let i = 0; i < 3; i++) {
         const others = anchors.filter((_, k) => k !== i);
-        const start = neighbours2(others[0], others[1]);
+        const start = neighbours(others[0], others[1]);
         if (start) return [act("coincident", [pointRef(anchors[i]), segRef(start)]), act("distance", [pointRef(anchors[i]), segRef(start)])];
       }
       return [];
@@ -2569,8 +2578,8 @@ function vectorConstraintActions(doc, selection) {
         [0, 2, 1, 3],
         [0, 3, 1, 2]
       ]) {
-        const s1 = neighbours2(anchors[i], anchors[j]);
-        const s2 = neighbours2(anchors[k], anchors[l]);
+        const s1 = neighbours(anchors[i], anchors[j]);
+        const s2 = neighbours(anchors[k], anchors[l]);
         if (s1 && s2) return ["parallel", "perpendicular", "equal", "collinear", "angle"].map((kind) => act(kind, [segRef(s1), segRef(s2)]));
       }
     }
@@ -5847,402 +5856,6 @@ function solveOnSegment(seg, base, cond) {
   return out;
 }
 
-// src/vector/pathEdit.ts
-var EPS = 1e-9;
-var unit2 = (x, y) => {
-  const l = Math.hypot(x, y);
-  return l > 1e-12 && Number.isFinite(l) ? [x / l, y / l] : null;
-};
-function cubicOf(sp, i) {
-  const s = subpathSegment(sp, i);
-  if (s.length === 4) return s;
-  const [a, b] = s;
-  return [a, [a[0] + (b[0] - a[0]) / 3, a[1] + (b[1] - a[1]) / 3], [a[0] + 2 * (b[0] - a[0]) / 3, a[1] + 2 * (b[1] - a[1]) / 3], b];
-}
-var isLine = (sp, i) => subpathSegment(sp, i).length === 2;
-function startTangent(c) {
-  for (let k = 1; k < 4; k++) {
-    const u = unit2(c[k][0] - c[0][0], c[k][1] - c[0][1]);
-    if (u) return u;
-  }
-  return [1, 0];
-}
-function endTangent(c) {
-  for (let k = 2; k >= 0; k--) {
-    const u = unit2(c[3][0] - c[k][0], c[3][1] - c[k][1]);
-    if (u) return u;
-  }
-  return [1, 0];
-}
-function sample(c, n2, out, withStart) {
-  for (let i = withStart ? 0 : 1; i <= n2; i++) out.push(segmentPoint(c, i / n2));
-}
-var onAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS && Math.abs(h.y - a.y) < EPS;
-function tidy(a, keepType = true) {
-  const next = cloneAnchor(a);
-  if (onAnchor(next, next.in)) delete next.in;
-  if (onAnchor(next, next.out)) delete next.out;
-  const shown = inferAnchorType(next);
-  const type = keepType && a.type ? a.type === "symmetric" && shown !== "symmetric" ? shown === "corner" ? "corner" : "smooth" : a.type === "smooth" && shown === "corner" ? "corner" : a.type : shown;
-  if (type === "corner") delete next.type;
-  else next.type = type;
-  return next;
-}
-function neighbours(sp, i) {
-  const n2 = sp.anchors.length;
-  const wrap2 = sp.closed && n2 > 1;
-  return [i > 0 ? i - 1 : wrap2 ? n2 - 1 : -1, i < n2 - 1 ? i + 1 : wrap2 ? 0 : -1];
-}
-function goldenMin(f, a, b) {
-  const R = 0.618033988749895;
-  let x1 = b - R * (b - a);
-  let x2 = a + R * (b - a);
-  let f1 = f(x1);
-  let f2 = f(x2);
-  for (let i = 0; i < 40; i++) {
-    if (f1.error < f2.error || Number.isNaN(f2.error)) {
-      b = x2;
-      x2 = x1;
-      f2 = f1;
-      x1 = b - R * (b - a);
-      f1 = f(x1);
-    } else {
-      a = x1;
-      x1 = x2;
-      f1 = f2;
-      x2 = a + R * (b - a);
-      f2 = f(x2);
-    }
-  }
-  return f1.error <= f2.error ? f1 : f2;
-}
-function fitAcross(pts, N, t0, t1) {
-  const fit = (k) => {
-    const u = [];
-    for (let i = 0; i <= N; i++) u.push(k * i / N);
-    for (let i = 1; i <= N; i++) u.push(k + (1 - k) * i / N);
-    return fitCubicWithTangents(pts, u, t0, t1);
-  };
-  return goldenMin(fit, 0, 1);
-}
-function removeAnchorKeepingShape(sp, index) {
-  const anchors = sp.anchors.map(cloneAnchor);
-  const n2 = anchors.length;
-  if (index < 0 || index >= n2) return { anchors, closed: sp.closed };
-  if ((sp.closed || index > 0 && index < n2 - 1) && n2 >= 3) {
-    const pi = (index + n2 - 1) % n2;
-    const ni = (index + 1) % n2;
-    if (!(isLine(sp, pi) && isLine(sp, index))) {
-      const left = cubicOf(sp, pi);
-      const right = cubicOf(sp, index);
-      const N = 16;
-      const pts = [];
-      sample(left, N, pts, true);
-      sample(right, N, pts, false);
-      const t0 = startTangent(left);
-      const t1 = endTangent(right);
-      const { curve } = fitAcross(pts, N, t0, t1);
-      if ([curve.p1, curve.p2].every((p) => Number.isFinite(p[0]) && Number.isFinite(p[1]))) {
-        anchors[pi] = tidy({ ...anchors[pi], out: { x: curve.p1[0], y: curve.p1[1] } });
-        anchors[ni] = tidy({ ...anchors[ni], in: { x: curve.p2[0], y: curve.p2[1] } });
-      }
-    }
-  }
-  anchors.splice(index, 1);
-  let closed = sp.closed;
-  if (!closed && anchors.length) {
-    anchors[0] = tidy({ ...anchors[0], in: null });
-    const last = anchors.length - 1;
-    anchors[last] = tidy({ ...anchors[last], out: null });
-  }
-  if (anchors.length < 3) closed = closed && anchors.length === 2 && anchors.some((a) => a.in || a.out);
-  return { anchors, closed };
-}
-function removeAnchorsKeepingShape(sp, indices) {
-  const order = [...new Set(indices)].filter((i) => i >= 0 && i < sp.anchors.length).sort((a, b) => b - a);
-  return order.reduce((acc, i) => removeAnchorKeepingShape(acc, i), { anchors: sp.anchors.map(cloneAnchor), closed: sp.closed });
-}
-function bendSegment(sp, segment, t, p) {
-  const anchors = sp.anchors.map(cloneAnchor);
-  const n2 = anchors.length;
-  if (segment < 0 || segment >= subpathSegmentCount(sp) || !Number.isFinite(t) || !Number.isFinite(p.x) || !Number.isFinite(p.y)) return { anchors, closed: sp.closed };
-  const tc = Math.min(0.95, Math.max(0.05, t));
-  const ia = segment;
-  const ib = (segment + 1) % n2;
-  const a = anchors[ia];
-  const b = anchors[ib];
-  const k = 3 * tc * (1 - tc);
-  const ox = (p.x - (a.x + (b.x - a.x) * tc)) / k;
-  const oy = (p.y - (a.y + (b.y - a.y) * tc)) / k;
-  const c1 = { x: a.x + (b.x - a.x) / 3 + ox, y: a.y + (b.y - a.y) / 3 + oy };
-  const c2 = { x: b.x + (a.x - b.x) / 3 + ox, y: b.y + (a.y - b.y) / 3 + oy };
-  anchors[ia] = moveAnchorHandle(a, "out", c1);
-  anchors[ib] = moveAnchorHandle(b, "in", c2);
-  return { anchors, closed: sp.closed };
-}
-function subpathPointAt(sp, segment, t) {
-  const [x, y] = segmentPoint(subpathSegment(sp, segment), t);
-  return { x, y };
-}
-function curvatureMoveAnchor(sp, index, q) {
-  const anchors = sp.anchors.map(cloneAnchor);
-  const a = sp.anchors[index];
-  if (!a) return { anchors, closed: sp.closed };
-  const own = [
-    a.in && !onAnchor(a, a.in) ? { x: a.in.x - a.x, y: a.in.y - a.y } : null,
-    a.out && !onAnchor(a, a.out) ? { x: a.out.x - a.x, y: a.out.y - a.y } : null
-  ];
-  const ends = [null, null];
-  neighbours(sp, index).forEach((j, side) => {
-    if (j < 0 || j === index) return;
-    const b = anchors[j];
-    const old = Math.hypot(a.x - b.x, a.y - b.y);
-    const s = old > 1e-9 ? Math.hypot(q.x - b.x, q.y - b.y) / old : 1;
-    const key = side === 0 ? "out" : "in";
-    const h = b[key];
-    if (h) b[key] = { x: b.x + (h.x - b.x) * s, y: b.y + (h.y - b.y) * s };
-    const o = own[side];
-    if (o) own[side] = { x: o.x * s, y: o.y * s };
-    ends[side] = { x: b.x, y: b.y };
-  });
-  const moved = { x: q.x, y: q.y };
-  if (own[0]) moved.in = { x: q.x + own[0].x, y: q.y + own[0].y };
-  if (own[1]) moved.out = { x: q.x + own[1].x, y: q.y + own[1].y };
-  if (a.type) moved.type = a.type;
-  if (a.corner) moved.corner = { ...a.corner };
-  if (a.id) moved.id = a.id;
-  const [prev, next] = ends;
-  if (a.type && a.type !== "corner" && prev && next) {
-    const dx = next.x - prev.x;
-    const dy = next.y - prev.y;
-    const l = Math.hypot(dx, dy);
-    if (l > 1e-9) {
-      const len2 = (h, to) => h ? Math.hypot(h.x, h.y) : Math.hypot(q.x - to.x, q.y - to.y) / 3;
-      let li = len2(own[0], prev);
-      let lo = len2(own[1], next);
-      if (a.type === "symmetric") li = lo = (li + lo) / 2;
-      moved.in = { x: q.x - dx * li / l, y: q.y - dy * li / l };
-      moved.out = { x: q.x + dx * lo / l, y: q.y + dy * lo / l };
-    }
-  }
-  anchors[index] = moved;
-  return { anchors, closed: sp.closed };
-}
-function cutSubpathAt(sp, at) {
-  const n2 = sp.anchors.length;
-  const cuts = [...new Set(at)].filter((i) => Number.isInteger(i) && i >= 0 && i < n2 && (sp.closed || i > 0 && i < n2 - 1)).sort((a, b) => a - b);
-  if (!cuts.length || n2 < 2) return [{ anchors: sp.anchors.map(cloneAnchor), closed: sp.closed }];
-  const first = cuts[0];
-  const run = sp.closed ? Array.from({ length: n2 + 1 }, (_, i) => sp.anchors[(first + i) % n2]) : sp.anchors;
-  const cutSet = new Set(sp.closed ? [...cuts.map((c) => (c - first + n2) % n2), n2] : cuts);
-  const pieces = [];
-  let cur = [];
-  run.forEach((a, i) => {
-    if (!cutSet.has(i)) {
-      cur.push(cloneAnchor(a));
-      return;
-    }
-    if (cur.length) {
-      cur.push(tidy({ ...a, out: null }, false));
-      pieces.push({ anchors: cur, closed: false });
-      cur = [];
-    }
-    if (i < n2) cur.push(tidy({ ...a, in: null }, false));
-  });
-  if (cur.length > 1) pieces.push({ anchors: cur, closed: false });
-  return pieces;
-}
-function splitSubpathAt(sp, segment, t, endTolerance = 1e-6) {
-  const n2 = sp.anchors.length;
-  if (segment < 0 || segment >= subpathSegmentCount(sp)) return [{ anchors: sp.anchors.map(cloneAnchor), closed: sp.closed }];
-  if (t <= endTolerance) return cutSubpathAt(sp, [segment]);
-  if (t >= 1 - endTolerance) return cutSubpathAt(sp, [(segment + 1) % n2]);
-  const { subpath, index } = insertAnchor(sp, segment, t);
-  return cutSubpathAt(subpath, [index]);
-}
-var endOf = (sp, last) => sp.anchors[last ? sp.anchors.length - 1 : 0];
-var dist2 = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
-function reverse(sp) {
-  return {
-    closed: sp.closed,
-    anchors: sp.anchors.slice().reverse().map((a) => {
-      const next = { x: a.x, y: a.y };
-      if (a.out) next.in = { ...a.out };
-      if (a.in) next.out = { ...a.in };
-      if (a.type) next.type = a.type;
-      if (a.corner) next.corner = { ...a.corner };
-      if (a.id) next.id = a.id;
-      return next;
-    })
-  };
-}
-function joinSubpaths(subpaths, tolerance) {
-  const closed = [];
-  let open = [];
-  for (const sp of subpaths) {
-    const copy = { anchors: sp.anchors.map(cloneAnchor), closed: sp.closed };
-    if (sp.closed || sp.anchors.length < 2) {
-      if (sp.anchors.length) closed.push(copy);
-    } else open.push(copy);
-  }
-  if (open.length === 1) {
-    const sp = open[0];
-    const first = sp.anchors[0];
-    const last = sp.anchors[sp.anchors.length - 1];
-    if (sp.anchors.length > 2 && dist2(first, last) <= tolerance) {
-      sp.anchors.pop();
-      sp.anchors[0] = tidy({ ...first, in: last.in ?? null }, false);
-    } else {
-      sp.anchors[0] = tidy({ ...first, in: null }, false);
-      sp.anchors[sp.anchors.length - 1] = tidy({ ...sp.anchors[sp.anchors.length - 1], out: null }, false);
-    }
-    sp.closed = true;
-    return [...closed, sp];
-  }
-  while (open.length > 1) {
-    let best = { d: Infinity, i: 0, j: 1, ei: true, ej: false };
-    for (let i = 0; i < open.length; i++) {
-      for (let j = i + 1; j < open.length; j++) {
-        for (const ei of [false, true]) {
-          for (const ej of [false, true]) {
-            const d = dist2(endOf(open[i], ei), endOf(open[j], ej));
-            if (d < best.d) best = { d, i, j, ei, ej };
-          }
-        }
-      }
-    }
-    let a = open[best.i];
-    let b = open[best.j];
-    open = open.filter((_, k) => k !== best.j);
-    if (!best.ei) a = reverse(a);
-    if (best.ej) b = reverse(b);
-    const anchors = a.anchors;
-    if (best.d <= tolerance) {
-      const [head, ...rest] = b.anchors;
-      const l = anchors[anchors.length - 1];
-      anchors[anchors.length - 1] = tidy({ ...l, out: head.out ?? null }, false);
-      anchors.push(...rest);
-    } else {
-      const l = anchors[anchors.length - 1];
-      anchors[anchors.length - 1] = tidy({ ...l, out: null }, false);
-      anchors.push(tidy({ ...b.anchors[0], in: null }, false), ...b.anchors.slice(1));
-    }
-    open[best.i > best.j ? best.i - 1 : best.i] = { anchors, closed: false };
-  }
-  return [...closed, ...open];
-}
-function smoothSubpath(sp, amount = 1, only) {
-  const t = Math.min(1, Math.max(0, amount));
-  const orig = sp.anchors;
-  const n2 = orig.length;
-  const anchors = orig.map(cloneAnchor);
-  if (n2 < 3 || t === 0) return { anchors, closed: sp.closed };
-  for (let i = 0; i < n2; i++) {
-    if (!sp.closed && (i === 0 || i === n2 - 1)) continue;
-    if (only && !only.has(i)) continue;
-    const prev = orig[(i + n2 - 1) % n2];
-    const next = orig[(i + 1) % n2];
-    const p = orig[i];
-    const dir = unit2(next.x - prev.x, next.y - prev.y);
-    if (!dir) continue;
-    const li = dist2(p, prev) / 3;
-    const lo = dist2(p, next) / 3;
-    const hin = p.in ?? p;
-    const hout = p.out ?? p;
-    const target = (h, x, y) => ({ x: h.x + (x - h.x) * t, y: h.y + (y - h.y) * t });
-    anchors[i] = tidy(
-      {
-        x: p.x,
-        y: p.y,
-        in: target(hin, p.x - dir[0] * li, p.y - dir[1] * li),
-        out: target(hout, p.x + dir[0] * lo, p.y + dir[1] * lo)
-      },
-      false
-    );
-  }
-  return { anchors, closed: sp.closed };
-}
-function segsOf(sp) {
-  const out = [];
-  for (let i = 0; i < subpathSegmentCount(sp); i++) {
-    const s = subpathSegment(sp, i);
-    out.push(s.length === 2 ? { c: s, line: true } : { c: s, line: false });
-  }
-  return out;
-}
-function segsToSubpath(segs, closed, types) {
-  if (!segs.length) return null;
-  const anchors = [];
-  const at = (p) => ({ x: p[0], y: p[1] });
-  anchors.push(at(segs[0].c[0]));
-  for (const s of segs) {
-    const end = s.c[s.c.length - 1];
-    if (!s.line) anchors[anchors.length - 1].out = { x: s.c[1][0], y: s.c[1][1] };
-    const next = at(end);
-    if (!s.line) next.in = { x: s.c[2][0], y: s.c[2][1] };
-    anchors.push(next);
-  }
-  if (closed) {
-    const last = anchors.pop();
-    if (last.in) anchors[0].in = last.in;
-  }
-  const typed2 = anchors.map((a) => {
-    const type = types.get(`${a.x},${a.y}`);
-    return tidy(type ? { ...a, type } : a, !!type);
-  });
-  return { anchors: typed2, closed };
-}
-var isZeroSeg = (s) => s.c.every((p) => Math.abs(p[0] - s.c[0][0]) < 1e-9 && Math.abs(p[1] - s.c[0][1]) < 1e-9);
-function mergePair(a, b, tol) {
-  const a0 = a.c[0];
-  const a3 = a.c[a.c.length - 1];
-  const b3 = b.c[b.c.length - 1];
-  if (a.line && b.line) {
-    const cx = b3[0] - a0[0];
-    const cy = b3[1] - a0[1];
-    const len2 = Math.hypot(cx, cy);
-    if (len2 < 1e-12) return null;
-    const mx = a3[0] - a0[0];
-    const my = a3[1] - a0[1];
-    const along = (mx * cx + my * cy) / len2;
-    return Math.abs((mx * cy - my * cx) / len2) <= tol && along >= 0 && along <= len2 ? { c: [a0, b3], line: true } : null;
-  }
-  const ca = a.line ? [a0, a0, a3, a3] : a.c;
-  const cb = b.line ? [a3, a3, b3, b3] : b.c;
-  const ta = endTangent(ca);
-  const tb = startTangent(cb);
-  if (ta[0] * tb[0] + ta[1] * tb[1] < 0.99) return null;
-  const pts = [];
-  sample(ca, 16, pts, true);
-  sample(cb, 16, pts, false);
-  const { curve, error } = fitAcross(pts, 16, startTangent(ca), endTangent(cb));
-  return error <= tol ? { c: [curve.p0, curve.p1, curve.p2, curve.p3], line: false } : null;
-}
-function removeRedundantPoints(sp, tolerance) {
-  const tol = Math.max(tolerance, 1e-9);
-  const types = new Map(sp.anchors.filter((a) => a.type).map((a) => [`${a.x},${a.y}`, a.type]));
-  const segs = segsOf(sp).filter((s) => !isZeroSeg(s));
-  if (!segs.length) return { anchors: sp.anchors.map(cloneAnchor), closed: sp.closed };
-  const minSegs = sp.closed ? 2 : 1;
-  let changed = true;
-  while (changed && segs.length > minSegs) {
-    changed = false;
-    const n2 = segs.length;
-    const joints = sp.closed ? n2 : n2 - 1;
-    for (let j = 0; j < joints; j++) {
-      const [i0, i1] = sp.closed ? [(j + n2 - 1) % n2, j] : [j, j + 1];
-      const m = mergePair(segs[i0], segs[i1], tol);
-      if (!m) continue;
-      segs[i0] = m;
-      segs.splice(i1, 1);
-      if (sp.closed && i1 === 0) segs.unshift(segs.pop());
-      changed = true;
-      break;
-    }
-  }
-  return segsToSubpath(segs, sp.closed, types) ?? { anchors: sp.anchors.map(cloneAnchor), closed: sp.closed };
-}
-
 // src/vector/ink.ts
 var LazyMouse = class {
   /** `length` is the string length in the units of the points (0 turns smoothing off). */
@@ -6297,7 +5910,7 @@ function vectorInkShapeName(shape) {
       return shape.points.length === 3 ? "triangle" : "polygon";
   }
 }
-var dist3 = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1]);
+var dist2 = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1]);
 function bbox(pts) {
   if (!pts.length) return [0, 0, 0, 0];
   let [x0, y0] = pts[0];
@@ -6315,7 +5928,7 @@ function segDistance(a, b, p) {
   const dy = b[1] - a[1];
   const len2 = dx * dx + dy * dy;
   const t = len2 > 0 ? Math.min(1, Math.max(0, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / len2)) : 0;
-  return dist3([a[0] + t * dx, a[1] + t * dy], p);
+  return dist2([a[0] + t * dx, a[1] + t * dy], p);
 }
 function polygonDistance(c, p) {
   let best = Infinity;
@@ -6377,7 +5990,7 @@ function corners(p, diag) {
   let far = 0;
   let farD = 0;
   p.forEach((q, i) => {
-    const d = dist3(start, q);
+    const d = dist2(start, q);
     if (d > farD) {
       farD = d;
       far = i;
@@ -6404,7 +6017,7 @@ function corners(p, diag) {
     }
     let short = -1;
     for (let j = 0; j < n2; j++) {
-      if (dist3(ring[j], ring[(j + 1) % n2]) < 0.1 * diag) {
+      if (dist2(ring[j], ring[(j + 1) % n2]) < 0.1 * diag) {
         short = j;
         break;
       }
@@ -6444,8 +6057,8 @@ function recognizeInkShape(points, options = {}) {
   const diag = Math.hypot(w, h);
   if (size < minSize) return null;
   let length = 0;
-  for (let i = 1; i < p.length; i++) length += dist3(p[i - 1], p[i]);
-  const gap = dist3(first, last);
+  for (let i = 1; i < p.length; i++) length += dist2(p[i - 1], p[i]);
+  const gap = dist2(first, last);
   if (gap > 0.85 * length && gap >= minSize) {
     const off = Math.max(...p.map((q) => segDistance(first, last, q)));
     if (off <= Math.max(0.06 * gap, 1.5 * minSize / 6)) return { kind: "line", a: first, b: last };
@@ -10687,7 +10300,7 @@ var VectorEditorController = class _VectorEditorController {
     if (input.radius !== void 0 && !(Number.isFinite(input.radius) && input.radius >= 0)) return { ok: false, message: "radius must be zero or more." };
     if (input.gap !== void 0 && !(Number.isFinite(input.gap) && input.gap >= 0)) return { ok: false, message: "gap must be zero or more." };
     const point = (e) => glued(e) ? { x: 0, y: 0 } : { x: e.x, y: e.y };
-    const endOf2 = (e) => glued(e) ? { nodeId: e.nodeId, ...e.side && e.side !== "auto" ? { side: e.side } : {} } : null;
+    const endOf = (e) => glued(e) ? { nodeId: e.nodeId, ...e.side && e.side !== "auto" ? { side: e.side } : {} } : null;
     const id = this.newId();
     const style = this.styleFor(true);
     const node = {
@@ -10700,8 +10313,8 @@ var VectorEditorController = class _VectorEditorController {
       ...input.startArrow !== void 0 ? { startArrow: input.startArrow } : {},
       endArrow: input.endArrow !== void 0 ? input.endArrow : style.endArrow ?? "triangle",
       connector: {
-        start: endOf2(input.start),
-        end: endOf2(input.end),
+        start: endOf(input.start),
+        end: endOf(input.end),
         ...route !== "straight" ? { route } : {},
         ...input.radius ? { radius: input.radius } : {},
         ...input.gap !== void 0 ? { gap: input.gap } : {}
@@ -10787,14 +10400,14 @@ var VectorEditorController = class _VectorEditorController {
       }
     }
     const set = new Set(ids);
-    const endOf2 = (e) => e ? { nodeId: e.nodeId, ...e.side && e.side !== "auto" ? { side: e.side } : {} } : null;
+    const endOf = (e) => e ? { nodeId: e.nodeId, ...e.side && e.side !== "auto" ? { side: e.side } : {} } : null;
     this.change("Connector", () => {
       this.setDoc(
         mapTree(this.doc.nodes, (n2) => {
           if (!set.has(n2.id) || n2.type !== "path") return n2;
           const c = { ...n2.connector ?? {} };
-          if (patch.start !== void 0) c.start = endOf2(patch.start);
-          if (patch.end !== void 0) c.end = endOf2(patch.end);
+          if (patch.start !== void 0) c.start = endOf(patch.start);
+          if (patch.end !== void 0) c.end = endOf(patch.end);
           if (patch.route !== void 0) {
             if (patch.route === "straight") delete c.route;
             else c.route = patch.route;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixerate/editor",
-  "version": "0.212.0",
+  "version": "0.214.0",
   "description": "UI-agnostic rich text and media editing core library",
   "author": "Pixerate",
   "license": "MIT",

package/skills/pixerate-image-editor/SKILL.md

@@ -103,6 +103,8 @@ Live per-layer effects (shadows, glows, bevel, overlays, strokes): see `referenc
 1. **Keep outlines as paths**: `make_work_path` turns the selection into the Work Path (the next
    one replaces it; `rename_path` saves it), `add_path` adds one from geometry.
 2. **Use them**: `path_to_selection` / `add_vector_mask` with `pathId`, `fill_path`, `stroke_path`.
+3. **Edit anchors** as the Pen and Direct Selection tools do: `get_path` → change anchors and handles
+   → `set_path_geometry` (one undo step); shapes `set_shape_component`, vector masks `set_vector_mask_path`.
 
 ### Painting
 
@@ -208,6 +210,7 @@ in the source frame at the document's bit depth, colour mode and profile. Read
 | `get_adjustments` | Read the current state: `values` by control id, `process` version (1 or 2), and `layers` bottom to top with id, kind, params, opacity, blend, enabled and mask. Call first, and to find layer ids. |
 | `list_controls` | Get every base control (id, label, section, min, max, step, default, `requiresProcess`), each layer kind's settable controls (plus `opacity`), the blend mode ids and the `layers.<layerId>.<controlId>` path format. Call once per session before writing. |
 | `get_selection` | Read the active selection: `empty`, `bounds` (natural pixels), `area` in pixels, `percent` of the image and a description. Check it after every select or modify step and before masking: a wand that covered 90% of the image is the wrong selection. |
+| `inspect_mask_edge` | Measure an edge without looking: the selection (default) or a layer's `layer-mask` / `vector-mask` (`layerId`). Returns `haloScore`, `edgeAlignment`, `jaggedness`, `softFraction`, `holes`, `islands`, `worst` regions for `capture_view` and `issues` with fixes. Inspect, fix, inspect again (see `pixerate-image-selection-masking`). |
 | `list_channels` | Read the alpha channels (saved selections): id, name, bounds, percent, overlay and visibility, and whether Quick Mask mode is on. |
 | `select_subject` | Select › Subject. With a host segmentation model, `target` describes what to select ("the dog", "the sky") and the model's outlines are selected (`maxSegments` 1 for one). Without one, the subject that stands out most is found classically; `target` can't choose it (`method: "saliency"`, `note`). Combined by `mode`. Returns the selection, `found` (label, bounds) and `method`; nothing found leaves the selection unchanged. |
 | `list_layers` | Read the layer stack bottom to top as a tree: id, type (`pixel`, `adjustment`, `group`, `shape`, `annotation`, `smart`; smart objects add their `contents`, `smartFilters` and `filterMask`; shapes a `shape` summary of component ops and kinds and paint types, and `annotation` when migrated from one), name, document `bounds` of pixel layers, visibility, opacity, `fillOpacity`, blend, `clipped`, locks, a `mask` summary, an `effects` summary (master switch, scale, effect ids and kinds), pixel-layer `filters` (the Background's `develop` filter is the base adjustments), adjustment `kind` and `params`, group `children`, and which layer is `active`. Call it to understand a document with more than the Background before changing it; adjustment layer ids work with every adjustment-layer tool. |

package/skills/pixerate-image-selection-masking/SKILL.md

@@ -44,10 +44,10 @@ This skill is the method. `pixerate-image-editor` has the full tool reference.
    what leaked, and `intersect` to limit it to a region (for example `select_rect` around the
    subject).
    **Check:** `bounds` hug the subject. A bounds as large as the image means a leak.
-3. **Look at the edge.** Use `capture_view` with `region: "selection"` and `includeOverlays: true`,
-   or `set_selection_display` `quickMask`, to see soft edges as a tint.
-   **Check:** no holes in the subject, no islands in the background, and edges on the subject's
-   outline.
+3. **Measure the edge, then look.** `inspect_mask_edge` scores it: `haloScore` ≥ 0.35 is old
+   background inside the edge, `edgeAlignment` < 0.5 is off the image's edges, `jaggedness` ≥ 15
+   zigzags; it counts `holes` and `islands`, `issues` names fixes, `worst` gives `capture_view` rects.
+   **Check:** `issues` is empty, or each one is intended (a deliberately soft edge or a second piece).
 4. **Clean it up.**
    - `modify_selection` `smooth` (2–4 px) removes wand speckle.
    - `grow_selection` (tolerance 10–30) picks up the shades a wand click missed;
@@ -89,7 +89,8 @@ This skill is the method. `pixerate-image-editor` has the full tool reference.
    writes the selection, a channel or a layer mask as a greyscale PNG; a matte that comes
    back goes into a channel with `load_channel_from_image` (or straight to the selection with
    `load_selection_from_image`).
-7. **Verify.** `render_preview` at 1024 px or more, and `capture_view` on the edge at 2–8×.
+7. **Verify.** `inspect_mask_edge` again (`target: "layer-mask"` and `layerId` for a mask),
+   `render_preview` at 1024 px or more, and `capture_view` on `worst` regions at 2–8×.
    **Check:** no fringe of the old background colour, no stair-steps, no visible line where an
    adjustment ends. To judge a layer mask itself, `set_mask_view` `gray` (or `overlay`) and
    `capture_view` with `includeOverlays: true`; holes and stray grey show plainly there. Set it
@@ -220,8 +221,7 @@ This skill is the method. `pixerate-image-editor` has the full tool reference.
 - `select_layer_transparency`: a layer's own pixels
 - `grow_selection`, `select_similar`: add similar colour, connected or anywhere
 - `reselect`: undo a deselect
-- `save_selection`, `load_selection_from_channel`, `list_channels`: keep selections as alpha channels
-- `set_channel_properties`, `duplicate_channel`, `delete_channel`: manage channels
+- `save_selection`, `load_selection_from_channel`, `list_channels`, `set_channel_properties`, `duplicate_channel`, `delete_channel`: keep and manage selections as alpha channels
 - `export_mask_image`: a selection, channel or layer mask as a greyscale PNG
 - `load_channel_from_image`: a mask image into a new channel
 - `set_quick_mask`: paint the selection
@@ -240,8 +240,8 @@ This skill is the method. `pixerate-image-editor` has the full tool reference.
 - `modify_selection`: expand, contract, feather, border, smooth
 - `refine_selection`: snap the edge to the image
 - `transform_selection`: move or scale the outline only
-- `capture_view`: inspect the edge at pixel level
-- `render_preview`: check the result
+- `inspect_mask_edge`: measured halo, alignment, jaggedness, softness, holes and islands of an edge
+- `capture_view`, `render_preview`: look at the edge at pixel level; check the result
 - `apply_selection_as_mask`: a masked adjustment layer in one step
 - `add_layer_mask`, `set_layer_mask_properties`, `apply_layer_mask`, `remove_layer_mask`: layer masks
 - `set_smart_filter_mask`: limit smart filters