@pibbl/core 0.0.1

package/dist/lib/geometry/path-warp-bezier.js

@@ -0,0 +1,109 @@
+const choose = Array.from({ length: 8 }, (_, n) => {
+  const row = [1];
+  for (let i = 1; i <= n; i++) row[i] = row[i - 1] * (n - i + 1) / i;
+  return row;
+});
+function product(a, b) {
+  const n = a.length - 1, m = b.length - 1;
+  const result = new Array(n + m + 1).fill(0);
+  for (let i = 0; i <= n; i++) {
+    for (let j = 0; j <= m; j++) {
+      result[i + j] += a[i] * b[j] * choose[n][i] * choose[m][j] / choose[n + m][i + j];
+    }
+  }
+  return result;
+}
+function endpoint(span, index) {
+  const w = span.w[index], x = span.x[index] / w, y = span.y[index] / w;
+  if (w === 0 || !Number.isFinite(x) || !Number.isFinite(y)) {
+    throw new RangeError("warpPath encountered a projection pole or coordinate overflow.");
+  }
+  return [x, y];
+}
+function errorBound(span, ax, ay, bx, by) {
+  const n = span.w.length - 1;
+  const sign = Math.sign(span.w[0]);
+  let lower = Infinity, scale = 0, magnitude = 0;
+  for (let i = 0; i <= n; i++) {
+    lower = Math.min(lower, sign * span.w[i]);
+    scale = Math.max(scale, Math.abs(span.w[i]));
+    magnitude = Math.max(magnitude, Math.abs(span.x[i]), Math.abs(span.y[i]));
+  }
+  if (lower <= 0) return Infinity;
+  let bound = 0;
+  for (let i = 0; i <= n + 1; i++) {
+    const t = i / (n + 1);
+    let x = 0, y = 0;
+    if (i <= n) {
+      x += (1 - t) * (span.x[i] - span.w[i] * ax);
+      y += (1 - t) * (span.y[i] - span.w[i] * ay);
+    }
+    if (i > 0) {
+      x += t * (span.x[i - 1] - span.w[i - 1] * bx);
+      y += t * (span.y[i - 1] - span.w[i - 1] * by);
+    }
+    bound = Math.max(bound, Math.hypot(x, y));
+  }
+  const roundoff = 64 * Number.EPSILON * (magnitude + scale * Math.max(Math.abs(ax), Math.abs(ay), Math.abs(bx), Math.abs(by)));
+  return (bound + roundoff) / lower;
+}
+function split(values, left, right, scratch) {
+  const n = values.length - 1;
+  for (let i = 0; i <= n; i++) scratch[i] = values[i];
+  left.length = right.length = n + 1;
+  left[0] = scratch[0];
+  right[n] = scratch[n];
+  for (let level = 1; level <= n; level++) {
+    for (let i = 0; i <= n - level; i++) scratch[i] = scratch[i] / 2 + scratch[i + 1] / 2;
+    left[level] = scratch[0];
+    right[n - level] = scratch[n - level];
+  }
+}
+function frame(work, index) {
+  return work.pool[index] ?? (work.pool[index] = { x: [], y: [], w: [] });
+}
+function emitSpan(span, tolerance, work, emit) {
+  const first = frame(work, 0);
+  for (const key of ["x", "y", "w"]) {
+    first[key].length = span[key].length;
+    for (let i = 0; i < span[key].length; i++) {
+      const value = span[key][i];
+      if (!Number.isFinite(value)) throw new RangeError("warpPath homogeneous coordinates overflowed.");
+      first[key][i] = value;
+    }
+  }
+  let size = 1;
+  work.depths[0] = 0;
+  while (size) {
+    if (--work.remaining < 0) throw new RangeError("warpPath exceeded its subdivision work limit.");
+    const index = --size, current = work.pool[index], depth = work.depths[index];
+    const n = current.w.length - 1;
+    const aw = current.w[0], bw = current.w[n];
+    const ax = current.x[0] / aw, ay = current.y[0] / aw, bx = current.x[n] / bw, by = current.y[n] / bw;
+    if (aw === 0 || bw === 0 || !Number.isFinite(ax) || !Number.isFinite(ay) || !Number.isFinite(bx) || !Number.isFinite(by)) {
+      throw new RangeError("warpPath encountered a projection pole or coordinate overflow.");
+    }
+    if (Math.sign(aw) !== Math.sign(bw)) throw new RangeError("warpPath crosses a projection pole.");
+    if (n === 1 && 64 * Number.EPSILON * Math.max(Math.abs(ax), Math.abs(ay), Math.abs(bx), Math.abs(by)) <= tolerance) {
+      emit(bx, by);
+      continue;
+    }
+    if (errorBound(current, ax, ay, bx, by) <= tolerance) {
+      emit(bx, by);
+      continue;
+    }
+    if (depth >= 52) throw new RangeError("warpPath cannot certify tolerance or finiteness at available precision.");
+    const left = frame(work, index + 1);
+    split(current.x, left.x, current.x, work.scratch);
+    split(current.y, left.y, current.y, work.scratch);
+    split(current.w, left.w, current.w, work.scratch);
+    work.depths[index] = work.depths[index + 1] = depth + 1;
+    size += 2;
+  }
+}
+export {
+  emitSpan,
+  endpoint,
+  product
+};
+//# sourceMappingURL=path-warp-bezier.js.map

package/dist/lib/geometry/path-warp-bezier.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/path-warp-bezier.ts"],
+  "sourcesContent": ["/** @internal Homogeneous Bernstein curves, degree at most six after warping. */\nexport interface WarpSpan { x: number[]; y: number[]; w: number[] }\nexport type WarpPoint = readonly [number, number];\n\nconst choose = Array.from({ length: 8 }, (_, n) => {\n  const row = [1];\n  for (let i = 1; i <= n; i++) row[i] = row[i - 1] * (n - i + 1) / i;\n  return row;\n});\n\nexport function product(a: readonly number[], b: readonly number[]): number[] {\n  const n = a.length - 1, m = b.length - 1;\n  const result = new Array<number>(n + m + 1).fill(0);\n  for (let i = 0; i <= n; i++) {\n    for (let j = 0; j <= m; j++) {\n      result[i + j] += a[i] * b[j] * choose[n][i] * choose[m][j] / choose[n + m][i + j];\n    }\n  }\n  return result;\n}\n\nexport function endpoint(span: WarpSpan, index: number): WarpPoint {\n  const w = span.w[index], x = span.x[index] / w, y = span.y[index] / w;\n  if (w === 0 || !Number.isFinite(x) || !Number.isFinite(y)) {\n    throw new RangeError('warpPath encountered a projection pole or coordinate overflow.');\n  }\n  return [x, y];\n}\n\n/** Bound |R(t)-lerp(R(0),R(1),t)|, including collinear backtracking. */\nfunction errorBound(span: WarpSpan, ax: number, ay: number, bx: number, by: number): number {\n  const n = span.w.length - 1;\n  const sign = Math.sign(span.w[0]);\n  let lower = Infinity, scale = 0, magnitude = 0;\n  for (let i = 0; i <= n; i++) {\n    lower = Math.min(lower, sign * span.w[i]);\n    scale = Math.max(scale, Math.abs(span.w[i]));\n    magnitude = Math.max(magnitude, Math.abs(span.x[i]), Math.abs(span.y[i]));\n  }\n  if (lower <= 0) return Infinity;\n  let bound = 0;\n  // Degree elevation of N minus the Bernstein product W*L. Computing\n  // centered terms reduces cancellation compared with subtracting products.\n  for (let i = 0; i <= n + 1; i++) {\n    const t = i / (n + 1);\n    let x = 0, y = 0;\n    if (i <= n) {\n      x += (1 - t) * (span.x[i] - span.w[i] * ax);\n      y += (1 - t) * (span.y[i] - span.w[i] * ay);\n    }\n    if (i > 0) {\n      x += t * (span.x[i - 1] - span.w[i - 1] * bx);\n      y += t * (span.y[i - 1] - span.w[i - 1] * by);\n    }\n    bound = Math.max(bound, Math.hypot(x, y));\n  }\n  const roundoff = 64 * Number.EPSILON * (magnitude + scale * Math.max(Math.abs(ax), Math.abs(ay), Math.abs(bx), Math.abs(by)));\n  return (bound + roundoff) / lower;\n}\n\n/** Split into reusable buffers. The right destination may alias the input. */\nfunction split(values: readonly number[], left: number[], right: number[], scratch: number[]): void {\n  const n = values.length - 1;\n  for (let i = 0; i <= n; i++) scratch[i] = values[i];\n  left.length = right.length = n + 1;\n  left[0] = scratch[0]; right[n] = scratch[n];\n  for (let level = 1; level <= n; level++) {\n    for (let i = 0; i <= n - level; i++) scratch[i] = scratch[i] / 2 + scratch[i + 1] / 2;\n    left[level] = scratch[0]; right[n - level] = scratch[n - level];\n  }\n}\n\n/** Call-owned workspace; at most 53 frames (degree <= 6), reused across spans. */\nexport interface WarpWork {\n  remaining: number;\n  pool: WarpSpan[];\n  depths: number[];\n  scratch: number[];\n}\nfunction frame(work: WarpWork, index: number): WarpSpan {\n  return work.pool[index] ?? (work.pool[index] = { x: [], y: [], w: [] });\n}\nexport function emitSpan(span: WarpSpan, tolerance: number, work: WarpWork, emit: (x: number, y: number) => void): void {\n  const first = frame(work, 0);\n  for (const key of ['x', 'y', 'w'] as const) {\n    first[key].length = span[key].length;\n    for (let i = 0; i < span[key].length; i++) {\n      const value = span[key][i];\n      if (!Number.isFinite(value)) throw new RangeError('warpPath homogeneous coordinates overflowed.');\n      first[key][i] = value;\n    }\n  }\n  let size = 1;\n  work.depths[0] = 0;\n  while (size) {\n    if (--work.remaining < 0) throw new RangeError('warpPath exceeded its subdivision work limit.');\n    const index = --size, current = work.pool[index], depth = work.depths[index];\n    const n = current.w.length - 1;\n    const aw = current.w[0], bw = current.w[n];\n    const ax = current.x[0] / aw, ay = current.y[0] / aw, bx = current.x[n] / bw, by = current.y[n] / bw;\n    if (aw === 0 || bw === 0 || !Number.isFinite(ax) || !Number.isFinite(ay) || !Number.isFinite(bx) || !Number.isFinite(by)) {\n      throw new RangeError('warpPath encountered a projection pole or coordinate overflow.');\n    }\n    if (Math.sign(aw) !== Math.sign(bw)) throw new RangeError('warpPath crosses a projection pole.');\n    // A degree-one rational curve with like-signed weights traverses the\n    // endpoint chord monotonically. Nonlinear parameter speed is not error.\n    if (n === 1 && 64 * Number.EPSILON * Math.max(Math.abs(ax), Math.abs(ay), Math.abs(bx), Math.abs(by)) <= tolerance) {\n      emit(bx, by); continue;\n    }\n    if (errorBound(current, ax, ay, bx, by) <= tolerance) { emit(bx, by); continue; }\n    // 52 halvings exhaust meaningful double-precision parameter resolution.\n    if (depth >= 52) throw new RangeError('warpPath cannot certify tolerance or finiteness at available precision.');\n    const left = frame(work, index + 1);\n    split(current.x, left.x, current.x, work.scratch);\n    split(current.y, left.y, current.y, work.scratch);\n    split(current.w, left.w, current.w, work.scratch);\n    work.depths[index] = work.depths[index + 1] = depth + 1;\n    size += 2;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/geometry/path-warp.d.ts

@@ -0,0 +1,27 @@
+import { PathGeometry } from './path-geometry.js';
+export interface PathWarpPoint {
+    readonly x: number;
+    readonly y: number;
+}
+export interface PathWarpRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface PathWarpCorners {
+    readonly topLeft: PathWarpPoint;
+    readonly topRight: PathWarpPoint;
+    readonly bottomLeft: PathWarpPoint;
+    readonly bottomRight: PathWarpPoint;
+}
+export type PathWarpMode = 'bilinear' | 'perspective';
+export interface WarpPathOptions {
+    readonly source: PathWarpRect;
+    readonly destination: PathWarpCorners;
+    readonly mode?: PathWarpMode;
+    readonly tolerance: number;
+    readonly maxSegments?: number;
+}
+/** Approximate a four-corner warp in destination units, returning independent line geometry. */
+export declare function warpPath(path: PathGeometry, options: Readonly<WarpPathOptions>): PathGeometry;

package/dist/lib/geometry/path-warp.js

@@ -0,0 +1,165 @@
+import { arcPoint } from "./path-arc.js";
+import { PathGeometry } from "./path-geometry.js";
+import { emitSpan, endpoint, product } from "./path-warp-bezier.js";
+function number(value, name) {
+  if (typeof value !== "number") throw new TypeError(`warpPath ${name} must be a number.`);
+  if (!Number.isFinite(value)) throw new RangeError(`warpPath ${name} must be finite.`);
+  return value;
+}
+function point(value, name) {
+  return [number(value?.x, `${name}.x`), number(value?.y, `${name}.y`)];
+}
+function polynomial(points) {
+  return { x: points.map((p) => p[0]), y: points.map((p) => p[1]), w: points.map(() => 1) };
+}
+function perspective(corners) {
+  const scale = Math.max(...corners.flatMap((p) => [Math.abs(p[0]), Math.abs(p[1])]));
+  if (scale === 0) throw new RangeError("Perspective warp requires a strictly convex quadrilateral.");
+  const normalized = corners.map((p) => [p[0] / scale, p[1] / scale]);
+  const origin = normalized[0];
+  const extent = Math.max(...normalized.flatMap((p) => [Math.abs(p[0] - origin[0]), Math.abs(p[1] - origin[1])]));
+  if (extent === 0) throw new RangeError("Perspective destination is degenerate.");
+  const q = normalized.map((p) => [(p[0] - origin[0]) / extent, (p[1] - origin[1]) / extent]);
+  const perimeter = [q[0], q[1], q[3], q[2]];
+  let orientation = 0;
+  for (let i = 0; i < 4; i++) {
+    const a2 = perimeter[i], b2 = perimeter[(i + 1) % 4], c2 = perimeter[(i + 2) % 4];
+    const p = (b2[0] - a2[0]) * (c2[1] - b2[1]), r = (b2[1] - a2[1]) * (c2[0] - b2[0]);
+    const cross = p - r;
+    if (Math.abs(cross) <= 32 * Number.EPSILON * (Math.abs(p) + Math.abs(r)) || orientation !== 0 && Math.sign(cross) !== orientation) {
+      throw new RangeError("Perspective warp requires a strictly convex, nondegenerate quadrilateral.");
+    }
+    orientation = Math.sign(cross);
+  }
+  const [a, b, c, d] = q;
+  const dx1 = b[0] - d[0], dx2 = c[0] - d[0], dx3 = a[0] - b[0] - c[0] + d[0];
+  const dy1 = b[1] - d[1], dy2 = c[1] - d[1], dy3 = a[1] - b[1] - c[1] + d[1];
+  const determinant = dx1 * dy2 - dx2 * dy1;
+  if (Math.abs(determinant) <= 32 * Number.EPSILON * (Math.abs(dx1 * dy2) + Math.abs(dx2 * dy1))) {
+    throw new RangeError("Perspective mapping is numerically singular.");
+  }
+  const g = (dx3 * dy2 - dx2 * dy3) / determinant;
+  const h = (dx1 * dy3 - dx3 * dy1) / determinant;
+  if ([1 + g, 1 + h, 1 + g + h].some((w) => w <= 64 * Number.EPSILON * (1 + Math.abs(g) + Math.abs(h)))) {
+    throw new RangeError("Perspective mapping cannot certify a finite source rectangle.");
+  }
+  const xx = b[0] - a[0] + g * b[0], xy = c[0] - a[0] + h * c[0];
+  const yx = b[1] - a[1] + g * b[1], yy = c[1] - a[1] + h * c[1];
+  return (span) => {
+    const w = span.w.map((weight, i) => g * span.x[i] + h * span.y[i] + weight);
+    const x = w.map((weight, i) => ((xx * span.x[i] + xy * span.y[i] + a[0] * span.w[i]) * extent + origin[0] * weight) * scale);
+    const y = w.map((weight, i) => ((yx * span.x[i] + yy * span.y[i] + a[1] * span.w[i]) * extent + origin[1] * weight) * scale);
+    return { x, y, w };
+  };
+}
+function warpPath(path, options) {
+  if (!(path instanceof PathGeometry)) throw new TypeError("warpPath requires PathGeometry.");
+  const source = options?.source, destination = options?.destination;
+  const sx = number(source?.x, "source.x"), sy = number(source?.y, "source.y");
+  const width = number(source?.width, "source.width"), height = number(source?.height, "source.height");
+  const tolerance = number(options?.tolerance, "tolerance");
+  const requestedLimit = options?.maxSegments;
+  const maxSegments = number(requestedLimit === void 0 ? 1e6 : requestedLimit, "maxSegments");
+  if (width <= 0 || height <= 0 || tolerance <= 0 || !Number.isSafeInteger(maxSegments) || maxSegments <= 0) {
+    throw new RangeError("warpPath requires positive dimensions, tolerance, and a positive safe-integer maxSegments.");
+  }
+  const requestedMode = options?.mode;
+  const mode = requestedMode === void 0 ? "bilinear" : requestedMode;
+  if (mode !== "bilinear" && mode !== "perspective") throw new TypeError("Unknown warpPath mode.");
+  const corners = [
+    point(destination?.topLeft, "topLeft"),
+    point(destination?.topRight, "topRight"),
+    point(destination?.bottomLeft, "bottomLeft"),
+    point(destination?.bottomRight, "bottomRight")
+  ];
+  const project = mode === "perspective" ? perspective(corners) : void 0;
+  const map = (span) => {
+    const u = span.x.map((x2, i) => (x2 - sx * span.w[i]) / width);
+    const v = span.y.map((y2, i) => (y2 - sy * span.w[i]) / height);
+    if (project) return project({ x: u, y: v, w: span.w });
+    const wu = span.w.map((w2, i) => w2 - u[i]), wv = span.w.map((w2, i) => w2 - v[i]);
+    const weights = [product(wu, wv), product(u, wv), product(wu, v), product(u, v)];
+    const w = product(span.w, span.w);
+    const x = w.map((_, i) => weights.reduce((sum, ws, j) => sum + ws[i] * corners[j][0], 0));
+    const y = w.map((_, i) => weights.reduce((sum, ws, j) => sum + ws[i] * corners[j][1], 0));
+    return { x, y, w };
+  };
+  const output = new PathGeometry();
+  let count = 0, closed = false;
+  const reserve = () => {
+    if (++count > maxSegments) throw new RangeError("warpPath exceeded maxSegments.");
+  };
+  const line = (x, y) => {
+    reserve();
+    output.lineTo(x, y);
+    closed = false;
+  };
+  const work = { remaining: Math.min(4e6, 2 * maxSegments + 53), pool: [], depths: [], scratch: [] };
+  const emit = (span) => {
+    if (count >= maxSegments) throw new RangeError("warpPath exceeded maxSegments.");
+    emitSpan(map(span), tolerance, work, line);
+  };
+  let current = [0, 0], start = current;
+  for (const segment of path) {
+    switch (segment.type) {
+      case "move": {
+        current = start = [segment.x, segment.y];
+        const p = endpoint(map(polynomial([current])), 0);
+        reserve();
+        output.moveTo(p[0], p[1]);
+        closed = false;
+        break;
+      }
+      case "line": {
+        const end = [segment.x, segment.y];
+        emit(polynomial([current, end]));
+        current = end;
+        break;
+      }
+      case "quadratic": {
+        const end = [segment.x, segment.y];
+        emit(polynomial([current, [segment.cpx, segment.cpy], end]));
+        current = end;
+        break;
+      }
+      case "cubic": {
+        const end = [segment.x, segment.y];
+        emit(polynomial([current, [segment.cp1x, segment.cp1y], [segment.cp2x, segment.cp2y], end]));
+        current = end;
+        break;
+      }
+      case "arc": {
+        const first = arcPoint(segment, segment.startAngle);
+        if (current[0] !== first[0] || current[1] !== first[1]) emit(polynomial([current, first]));
+        const pieces = Math.max(1, Math.ceil(Math.abs(segment.sweep) / (Math.PI / 2)));
+        for (let i = 0; i < pieces; i++) {
+          const a = segment.startAngle + segment.sweep * i / pieces;
+          const b = segment.startAngle + segment.sweep * (i + 1) / pieces;
+          const mid = (a + b) / 2, weight = Math.cos((b - a) / 2);
+          const p = arcPoint(segment, a), q = arcPoint(segment, b);
+          emit({
+            x: [p[0], segment.cx * weight + segment.ux * Math.cos(mid) + segment.vx * Math.sin(mid), q[0]],
+            y: [p[1], segment.cy * weight + segment.uy * Math.cos(mid) + segment.vy * Math.sin(mid), q[1]],
+            w: [1, weight, 1]
+          });
+        }
+        current = arcPoint(segment, segment.startAngle + segment.sweep);
+        break;
+      }
+      case "close":
+        if (current[0] !== start[0] || current[1] !== start[1]) emit(polynomial([current, start]));
+        if (!closed) {
+          reserve();
+          output.closePath();
+          closed = true;
+        }
+        current = start;
+        break;
+    }
+  }
+  return output;
+}
+export {
+  warpPath
+};
+//# sourceMappingURL=path-warp.js.map

package/dist/lib/geometry/path-warp.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/path-warp.ts"],
+  "sourcesContent": ["import { arcPoint } from './path-arc.js';\nimport { PathGeometry } from './path-geometry.js';\nimport { emitSpan, endpoint, product, type WarpPoint, type WarpSpan, type WarpWork } from './path-warp-bezier.js';\n\nexport interface PathWarpPoint { readonly x: number; readonly y: number }\nexport interface PathWarpRect { readonly x: number; readonly y: number; readonly width: number; readonly height: number }\nexport interface PathWarpCorners {\n  readonly topLeft: PathWarpPoint;\n  readonly topRight: PathWarpPoint;\n  readonly bottomLeft: PathWarpPoint;\n  readonly bottomRight: PathWarpPoint;\n}\nexport type PathWarpMode = 'bilinear' | 'perspective';\nexport interface WarpPathOptions {\n  readonly source: PathWarpRect;\n  readonly destination: PathWarpCorners;\n  readonly mode?: PathWarpMode;\n  readonly tolerance: number;\n  readonly maxSegments?: number;\n}\n\nfunction number(value: unknown, name: string): number {\n  if (typeof value !== 'number') throw new TypeError(`warpPath ${name} must be a number.`);\n  if (!Number.isFinite(value)) throw new RangeError(`warpPath ${name} must be finite.`);\n  return value;\n}\nfunction point(value: PathWarpPoint | undefined, name: string): WarpPoint {\n  return [number(value?.x, `${name}.x`), number(value?.y, `${name}.y`)];\n}\nfunction polynomial(points: readonly WarpPoint[]): WarpSpan {\n  return { x: points.map(p => p[0]), y: points.map(p => p[1]), w: points.map(() => 1) };\n}\n\n/** Normalize destination coordinates before solving the unit-square homography. */\nfunction perspective(corners: readonly WarpPoint[]): (span: WarpSpan) => WarpSpan {\n  const scale = Math.max(...corners.flatMap(p => [Math.abs(p[0]), Math.abs(p[1])]));\n  if (scale === 0) throw new RangeError('Perspective warp requires a strictly convex quadrilateral.');\n  const normalized = corners.map(p => [p[0] / scale, p[1] / scale] as const);\n  const origin = normalized[0];\n  const extent = Math.max(...normalized.flatMap(p => [Math.abs(p[0] - origin[0]), Math.abs(p[1] - origin[1])]));\n  if (extent === 0) throw new RangeError('Perspective destination is degenerate.');\n  const q = normalized.map(p => [(p[0] - origin[0]) / extent, (p[1] - origin[1]) / extent] as const);\n  const perimeter = [q[0], q[1], q[3], q[2]];\n  let orientation = 0;\n  for (let i = 0; i < 4; i++) {\n    const a = perimeter[i], b = perimeter[(i + 1) % 4], c = perimeter[(i + 2) % 4];\n    const p = (b[0] - a[0]) * (c[1] - b[1]), r = (b[1] - a[1]) * (c[0] - b[0]);\n    const cross = p - r;\n    if (Math.abs(cross) <= 32 * Number.EPSILON * (Math.abs(p) + Math.abs(r)) ||\n        (orientation !== 0 && Math.sign(cross) !== orientation)) {\n      throw new RangeError('Perspective warp requires a strictly convex, nondegenerate quadrilateral.');\n    }\n    orientation = Math.sign(cross);\n  }\n  const [a, b, c, d] = q;\n  const dx1 = b[0] - d[0], dx2 = c[0] - d[0], dx3 = a[0] - b[0] - c[0] + d[0];\n  const dy1 = b[1] - d[1], dy2 = c[1] - d[1], dy3 = a[1] - b[1] - c[1] + d[1];\n  const determinant = dx1 * dy2 - dx2 * dy1;\n  if (Math.abs(determinant) <= 32 * Number.EPSILON * (Math.abs(dx1 * dy2) + Math.abs(dx2 * dy1))) {\n    throw new RangeError('Perspective mapping is numerically singular.');\n  }\n  const g = (dx3 * dy2 - dx2 * dy3) / determinant;\n  const h = (dx1 * dy3 - dx3 * dy1) / determinant;\n  if ([1 + g, 1 + h, 1 + g + h].some(w => w <= 64 * Number.EPSILON * (1 + Math.abs(g) + Math.abs(h)))) {\n    throw new RangeError('Perspective mapping cannot certify a finite source rectangle.');\n  }\n  const xx = b[0] - a[0] + g * b[0], xy = c[0] - a[0] + h * c[0];\n  const yx = b[1] - a[1] + g * b[1], yy = c[1] - a[1] + h * c[1];\n  return span => {\n    const w = span.w.map((weight, i) => g * span.x[i] + h * span.y[i] + weight);\n    const x = w.map((weight, i) => ((xx * span.x[i] + xy * span.y[i] + a[0] * span.w[i]) * extent + origin[0] * weight) * scale);\n    const y = w.map((weight, i) => ((yx * span.x[i] + yy * span.y[i] + a[1] * span.w[i]) * extent + origin[1] * weight) * scale);\n    return { x, y, w };\n  };\n}\n\n/** Approximate a four-corner warp in destination units, returning independent line geometry. */\nexport function warpPath(path: PathGeometry, options: Readonly<WarpPathOptions>): PathGeometry {\n  if (!(path instanceof PathGeometry)) throw new TypeError('warpPath requires PathGeometry.');\n  const source = options?.source, destination = options?.destination;\n  const sx = number(source?.x, 'source.x'), sy = number(source?.y, 'source.y');\n  const width = number(source?.width, 'source.width'), height = number(source?.height, 'source.height');\n  const tolerance = number(options?.tolerance, 'tolerance');\n  const requestedLimit = options?.maxSegments;\n  const maxSegments = number(requestedLimit === undefined ? 1_000_000 : requestedLimit, 'maxSegments');\n  if (width <= 0 || height <= 0 || tolerance <= 0 || !Number.isSafeInteger(maxSegments) || maxSegments <= 0) {\n    throw new RangeError('warpPath requires positive dimensions, tolerance, and a positive safe-integer maxSegments.');\n  }\n  const requestedMode = options?.mode;\n  const mode = requestedMode === undefined ? 'bilinear' : requestedMode;\n  if (mode !== 'bilinear' && mode !== 'perspective') throw new TypeError('Unknown warpPath mode.');\n  const corners = [point(destination?.topLeft, 'topLeft'), point(destination?.topRight, 'topRight'),\n    point(destination?.bottomLeft, 'bottomLeft'), point(destination?.bottomRight, 'bottomRight')];\n  const project = mode === 'perspective' ? perspective(corners) : undefined;\n  const map = (span: WarpSpan): WarpSpan => {\n    const u = span.x.map((x, i) => (x - sx * span.w[i]) / width);\n    const v = span.y.map((y, i) => (y - sy * span.w[i]) / height);\n    if (project) return project({ x: u, y: v, w: span.w });\n    const wu = span.w.map((w, i) => w - u[i]), wv = span.w.map((w, i) => w - v[i]);\n    const weights = [product(wu, wv), product(u, wv), product(wu, v), product(u, v)];\n    const w = product(span.w, span.w);\n    const x = w.map((_, i) => weights.reduce((sum, ws, j) => sum + ws[i] * corners[j][0], 0));\n    const y = w.map((_, i) => weights.reduce((sum, ws, j) => sum + ws[i] * corners[j][1], 0));\n    return { x, y, w };\n  };\n  const output = new PathGeometry();\n  let count = 0, closed = false;\n  const reserve = () => {\n    if (++count > maxSegments) throw new RangeError('warpPath exceeded maxSegments.');\n  };\n  const line = (x: number, y: number) => { reserve(); output.lineTo(x, y); closed = false; };\n  // At most 4M subdivision visits per call, even for a pole with no output.\n  const work: WarpWork = { remaining: Math.min(4_000_000, 2 * maxSegments + 53), pool: [], depths: [], scratch: [] };\n  const emit = (span: WarpSpan) => {\n    if (count >= maxSegments) throw new RangeError('warpPath exceeded maxSegments.');\n    emitSpan(map(span), tolerance, work, line);\n  };\n  let current: WarpPoint = [0, 0], start: WarpPoint = current;\n  for (const segment of path) {\n    switch (segment.type) {\n      case 'move': {\n        current = start = [segment.x, segment.y];\n        const p = endpoint(map(polynomial([current])), 0);\n        reserve(); output.moveTo(p[0], p[1]); closed = false;\n        break;\n      }\n      case 'line': {\n        const end: WarpPoint = [segment.x, segment.y];\n        emit(polynomial([current, end])); current = end; break;\n      }\n      case 'quadratic': {\n        const end: WarpPoint = [segment.x, segment.y];\n        emit(polynomial([current, [segment.cpx, segment.cpy], end])); current = end; break;\n      }\n      case 'cubic': {\n        const end: WarpPoint = [segment.x, segment.y];\n        emit(polynomial([current, [segment.cp1x, segment.cp1y], [segment.cp2x, segment.cp2y], end]));\n        current = end; break;\n      }\n      case 'arc': {\n        const first = arcPoint(segment, segment.startAngle);\n        if (current[0] !== first[0] || current[1] !== first[1]) emit(polynomial([current, first]));\n        const pieces = Math.max(1, Math.ceil(Math.abs(segment.sweep) / (Math.PI / 2)));\n        for (let i = 0; i < pieces; i++) {\n          const a = segment.startAngle + segment.sweep * i / pieces;\n          const b = segment.startAngle + segment.sweep * (i + 1) / pieces;\n          const mid = (a + b) / 2, weight = Math.cos((b - a) / 2);\n          const p = arcPoint(segment, a), q = arcPoint(segment, b);\n          emit({\n            x: [p[0], segment.cx * weight + segment.ux * Math.cos(mid) + segment.vx * Math.sin(mid), q[0]],\n            y: [p[1], segment.cy * weight + segment.uy * Math.cos(mid) + segment.vy * Math.sin(mid), q[1]],\n            w: [1, weight, 1],\n          });\n        }\n        current = arcPoint(segment, segment.startAngle + segment.sweep);\n        break;\n      }\n      case 'close':\n        if (current[0] !== start[0] || current[1] !== start[1]) emit(polynomial([current, start]));\n        if (!closed) { reserve(); output.closePath(); closed = true; }\n        current = start; break;\n    }\n  }\n  return output;\n}\n"],
+  "mappings": "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",
+  "names": ["a", "b", "c", "x", "y", "w"]
+}

package/dist/lib/geometry/polygon.d.ts

@@ -0,0 +1,21 @@
+import type { RoundedCornerPathOptions } from './rounded-corners.js';
+/**
+ * Geometry and construction options for a polygon path.
+ *
+ * @see {@link RoundedCornerPathOptions}
+ * @see {@link createPolygonPath}
+ */
+export interface PolygonPathOptions extends RoundedCornerPathOptions {
+    /** Ordered coordinate pairs describing the path vertices. See {@link PolygonPathOptions}. */
+    coords: readonly (readonly [number, number])[];
+}
+/**
+ * Creates a Canvas Path2D for polygon geometry from validated options.
+ *
+ * @param options - Ordered polygon vertices and corner rounding settings. See
+ * {@link PolygonPathOptions} .
+ * @returns A native Canvas path containing the polygon.
+ *
+ * @see {@link PolygonPathOptions}
+ */
+export declare function createPolygonPath(options: Readonly<PolygonPathOptions>): Path2D;

package/dist/lib/geometry/polygon.js

@@ -0,0 +1,12 @@
+import { createRoundedClosedPolygonPath, resolveNumericCornerRadii } from "./rounded-corners.js";
+import { validateCoordinates } from "./validation.js";
+function createPolygonPath(options) {
+  const coords = validateCoordinates(options.coords);
+  const radii = resolveNumericCornerRadii(coords.length, options);
+  if (coords.length < 3) return new Path2D();
+  return createRoundedClosedPolygonPath(coords, radii);
+}
+export {
+  createPolygonPath
+};
+//# sourceMappingURL=polygon.js.map

package/dist/lib/geometry/polygon.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/polygon.ts"],
+  "sourcesContent": ["import { createRoundedClosedPolygonPath, resolveNumericCornerRadii } from './rounded-corners.js';\nimport type { RoundedCornerPathOptions } from './rounded-corners.js';\nimport { validateCoordinates } from './validation.js';\n\n/**\n * Geometry and construction options for a polygon path.\n *\n * @see {@link RoundedCornerPathOptions}\n * @see {@link createPolygonPath}\n */\nexport interface PolygonPathOptions extends RoundedCornerPathOptions {\n  /** Ordered coordinate pairs describing the path vertices. See {@link PolygonPathOptions}. */\n  coords: readonly (readonly [number, number])[];\n}\n\n/**\n * Creates a Canvas Path2D for polygon geometry from validated options.\n *\n * @param options - Ordered polygon vertices and corner rounding settings. See\n * {@link PolygonPathOptions} .\n * @returns A native Canvas path containing the polygon.\n *\n * @see {@link PolygonPathOptions}\n */\nexport function createPolygonPath(\n  options: Readonly<PolygonPathOptions>,\n): Path2D {\n  const coords = validateCoordinates(options.coords);\n  const radii = resolveNumericCornerRadii(coords.length, options);\n  if (coords.length < 3) return new Path2D();\n  return createRoundedClosedPolygonPath(coords, radii);\n}\n"],
+  "mappings": "AAAA,SAAS,gCAAgC,iCAAiC;AAE1E,SAAS,2BAA2B;AAsB7B,SAAS,kBACd,SACQ;AACR,QAAM,SAAS,oBAAoB,QAAQ,MAAM;AACjD,QAAM,QAAQ,0BAA0B,OAAO,QAAQ,OAAO;AAC9D,MAAI,OAAO,SAAS,EAAG,QAAO,IAAI,OAAO;AACzC,SAAO,+BAA+B,QAAQ,KAAK;AACrD;",
+  "names": []
+}

package/dist/lib/geometry/rectangle.d.ts

@@ -0,0 +1,38 @@
+import { type RoundedCornerPathOptions } from './rounded-corners.js';
+/**
+ * Geometry and construction options for a rectangle path.
+ *
+ * @see {@link RoundedCornerPathOptions}
+ * @see {@link createRectanglePath}
+ */
+export interface RectanglePathOptions extends RoundedCornerPathOptions {
+    /**
+     * Horizontal coordinate or displacement in the containing coordinate system. See
+     * {@link RectanglePathOptions}.
+     */
+    x?: number;
+    /**
+     * Vertical coordinate or displacement in the containing coordinate system. See
+     * {@link RectanglePathOptions}.
+     */
+    y?: number;
+    /**
+     * Horizontal extent in the units of the containing geometry or surface. See
+     * {@link RectanglePathOptions}.
+     */
+    width: number;
+    /**
+     * Vertical extent in the units of the containing geometry or surface. See
+     * {@link RectanglePathOptions}.
+     */
+    height: number;
+}
+/**
+ * Creates a Canvas Path2D for rectangle geometry from validated options.
+ *
+ * @param options - Rectangle bounds and corner options. See {@link RectanglePathOptions}.
+ * @returns A native Canvas path containing the rectangle.
+ *
+ * @see {@link RectanglePathOptions}
+ */
+export declare function createRectanglePath(options: Readonly<RectanglePathOptions>): Path2D;

package/dist/lib/geometry/rectangle.js

@@ -0,0 +1,22 @@
+import {
+  resolveNumericCornerRadii
+} from "./rounded-corners.js";
+import { finiteNumber } from "./validation.js";
+function createRectanglePath(options) {
+  const x = finiteNumber(options.x ?? 0, "x");
+  const y = finiteNumber(options.y ?? 0, "y");
+  const width = finiteNumber(options.width, "width");
+  const height = finiteNumber(options.height, "height");
+  const radii = resolveNumericCornerRadii(4, options);
+  const path = new Path2D();
+  if (radii.every((radius) => radius === 0)) {
+    path.rect(x, y, width, height);
+  } else {
+    path.roundRect(x, y, width, height, [...radii]);
+  }
+  return path;
+}
+export {
+  createRectanglePath
+};
+//# sourceMappingURL=rectangle.js.map

package/dist/lib/geometry/rectangle.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/rectangle.ts"],
+  "sourcesContent": ["import {\n  resolveNumericCornerRadii,\n  type RoundedCornerPathOptions,\n} from './rounded-corners.js';\nimport { finiteNumber } from './validation.js';\n\n/**\n * Geometry and construction options for a rectangle path.\n *\n * @see {@link RoundedCornerPathOptions}\n * @see {@link createRectanglePath}\n */\nexport interface RectanglePathOptions extends RoundedCornerPathOptions {\n  /**\n   * Horizontal coordinate or displacement in the containing coordinate system. See\n   * {@link RectanglePathOptions}.\n   */\n  x?: number;\n  /**\n   * Vertical coordinate or displacement in the containing coordinate system. See\n   * {@link RectanglePathOptions}.\n   */\n  y?: number;\n  /**\n   * Horizontal extent in the units of the containing geometry or surface. See\n   * {@link RectanglePathOptions}.\n   */\n  width: number;\n  /**\n   * Vertical extent in the units of the containing geometry or surface. See\n   * {@link RectanglePathOptions}.\n   */\n  height: number;\n}\n\n/**\n * Creates a Canvas Path2D for rectangle geometry from validated options.\n *\n * @param options - Rectangle bounds and corner options. See {@link RectanglePathOptions}.\n * @returns A native Canvas path containing the rectangle.\n *\n * @see {@link RectanglePathOptions}\n */\nexport function createRectanglePath(\n  options: Readonly<RectanglePathOptions>,\n): Path2D {\n  const x = finiteNumber(options.x ?? 0, 'x');\n  const y = finiteNumber(options.y ?? 0, 'y');\n  const width = finiteNumber(options.width, 'width');\n  const height = finiteNumber(options.height, 'height');\n  const radii = resolveNumericCornerRadii(4, options);\n  const path = new Path2D();\n\n  if (radii.every(radius => radius === 0)) {\n    path.rect(x, y, width, height);\n  } else {\n    path.roundRect(x, y, width, height, [...radii]);\n  }\n\n  return path;\n}\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,OAEK;AACP,SAAS,oBAAoB;AAuCtB,SAAS,oBACd,SACQ;AACR,QAAM,IAAI,aAAa,QAAQ,KAAK,GAAG,GAAG;AAC1C,QAAM,IAAI,aAAa,QAAQ,KAAK,GAAG,GAAG;AAC1C,QAAM,QAAQ,aAAa,QAAQ,OAAO,OAAO;AACjD,QAAM,SAAS,aAAa,QAAQ,QAAQ,QAAQ;AACpD,QAAM,QAAQ,0BAA0B,GAAG,OAAO;AAClD,QAAM,OAAO,IAAI,OAAO;AAExB,MAAI,MAAM,MAAM,YAAU,WAAW,CAAC,GAAG;AACvC,SAAK,KAAK,GAAG,GAAG,OAAO,MAAM;AAAA,EAC/B,OAAO;AACL,SAAK,UAAU,GAAG,GAAG,OAAO,QAAQ,CAAC,GAAG,KAAK,CAAC;AAAA,EAChD;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/lib/geometry/regular-polygon.d.ts

@@ -0,0 +1,88 @@
+import type { LayoutBox } from '../layout/types.js';
+import { type RoundedCornerPathOptions } from './rounded-corners.js';
+import { type GeometryErrorFactory } from './validation.js';
+/**
+ * Center, side count, and rotation for a regular polygon path.
+ *
+ * @see {@link RegularPolygonPathOptions}
+ */
+export interface RegularPolygonPathPosition {
+    /** Number of sides of the regular polygon. See {@link RegularPolygonPathPosition}. */
+    sides: number;
+    /** Horizontal coordinate of the center. See {@link RegularPolygonPathPosition}. */
+    cx?: number;
+    /** Vertical coordinate of the center. See {@link RegularPolygonPathPosition}. */
+    cy?: number;
+    /** Rotation applied to the containing geometry. See {@link RegularPolygonPathPosition}. */
+    rotation?: number;
+}
+/**
+ * Exactly one size measure for a regular polygon: circumradius, inradius, or side length.
+ *
+ * @see {@link RegularPolygonPathOptions}
+ */
+export type RegularPolygonNumericSize = {
+    /** Distance from the polygon center to a vertex. See {@link RegularPolygonNumericSize}. */
+    circumradius: number;
+    /**
+     * Not accepted in this variant; use the alternative fields instead. See
+     * {@link RegularPolygonNumericSize}.
+     */
+    inradius?: never;
+    /**
+     * Not accepted in this variant; use the alternative fields instead. See
+     * {@link RegularPolygonNumericSize}.
+     */
+    sideLength?: never;
+} | {
+    /**
+     * Not accepted in this variant; use the alternative fields instead. See
+     * {@link RegularPolygonNumericSize}.
+     */
+    circumradius?: never;
+    /** Distance from the polygon center to an edge. See {@link RegularPolygonNumericSize}. */
+    inradius: number;
+    /**
+     * Not accepted in this variant; use the alternative fields instead. See
+     * {@link RegularPolygonNumericSize}.
+     */
+    sideLength?: never;
+} | {
+    /**
+     * Not accepted in this variant; use the alternative fields instead. See
+     * {@link RegularPolygonNumericSize}.
+     */
+    circumradius?: never;
+    /**
+     * Not accepted in this variant; use the alternative fields instead. See
+     * {@link RegularPolygonNumericSize}.
+     */
+    inradius?: never;
+    /** Length of one polygon edge. See {@link RegularPolygonNumericSize}. */
+    sideLength: number;
+};
+/**
+ * Geometry and construction options for a regular polygon path.
+ *
+ * @see {@link RegularPolygonPathPosition}
+ * @see {@link RegularPolygonNumericSize}
+ * @see {@link RoundedCornerPathOptions}
+ * @see {@link createRegularPolygonPath}
+ */
+export type RegularPolygonPathOptions = RegularPolygonPathPosition & RegularPolygonNumericSize & RoundedCornerPathOptions;
+export interface ResolvedRegularPolygonGeometry {
+    path: Path2D;
+    vertices: readonly (readonly [number, number])[];
+    bounds?: LayoutBox;
+}
+export declare function resolveRegularPolygonGeometry(options: Readonly<RegularPolygonPathOptions>, errorFactory?: GeometryErrorFactory): ResolvedRegularPolygonGeometry;
+/**
+ * Creates a Canvas Path2D for regular polygon geometry from validated options.
+ *
+ * @param options - Polygon center, radius, side count, and rotation. See
+ * {@link RegularPolygonPathOptions} .
+ * @returns A native Canvas path containing the regular polygon.
+ *
+ * @see {@link RegularPolygonPathOptions}
+ */
+export declare function createRegularPolygonPath(options: Readonly<RegularPolygonPathOptions>): Path2D;

package/dist/lib/geometry/regular-polygon.js

@@ -0,0 +1,67 @@
+import { createPolygonPath } from "./polygon.js";
+import {
+  resolveNumericCornerRadii
+} from "./rounded-corners.js";
+import {
+  finiteNumber,
+  integerAtLeast,
+  nonnegativeNumber,
+  pathRangeError
+} from "./validation.js";
+const SIZE_KEYS = ["circumradius", "inradius", "sideLength"];
+function resolveRegularPolygonGeometry(options, errorFactory = pathRangeError) {
+  const sides = integerAtLeast(options.sides, 3, "sides", errorFactory);
+  const sizeKeys = SIZE_KEYS.filter((key) => options[key] !== void 0);
+  if (sizeKeys.length !== 1) {
+    throw errorFactory(
+      "circumradius|inradius|sideLength",
+      options,
+      "must provide exactly one size option"
+    );
+  }
+  const sizeKind = sizeKeys[0];
+  const size = nonnegativeNumber(options[sizeKind], sizeKind, errorFactory);
+  const cx = finiteNumber(options.cx ?? 0, "cx", errorFactory);
+  const cy = finiteNumber(options.cy ?? 0, "cy", errorFactory);
+  const rotation = finiteNumber(
+    options.rotation ?? -Math.PI / 2,
+    "rotation",
+    errorFactory
+  );
+  const radii = resolveNumericCornerRadii(sides, options, errorFactory);
+  const circumradius = sizeKind === "circumradius" ? size : sizeKind === "inradius" ? size / Math.cos(Math.PI / sides) : size / (2 * Math.sin(Math.PI / sides));
+  let left = Number.POSITIVE_INFINITY;
+  let right = Number.NEGATIVE_INFINITY;
+  let top = Number.POSITIVE_INFINITY;
+  let bottom = Number.NEGATIVE_INFINITY;
+  const vertices = Array.from({ length: sides }, (_, index) => {
+    const angle = rotation + index * Math.PI * 2 / sides;
+    const vertex = [
+      cx + circumradius * Math.cos(angle),
+      cy + circumradius * Math.sin(angle)
+    ];
+    left = Math.min(left, vertex[0]);
+    right = Math.max(right, vertex[0]);
+    top = Math.min(top, vertex[1]);
+    bottom = Math.max(bottom, vertex[1]);
+    return vertex;
+  });
+  return {
+    path: circumradius === 0 ? new Path2D() : createPolygonPath({ coords: vertices, cornerRadii: radii }),
+    vertices,
+    bounds: {
+      x: left,
+      y: top,
+      width: right - left,
+      height: bottom - top
+    }
+  };
+}
+function createRegularPolygonPath(options) {
+  return resolveRegularPolygonGeometry(options).path;
+}
+export {
+  createRegularPolygonPath,
+  resolveRegularPolygonGeometry
+};
+//# sourceMappingURL=regular-polygon.js.map