@weasel-js/geom 1.10.1 → 1.11.1

package/dist/chunk-B53BERKG.js

@@ -0,0 +1,386 @@
+// src/box.ts
+function boundsOfCoords(coords) {
+  if (coords.length < 2) return null;
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (let i = 0; i + 1 < coords.length; i += 2) {
+    const x = coords[i], y = coords[i + 1];
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (x > maxX) maxX = x;
+    if (y > maxY) maxY = y;
+  }
+  return [minX, minY, maxX, maxY];
+}
+function unionBox(a, b) {
+  return [
+    Math.min(a[0], b[0]),
+    Math.min(a[1], b[1]),
+    Math.max(a[2], b[2]),
+    Math.max(a[3], b[3])
+  ];
+}
+function boxContainsPoint(b, x, y) {
+  return x >= b[0] && x <= b[2] && y >= b[1] && y <= b[3];
+}
+function boxContainsBox(outer, inner) {
+  return inner[0] >= outer[0] && inner[1] >= outer[1] && inner[2] <= outer[2] && inner[3] <= outer[3];
+}
+function rectToContour(x, y, w, h) {
+  return Float64Array.of(x, y, x + w, y, x + w, y + h, x, y + h);
+}
+
+// src/commands.ts
+var PATH_COMMANDS = {
+  /** moveTo — opens a new subpath. */
+  M: { code: 0, coords: 2 },
+  /** Straight segment from the pen to the next coord pair. */
+  L: { code: 1, coords: 2 },
+  /** Cubic bezier: two control points then the endpoint. */
+  C: { code: 2, coords: 6 },
+  /** Quadratic bezier: one control point then the endpoint. */
+  Q: { code: 3, coords: 4 },
+  /** Close the current subpath back to its start. Consumes no coords and
+   *  leaves the pen where it is. */
+  Z: { code: 4, coords: 0 }
+};
+var PATH_M = PATH_COMMANDS.M.code;
+var PATH_L = PATH_COMMANDS.L.code;
+var PATH_C = PATH_COMMANDS.C.code;
+var PATH_Q = PATH_COMMANDS.Q.code;
+var PATH_Z = PATH_COMMANDS.Z.code;
+var PATH_CMD_LENGTHS = buildCmdLengths();
+function buildCmdLengths() {
+  const lengths = [];
+  for (const { code, coords } of Object.values(PATH_COMMANDS)) lengths[code] = coords;
+  return lengths;
+}
+function pathCommandCoordCount(cmd) {
+  return PATH_CMD_LENGTHS[cmd];
+}
+function forEachSegment(commands, coords, visit) {
+  let ci = 0;
+  let px = 0, py = 0;
+  let startX = 0, startY = 0;
+  let open = false;
+  for (let i = 0; i < commands.length; i++) {
+    const cmd = commands[i];
+    const opens = !open && cmd !== PATH_M && cmd !== PATH_Z;
+    if (opens) {
+      startX = px;
+      startY = py;
+    }
+    open = cmd !== PATH_Z;
+    if (visit(cmd, ci, px, py, i, opens) === false) return;
+    const len = pathCommandCoordCount(cmd);
+    if (len === void 0) throw new Error(`forEachSegment: unknown command code ${cmd}`);
+    if (len > 0) {
+      px = coords[ci + len - 2];
+      py = coords[ci + len - 1];
+      ci += len;
+      if (cmd === PATH_M) {
+        startX = px;
+        startY = py;
+      }
+    } else if (cmd === PATH_Z) {
+      px = startX;
+      py = startY;
+    }
+  }
+}
+
+// src/curve.ts
+function cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, t) {
+  const u = 1 - t;
+  const a = u * u * u, b = 3 * u * u * t, c = 3 * u * t * t, d = t * t * t;
+  return [
+    a * x0 + b * x1 + c * x2 + d * x3,
+    a * y0 + b * y1 + c * y2 + d * y3
+  ];
+}
+function elevateQuadraticToCubic(q0x, q0y, cx, cy, q1x, q1y) {
+  return [
+    q0x + 2 / 3 * (cx - q0x),
+    q0y + 2 / 3 * (cy - q0y),
+    q1x + 2 / 3 * (cx - q1x),
+    q1y + 2 / 3 * (cy - q1y)
+  ];
+}
+function cubicAxisExtremaTs(p0, p1, p2, p3) {
+  const a = -p0 + 3 * p1 - 3 * p2 + p3;
+  const b = 2 * (p0 - 2 * p1 + p2);
+  const c = -p0 + p1;
+  const ts = [];
+  const push = (t) => {
+    if (t > 0 && t < 1) ts.push(t);
+  };
+  if (Math.abs(a) < 1e-12) {
+    if (Math.abs(b) > 1e-12) push(-c / b);
+  } else {
+    const disc = b * b - 4 * a * c;
+    if (disc >= 0) {
+      const sq = Math.sqrt(disc);
+      push((-b + sq) / (2 * a));
+      push((-b - sq) / (2 * a));
+    }
+  }
+  return ts;
+}
+function cubicBounds(x0, y0, x1, y1, x2, y2, x3, y3) {
+  let minX = Math.min(x0, x3), maxX = Math.max(x0, x3);
+  let minY = Math.min(y0, y3), maxY = Math.max(y0, y3);
+  for (const t of cubicAxisExtremaTs(x0, x1, x2, x3)) {
+    const [ex] = cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, t);
+    if (ex < minX) minX = ex;
+    if (ex > maxX) maxX = ex;
+  }
+  for (const t of cubicAxisExtremaTs(y0, y1, y2, y3)) {
+    const [, ey] = cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, t);
+    if (ey < minY) minY = ey;
+    if (ey > maxY) maxY = ey;
+  }
+  return [minX, minY, maxX, maxY];
+}
+function quadraticEvalAt(x0, y0, x1, y1, x2, y2, t) {
+  const u = 1 - t;
+  const a = u * u, b = 2 * u * t, c = t * t;
+  return [a * x0 + b * x1 + c * x2, a * y0 + b * y1 + c * y2];
+}
+function splitCubicAt(x0, y0, x1, y1, x2, y2, x3, y3, t) {
+  const ax = x0 + (x1 - x0) * t, ay = y0 + (y1 - y0) * t;
+  const bx = x1 + (x2 - x1) * t, by = y1 + (y2 - y1) * t;
+  const cx = x2 + (x3 - x2) * t, cy = y2 + (y3 - y2) * t;
+  const dx = ax + (bx - ax) * t, dy = ay + (by - ay) * t;
+  const ex = bx + (cx - bx) * t, ey = by + (cy - by) * t;
+  const mx = dx + (ex - dx) * t, my = dy + (ey - dy) * t;
+  return [[x0, y0, ax, ay, dx, dy, mx, my], [mx, my, ex, ey, cx, cy, x3, y3]];
+}
+function splitQuadraticAt(x0, y0, x1, y1, x2, y2, t) {
+  const ax = x0 + (x1 - x0) * t, ay = y0 + (y1 - y0) * t;
+  const bx = x1 + (x2 - x1) * t, by = y1 + (y2 - y1) * t;
+  const mx = ax + (bx - ax) * t, my = ay + (by - ay) * t;
+  return [[x0, y0, ax, ay, mx, my], [mx, my, bx, by, x2, y2]];
+}
+function splitLineAt(x0, y0, x1, y1, t) {
+  const mx = x0 + (x1 - x0) * t, my = y0 + (y1 - y0) * t;
+  return [[x0, y0, mx, my], [mx, my, x1, y1]];
+}
+
+// src/paths/builder.ts
+var PathBuilder = class _PathBuilder {
+  cmds = [];
+  xs = [];
+  fillRule = "nonzero";
+  /** Seed a builder with an existing `PolygonPath`. Useful for extending
+   *  an in-flight path with another segment (e.g. appending a cubic to
+   *  the end of a curve in response to a user action) without hand-
+   *  reaching into the `commands` / `coords` typed arrays.
+   *
+   *  ```ts
+   *  const next = PathBuilder.fromPath(current).curveTo(...).build();
+   *  ```
+   */
+  static fromPath(path) {
+    const b = new _PathBuilder();
+    b.cmds = Array.from(path.commands);
+    b.xs = Array.from(path.coords);
+    b.fillRule = path.fillRule;
+    return b;
+  }
+  setFillRule(rule) {
+    this.fillRule = rule;
+    return this;
+  }
+  moveTo(x, y) {
+    this.cmds.push(PATH_M);
+    this.xs.push(x, y);
+    return this;
+  }
+  lineTo(x, y) {
+    this.cmds.push(PATH_L);
+    this.xs.push(x, y);
+    return this;
+  }
+  /** Cubic bezier to (x, y) with control points (x1, y1) and (x2, y2). */
+  curveTo(x1, y1, x2, y2, x, y) {
+    this.cmds.push(PATH_C);
+    this.xs.push(x1, y1, x2, y2, x, y);
+    return this;
+  }
+  /** Quadratic bezier to (x, y) with control point (x1, y1). */
+  quadTo(x1, y1, x, y) {
+    this.cmds.push(PATH_Q);
+    this.xs.push(x1, y1, x, y);
+    return this;
+  }
+  close() {
+    this.cmds.push(PATH_Z);
+    return this;
+  }
+  build() {
+    return {
+      kind: "polygon",
+      commands: new Uint8Array(this.cmds),
+      coords: new Float32Array(this.xs),
+      fillRule: this.fillRule
+    };
+  }
+};
+function rectPath(x, y, width, height) {
+  return { kind: "rect", x, y, width, height };
+}
+function asPolygonPath(path) {
+  if (path.kind === "polygon") return path;
+  return {
+    kind: "polygon",
+    commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),
+    coords: Float32Array.from(rectToContour(path.x, path.y, path.width, path.height)),
+    fillRule: "nonzero"
+  };
+}
+function polylineFromPoints(points) {
+  const b = new PathBuilder();
+  const first = points[0];
+  if (!first) return rectPath(0, 0, 0, 0);
+  b.moveTo(first.x, first.y);
+  for (let i = 1; i < points.length; i++) {
+    const p = points[i];
+    if (p) b.lineTo(p.x, p.y);
+  }
+  return b.build();
+}
+function polygonFromPoints(points, opts = {}) {
+  if (points.length === 0) {
+    return {
+      kind: "polygon",
+      commands: new Uint8Array(),
+      coords: new Float32Array(),
+      fillRule: opts.fillRule ?? "nonzero"
+    };
+  }
+  const b = new PathBuilder();
+  if (opts.fillRule) b.setFillRule(opts.fillRule);
+  b.moveTo(points[0].x, points[0].y);
+  for (let i = 1; i < points.length; i++) b.lineTo(points[i].x, points[i].y);
+  b.close();
+  return b.build();
+}
+var ELLIPSE_KAPPA = 0.5522847498307936;
+function ellipsePath(bounds) {
+  const cx = bounds.x + bounds.width / 2;
+  const cy = bounds.y + bounds.height / 2;
+  const rx = bounds.width / 2;
+  const ry = bounds.height / 2;
+  const ox = rx * ELLIPSE_KAPPA;
+  const oy = ry * ELLIPSE_KAPPA;
+  const b = new PathBuilder();
+  b.moveTo(cx + rx, cy);
+  b.curveTo(cx + rx, cy + oy, cx + ox, cy + ry, cx, cy + ry);
+  b.curveTo(cx - ox, cy + ry, cx - rx, cy + oy, cx - rx, cy);
+  b.curveTo(cx - rx, cy - oy, cx - ox, cy - ry, cx, cy - ry);
+  b.curveTo(cx + ox, cy - ry, cx + rx, cy - oy, cx + rx, cy);
+  b.close();
+  return b.build();
+}
+function regularPolygonPath(center, radius, sides, rotation = 0) {
+  const b = new PathBuilder();
+  for (let i = 0; i < sides; i++) {
+    const a = rotation + i / sides * Math.PI * 2;
+    const x = center.x + radius * Math.cos(a);
+    const y = center.y + radius * Math.sin(a);
+    if (i === 0) b.moveTo(x, y);
+    else b.lineTo(x, y);
+  }
+  b.close();
+  return b.build();
+}
+function starPath(center, outerRadius, points = 5, innerRadius = outerRadius / 2, rotation = 0) {
+  const b = new PathBuilder();
+  const n = points * 2;
+  for (let i = 0; i < n; i++) {
+    const a = rotation + i / n * Math.PI * 2;
+    const r = i % 2 === 0 ? outerRadius : innerRadius;
+    const x = center.x + r * Math.cos(a);
+    const y = center.y + r * Math.sin(a);
+    if (i === 0) b.moveTo(x, y);
+    else b.lineTo(x, y);
+  }
+  b.close();
+  return b.build();
+}
+function linePath(a, b) {
+  const pb = new PathBuilder();
+  pb.moveTo(a.x, a.y);
+  pb.lineTo(b.x, b.y);
+  return pb.build();
+}
+
+// src/paths/cornerSpec.ts
+function cornerAt(path, index) {
+  const spec = path.corners?.[index];
+  return spec && spec.radius > 0 ? spec : null;
+}
+function cornerSpecAt(path, index) {
+  return path.corners?.[index] ?? null;
+}
+function hasCorners(path) {
+  const corners = path.corners;
+  if (!corners) return false;
+  for (const c of corners) if (c && c.radius > 0) return true;
+  return false;
+}
+function compactCorners(corners) {
+  let end = corners.length;
+  while (end > 0 && !corners[end - 1]) end--;
+  if (end === 0) return void 0;
+  const out = new Array(end);
+  for (let i = 0; i < end; i++) out[i] = corners[i] ?? null;
+  return out;
+}
+function withoutCorners(path) {
+  if (path.corners === void 0) return path;
+  const { corners: _dropped, ...rest } = path;
+  return rest;
+}
+function withCorner(path, index, spec) {
+  const next = path.corners ? [...path.corners] : [];
+  while (next.length <= index) next.push(null);
+  next[index] = spec ? { shape: spec.shape, radius: Math.max(0, spec.radius) } : null;
+  const corners = compactCorners(next);
+  const bare = withoutCorners(path);
+  return corners ? { ...bare, corners } : bare;
+}
+function scaleCorners(path, factor) {
+  if (!path.corners || factor === 1) return path;
+  return {
+    ...path,
+    corners: path.corners.map((c) => c ? { shape: c.shape, radius: c.radius * factor } : null)
+  };
+}
+function lerpCorners(a, b, t) {
+  if (!a && !b) return void 0;
+  const n = Math.max(a?.length ?? 0, b?.length ?? 0);
+  const out = new Array(n);
+  for (let i = 0; i < n; i++) {
+    const ca = a?.[i] ?? null, cb = b?.[i] ?? null;
+    const either = ca ?? cb;
+    if (!either) out[i] = null;
+    else if (ca && cb && ca.shape !== cb.shape) out[i] = t < 0.5 ? ca : cb;
+    else out[i] = { shape: either.shape, radius: (ca?.radius ?? 0) + ((cb?.radius ?? 0) - (ca?.radius ?? 0)) * t };
+  }
+  return compactCorners(out);
+}
+
+// src/paths/cubicMath.ts
+function cubicPointAt(p0, p1, p2, p3, t) {
+  const [x, y] = cubicEvalAt(p0.x, p0.y, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, t);
+  return { x, y };
+}
+function splitCubicAtT(p0, p1, p2, p3, t) {
+  const [l, r] = splitCubicAt(p0.x, p0.y, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, t);
+  const quad = (c) => [{ x: c[0], y: c[1] }, { x: c[2], y: c[3] }, { x: c[4], y: c[5] }, { x: c[6], y: c[7] }];
+  return { left: quad(l), right: quad(r) };
+}
+
+export { PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, PathBuilder, asPolygonPath, boundsOfCoords, boxContainsBox, boxContainsPoint, compactCorners, cornerAt, cornerSpecAt, cubicAxisExtremaTs, cubicBounds, cubicEvalAt, cubicPointAt, elevateQuadraticToCubic, ellipsePath, forEachSegment, hasCorners, lerpCorners, linePath, pathCommandCoordCount, polygonFromPoints, polylineFromPoints, quadraticEvalAt, rectPath, rectToContour, regularPolygonPath, scaleCorners, splitCubicAt, splitCubicAtT, splitLineAt, splitQuadraticAt, starPath, unionBox, withCorner, withoutCorners };
+//# sourceMappingURL=chunk-B53BERKG.js.map
+//# sourceMappingURL=chunk-B53BERKG.js.map

package/dist/chunk-B53BERKG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/box.ts","../src/commands.ts","../src/curve.ts","../src/paths/builder.ts","../src/paths/cornerSpec.ts","../src/paths/cubicMath.ts"],"names":[],"mappings":"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","file":"chunk-B53BERKG.js","sourcesContent":["/** Axis-aligned box as [minX, minY, maxX, maxY]. */\nexport type Box = readonly [number, number, number, number];\n\n/** An axis-aligned rectangle in object form. `Box` is the tuple form; this is\n *  the one that survives being read by a human. */\nexport interface Rect { x: number; y: number; width: number; height: number }\n\n/** Tight bounds of an interleaved coord stream, or null if empty. */\nexport function boundsOfCoords(coords: ArrayLike<number>): Box | null {\n  if (coords.length < 2) return null;\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  for (let i = 0; i + 1 < coords.length; i += 2) {\n    const x = coords[i], y = coords[i + 1];\n    if (x < minX) minX = x;\n    if (y < minY) minY = y;\n    if (x > maxX) maxX = x;\n    if (y > maxY) maxY = y;\n  }\n  return [minX, minY, maxX, maxY];\n}\n\n/** Smallest box containing both inputs. */\nexport function unionBox(a: Box, b: Box): Box {\n  return [\n    Math.min(a[0], b[0]),\n    Math.min(a[1], b[1]),\n    Math.max(a[2], b[2]),\n    Math.max(a[3], b[3]),\n  ];\n}\n\n/** Inclusive point-in-box test. */\nexport function boxContainsPoint(b: Box, x: number, y: number): boolean {\n  return x >= b[0] && x <= b[2] && y >= b[1] && y <= b[3];\n}\n\n/** Whether `outer` wholly holds `inner`, edges inclusive. Two boxes that merely\n *  overlap answer false. */\nexport function boxContainsBox(outer: Box, inner: Box): boolean {\n  return inner[0] >= outer[0] && inner[1] >= outer[1] && inner[2] <= outer[2] && inner[3] <= outer[3];\n}\n\n/** Interleaved corner ring for a rect at (x,y,w,h), wound clockwise from the\n *  origin corner. The closing edge is implicit — the same unclosed shape\n *  `pointInPolygon` takes, and what a repeated first vertex would leave as a\n *  zero-length segment for anything that strokes it. */\nexport function rectToContour(x: number, y: number, w: number, h: number): Float64Array {\n  return Float64Array.of(x, y, x + w, y, x + w, y + h, x, y + h);\n}\n","/**\n * SVG-style command-stream encoding — the kit's single declaration of the path\n * opcodes.\n *\n * The codes index a `Uint8Array` command stream whose coords live in a\n * parallel float array, so a code declared anywhere but `PATH_COMMANDS` makes\n * every walker that doesn't know it misread the coord stream from that command\n * on — silently, for every path.\n */\n\n/** Opcode table: command code and the float coords it consumes. */\nexport const PATH_COMMANDS = {\n  /** moveTo — opens a new subpath. */\n  M: { code: 0, coords: 2 },\n  /** Straight segment from the pen to the next coord pair. */\n  L: { code: 1, coords: 2 },\n  /** Cubic bezier: two control points then the endpoint. */\n  C: { code: 2, coords: 6 },\n  /** Quadratic bezier: one control point then the endpoint. */\n  Q: { code: 3, coords: 4 },\n  /** Close the current subpath back to its start. Consumes no coords and\n   *  leaves the pen where it is. */\n  Z: { code: 4, coords: 0 },\n} as const;\n\n/** Mnemonic of a declared command (`'M' | 'L' | …`). */\nexport type PathCommandName = keyof typeof PATH_COMMANDS;\n/** Numeric code of a declared command. */\nexport type PathCommandCode = (typeof PATH_COMMANDS)[PathCommandName]['code'];\n\n/** Command code of `M` (moveTo). */\nexport const PATH_M = PATH_COMMANDS.M.code;\n/** Command code of `L` (lineTo). */\nexport const PATH_L = PATH_COMMANDS.L.code;\n/** Command code of `C` (cubic bezier). */\nexport const PATH_C = PATH_COMMANDS.C.code;\n/** Command code of `Q` (quadratic bezier). */\nexport const PATH_Q = PATH_COMMANDS.Q.code;\n/** Command code of `Z` (close subpath). */\nexport const PATH_Z = PATH_COMMANDS.Z.code;\n\n/** Float coords consumed by each command, indexed by command code. */\nexport const PATH_CMD_LENGTHS: readonly number[] = buildCmdLengths();\n\nfunction buildCmdLengths(): number[] {\n  const lengths: number[] = [];\n  for (const { code, coords } of Object.values(PATH_COMMANDS)) lengths[code] = coords;\n  return lengths;\n}\n\n/** Float coords consumed by the command with this code. */\nexport function pathCommandCoordCount(cmd: number): number {\n  return PATH_CMD_LENGTHS[cmd];\n}\n\n/**\n * Visit each command with its coord offset and the pen position BEFORE the\n * command consumes its coords (the segment start). The callback stops the\n * walk by returning `false`. `Z` returns the pen to the subpath's opening `M`.\n *\n * A command following a `Z` without an intervening `M` opens a new subpath at\n * the pen, as does a drawing command no `M` precedes at all. The visitor is\n * told with `opensSubpath`, and has to start its contour at `(penX, penY)`\n * then: there is no `M` to do it.\n *\n * A code `PATH_COMMANDS` does not declare throws once the visitor has seen it.\n */\nexport function forEachSegment(\n  commands: ArrayLike<number>,\n  coords: ArrayLike<number>,\n  visit: (\n    cmd: number,\n    coordIndex: number,\n    penX: number,\n    penY: number,\n    commandIndex: number,\n    opensSubpath: boolean,\n  ) => void | boolean,\n): void {\n  let ci = 0;\n  let px = 0, py = 0;\n  let startX = 0, startY = 0;\n  let open = false;\n  for (let i = 0; i < commands.length; i++) {\n    const cmd = commands[i];\n    const opens = !open && cmd !== PATH_M && cmd !== PATH_Z;\n    if (opens) { startX = px; startY = py; }\n    open = cmd !== PATH_Z;\n    if (visit(cmd, ci, px, py, i, opens) === false) return;\n    const len = pathCommandCoordCount(cmd);\n    if (len === undefined) throw new Error(`forEachSegment: unknown command code ${cmd}`);\n    if (len > 0) {\n      px = coords[ci + len - 2];\n      py = coords[ci + len - 1];\n      ci += len;\n      if (cmd === PATH_M) { startX = px; startY = py; }\n    } else if (cmd === PATH_Z) {\n      px = startX; py = startY;\n    }\n  }\n}\n","import type { Box } from './box';\n\n/** Cubic Bezier point at parameter t (de Casteljau / Bernstein form). */\nexport function cubicEvalAt(\n  x0: number, y0: number, x1: number, y1: number,\n  x2: number, y2: number, x3: number, y3: number, t: number,\n): [number, number] {\n  const u = 1 - t;\n  const a = u * u * u, b = 3 * u * u * t, c = 3 * u * t * t, d = t * t * t;\n  return [\n    a * x0 + b * x1 + c * x2 + d * x3,\n    a * y0 + b * y1 + c * y2 + d * y3,\n  ];\n}\n\n/**\n * Degree-elevate a quadratic (q0, ctrl, q1) to a cubic. Returns the two\n * cubic control points [c1x, c1y, c2x, c2y]; the cubic endpoints equal the\n * quadratic endpoints. c1 = q0 + 2/3(ctrl-q0), c2 = q1 + 2/3(ctrl-q1).\n */\nexport function elevateQuadraticToCubic(\n  q0x: number, q0y: number, cx: number, cy: number, q1x: number, q1y: number,\n): [number, number, number, number] {\n  return [\n    q0x + (2 / 3) * (cx - q0x),\n    q0y + (2 / 3) * (cy - q0y),\n    q1x + (2 / 3) * (cx - q1x),\n    q1y + (2 / 3) * (cy - q1y),\n  ];\n}\n\n/** The parameters in (0, 1) where one coordinate of a cubic, with control\n *  values `p0..p3`, turns: the roots of its derivative. */\nexport function cubicAxisExtremaTs(p0: number, p1: number, p2: number, p3: number): number[] {\n  // B'(t)=0 → quadratic a t² + b t + c = 0 with:\n  const a = -p0 + 3 * p1 - 3 * p2 + p3;\n  const b = 2 * (p0 - 2 * p1 + p2);\n  const c = -p0 + p1;\n  const ts: number[] = [];\n  const push = (t: number) => { if (t > 0 && t < 1) ts.push(t); };\n  if (Math.abs(a) < 1e-12) {\n    if (Math.abs(b) > 1e-12) push(-c / b);\n  } else {\n    const disc = b * b - 4 * a * c;\n    if (disc >= 0) {\n      const sq = Math.sqrt(disc);\n      push((-b + sq) / (2 * a));\n      push((-b - sq) / (2 * a));\n    }\n  }\n  return ts;\n}\n\n/** Tight AABB of a cubic, evaluating only extrema that lie on the curve. */\nexport function cubicBounds(\n  x0: number, y0: number, x1: number, y1: number,\n  x2: number, y2: number, x3: number, y3: number,\n): Box {\n  let minX = Math.min(x0, x3), maxX = Math.max(x0, x3);\n  let minY = Math.min(y0, y3), maxY = Math.max(y0, y3);\n  for (const t of cubicAxisExtremaTs(x0, x1, x2, x3)) {\n    const [ex] = cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, t);\n    if (ex < minX) minX = ex;\n    if (ex > maxX) maxX = ex;\n  }\n  for (const t of cubicAxisExtremaTs(y0, y1, y2, y3)) {\n    const [, ey] = cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, t);\n    if (ey < minY) minY = ey;\n    if (ey > maxY) maxY = ey;\n  }\n  return [minX, minY, maxX, maxY];\n}\n\n/** Quadratic Bezier point at parameter t (Bernstein form). */\nexport function quadraticEvalAt(\n  x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, t: number,\n): [number, number] {\n  const u = 1 - t;\n  const a = u * u, b = 2 * u * t, c = t * t;\n  return [a * x0 + b * x1 + c * x2, a * y0 + b * y1 + c * y2];\n}\n\n/** A line segment's coords: start, end. */\nexport type LineCoords = [number, number, number, number];\n/** A quadratic Bezier's coords: start, control, end. */\nexport type QuadraticCoords = [number, number, number, number, number, number];\n/** A cubic Bezier's coords: start, two controls, end. */\nexport type CubicCoords = [number, number, number, number, number, number, number, number];\n\n/**\n * Split a cubic at parameter t (de Casteljau). The two halves share the point\n * at t and together trace the original exactly. A t outside [0, 1] splits the\n * curve's polynomial extension.\n */\nexport function splitCubicAt(\n  x0: number, y0: number, x1: number, y1: number,\n  x2: number, y2: number, x3: number, y3: number, t: number,\n): [CubicCoords, CubicCoords] {\n  const ax = x0 + (x1 - x0) * t, ay = y0 + (y1 - y0) * t;\n  const bx = x1 + (x2 - x1) * t, by = y1 + (y2 - y1) * t;\n  const cx = x2 + (x3 - x2) * t, cy = y2 + (y3 - y2) * t;\n  const dx = ax + (bx - ax) * t, dy = ay + (by - ay) * t;\n  const ex = bx + (cx - bx) * t, ey = by + (cy - by) * t;\n  const mx = dx + (ex - dx) * t, my = dy + (ey - dy) * t;\n  return [[x0, y0, ax, ay, dx, dy, mx, my], [mx, my, ex, ey, cx, cy, x3, y3]];\n}\n\n/** Split a quadratic at parameter t (de Casteljau). See {@link splitCubicAt}. */\nexport function splitQuadraticAt(\n  x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, t: number,\n): [QuadraticCoords, QuadraticCoords] {\n  const ax = x0 + (x1 - x0) * t, ay = y0 + (y1 - y0) * t;\n  const bx = x1 + (x2 - x1) * t, by = y1 + (y2 - y1) * t;\n  const mx = ax + (bx - ax) * t, my = ay + (by - ay) * t;\n  return [[x0, y0, ax, ay, mx, my], [mx, my, bx, by, x2, y2]];\n}\n\n/** Split a line segment at parameter t. See {@link splitCubicAt}. */\nexport function splitLineAt(\n  x0: number, y0: number, x1: number, y1: number, t: number,\n): [LineCoords, LineCoords] {\n  const mx = x0 + (x1 - x0) * t, my = y0 + (y1 - y0) * t;\n  return [[x0, y0, mx, my], [mx, my, x1, y1]];\n}\n","/**\n * Fluent builder for `PolygonPath`. Hides the `Uint8Array` / `Float32Array`\n * encoding behind move/line/curve/close calls and a final `build()`. Use\n * this to construct paths in tests and demos; production callers that need\n * to mutate large paths in place should reach for the raw arrays directly.\n *\n * Numeric capacity grows by doubling — typical for amortized O(1) push.\n *\n * Also exposes `rectPath` / `polygonFromPoints` shortcuts for the common\n * cases. `rectPath` returns the lighter `RectPath` subtype, not a polygon.\n */\n\nimport { rectToContour } from '../box';\nimport { PATH_C, PATH_L, PATH_M, PATH_Q, PATH_Z } from '../commands';\nimport type { Path, PathFillRule, PolygonPath, RectPath } from '../path';\n\n/** Fluent builder for `PolygonPath`; hides the `Uint8Array`/`Float32Array` encoding behind move/line/curve/close calls. */\nexport class PathBuilder {\n  private cmds: number[] = [];\n  private xs: number[] = [];\n  private fillRule: PathFillRule = 'nonzero';\n\n  /** Seed a builder with an existing `PolygonPath`. Useful for extending\n   *  an in-flight path with another segment (e.g. appending a cubic to\n   *  the end of a curve in response to a user action) without hand-\n   *  reaching into the `commands` / `coords` typed arrays.\n   *\n   *  ```ts\n   *  const next = PathBuilder.fromPath(current).curveTo(...).build();\n   *  ```\n   */\n  static fromPath(path: PolygonPath): PathBuilder {\n    const b = new PathBuilder();\n    b.cmds = Array.from(path.commands);\n    b.xs = Array.from(path.coords);\n    b.fillRule = path.fillRule;\n    return b;\n  }\n\n  setFillRule(rule: PathFillRule): this {\n    this.fillRule = rule;\n    return this;\n  }\n\n  moveTo(x: number, y: number): this {\n    this.cmds.push(PATH_M);\n    this.xs.push(x, y);\n    return this;\n  }\n\n  lineTo(x: number, y: number): this {\n    this.cmds.push(PATH_L);\n    this.xs.push(x, y);\n    return this;\n  }\n\n  /** Cubic bezier to (x, y) with control points (x1, y1) and (x2, y2). */\n  curveTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): this {\n    this.cmds.push(PATH_C);\n    this.xs.push(x1, y1, x2, y2, x, y);\n    return this;\n  }\n\n  /** Quadratic bezier to (x, y) with control point (x1, y1). */\n  quadTo(x1: number, y1: number, x: number, y: number): this {\n    this.cmds.push(PATH_Q);\n    this.xs.push(x1, y1, x, y);\n    return this;\n  }\n\n  close(): this {\n    this.cmds.push(PATH_Z);\n    return this;\n  }\n\n  build(): PolygonPath {\n    return {\n      kind: 'polygon',\n      commands: new Uint8Array(this.cmds),\n      coords: new Float32Array(this.xs),\n      fillRule: this.fillRule,\n    };\n  }\n}\n\n/** Construct a `RectPath` (the fast-path subtype). */\nexport function rectPath(x: number, y: number, width: number, height: number): RectPath {\n  return { kind: 'rect', x, y, width, height };\n}\n\n/** `path` as a command stream drawing the same outline. A rect becomes its four\n *  corners clockwise from `(x, y)`, the order `countPathAnchors` numbers them in. */\nexport function asPolygonPath(path: Path): PolygonPath {\n  if (path.kind === 'polygon') return path;\n  return {\n    kind: 'polygon',\n    commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),\n    coords: Float32Array.from(rectToContour(path.x, path.y, path.width, path.height)),\n    fillRule: 'nonzero',\n  };\n}\n\n/** Build an open polyline from a flat list of points — the same geometry as\n *  {@link polygonFromPoints} without the closing edge. A freehand stroke and a\n *  measurement line want this; a region wants the closed one. */\nexport function polylineFromPoints(\n  points: readonly { x: number; y: number }[],\n): PolygonPath | RectPath {\n  const b = new PathBuilder();\n  const first = points[0];\n  if (!first) return rectPath(0, 0, 0, 0);\n  b.moveTo(first.x, first.y);\n  for (let i = 1; i < points.length; i++) {\n    const p = points[i];\n    if (p) b.lineTo(p.x, p.y);\n  }\n  return b.build();\n}\n\n/** Build a closed polygon from a flat list of points. */\nexport function polygonFromPoints(\n  points: readonly { x: number; y: number }[],\n  opts: { fillRule?: PathFillRule } = {},\n): PolygonPath {\n  if (points.length === 0) {\n    return {\n      kind: 'polygon',\n      commands: new Uint8Array(),\n      coords: new Float32Array(),\n      fillRule: opts.fillRule ?? 'nonzero',\n    };\n  }\n  const b = new PathBuilder();\n  if (opts.fillRule) b.setFillRule(opts.fillRule);\n  b.moveTo(points[0].x, points[0].y);\n  for (let i = 1; i < points.length; i++) b.lineTo(points[i].x, points[i].y);\n  b.close();\n  return b.build();\n}\n\n/** Cubic-Bezier kappa for circular-quadrant approximation (<1% max error). */\nconst ELLIPSE_KAPPA = 0.5522847498307936;\n\n/** Closed ellipse inscribed in `bounds`, as a 4-cubic-Bezier `PolygonPath`.\n *  Matches the geometry `useEllipseTool`'s overlay paints. */\nexport function ellipsePath(\n  bounds: { x: number; y: number; width: number; height: number },\n): PolygonPath {\n  const cx = bounds.x + bounds.width / 2;\n  const cy = bounds.y + bounds.height / 2;\n  const rx = bounds.width / 2;\n  const ry = bounds.height / 2;\n  const ox = rx * ELLIPSE_KAPPA;\n  const oy = ry * ELLIPSE_KAPPA;\n  const b = new PathBuilder();\n  b.moveTo(cx + rx, cy);\n  b.curveTo(cx + rx, cy + oy, cx + ox, cy + ry, cx, cy + ry);\n  b.curveTo(cx - ox, cy + ry, cx - rx, cy + oy, cx - rx, cy);\n  b.curveTo(cx - rx, cy - oy, cx - ox, cy - ry, cx, cy - ry);\n  b.curveTo(cx + ox, cy - ry, cx + rx, cy - oy, cx + rx, cy);\n  b.close();\n  return b.build();\n}\n\n/** Closed regular n-gon centered at `center`, circumscribed by `radius`.\n *  `rotation` is in radians; default 0 puts the first vertex on the +x axis. */\nexport function regularPolygonPath(\n  center: { x: number; y: number },\n  radius: number,\n  sides: number,\n  rotation = 0,\n): PolygonPath {\n  const b = new PathBuilder();\n  for (let i = 0; i < sides; i++) {\n    const a = rotation + (i / sides) * Math.PI * 2;\n    const x = center.x + radius * Math.cos(a);\n    const y = center.y + radius * Math.sin(a);\n    if (i === 0) b.moveTo(x, y); else b.lineTo(x, y);\n  }\n  b.close();\n  return b.build();\n}\n\n/** Closed n-pointed star centered at `center`, alternating `outerRadius` and\n *  `innerRadius` (default `outerRadius / 2`). `rotation` is in radians. */\nexport function starPath(\n  center: { x: number; y: number },\n  outerRadius: number,\n  points = 5,\n  innerRadius: number = outerRadius / 2,\n  rotation = 0,\n): PolygonPath {\n  const b = new PathBuilder();\n  const n = points * 2;\n  for (let i = 0; i < n; i++) {\n    const a = rotation + (i / n) * Math.PI * 2;\n    const r = i % 2 === 0 ? outerRadius : innerRadius;\n    const x = center.x + r * Math.cos(a);\n    const y = center.y + r * Math.sin(a);\n    if (i === 0) b.moveTo(x, y); else b.lineTo(x, y);\n  }\n  b.close();\n  return b.build();\n}\n\n/** Open 2-vertex polyline from `a` to `b` — strokeable, not fillable. */\nexport function linePath(\n  a: { x: number; y: number },\n  b: { x: number; y: number },\n): PolygonPath {\n  const pb = new PathBuilder();\n  pb.moveTo(a.x, a.y);\n  pb.lineTo(b.x, b.y);\n  return pb.build();\n}\n","/**\n * Per-anchor corner specs: the stored half of corner shapes. A path carries\n * them in `PolygonPath.corners`, indexed by flat anchor index, and every\n * reader of its geometry sees them expanded (`resolveCorners`).\n */\nimport type { PolygonPath } from '../path';\nimport type { CornerShape } from './cornerShape';\n\n/** The corner at one anchor: its shape, and its setback, how far along each\n *  edge from the anchor the cut starts. A `round` corner between edges at a\n *  right angle is a circle of that radius. */\nexport interface CornerSpec {\n  shape: CornerShape;\n  radius: number;\n}\n\n/** The corner cut at flat anchor `index`, or null. A zero radius cuts nothing. */\nexport function cornerAt(path: PolygonPath, index: number): CornerSpec | null {\n  const spec = path.corners?.[index];\n  return spec && spec.radius > 0 ? spec : null;\n}\n\n/** The spec stored at flat anchor `index`, radius zero included: a shape\n *  picked before any radius is dragged out. */\nexport function cornerSpecAt(path: PolygonPath, index: number): CornerSpec | null {\n  return path.corners?.[index] ?? null;\n}\n\n/** Whether any anchor of `path` carries a corner with a radius. */\nexport function hasCorners(path: { kind: string; corners?: PolygonPath['corners'] }): boolean {\n  const corners = path.corners;\n  if (!corners) return false;\n  for (const c of corners) if (c && c.radius > 0) return true;\n  return false;\n}\n\n/** `corners` without trailing empty slots, or undefined when none is left. */\nexport function compactCorners(\n  corners: readonly (CornerSpec | null | undefined)[],\n): (CornerSpec | null)[] | undefined {\n  let end = corners.length;\n  while (end > 0 && !corners[end - 1]) end--;\n  if (end === 0) return undefined;\n  const out: (CornerSpec | null)[] = new Array(end);\n  for (let i = 0; i < end; i++) out[i] = corners[i] ?? null;\n  return out;\n}\n\n/** `path` without its corner specs: the bare anchors the specs decorate. */\nexport function withoutCorners(path: PolygonPath): PolygonPath {\n  if (path.corners === undefined) return path;\n  const { corners: _dropped, ...rest } = path;\n  return rest;\n}\n\n/** `path` with the corner at flat anchor `index` set to `spec`, or cleared\n *  when `spec` is null. A zero radius keeps the shape and cuts nothing.\n *  Never mutates `path`. */\nexport function withCorner(path: PolygonPath, index: number, spec: CornerSpec | null): PolygonPath {\n  const next: (CornerSpec | null)[] = path.corners ? [...path.corners] : [];\n  while (next.length <= index) next.push(null);\n  next[index] = spec ? { shape: spec.shape, radius: Math.max(0, spec.radius) } : null;\n  const corners = compactCorners(next);\n  const bare = withoutCorners(path);\n  return corners ? { ...bare, corners } : bare;\n}\n\n/** `path` with every corner radius multiplied by `factor`, as a uniform\n *  scale of its geometry would carry them. */\nexport function scaleCorners(path: PolygonPath, factor: number): PolygonPath {\n  if (!path.corners || factor === 1) return path;\n  return {\n    ...path,\n    corners: path.corners.map((c) => (c ? { shape: c.shape, radius: c.radius * factor } : null)),\n  };\n}\n\n/**\n * The corners of a path `t` of the way from `a` to `b`, which share their\n * anchors. A corner whose shape both ends agree on, or that one end leaves\n * sharp, grows its radius between them; one whose shape changes takes the\n * nearer end's.\n */\nexport function lerpCorners(\n  a: PolygonPath['corners'],\n  b: PolygonPath['corners'],\n  t: number,\n): (CornerSpec | null)[] | undefined {\n  if (!a && !b) return undefined;\n  const n = Math.max(a?.length ?? 0, b?.length ?? 0);\n  const out: (CornerSpec | null)[] = new Array(n);\n  for (let i = 0; i < n; i++) {\n    const ca = a?.[i] ?? null, cb = b?.[i] ?? null;\n    const either = ca ?? cb;\n    if (!either) out[i] = null;\n    else if (ca && cb && ca.shape !== cb.shape) out[i] = t < 0.5 ? ca : cb;\n    else out[i] = { shape: either.shape, radius: (ca?.radius ?? 0) + ((cb?.radius ?? 0) - (ca?.radius ?? 0)) * t };\n  }\n  return compactCorners(out);\n}\n","import { cubicEvalAt, splitCubicAt, type CubicCoords } from '../curve';\n\n/** A 2D point, the shape the point-taking path helpers read and return. */\nexport interface Point { x: number; y: number; }\n\n/** Point on the cubic Bezier (p0, p1, p2, p3) at parameter t. The point-shaped\n *  face of geom's `cubicEvalAt`. */\nexport function cubicPointAt(p0: Point, p1: Point, p2: Point, p3: Point, t: number): Point {\n  const [x, y] = cubicEvalAt(p0.x, p0.y, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, t);\n  return { x, y };\n}\n\n/** De Casteljau subdivision of a cubic at parameter t. The point-shaped face\n *  of geom's `splitCubicAt`; `left[3]` and `right[0]` are the point at t. */\nexport function splitCubicAtT(\n  p0: Point, p1: Point, p2: Point, p3: Point,\n  t: number,\n): { left: [Point, Point, Point, Point]; right: [Point, Point, Point, Point] } {\n  const [l, r] = splitCubicAt(p0.x, p0.y, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, t);\n  const quad = (c: CubicCoords): [Point, Point, Point, Point] =>\n    [{ x: c[0], y: c[1] }, { x: c[2], y: c[3] }, { x: c[4], y: c[5] }, { x: c[6], y: c[7] }];\n  return { left: quad(l), right: quad(r) };\n}\n"]}

package/dist/chunk-CE7IY7TB.js

@@ -0,0 +1,104 @@
+import { cubicEvalAt, elevateQuadraticToCubic, forEachSegment, PATH_M, PATH_L, PATH_Q, PATH_C, PATH_Z } from './chunk-B53BERKG.js';
+
+// src/nearest.ts
+function nearestOnLine(px, py, x0, y0, x1, y1) {
+  const vx = x1 - x0, vy = y1 - y0;
+  const vv = vx * vx + vy * vy;
+  let t = vv === 0 ? 0 : ((px - x0) * vx + (py - y0) * vy) / vv;
+  t = t < 0 ? 0 : t > 1 ? 1 : t;
+  const x = t === 1 ? x1 : x0 + t * vx;
+  const y = t === 1 ? y1 : y0 + t * vy;
+  return { x, y, t, dist: Math.hypot(px - x, py - y) };
+}
+var CUBIC_SAMPLES = 32;
+var REFINE_ITERS = 40;
+var T_EPS = 1e-14;
+function nearestOnCubic(px, py, x0, y0, x1, y1, x2, y2, x3, y3) {
+  const ax = -x0 + 3 * x1 - 3 * x2 + x3, ay = -y0 + 3 * y1 - 3 * y2 + y3;
+  const bx = 3 * x0 - 6 * x1 + 3 * x2, by = 3 * y0 - 6 * y1 + 3 * y2;
+  const cx = 3 * (x1 - x0), cy = 3 * (y1 - y0);
+  const d2At = (t) => {
+    const [x4, y4] = cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, t);
+    return (x4 - px) ** 2 + (y4 - py) ** 2;
+  };
+  const d2s = [];
+  for (let k = 0; k <= CUBIC_SAMPLES; k++) d2s.push(d2At(k / CUBIC_SAMPLES));
+  let bestT = 0, bestD2 = d2s[0];
+  for (let k = 0; k <= CUBIC_SAMPLES; k++) {
+    const d = d2s[k];
+    const prev = k > 0 ? d2s[k - 1] : Infinity;
+    const next = k < CUBIC_SAMPLES ? d2s[k + 1] : Infinity;
+    if (!(d <= prev && d <= next)) continue;
+    let lo = Math.max(0, (k - 1) / CUBIC_SAMPLES);
+    let hi = Math.min(1, (k + 1) / CUBIC_SAMPLES);
+    let t = k / CUBIC_SAMPLES;
+    for (let i = 0; i < REFINE_ITERS; i++) {
+      const t2 = t * t;
+      const ex = ax * t2 * t + bx * t2 + cx * t + x0 - px;
+      const ey = ay * t2 * t + by * t2 + cy * t + y0 - py;
+      const dx = 3 * ax * t2 + 2 * bx * t + cx, dy = 3 * ay * t2 + 2 * by * t + cy;
+      const ddx = 6 * ax * t + 2 * bx, ddy = 6 * ay * t + 2 * by;
+      const g = ex * dx + ey * dy;
+      const gp = dx * dx + dy * dy + ex * ddx + ey * ddy;
+      if (g > 0) hi = t;
+      else if (g < 0) lo = t;
+      else break;
+      let tn = gp > 0 ? t - g / gp : NaN;
+      if (!(tn > lo && tn < hi)) tn = (lo + hi) / 2;
+      const step = Math.abs(tn - t);
+      t = tn;
+      if (step < T_EPS || hi - lo < T_EPS) break;
+    }
+    const refined = d2At(t);
+    const [tk, dk] = refined <= d ? [t, refined] : [k / CUBIC_SAMPLES, d];
+    if (dk < bestD2) {
+      bestD2 = dk;
+      bestT = tk;
+    }
+  }
+  const [x, y] = cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, bestT);
+  return { x, y, t: bestT, dist: Math.hypot(x - px, y - py) };
+}
+function nearestOnQuadratic(px, py, x0, y0, x1, y1, x2, y2) {
+  const [c1x, c1y, c2x, c2y] = elevateQuadraticToCubic(x0, y0, x1, y1, x2, y2);
+  return nearestOnCubic(px, py, x0, y0, c1x, c1y, c2x, c2y, x2, y2);
+}
+function nearestOnPath(commands, coords, px, py) {
+  let best = null;
+  let startX = 0, startY = 0;
+  forEachSegment(commands, coords, (cmd, ci, x0, y0, commandIndex) => {
+    let hit;
+    if (cmd === PATH_M) {
+      startX = coords[ci];
+      startY = coords[ci + 1];
+      return;
+    } else if (cmd === PATH_L) {
+      hit = nearestOnLine(px, py, x0, y0, coords[ci], coords[ci + 1]);
+    } else if (cmd === PATH_Q) {
+      hit = nearestOnQuadratic(px, py, x0, y0, coords[ci], coords[ci + 1], coords[ci + 2], coords[ci + 3]);
+    } else if (cmd === PATH_C) {
+      hit = nearestOnCubic(
+        px,
+        py,
+        x0,
+        y0,
+        coords[ci],
+        coords[ci + 1],
+        coords[ci + 2],
+        coords[ci + 3],
+        coords[ci + 4],
+        coords[ci + 5]
+      );
+    } else if (cmd === PATH_Z) {
+      hit = nearestOnLine(px, py, x0, y0, startX, startY);
+    } else {
+      throw new Error(`nearestOnPath: unknown command code ${cmd}`);
+    }
+    if (best === null || hit.dist < best.dist) best = { ...hit, commandIndex, coordIndex: ci };
+  });
+  return best;
+}
+
+export { nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic };
+//# sourceMappingURL=chunk-CE7IY7TB.js.map
+//# sourceMappingURL=chunk-CE7IY7TB.js.map

package/dist/chunk-CE7IY7TB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/nearest.ts"],"names":["x","y"],"mappings":"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","file":"chunk-CE7IY7TB.js","sourcesContent":["/**\n * Nearest point on a segment or a whole path to a probe point: where it is,\n * its curve parameter, and how far away it lies.\n */\nimport { cubicEvalAt, elevateQuadraticToCubic } from './curve';\nimport { forEachSegment, PATH_M, PATH_L, PATH_Q, PATH_C, PATH_Z } from './commands';\n\n/** The point on one segment nearest a probe. */\nexport interface CurveNearest {\n  x: number;\n  y: number;\n  /** Curve parameter of the point, in [0, 1]. */\n  t: number;\n  /** Euclidean distance from the probe. */\n  dist: number;\n}\n\n/** The point on a path nearest a probe, and the command whose segment holds it. */\nexport interface PathNearest extends CurveNearest {\n  /** Index of the segment's command in the command stream (`L`, `Q`, `C` or `Z`). */\n  commandIndex: number;\n  /** Offset of that command's first coord; for a `Z`, where its coords would begin. */\n  coordIndex: number;\n}\n\n/** Nearest point on segment (x0,y0)-(x1,y1) to (px,py). */\nexport function nearestOnLine(\n  px: number, py: number, x0: number, y0: number, x1: number, y1: number,\n): CurveNearest {\n  const vx = x1 - x0, vy = y1 - y0;\n  const vv = vx * vx + vy * vy;\n  let t = vv === 0 ? 0 : ((px - x0) * vx + (py - y0) * vy) / vv;\n  t = t < 0 ? 0 : t > 1 ? 1 : t;\n  const x = t === 1 ? x1 : x0 + t * vx;\n  const y = t === 1 ? y1 : y0 + t * vy;\n  return { x, y, t, dist: Math.hypot(px - x, py - y) };\n}\n\n/** Coarse samples per cubic. Each local minimum among them is refined, so this\n *  only has to separate the distance function's minima (a cubic has at most\n *  three), not locate them. */\nconst CUBIC_SAMPLES = 32;\nconst REFINE_ITERS = 40;\nconst T_EPS = 1e-14;\n\n/**\n * Nearest point on the cubic (x0,y0)…(x3,y3) to (px,py). Samples the curve,\n * then refines every sampled local minimum with bracketed Newton on the\n * distance derivative, so a loop or cusp cannot capture it in the wrong basin.\n */\nexport function nearestOnCubic(\n  px: number, py: number,\n  x0: number, y0: number, x1: number, y1: number,\n  x2: number, y2: number, x3: number, y3: number,\n): CurveNearest {\n  // Power basis B(t) = a t³ + b t² + c t + p0, for the derivatives.\n  const ax = -x0 + 3 * x1 - 3 * x2 + x3, ay = -y0 + 3 * y1 - 3 * y2 + y3;\n  const bx = 3 * x0 - 6 * x1 + 3 * x2, by = 3 * y0 - 6 * y1 + 3 * y2;\n  const cx = 3 * (x1 - x0), cy = 3 * (y1 - y0);\n\n  const d2At = (t: number): number => {\n    const [x, y] = cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, t);\n    return (x - px) ** 2 + (y - py) ** 2;\n  };\n\n  const d2s: number[] = [];\n  for (let k = 0; k <= CUBIC_SAMPLES; k++) d2s.push(d2At(k / CUBIC_SAMPLES));\n\n  let bestT = 0, bestD2 = d2s[0];\n  for (let k = 0; k <= CUBIC_SAMPLES; k++) {\n    const d = d2s[k];\n    const prev = k > 0 ? d2s[k - 1] : Infinity;\n    const next = k < CUBIC_SAMPLES ? d2s[k + 1] : Infinity;\n    if (!(d <= prev && d <= next)) continue;\n\n    let lo = Math.max(0, (k - 1) / CUBIC_SAMPLES);\n    let hi = Math.min(1, (k + 1) / CUBIC_SAMPLES);\n    let t = k / CUBIC_SAMPLES;\n    for (let i = 0; i < REFINE_ITERS; i++) {\n      const t2 = t * t;\n      const ex = ax * t2 * t + bx * t2 + cx * t + x0 - px;\n      const ey = ay * t2 * t + by * t2 + cy * t + y0 - py;\n      const dx = 3 * ax * t2 + 2 * bx * t + cx, dy = 3 * ay * t2 + 2 * by * t + cy;\n      const ddx = 6 * ax * t + 2 * bx, ddy = 6 * ay * t + 2 * by;\n      // g = ½ d/dt |B - P|², zero at a critical point; its sign says which side the minimum is on.\n      const g = ex * dx + ey * dy;\n      const gp = dx * dx + dy * dy + ex * ddx + ey * ddy;\n      if (g > 0) hi = t; else if (g < 0) lo = t; else break;\n      let tn = gp > 0 ? t - g / gp : NaN;\n      if (!(tn > lo && tn < hi)) tn = (lo + hi) / 2;\n      const step = Math.abs(tn - t);\n      t = tn;\n      if (step < T_EPS || hi - lo < T_EPS) break;\n    }\n    const refined = d2At(t);\n    const [tk, dk] = refined <= d ? [t, refined] : [k / CUBIC_SAMPLES, d];\n    if (dk < bestD2) { bestD2 = dk; bestT = tk; }\n  }\n\n  const [x, y] = cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, bestT);\n  return { x, y, t: bestT, dist: Math.hypot(x - px, y - py) };\n}\n\n/** Nearest point on the quadratic (x0,y0)(x1,y1)(x2,y2) to (px,py). */\nexport function nearestOnQuadratic(\n  px: number, py: number,\n  x0: number, y0: number, x1: number, y1: number, x2: number, y2: number,\n): CurveNearest {\n  // Degree elevation keeps the parameterization, so t carries over unchanged.\n  const [c1x, c1y, c2x, c2y] = elevateQuadraticToCubic(x0, y0, x1, y1, x2, y2);\n  return nearestOnCubic(px, py, x0, y0, c1x, c1y, c2x, c2y, x2, y2);\n}\n\n/**\n * Nearest point on a command-stream path to (px,py), over every `L`, `Q`, `C`\n * and the closing edge each `Z` draws. The earliest segment wins a tie.\n * Returns `null` when the path has no segment, and throws on a command code\n * `PATH_COMMANDS` does not declare.\n */\nexport function nearestOnPath(\n  commands: ArrayLike<number>,\n  coords: ArrayLike<number>,\n  px: number,\n  py: number,\n): PathNearest | null {\n  let best: PathNearest | null = null;\n  let startX = 0, startY = 0;\n  forEachSegment(commands, coords, (cmd, ci, x0, y0, commandIndex) => {\n    let hit: CurveNearest;\n    if (cmd === PATH_M) {\n      startX = coords[ci]; startY = coords[ci + 1];\n      return;\n    } else if (cmd === PATH_L) {\n      hit = nearestOnLine(px, py, x0, y0, coords[ci], coords[ci + 1]);\n    } else if (cmd === PATH_Q) {\n      hit = nearestOnQuadratic(px, py, x0, y0, coords[ci], coords[ci + 1], coords[ci + 2], coords[ci + 3]);\n    } else if (cmd === PATH_C) {\n      hit = nearestOnCubic(\n        px, py, x0, y0,\n        coords[ci], coords[ci + 1], coords[ci + 2], coords[ci + 3], coords[ci + 4], coords[ci + 5],\n      );\n    } else if (cmd === PATH_Z) {\n      hit = nearestOnLine(px, py, x0, y0, startX, startY);\n    } else {\n      throw new Error(`nearestOnPath: unknown command code ${cmd}`);\n    }\n    if (best === null || hit.dist < best.dist) best = { ...hit, commandIndex, coordIndex: ci };\n  });\n  return best;\n}\n"]}