@pibbl/core 0.0.1

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

@@ -0,0 +1,341 @@
+import { arcPoint, TAU } from "./path-arc.js";
+import { PathGeometry } from "./path-geometry.js";
+const DEFAULT_MAX_SEGMENTS = 1e6;
+function flattenPath(path, options) {
+  const tolerance = requiredPositive(options.tolerance, "tolerance");
+  const output = collector(options.maxSegments);
+  let current = [0, 0];
+  let start = [0, 0];
+  for (const segment of path) {
+    switch (segment.type) {
+      case "move":
+        current = start = [segment.x, segment.y];
+        output.add(segment);
+        break;
+      case "line":
+        current = [segment.x, segment.y];
+        output.add(segment);
+        break;
+      case "close":
+        current = start;
+        output.add(segment);
+        break;
+      case "quadratic": {
+        const end = [segment.x, segment.y];
+        flattenQuadratic(current, [segment.cpx, segment.cpy], end, tolerance, output);
+        current = end;
+        break;
+      }
+      case "cubic": {
+        const end = [segment.x, segment.y];
+        flattenCubic(current, [segment.cp1x, segment.cp1y], [segment.cp2x, segment.cp2y], end, tolerance, output);
+        current = end;
+        break;
+      }
+      case "arc": {
+        const arcStart = arcPoint(segment, segment.startAngle);
+        if (!samePoint(current, arcStart)) output.add(line(arcStart));
+        flattenArc(segment, tolerance, output);
+        current = arcPoint(segment, segment.startAngle + segment.sweep);
+        break;
+      }
+    }
+  }
+  return output.finish();
+}
+function subdividePath(path, options) {
+  const divisions = requiredInteger(options.divisions, "divisions");
+  const output = collector(options.maxSegments);
+  let current = [0, 0];
+  let start = [0, 0];
+  for (const segment of path) {
+    switch (segment.type) {
+      case "move":
+        current = start = [segment.x, segment.y];
+        output.add(segment);
+        break;
+      case "line": {
+        const end = [segment.x, segment.y];
+        subdivideLine(current, end, divisions, output);
+        current = end;
+        break;
+      }
+      case "quadratic": {
+        const end = [segment.x, segment.y];
+        subdivideQuadratic(current, [segment.cpx, segment.cpy], end, divisions, output);
+        current = end;
+        break;
+      }
+      case "cubic": {
+        const end = [segment.x, segment.y];
+        subdivideCubic(current, [segment.cp1x, segment.cp1y], [segment.cp2x, segment.cp2y], end, divisions, output);
+        current = end;
+        break;
+      }
+      case "arc": {
+        const arcStart = arcPoint(segment, segment.startAngle);
+        if (!samePoint(current, arcStart)) output.add(line(arcStart));
+        for (let i = 0; i < divisions; i++) {
+          output.add({ ...segment, startAngle: normalizeAngle(segment.startAngle + segment.sweep * i / divisions), sweep: segment.sweep / divisions });
+        }
+        current = arcPoint(segment, segment.startAngle + segment.sweep);
+        break;
+      }
+      case "close":
+        if (!samePoint(current, start)) subdivideLine(current, start, divisions, output);
+        current = start;
+        output.add(segment);
+        break;
+    }
+  }
+  return output.finish();
+}
+function simplifyPath(path, options) {
+  const tolerance = requiredPositive(options.tolerance, "tolerance");
+  const output = collector(options.maxSegments);
+  let current;
+  let start;
+  let run = [];
+  const flushOpen = () => {
+    if (!run.length) return;
+    for (const point of simplifyOpen(run, tolerance).slice(1)) output.add(line(point));
+    run = current ? [current] : [];
+  };
+  for (const segment of path) {
+    switch (segment.type) {
+      case "move":
+        flushOpen();
+        current = start = [segment.x, segment.y];
+        run = [current];
+        output.add(segment);
+        break;
+      case "line":
+        current = [segment.x, segment.y];
+        run.push(current);
+        break;
+      case "close": {
+        if (!current || !start) throw new TypeError("simplifyPath requires a move segment before close.");
+        const simplified = simplifyClosed(withoutClosingDuplicate(run), tolerance);
+        for (const point of simplified.slice(1)) output.add(line(point));
+        output.add(segment);
+        current = start;
+        run = [current];
+        break;
+      }
+      default:
+        throw new TypeError("simplifyPath requires line-only geometry.");
+    }
+  }
+  flushOpen();
+  return output.finish();
+}
+function collector(maxSegments) {
+  const limit = maxSegments === void 0 ? DEFAULT_MAX_SEGMENTS : requiredInteger(maxSegments, "maxSegments");
+  const segments = [];
+  return {
+    add(segment) {
+      if (segments.length >= limit) throw new RangeError("Path utility output exceeds maxSegments.");
+      segments.push(segment);
+    },
+    finish() {
+      const output = new PathGeometry();
+      if (segments.length) output.spliceSegments(0, 0, segments);
+      return output;
+    }
+  };
+}
+function requiredPositive(value, name) {
+  if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${name} must be a finite positive number.`);
+  return value;
+}
+function requiredInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`${name} must be a positive integer.`);
+  return value;
+}
+function flattenQuadratic(a, b, c, tolerance, output) {
+  const stack = [[a, b, c, 0]];
+  while (stack.length) {
+    const [p0, p1, p2, depth] = stack.pop();
+    if (pointSegmentDistance(p1, p0, p2) <= tolerance) {
+      output.add(line(p2));
+      continue;
+    }
+    if (depth >= 60) throw new RangeError("flattenPath cannot satisfy tolerance due to numerical nonprogress.");
+    const p01 = midpoint(p0, p1), p12 = midpoint(p1, p2), p = midpoint(p01, p12);
+    stack.push([p, p12, p2, depth + 1], [p0, p01, p, depth + 1]);
+  }
+}
+function flattenCubic(a, b, c, d, tolerance, output) {
+  const stack = [[a, b, c, d, 0]];
+  while (stack.length) {
+    const [p0, p1, p2, p3, depth] = stack.pop();
+    if (Math.max(pointSegmentDistance(p1, p0, p3), pointSegmentDistance(p2, p0, p3)) <= tolerance) {
+      output.add(line(p3));
+      continue;
+    }
+    if (depth >= 60) throw new RangeError("flattenPath cannot satisfy tolerance due to numerical nonprogress.");
+    const p01 = midpoint(p0, p1), p12 = midpoint(p1, p2), p23 = midpoint(p2, p3);
+    const p012 = midpoint(p01, p12), p123 = midpoint(p12, p23), p = midpoint(p012, p123);
+    stack.push([p, p123, p23, p3, depth + 1], [p0, p01, p012, p, depth + 1]);
+  }
+}
+function flattenArc(arc, tolerance, output) {
+  const radius = Math.hypot(arc.ux, arc.uy, arc.vx, arc.vy);
+  const stack = [[arc.startAngle, arc.startAngle + arc.sweep, 0]];
+  while (stack.length) {
+    const [from, to, depth] = stack.pop();
+    const middle = (from + to) / 2;
+    const a = arcPoint(arc, from), b = arcPoint(arc, to);
+    const sampled = Math.max(
+      pointSegmentDistance(arcPoint(arc, from + (to - from) / 4), a, b),
+      pointSegmentDistance(arcPoint(arc, middle), a, b),
+      pointSegmentDistance(arcPoint(arc, to - (to - from) / 4), a, b)
+    );
+    const bound = radius * (to - from) ** 2 / 8;
+    if (sampled <= tolerance && bound <= tolerance) {
+      output.add(line(b));
+      continue;
+    }
+    if (depth >= 60 || middle === from || middle === to) throw new RangeError("flattenPath cannot satisfy tolerance due to numerical nonprogress.");
+    stack.push([middle, to, depth + 1], [from, middle, depth + 1]);
+  }
+}
+function subdivideLine(a, b, divisions, output) {
+  for (let i = 1; i <= divisions; i++) output.add(line(interpolate(a, b, i / divisions)));
+}
+function subdivideQuadratic(a, b, c, divisions, output) {
+  let rest = [a, b, c];
+  for (let i = divisions; i > 1; i--) {
+    const [left, right] = splitQuadratic(...rest, 1 / i);
+    output.add({ type: "quadratic", cpx: left[1][0], cpy: left[1][1], x: left[2][0], y: left[2][1] });
+    rest = right;
+  }
+  output.add({ type: "quadratic", cpx: rest[1][0], cpy: rest[1][1], x: rest[2][0], y: rest[2][1] });
+}
+function subdivideCubic(a, b, c, d, divisions, output) {
+  let rest = [a, b, c, d];
+  for (let i = divisions; i > 1; i--) {
+    const [left, right] = splitCubic(...rest, 1 / i);
+    output.add({ type: "cubic", cp1x: left[1][0], cp1y: left[1][1], cp2x: left[2][0], cp2y: left[2][1], x: left[3][0], y: left[3][1] });
+    rest = right;
+  }
+  output.add({ type: "cubic", cp1x: rest[1][0], cp1y: rest[1][1], cp2x: rest[2][0], cp2y: rest[2][1], x: rest[3][0], y: rest[3][1] });
+}
+function simplifyOpen(points, tolerance) {
+  if (points.length <= 2) return [...points];
+  const keep = new Uint8Array(points.length);
+  keep[0] = keep[points.length - 1] = 1;
+  const stack = [[0, points.length - 1]];
+  while (stack.length) {
+    const [first, last] = stack.pop();
+    let index = -1, maximum = tolerance;
+    for (let i = first + 1; i < last; i++) {
+      const distance = pointSegmentDistance(points[i], points[first], points[last]);
+      if (distance > maximum) {
+        maximum = distance;
+        index = i;
+      }
+    }
+    if (index !== -1) {
+      keep[index] = 1;
+      stack.push([first, index], [index, last]);
+    }
+  }
+  const result = [];
+  for (let i = 0; i < points.length; i++) if (keep[i]) result.push(points[i]);
+  return result;
+}
+function simplifyClosed(points, tolerance) {
+  if (points.length <= 3 || !hasThreeDistinct(points)) return [...points];
+  const [firstAnchor, secondAnchor] = closedAnchors(points);
+  const first = simplifyOpen(points.slice(0, firstAnchor + 1), tolerance);
+  const second = simplifyOpen(points.slice(firstAnchor, secondAnchor + 1), tolerance);
+  const third = simplifyOpen([...points.slice(secondAnchor), points[0]], tolerance);
+  return [...first, ...second.slice(1), ...third.slice(1, -1)];
+}
+function closedAnchors(points) {
+  let farthest = 1, farthestDistance = -1;
+  for (let i = 1; i < points.length; i++) {
+    const distance = pointDistance(points[0], points[i]);
+    if (distance > farthestDistance) {
+      farthestDistance = distance;
+      farthest = i;
+    }
+  }
+  let third = -1, thirdDistance = -1;
+  for (let i = 1; i < points.length; i++) {
+    if (i === farthest || samePoint(points[i], points[0]) || samePoint(points[i], points[farthest])) continue;
+    const distance = pointSegmentDistance(points[i], points[0], points[farthest]);
+    if (distance > thirdDistance) {
+      thirdDistance = distance;
+      third = i;
+    }
+  }
+  const [firstAnchor, secondAnchor] = [farthest, third].sort((a, b) => a - b);
+  return [firstAnchor, secondAnchor];
+}
+function withoutClosingDuplicate(points) {
+  return points.length > 1 && samePoint(points[0], points.at(-1)) ? points.slice(0, -1) : [...points];
+}
+function hasThreeDistinct(points) {
+  const first = points[0];
+  let second;
+  for (let i = 1; i < points.length; i++) {
+    const point = points[i];
+    if (samePoint(point, first)) continue;
+    if (!second) second = point;
+    else if (!samePoint(point, second)) return true;
+  }
+  return false;
+}
+function splitQuadratic(a, b, c, t) {
+  const ab = interpolate(a, b, t), bc = interpolate(b, c, t), p = interpolate(ab, bc, t);
+  return [[a, ab, p], [p, bc, c]];
+}
+function splitCubic(a, b, c, d, t) {
+  const ab = interpolate(a, b, t), bc = interpolate(b, c, t), cd = interpolate(c, d, t);
+  const abc = interpolate(ab, bc, t), bcd = interpolate(bc, cd, t), p = interpolate(abc, bcd, t);
+  return [[a, ab, abc, p], [p, bcd, cd, d]];
+}
+function line([x, y]) {
+  return { type: "line", x, y };
+}
+function midpoint(a, b) {
+  return interpolate(a, b, 0.5);
+}
+function interpolate(a, b, t) {
+  return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+}
+function pointDistance(a, b) {
+  return Math.hypot(difference(a[0], b[0]), difference(a[1], b[1]));
+}
+function samePoint(a, b) {
+  return a[0] === b[0] && a[1] === b[1];
+}
+function pointSegmentDistance(point, a, b) {
+  const x = difference(b[0], a[0]), y = difference(b[1], a[1]);
+  const px = difference(point[0], a[0]), py = difference(point[1], a[1]);
+  const scale = Math.max(Math.abs(x), Math.abs(y), Math.abs(px), Math.abs(py));
+  if (scale === 0) return Math.hypot(px, py);
+  const scaledX = x / scale, scaledY = y / scale;
+  const scaledPX = px / scale, scaledPY = py / scale;
+  const length = scaledX * scaledX + scaledY * scaledY;
+  if (length === 0) return Math.hypot(px, py);
+  const t = Math.max(0, Math.min(1, (scaledPX * scaledX + scaledPY * scaledY) / length));
+  return scale * Math.hypot(scaledPX - scaledX * t, scaledPY - scaledY * t);
+}
+function difference(value, origin) {
+  const result = value - origin;
+  if (!Number.isFinite(result)) throw new RangeError("Path utility cannot compare coordinates with an unrepresentable difference.");
+  return result;
+}
+function normalizeAngle(angle) {
+  const normalized = angle % TAU;
+  return Object.is(normalized, -0) ? 0 : normalized;
+}
+export {
+  flattenPath,
+  simplifyPath,
+  subdividePath
+};
+//# sourceMappingURL=path-utilities.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/path-utilities.ts"],
+  "sourcesContent": ["import type { flattenPathWang } from './path-wang.js';\nimport type { simplifyPathRadial } from './path-radial.js';\nimport { arcPoint, TAU, type ArcSegment } from './path-arc.js';\nimport { PathGeometry, type PathSegment } from './path-geometry.js';\n\nconst DEFAULT_MAX_SEGMENTS = 1_000_000;\n\n/**\n * Positive approximation tolerance and output-segment budget for curve flattening.\n *\n * @see {@link flattenPath}\n * @see {@link flattenPathWang}\n */\nexport interface FlattenPathOptions {\n  /** Positive maximum geometric approximation error. See {@link FlattenPathOptions}. */\n  readonly tolerance: number;\n  /** Upper bound on the number of output path segments. See {@link FlattenPathOptions}. */\n  readonly maxSegments?: number;\n}\n\n/**\n * Positive tolerance and output-segment budget for polyline simplification.\n *\n * @see {@link simplifyPath}\n * @see {@link simplifyPathRadial}\n */\nexport interface SimplifyPathOptions {\n  /** Positive maximum geometric approximation error. See {@link SimplifyPathOptions}. */\n  readonly tolerance: number;\n  /** Upper bound on the number of output path segments. See {@link SimplifyPathOptions}. */\n  readonly maxSegments?: number;\n}\n\n/**\n * Subdivision count and output-segment budget for splitting path segments.\n *\n * @see {@link subdividePath}\n */\nexport interface SubdividePathOptions {\n  /**\n   * Number of pieces produced from each drawable path segment. See {@link SubdividePathOptions}.\n   */\n  readonly divisions: number;\n  /** Upper bound on the number of output path segments. See {@link SubdividePathOptions}. */\n  readonly maxSegments?: number;\n}\n\ntype Point = readonly [number, number];\n\n/**\n * Returns independent geometry with curves approximated by line segments within the requested\n * tolerance.\n *\n * @param path - Source geometry; it is not modified. See {@link PathGeometry}.\n * @param options - Maximum approximation error and flattening work limits. See\n * {@link FlattenPathOptions} .\n * @returns Independent geometry with curves replaced by line segments. See {@link PathGeometry}.\n *\n * @see {@link PathGeometry}\n * @see {@link FlattenPathOptions}\n */\nexport function flattenPath(path: PathGeometry, options: Readonly<FlattenPathOptions>): PathGeometry {\n  const tolerance = requiredPositive(options.tolerance, 'tolerance');\n  const output = collector(options.maxSegments);\n  let current: Point = [0, 0];\n  let start: Point = [0, 0];\n  for (const segment of path) {\n    switch (segment.type) {\n      case 'move': current = start = [segment.x, segment.y]; output.add(segment); break;\n      case 'line': current = [segment.x, segment.y]; output.add(segment); break;\n      case 'close': current = start; output.add(segment); break;\n      case 'quadratic': {\n        const end: Point = [segment.x, segment.y];\n        flattenQuadratic(current, [segment.cpx, segment.cpy], end, tolerance, output);\n        current = end;\n        break;\n      }\n      case 'cubic': {\n        const end: Point = [segment.x, segment.y];\n        flattenCubic(current, [segment.cp1x, segment.cp1y], [segment.cp2x, segment.cp2y], end, tolerance, output);\n        current = end;\n        break;\n      }\n      case 'arc': {\n        const arcStart = arcPoint(segment, segment.startAngle);\n        if (!samePoint(current, arcStart)) output.add(line(arcStart));\n        flattenArc(segment, tolerance, output);\n        current = arcPoint(segment, segment.startAngle + segment.sweep);\n        break;\n      }\n    }\n  }\n  return output.finish();\n}\n\n/**\n * Returns independent geometry with each drawable segment split into the requested number of\n * pieces.\n *\n * @param path - Source geometry; it is not modified. See {@link PathGeometry}.\n * @param options - Subdivision length and work limits. See {@link SubdividePathOptions}.\n * @returns Independent geometry with segments split according to the requested limits. See\n * {@link PathGeometry} .\n *\n * @see {@link PathGeometry}\n * @see {@link SubdividePathOptions}\n */\nexport function subdividePath(path: PathGeometry, options: Readonly<SubdividePathOptions>): PathGeometry {\n  const divisions = requiredInteger(options.divisions, 'divisions');\n  const output = collector(options.maxSegments);\n  let current: Point = [0, 0];\n  let start: Point = [0, 0];\n  for (const segment of path) {\n    switch (segment.type) {\n      case 'move': current = start = [segment.x, segment.y]; output.add(segment); break;\n      case 'line': {\n        const end: Point = [segment.x, segment.y];\n        subdivideLine(current, end, divisions, output);\n        current = end;\n        break;\n      }\n      case 'quadratic': {\n        const end: Point = [segment.x, segment.y];\n        subdivideQuadratic(current, [segment.cpx, segment.cpy], end, divisions, output);\n        current = end;\n        break;\n      }\n      case 'cubic': {\n        const end: Point = [segment.x, segment.y];\n        subdivideCubic(current, [segment.cp1x, segment.cp1y], [segment.cp2x, segment.cp2y], end, divisions, output);\n        current = end;\n        break;\n      }\n      case 'arc': {\n        const arcStart = arcPoint(segment, segment.startAngle);\n        if (!samePoint(current, arcStart)) output.add(line(arcStart));\n        for (let i = 0; i < divisions; i++) {\n          output.add({ ...segment, startAngle: normalizeAngle(segment.startAngle + segment.sweep * i / divisions), sweep: segment.sweep / divisions });\n        }\n        current = arcPoint(segment, segment.startAngle + segment.sweep);\n        break;\n      }\n      case 'close':\n        if (!samePoint(current, start)) subdivideLine(current, start, divisions, output);\n        current = start;\n        output.add(segment);\n        break;\n    }\n  }\n  return output.finish();\n}\n\n/**\n * Returns independent polyline geometry with redundant points removed within the requested\n * tolerance.\n *\n * @param path - Source geometry; it is not modified. See {@link PathGeometry}.\n * @param options - Simplification tolerance and work limits. See {@link SimplifyPathOptions}.\n * @returns Independent geometry with redundant line vertices removed. See {@link PathGeometry}.\n *\n * @see {@link PathGeometry}\n * @see {@link SimplifyPathOptions}\n */\nexport function simplifyPath(path: PathGeometry, options: Readonly<SimplifyPathOptions>): PathGeometry {\n  const tolerance = requiredPositive(options.tolerance, 'tolerance');\n  const output = collector(options.maxSegments);\n  let current: Point | undefined;\n  let start: Point | undefined;\n  let run: Point[] = [];\n  const flushOpen = () => {\n    if (!run.length) return;\n    for (const point of simplifyOpen(run, tolerance).slice(1)) output.add(line(point));\n    run = current ? [current] : [];\n  };\n  for (const segment of path) {\n    switch (segment.type) {\n      case 'move':\n        flushOpen();\n        current = start = [segment.x, segment.y];\n        run = [current];\n        output.add(segment);\n        break;\n      case 'line':\n        current = [segment.x, segment.y];\n        run.push(current);\n        break;\n      case 'close': {\n        if (!current || !start) throw new TypeError('simplifyPath requires a move segment before close.');\n        const simplified = simplifyClosed(withoutClosingDuplicate(run), tolerance);\n        for (const point of simplified.slice(1)) output.add(line(point));\n        output.add(segment);\n        current = start;\n        run = [current];\n        break;\n      }\n      default: throw new TypeError('simplifyPath requires line-only geometry.');\n    }\n  }\n  flushOpen();\n  return output.finish();\n}\n\nfunction collector(maxSegments: number | undefined) {\n  const limit = maxSegments === undefined ? DEFAULT_MAX_SEGMENTS : requiredInteger(maxSegments, 'maxSegments');\n  const segments: PathSegment[] = [];\n  return {\n    add(segment: PathSegment) {\n      if (segments.length >= limit) throw new RangeError('Path utility output exceeds maxSegments.');\n      segments.push(segment);\n    },\n    finish() {\n      const output = new PathGeometry();\n      if (segments.length) output.spliceSegments(0, 0, segments);\n      return output;\n    },\n  };\n}\n\nfunction requiredPositive(value: number, name: string): number {\n  if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${name} must be a finite positive number.`);\n  return value;\n}\n\nfunction requiredInteger(value: number, name: string): number {\n  if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`${name} must be a positive integer.`);\n  return value;\n}\n\nfunction flattenQuadratic(a: Point, b: Point, c: Point, tolerance: number, output: ReturnType<typeof collector>): void {\n  const stack: Array<readonly [Point, Point, Point, number]> = [[a, b, c, 0]];\n  while (stack.length) {\n    const [p0, p1, p2, depth] = stack.pop()!;\n    if (pointSegmentDistance(p1, p0, p2) <= tolerance) { output.add(line(p2)); continue; }\n    if (depth >= 60) throw new RangeError('flattenPath cannot satisfy tolerance due to numerical nonprogress.');\n    const p01 = midpoint(p0, p1), p12 = midpoint(p1, p2), p = midpoint(p01, p12);\n    stack.push([p, p12, p2, depth + 1], [p0, p01, p, depth + 1]);\n  }\n}\n\nfunction flattenCubic(a: Point, b: Point, c: Point, d: Point, tolerance: number, output: ReturnType<typeof collector>): void {\n  const stack: Array<readonly [Point, Point, Point, Point, number]> = [[a, b, c, d, 0]];\n  while (stack.length) {\n    const [p0, p1, p2, p3, depth] = stack.pop()!;\n    if (Math.max(pointSegmentDistance(p1, p0, p3), pointSegmentDistance(p2, p0, p3)) <= tolerance) { output.add(line(p3)); continue; }\n    if (depth >= 60) throw new RangeError('flattenPath cannot satisfy tolerance due to numerical nonprogress.');\n    const p01 = midpoint(p0, p1), p12 = midpoint(p1, p2), p23 = midpoint(p2, p3);\n    const p012 = midpoint(p01, p12), p123 = midpoint(p12, p23), p = midpoint(p012, p123);\n    stack.push([p, p123, p23, p3, depth + 1], [p0, p01, p012, p, depth + 1]);\n  }\n}\n\nfunction flattenArc(arc: ArcSegment, tolerance: number, output: ReturnType<typeof collector>): void {\n  const radius = Math.hypot(arc.ux, arc.uy, arc.vx, arc.vy);\n  const stack: Array<readonly [number, number, number]> = [[arc.startAngle, arc.startAngle + arc.sweep, 0]];\n  while (stack.length) {\n    const [from, to, depth] = stack.pop()!;\n    const middle = (from + to) / 2;\n    const a = arcPoint(arc, from), b = arcPoint(arc, to);\n    const sampled = Math.max(\n      pointSegmentDistance(arcPoint(arc, from + (to - from) / 4), a, b),\n      pointSegmentDistance(arcPoint(arc, middle), a, b),\n      pointSegmentDistance(arcPoint(arc, to - (to - from) / 4), a, b),\n    );\n    const bound = radius * (to - from) ** 2 / 8;\n    if (sampled <= tolerance && bound <= tolerance) { output.add(line(b)); continue; }\n    if (depth >= 60 || middle === from || middle === to) throw new RangeError('flattenPath cannot satisfy tolerance due to numerical nonprogress.');\n    stack.push([middle, to, depth + 1], [from, middle, depth + 1]);\n  }\n}\n\nfunction subdivideLine(a: Point, b: Point, divisions: number, output: ReturnType<typeof collector>) {\n  for (let i = 1; i <= divisions; i++) output.add(line(interpolate(a, b, i / divisions)));\n}\n\nfunction subdivideQuadratic(a: Point, b: Point, c: Point, divisions: number, output: ReturnType<typeof collector>) {\n  let rest: readonly [Point, Point, Point] = [a, b, c];\n  for (let i = divisions; i > 1; i--) {\n    const [left, right] = splitQuadratic(...rest, 1 / i);\n    output.add({ type: 'quadratic', cpx: left[1][0], cpy: left[1][1], x: left[2][0], y: left[2][1] });\n    rest = right;\n  }\n  output.add({ type: 'quadratic', cpx: rest[1][0], cpy: rest[1][1], x: rest[2][0], y: rest[2][1] });\n}\n\nfunction subdivideCubic(a: Point, b: Point, c: Point, d: Point, divisions: number, output: ReturnType<typeof collector>) {\n  let rest: readonly [Point, Point, Point, Point] = [a, b, c, d];\n  for (let i = divisions; i > 1; i--) {\n    const [left, right] = splitCubic(...rest, 1 / i);\n    output.add({ type: 'cubic', cp1x: left[1][0], cp1y: left[1][1], cp2x: left[2][0], cp2y: left[2][1], x: left[3][0], y: left[3][1] });\n    rest = right;\n  }\n  output.add({ type: 'cubic', cp1x: rest[1][0], cp1y: rest[1][1], cp2x: rest[2][0], cp2y: rest[2][1], x: rest[3][0], y: rest[3][1] });\n}\n\nfunction simplifyOpen(points: readonly Point[], tolerance: number): Point[] {\n  if (points.length <= 2) return [...points];\n  const keep = new Uint8Array(points.length);\n  keep[0] = keep[points.length - 1] = 1;\n  const stack: Array<readonly [number, number]> = [[0, points.length - 1]];\n  while (stack.length) {\n    const [first, last] = stack.pop()!;\n    let index = -1, maximum = tolerance;\n    for (let i = first + 1; i < last; i++) {\n      const distance = pointSegmentDistance(points[i], points[first], points[last]);\n      if (distance > maximum) { maximum = distance; index = i; }\n    }\n    if (index !== -1) { keep[index] = 1; stack.push([first, index], [index, last]); }\n  }\n  const result: Point[] = [];\n  for (let i = 0; i < points.length; i++) if (keep[i]) result.push(points[i]);\n  return result;\n}\n\nfunction simplifyClosed(points: readonly Point[], tolerance: number): Point[] {\n  if (points.length <= 3 || !hasThreeDistinct(points)) return [...points];\n  const [firstAnchor, secondAnchor] = closedAnchors(points);\n  const first = simplifyOpen(points.slice(0, firstAnchor + 1), tolerance);\n  const second = simplifyOpen(points.slice(firstAnchor, secondAnchor + 1), tolerance);\n  const third = simplifyOpen([...points.slice(secondAnchor), points[0]], tolerance);\n  return [...first, ...second.slice(1), ...third.slice(1, -1)];\n}\n\nfunction closedAnchors(points: readonly Point[]): readonly [number, number] {\n  let farthest = 1, farthestDistance = -1;\n  for (let i = 1; i < points.length; i++) {\n    const distance = pointDistance(points[0], points[i]);\n    if (distance > farthestDistance) { farthestDistance = distance; farthest = i; }\n  }\n  let third = -1, thirdDistance = -1;\n  for (let i = 1; i < points.length; i++) {\n    if (i === farthest || samePoint(points[i], points[0]) || samePoint(points[i], points[farthest])) continue;\n    const distance = pointSegmentDistance(points[i], points[0], points[farthest]);\n    if (distance > thirdDistance) { thirdDistance = distance; third = i; }\n  }\n  const [firstAnchor, secondAnchor] = [farthest, third].sort((a, b) => a - b);\n  return [firstAnchor, secondAnchor];\n}\n\nfunction withoutClosingDuplicate(points: readonly Point[]): Point[] {\n  return points.length > 1 && samePoint(points[0], points.at(-1)!) ? points.slice(0, -1) : [...points];\n}\nfunction hasThreeDistinct(points: readonly Point[]): boolean {\n  const first = points[0];\n  let second: Point | undefined;\n  for (let i = 1; i < points.length; i++) {\n    const point = points[i];\n    if (samePoint(point, first)) continue;\n    if (!second) second = point;\n    else if (!samePoint(point, second)) return true;\n  }\n  return false;\n}\nfunction splitQuadratic(a: Point, b: Point, c: Point, t: number): readonly [readonly [Point, Point, Point], readonly [Point, Point, Point]] {\n  const ab = interpolate(a, b, t), bc = interpolate(b, c, t), p = interpolate(ab, bc, t);\n  return [[a, ab, p], [p, bc, c]];\n}\nfunction splitCubic(a: Point, b: Point, c: Point, d: Point, t: number): readonly [readonly [Point, Point, Point, Point], readonly [Point, Point, Point, Point]] {\n  const ab = interpolate(a, b, t), bc = interpolate(b, c, t), cd = interpolate(c, d, t);\n  const abc = interpolate(ab, bc, t), bcd = interpolate(bc, cd, t), p = interpolate(abc, bcd, t);\n  return [[a, ab, abc, p], [p, bcd, cd, d]];\n}\nfunction line([x, y]: Point): PathSegment { return { type: 'line', x, y }; }\nfunction midpoint(a: Point, b: Point): Point { return interpolate(a, b, 0.5); }\nfunction interpolate(a: Point, b: Point, t: number): Point { return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]; }\nfunction pointDistance(a: Point, b: Point): number { return Math.hypot(difference(a[0], b[0]), difference(a[1], b[1])); }\nfunction samePoint(a: Point, b: Point): boolean { return a[0] === b[0] && a[1] === b[1]; }\nfunction pointSegmentDistance(point: Point, a: Point, b: Point): number {\n  const x = difference(b[0], a[0]), y = difference(b[1], a[1]);\n  const px = difference(point[0], a[0]), py = difference(point[1], a[1]);\n  const scale = Math.max(Math.abs(x), Math.abs(y), Math.abs(px), Math.abs(py));\n  if (scale === 0) return Math.hypot(px, py);\n  const scaledX = x / scale, scaledY = y / scale;\n  const scaledPX = px / scale, scaledPY = py / scale;\n  const length = scaledX * scaledX + scaledY * scaledY;\n  if (length === 0) return Math.hypot(px, py);\n  const t = Math.max(0, Math.min(1, (scaledPX * scaledX + scaledPY * scaledY) / length));\n  return scale * Math.hypot(scaledPX - scaledX * t, scaledPY - scaledY * t);\n}\nfunction difference(value: number, origin: number): number {\n  const result = value - origin;\n  if (!Number.isFinite(result)) throw new RangeError('Path utility cannot compare coordinates with an unrepresentable difference.');\n  return result;\n}\nfunction normalizeAngle(angle: number): number { const normalized = angle % TAU; return Object.is(normalized, -0) ? 0 : normalized; }\n"],
+  "mappings": "AAEA,SAAS,UAAU,WAA4B;AAC/C,SAAS,oBAAsC;AAE/C,MAAM,uBAAuB;AAwDtB,SAAS,YAAY,MAAoB,SAAqD;AACnG,QAAM,YAAY,iBAAiB,QAAQ,WAAW,WAAW;AACjE,QAAM,SAAS,UAAU,QAAQ,WAAW;AAC5C,MAAI,UAAiB,CAAC,GAAG,CAAC;AAC1B,MAAI,QAAe,CAAC,GAAG,CAAC;AACxB,aAAW,WAAW,MAAM;AAC1B,YAAQ,QAAQ,MAAM;AAAA,MACpB,KAAK;AAAQ,kBAAU,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC;AAAG,eAAO,IAAI,OAAO;AAAG;AAAA,MAC5E,KAAK;AAAQ,kBAAU,CAAC,QAAQ,GAAG,QAAQ,CAAC;AAAG,eAAO,IAAI,OAAO;AAAG;AAAA,MACpE,KAAK;AAAS,kBAAU;AAAO,eAAO,IAAI,OAAO;AAAG;AAAA,MACpD,KAAK,aAAa;AAChB,cAAM,MAAa,CAAC,QAAQ,GAAG,QAAQ,CAAC;AACxC,yBAAiB,SAAS,CAAC,QAAQ,KAAK,QAAQ,GAAG,GAAG,KAAK,WAAW,MAAM;AAC5E,kBAAU;AACV;AAAA,MACF;AAAA,MACA,KAAK,SAAS;AACZ,cAAM,MAAa,CAAC,QAAQ,GAAG,QAAQ,CAAC;AACxC,qBAAa,SAAS,CAAC,QAAQ,MAAM,QAAQ,IAAI,GAAG,CAAC,QAAQ,MAAM,QAAQ,IAAI,GAAG,KAAK,WAAW,MAAM;AACxG,kBAAU;AACV;AAAA,MACF;AAAA,MACA,KAAK,OAAO;AACV,cAAM,WAAW,SAAS,SAAS,QAAQ,UAAU;AACrD,YAAI,CAAC,UAAU,SAAS,QAAQ,EAAG,QAAO,IAAI,KAAK,QAAQ,CAAC;AAC5D,mBAAW,SAAS,WAAW,MAAM;AACrC,kBAAU,SAAS,SAAS,QAAQ,aAAa,QAAQ,KAAK;AAC9D;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,SAAO,OAAO,OAAO;AACvB;AAcO,SAAS,cAAc,MAAoB,SAAuD;AACvG,QAAM,YAAY,gBAAgB,QAAQ,WAAW,WAAW;AAChE,QAAM,SAAS,UAAU,QAAQ,WAAW;AAC5C,MAAI,UAAiB,CAAC,GAAG,CAAC;AAC1B,MAAI,QAAe,CAAC,GAAG,CAAC;AACxB,aAAW,WAAW,MAAM;AAC1B,YAAQ,QAAQ,MAAM;AAAA,MACpB,KAAK;AAAQ,kBAAU,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC;AAAG,eAAO,IAAI,OAAO;AAAG;AAAA,MAC5E,KAAK,QAAQ;AACX,cAAM,MAAa,CAAC,QAAQ,GAAG,QAAQ,CAAC;AACxC,sBAAc,SAAS,KAAK,WAAW,MAAM;AAC7C,kBAAU;AACV;AAAA,MACF;AAAA,MACA,KAAK,aAAa;AAChB,cAAM,MAAa,CAAC,QAAQ,GAAG,QAAQ,CAAC;AACxC,2BAAmB,SAAS,CAAC,QAAQ,KAAK,QAAQ,GAAG,GAAG,KAAK,WAAW,MAAM;AAC9E,kBAAU;AACV;AAAA,MACF;AAAA,MACA,KAAK,SAAS;AACZ,cAAM,MAAa,CAAC,QAAQ,GAAG,QAAQ,CAAC;AACxC,uBAAe,SAAS,CAAC,QAAQ,MAAM,QAAQ,IAAI,GAAG,CAAC,QAAQ,MAAM,QAAQ,IAAI,GAAG,KAAK,WAAW,MAAM;AAC1G,kBAAU;AACV;AAAA,MACF;AAAA,MACA,KAAK,OAAO;AACV,cAAM,WAAW,SAAS,SAAS,QAAQ,UAAU;AACrD,YAAI,CAAC,UAAU,SAAS,QAAQ,EAAG,QAAO,IAAI,KAAK,QAAQ,CAAC;AAC5D,iBAAS,IAAI,GAAG,IAAI,WAAW,KAAK;AAClC,iBAAO,IAAI,EAAE,GAAG,SAAS,YAAY,eAAe,QAAQ,aAAa,QAAQ,QAAQ,IAAI,SAAS,GAAG,OAAO,QAAQ,QAAQ,UAAU,CAAC;AAAA,QAC7I;AACA,kBAAU,SAAS,SAAS,QAAQ,aAAa,QAAQ,KAAK;AAC9D;AAAA,MACF;AAAA,MACA,KAAK;AACH,YAAI,CAAC,UAAU,SAAS,KAAK,EAAG,eAAc,SAAS,OAAO,WAAW,MAAM;AAC/E,kBAAU;AACV,eAAO,IAAI,OAAO;AAClB;AAAA,IACJ;AAAA,EACF;AACA,SAAO,OAAO,OAAO;AACvB;AAaO,SAAS,aAAa,MAAoB,SAAsD;AACrG,QAAM,YAAY,iBAAiB,QAAQ,WAAW,WAAW;AACjE,QAAM,SAAS,UAAU,QAAQ,WAAW;AAC5C,MAAI;AACJ,MAAI;AACJ,MAAI,MAAe,CAAC;AACpB,QAAM,YAAY,MAAM;AACtB,QAAI,CAAC,IAAI,OAAQ;AACjB,eAAW,SAAS,aAAa,KAAK,SAAS,EAAE,MAAM,CAAC,EAAG,QAAO,IAAI,KAAK,KAAK,CAAC;AACjF,UAAM,UAAU,CAAC,OAAO,IAAI,CAAC;AAAA,EAC/B;AACA,aAAW,WAAW,MAAM;AAC1B,YAAQ,QAAQ,MAAM;AAAA,MACpB,KAAK;AACH,kBAAU;AACV,kBAAU,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC;AACvC,cAAM,CAAC,OAAO;AACd,eAAO,IAAI,OAAO;AAClB;AAAA,MACF,KAAK;AACH,kBAAU,CAAC,QAAQ,GAAG,QAAQ,CAAC;AAC/B,YAAI,KAAK,OAAO;AAChB;AAAA,MACF,KAAK,SAAS;AACZ,YAAI,CAAC,WAAW,CAAC,MAAO,OAAM,IAAI,UAAU,oDAAoD;AAChG,cAAM,aAAa,eAAe,wBAAwB,GAAG,GAAG,SAAS;AACzE,mBAAW,SAAS,WAAW,MAAM,CAAC,EAAG,QAAO,IAAI,KAAK,KAAK,CAAC;AAC/D,eAAO,IAAI,OAAO;AAClB,kBAAU;AACV,cAAM,CAAC,OAAO;AACd;AAAA,MACF;AAAA,MACA;AAAS,cAAM,IAAI,UAAU,2CAA2C;AAAA,IAC1E;AAAA,EACF;AACA,YAAU;AACV,SAAO,OAAO,OAAO;AACvB;AAEA,SAAS,UAAU,aAAiC;AAClD,QAAM,QAAQ,gBAAgB,SAAY,uBAAuB,gBAAgB,aAAa,aAAa;AAC3G,QAAM,WAA0B,CAAC;AACjC,SAAO;AAAA,IACL,IAAI,SAAsB;AACxB,UAAI,SAAS,UAAU,MAAO,OAAM,IAAI,WAAW,0CAA0C;AAC7F,eAAS,KAAK,OAAO;AAAA,IACvB;AAAA,IACA,SAAS;AACP,YAAM,SAAS,IAAI,aAAa;AAChC,UAAI,SAAS,OAAQ,QAAO,eAAe,GAAG,GAAG,QAAQ;AACzD,aAAO;AAAA,IACT;AAAA,EACF;AACF;AAEA,SAAS,iBAAiB,OAAe,MAAsB;AAC7D,MAAI,CAAC,OAAO,SAAS,KAAK,KAAK,SAAS,EAAG,OAAM,IAAI,WAAW,GAAG,IAAI,oCAAoC;AAC3G,SAAO;AACT;AAEA,SAAS,gBAAgB,OAAe,MAAsB;AAC5D,MAAI,CAAC,OAAO,cAAc,KAAK,KAAK,SAAS,EAAG,OAAM,IAAI,WAAW,GAAG,IAAI,8BAA8B;AAC1G,SAAO;AACT;AAEA,SAAS,iBAAiB,GAAU,GAAU,GAAU,WAAmB,QAA4C;AACrH,QAAM,QAAuD,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC;AAC1E,SAAO,MAAM,QAAQ;AACnB,UAAM,CAAC,IAAI,IAAI,IAAI,KAAK,IAAI,MAAM,IAAI;AACtC,QAAI,qBAAqB,IAAI,IAAI,EAAE,KAAK,WAAW;AAAE,aAAO,IAAI,KAAK,EAAE,CAAC;AAAG;AAAA,IAAU;AACrF,QAAI,SAAS,GAAI,OAAM,IAAI,WAAW,oEAAoE;AAC1G,UAAM,MAAM,SAAS,IAAI,EAAE,GAAG,MAAM,SAAS,IAAI,EAAE,GAAG,IAAI,SAAS,KAAK,GAAG;AAC3E,UAAM,KAAK,CAAC,GAAG,KAAK,IAAI,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,GAAG,QAAQ,CAAC,CAAC;AAAA,EAC7D;AACF;AAEA,SAAS,aAAa,GAAU,GAAU,GAAU,GAAU,WAAmB,QAA4C;AAC3H,QAAM,QAA8D,CAAC,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;AACpF,SAAO,MAAM,QAAQ;AACnB,UAAM,CAAC,IAAI,IAAI,IAAI,IAAI,KAAK,IAAI,MAAM,IAAI;AAC1C,QAAI,KAAK,IAAI,qBAAqB,IAAI,IAAI,EAAE,GAAG,qBAAqB,IAAI,IAAI,EAAE,CAAC,KAAK,WAAW;AAAE,aAAO,IAAI,KAAK,EAAE,CAAC;AAAG;AAAA,IAAU;AACjI,QAAI,SAAS,GAAI,OAAM,IAAI,WAAW,oEAAoE;AAC1G,UAAM,MAAM,SAAS,IAAI,EAAE,GAAG,MAAM,SAAS,IAAI,EAAE,GAAG,MAAM,SAAS,IAAI,EAAE;AAC3E,UAAM,OAAO,SAAS,KAAK,GAAG,GAAG,OAAO,SAAS,KAAK,GAAG,GAAG,IAAI,SAAS,MAAM,IAAI;AACnF,UAAM,KAAK,CAAC,GAAG,MAAM,KAAK,IAAI,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,MAAM,GAAG,QAAQ,CAAC,CAAC;AAAA,EACzE;AACF;AAEA,SAAS,WAAW,KAAiB,WAAmB,QAA4C;AAClG,QAAM,SAAS,KAAK,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE;AACxD,QAAM,QAAkD,CAAC,CAAC,IAAI,YAAY,IAAI,aAAa,IAAI,OAAO,CAAC,CAAC;AACxG,SAAO,MAAM,QAAQ;AACnB,UAAM,CAAC,MAAM,IAAI,KAAK,IAAI,MAAM,IAAI;AACpC,UAAM,UAAU,OAAO,MAAM;AAC7B,UAAM,IAAI,SAAS,KAAK,IAAI,GAAG,IAAI,SAAS,KAAK,EAAE;AACnD,UAAM,UAAU,KAAK;AAAA,MACnB,qBAAqB,SAAS,KAAK,QAAQ,KAAK,QAAQ,CAAC,GAAG,GAAG,CAAC;AAAA,MAChE,qBAAqB,SAAS,KAAK,MAAM,GAAG,GAAG,CAAC;AAAA,MAChD,qBAAqB,SAAS,KAAK,MAAM,KAAK,QAAQ,CAAC,GAAG,GAAG,CAAC;AAAA,IAChE;AACA,UAAM,QAAQ,UAAU,KAAK,SAAS,IAAI;AAC1C,QAAI,WAAW,aAAa,SAAS,WAAW;AAAE,aAAO,IAAI,KAAK,CAAC,CAAC;AAAG;AAAA,IAAU;AACjF,QAAI,SAAS,MAAM,WAAW,QAAQ,WAAW,GAAI,OAAM,IAAI,WAAW,oEAAoE;AAC9I,UAAM,KAAK,CAAC,QAAQ,IAAI,QAAQ,CAAC,GAAG,CAAC,MAAM,QAAQ,QAAQ,CAAC,CAAC;AAAA,EAC/D;AACF;AAEA,SAAS,cAAc,GAAU,GAAU,WAAmB,QAAsC;AAClG,WAAS,IAAI,GAAG,KAAK,WAAW,IAAK,QAAO,IAAI,KAAK,YAAY,GAAG,GAAG,IAAI,SAAS,CAAC,CAAC;AACxF;AAEA,SAAS,mBAAmB,GAAU,GAAU,GAAU,WAAmB,QAAsC;AACjH,MAAI,OAAuC,CAAC,GAAG,GAAG,CAAC;AACnD,WAAS,IAAI,WAAW,IAAI,GAAG,KAAK;AAClC,UAAM,CAAC,MAAM,KAAK,IAAI,eAAe,GAAG,MAAM,IAAI,CAAC;AACnD,WAAO,IAAI,EAAE,MAAM,aAAa,KAAK,KAAK,CAAC,EAAE,CAAC,GAAG,KAAK,KAAK,CAAC,EAAE,CAAC,GAAG,GAAG,KAAK,CAAC,EAAE,CAAC,GAAG,GAAG,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC;AAChG,WAAO;AAAA,EACT;AACA,SAAO,IAAI,EAAE,MAAM,aAAa,KAAK,KAAK,CAAC,EAAE,CAAC,GAAG,KAAK,KAAK,CAAC,EAAE,CAAC,GAAG,GAAG,KAAK,CAAC,EAAE,CAAC,GAAG,GAAG,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC;AAClG;AAEA,SAAS,eAAe,GAAU,GAAU,GAAU,GAAU,WAAmB,QAAsC;AACvH,MAAI,OAA8C,CAAC,GAAG,GAAG,GAAG,CAAC;AAC7D,WAAS,IAAI,WAAW,IAAI,GAAG,KAAK;AAClC,UAAM,CAAC,MAAM,KAAK,IAAI,WAAW,GAAG,MAAM,IAAI,CAAC;AAC/C,WAAO,IAAI,EAAE,MAAM,SAAS,MAAM,KAAK,CAAC,EAAE,CAAC,GAAG,MAAM,KAAK,CAAC,EAAE,CAAC,GAAG,MAAM,KAAK,CAAC,EAAE,CAAC,GAAG,MAAM,KAAK,CAAC,EAAE,CAAC,GAAG,GAAG,KAAK,CAAC,EAAE,CAAC,GAAG,GAAG,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC;AAClI,WAAO;AAAA,EACT;AACA,SAAO,IAAI,EAAE,MAAM,SAAS,MAAM,KAAK,CAAC,EAAE,CAAC,GAAG,MAAM,KAAK,CAAC,EAAE,CAAC,GAAG,MAAM,KAAK,CAAC,EAAE,CAAC,GAAG,MAAM,KAAK,CAAC,EAAE,CAAC,GAAG,GAAG,KAAK,CAAC,EAAE,CAAC,GAAG,GAAG,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC;AACpI;AAEA,SAAS,aAAa,QAA0B,WAA4B;AAC1E,MAAI,OAAO,UAAU,EAAG,QAAO,CAAC,GAAG,MAAM;AACzC,QAAM,OAAO,IAAI,WAAW,OAAO,MAAM;AACzC,OAAK,CAAC,IAAI,KAAK,OAAO,SAAS,CAAC,IAAI;AACpC,QAAM,QAA0C,CAAC,CAAC,GAAG,OAAO,SAAS,CAAC,CAAC;AACvE,SAAO,MAAM,QAAQ;AACnB,UAAM,CAAC,OAAO,IAAI,IAAI,MAAM,IAAI;AAChC,QAAI,QAAQ,IAAI,UAAU;AAC1B,aAAS,IAAI,QAAQ,GAAG,IAAI,MAAM,KAAK;AACrC,YAAM,WAAW,qBAAqB,OAAO,CAAC,GAAG,OAAO,KAAK,GAAG,OAAO,IAAI,CAAC;AAC5E,UAAI,WAAW,SAAS;AAAE,kBAAU;AAAU,gBAAQ;AAAA,MAAG;AAAA,IAC3D;AACA,QAAI,UAAU,IAAI;AAAE,WAAK,KAAK,IAAI;AAAG,YAAM,KAAK,CAAC,OAAO,KAAK,GAAG,CAAC,OAAO,IAAI,CAAC;AAAA,IAAG;AAAA,EAClF;AACA,QAAM,SAAkB,CAAC;AACzB,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,IAAK,KAAI,KAAK,CAAC,EAAG,QAAO,KAAK,OAAO,CAAC,CAAC;AAC1E,SAAO;AACT;AAEA,SAAS,eAAe,QAA0B,WAA4B;AAC5E,MAAI,OAAO,UAAU,KAAK,CAAC,iBAAiB,MAAM,EAAG,QAAO,CAAC,GAAG,MAAM;AACtE,QAAM,CAAC,aAAa,YAAY,IAAI,cAAc,MAAM;AACxD,QAAM,QAAQ,aAAa,OAAO,MAAM,GAAG,cAAc,CAAC,GAAG,SAAS;AACtE,QAAM,SAAS,aAAa,OAAO,MAAM,aAAa,eAAe,CAAC,GAAG,SAAS;AAClF,QAAM,QAAQ,aAAa,CAAC,GAAG,OAAO,MAAM,YAAY,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS;AAChF,SAAO,CAAC,GAAG,OAAO,GAAG,OAAO,MAAM,CAAC,GAAG,GAAG,MAAM,MAAM,GAAG,EAAE,CAAC;AAC7D;AAEA,SAAS,cAAc,QAAqD;AAC1E,MAAI,WAAW,GAAG,mBAAmB;AACrC,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,UAAM,WAAW,cAAc,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC;AACnD,QAAI,WAAW,kBAAkB;AAAE,yBAAmB;AAAU,iBAAW;AAAA,IAAG;AAAA,EAChF;AACA,MAAI,QAAQ,IAAI,gBAAgB;AAChC,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,QAAI,MAAM,YAAY,UAAU,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,KAAK,UAAU,OAAO,CAAC,GAAG,OAAO,QAAQ,CAAC,EAAG;AACjG,UAAM,WAAW,qBAAqB,OAAO,CAAC,GAAG,OAAO,CAAC,GAAG,OAAO,QAAQ,CAAC;AAC5E,QAAI,WAAW,eAAe;AAAE,sBAAgB;AAAU,cAAQ;AAAA,IAAG;AAAA,EACvE;AACA,QAAM,CAAC,aAAa,YAAY,IAAI,CAAC,UAAU,KAAK,EAAE,KAAK,CAAC,GAAG,MAAM,IAAI,CAAC;AAC1E,SAAO,CAAC,aAAa,YAAY;AACnC;AAEA,SAAS,wBAAwB,QAAmC;AAClE,SAAO,OAAO,SAAS,KAAK,UAAU,OAAO,CAAC,GAAG,OAAO,GAAG,EAAE,CAAE,IAAI,OAAO,MAAM,GAAG,EAAE,IAAI,CAAC,GAAG,MAAM;AACrG;AACA,SAAS,iBAAiB,QAAmC;AAC3D,QAAM,QAAQ,OAAO,CAAC;AACtB,MAAI;AACJ,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,UAAM,QAAQ,OAAO,CAAC;AACtB,QAAI,UAAU,OAAO,KAAK,EAAG;AAC7B,QAAI,CAAC,OAAQ,UAAS;AAAA,aACb,CAAC,UAAU,OAAO,MAAM,EAAG,QAAO;AAAA,EAC7C;AACA,SAAO;AACT;AACA,SAAS,eAAe,GAAU,GAAU,GAAU,GAAsF;AAC1I,QAAM,KAAK,YAAY,GAAG,GAAG,CAAC,GAAG,KAAK,YAAY,GAAG,GAAG,CAAC,GAAG,IAAI,YAAY,IAAI,IAAI,CAAC;AACrF,SAAO,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;AAChC;AACA,SAAS,WAAW,GAAU,GAAU,GAAU,GAAU,GAAoG;AAC9J,QAAM,KAAK,YAAY,GAAG,GAAG,CAAC,GAAG,KAAK,YAAY,GAAG,GAAG,CAAC,GAAG,KAAK,YAAY,GAAG,GAAG,CAAC;AACpF,QAAM,MAAM,YAAY,IAAI,IAAI,CAAC,GAAG,MAAM,YAAY,IAAI,IAAI,CAAC,GAAG,IAAI,YAAY,KAAK,KAAK,CAAC;AAC7F,SAAO,CAAC,CAAC,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC;AAC1C;AACA,SAAS,KAAK,CAAC,GAAG,CAAC,GAAuB;AAAE,SAAO,EAAE,MAAM,QAAQ,GAAG,EAAE;AAAG;AAC3E,SAAS,SAAS,GAAU,GAAiB;AAAE,SAAO,YAAY,GAAG,GAAG,GAAG;AAAG;AAC9E,SAAS,YAAY,GAAU,GAAU,GAAkB;AAAE,SAAO,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;AAAG;AAC1H,SAAS,cAAc,GAAU,GAAkB;AAAE,SAAO,KAAK,MAAM,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;AAAG;AACxH,SAAS,UAAU,GAAU,GAAmB;AAAE,SAAO,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,CAAC;AAAG;AACzF,SAAS,qBAAqB,OAAc,GAAU,GAAkB;AACtE,QAAM,IAAI,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,IAAI,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;AAC3D,QAAM,KAAK,WAAW,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,KAAK,WAAW,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC;AACrE,QAAM,QAAQ,KAAK,IAAI,KAAK,IAAI,CAAC,GAAG,KAAK,IAAI,CAAC,GAAG,KAAK,IAAI,EAAE,GAAG,KAAK,IAAI,EAAE,CAAC;AAC3E,MAAI,UAAU,EAAG,QAAO,KAAK,MAAM,IAAI,EAAE;AACzC,QAAM,UAAU,IAAI,OAAO,UAAU,IAAI;AACzC,QAAM,WAAW,KAAK,OAAO,WAAW,KAAK;AAC7C,QAAM,SAAS,UAAU,UAAU,UAAU;AAC7C,MAAI,WAAW,EAAG,QAAO,KAAK,MAAM,IAAI,EAAE;AAC1C,QAAM,IAAI,KAAK,IAAI,GAAG,KAAK,IAAI,IAAI,WAAW,UAAU,WAAW,WAAW,MAAM,CAAC;AACrF,SAAO,QAAQ,KAAK,MAAM,WAAW,UAAU,GAAG,WAAW,UAAU,CAAC;AAC1E;AACA,SAAS,WAAW,OAAe,QAAwB;AACzD,QAAM,SAAS,QAAQ;AACvB,MAAI,CAAC,OAAO,SAAS,MAAM,EAAG,OAAM,IAAI,WAAW,6EAA6E;AAChI,SAAO;AACT;AACA,SAAS,eAAe,OAAuB;AAAE,QAAM,aAAa,QAAQ;AAAK,SAAO,OAAO,GAAG,YAAY,EAAE,IAAI,IAAI;AAAY;",
+  "names": []
+}

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

@@ -0,0 +1,18 @@
+import { PathGeometry } from './path-geometry.js';
+import type { FlattenPathOptions } from './path-utilities.js';
+/**
+ * Flattens curves with Wang's uniform-parameter bound.
+ *
+ * This trades adaptive placement for a known output count and independent point
+ * evaluation. It is most useful when predictable allocation or parallel output
+ * generation matters more than minimizing the number of line segments.
+ *
+ * @param path - Source geometry; it is not modified. See {@link PathGeometry}.
+ * @param options - Maximum approximation error and flattening work limits. See
+ * {@link FlattenPathOptions} .
+ * @returns Independent geometry with curves replaced by line segments. See {@link PathGeometry}.
+ *
+ * @see {@link PathGeometry}
+ * @see {@link FlattenPathOptions}
+ */
+export declare function flattenPathWang(path: PathGeometry, options: Readonly<FlattenPathOptions>): PathGeometry;

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

@@ -0,0 +1,136 @@
+import { arcPoint } from "./path-arc.js";
+import { PathGeometry } from "./path-geometry.js";
+const DEFAULT_MAX_SEGMENTS = 1e6;
+function flattenPathWang(path, options) {
+  const tolerance = requiredPositive(options.tolerance, "tolerance");
+  const output = collector(options.maxSegments);
+  let current = [0, 0];
+  let start = [0, 0];
+  for (const segment of path) {
+    switch (segment.type) {
+      case "move":
+        current = start = [segment.x, segment.y];
+        output.add(segment);
+        break;
+      case "line":
+        current = [segment.x, segment.y];
+        output.add(segment);
+        break;
+      case "close":
+        current = start;
+        output.add(segment);
+        break;
+      case "quadratic": {
+        const end = [segment.x, segment.y];
+        flattenQuadratic(current, [segment.cpx, segment.cpy], end, tolerance, output);
+        current = end;
+        break;
+      }
+      case "cubic": {
+        const end = [segment.x, segment.y];
+        flattenCubic(current, [segment.cp1x, segment.cp1y], [segment.cp2x, segment.cp2y], end, tolerance, output);
+        current = end;
+        break;
+      }
+      case "arc": {
+        const arcStart = arcPoint(segment, segment.startAngle);
+        if (!samePoint(current, arcStart)) output.add(line(arcStart));
+        flattenArc(segment, tolerance, output);
+        current = arcPoint(segment, segment.startAngle + segment.sweep);
+        break;
+      }
+    }
+  }
+  return output.finish();
+}
+function flattenQuadratic(a, b, c, tolerance, output) {
+  const n = segmentsForSecondDifference(secondDifference(a, b, c), 2, tolerance);
+  output.reserve(n);
+  for (let i = 1; i <= n; i++) output.add(line(i === n ? c : evaluateQuadratic(a, b, c, i / n)));
+}
+function flattenCubic(a, b, c, d, tolerance, output) {
+  const n = Math.max(
+    segmentsForSecondDifference(secondDifference(a, b, c), 3, tolerance),
+    segmentsForSecondDifference(secondDifference(b, c, d), 3, tolerance)
+  );
+  output.reserve(n);
+  for (let i = 1; i <= n; i++) output.add(line(i === n ? d : evaluateCubic(a, b, c, d, i / n)));
+}
+function flattenArc(arc, tolerance, output) {
+  const stretch = operatorNorm(arc.ux, arc.uy, arc.vx, arc.vy);
+  if (!Number.isFinite(stretch)) throw new RangeError("flattenPathWang arc calculation overflowed.");
+  if (stretch === 0 || arc.sweep === 0) {
+    output.add(line(arcPoint(arc, arc.startAngle + arc.sweep)));
+    return;
+  }
+  const ratio = Math.min(1, tolerance / stretch);
+  const span = Math.min(Math.PI, 4 * Math.asin(Math.sqrt(ratio / 2)));
+  const n = checkedSegments(Math.ceil(Math.abs(arc.sweep) / span));
+  output.reserve(n);
+  for (let i = 1; i <= n; i++) output.add(line(arcPoint(arc, i === n ? arc.startAngle + arc.sweep : arc.startAngle + arc.sweep * i / n)));
+}
+function segmentsForSecondDifference(difference, degree, tolerance) {
+  const length = Math.hypot(difference[0], difference[1]);
+  if (!Number.isFinite(length)) throw new RangeError("flattenPathWang curve calculation overflowed.");
+  return checkedSegments(Math.max(1, Math.ceil(Math.sqrt(length * degree * (degree - 1) / (8 * tolerance)))));
+}
+function evaluateQuadratic(a, b, c, t) {
+  const ab = interpolate(a, b, t), bc = interpolate(b, c, t);
+  return interpolate(ab, bc, t);
+}
+function evaluateCubic(a, b, c, d, t) {
+  const ab = interpolate(a, b, t), bc = interpolate(b, c, t), cd = interpolate(c, d, t);
+  return interpolate(interpolate(ab, bc, t), interpolate(bc, cd, t), t);
+}
+function secondDifference(a, b, c) {
+  return [a[0] - 2 * b[0] + c[0], a[1] - 2 * b[1] + c[1]];
+}
+function operatorNorm(ux, uy, vx, vy) {
+  const scale = Math.max(Math.abs(ux), Math.abs(uy), Math.abs(vx), Math.abs(vy));
+  if (scale === 0) return 0;
+  const a = ux / scale, b = uy / scale, c = vx / scale, d = vy / scale;
+  return scale * Math.sqrt((a * a + b * b + c * c + d * d + Math.hypot(a * a + c * c - b * b - d * d, 2 * (a * b + c * d))) / 2);
+}
+function collector(maxSegments) {
+  const limit = maxSegments === void 0 ? DEFAULT_MAX_SEGMENTS : requiredInteger(maxSegments, "maxSegments");
+  const segments = [];
+  return {
+    reserve(count) {
+      if (segments.length + count > limit) throw new RangeError("Path utility output exceeds maxSegments.");
+    },
+    add(segment) {
+      if (segments.length >= limit) throw new RangeError("Path utility output exceeds maxSegments.");
+      segments.push(segment);
+    },
+    finish() {
+      const output = new PathGeometry();
+      if (segments.length) output.spliceSegments(0, 0, segments);
+      return output;
+    }
+  };
+}
+function checkedSegments(value) {
+  if (!Number.isSafeInteger(value) || value < 1) throw new RangeError("flattenPathWang cannot satisfy tolerance due to numerical nonprogress.");
+  return value;
+}
+function requiredPositive(value, name) {
+  if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${name} must be a finite positive number.`);
+  return value;
+}
+function requiredInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`${name} must be a positive integer.`);
+  return value;
+}
+function line([x, y]) {
+  return { type: "line", x, y };
+}
+function interpolate(a, b, t) {
+  return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+}
+function samePoint(a, b) {
+  return a[0] === b[0] && a[1] === b[1];
+}
+export {
+  flattenPathWang
+};
+//# sourceMappingURL=path-wang.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/path-wang.ts"],
+  "sourcesContent": ["import { arcPoint, type ArcSegment } from './path-arc.js';\nimport { PathGeometry, type PathSegment } from './path-geometry.js';\nimport type { FlattenPathOptions } from './path-utilities.js';\n\nconst DEFAULT_MAX_SEGMENTS = 1_000_000;\n\ntype Point = readonly [number, number];\n\n/**\n * Flattens curves with Wang's uniform-parameter bound.\n *\n * This trades adaptive placement for a known output count and independent point\n * evaluation. It is most useful when predictable allocation or parallel output\n * generation matters more than minimizing the number of line segments.\n *\n * @param path - Source geometry; it is not modified. See {@link PathGeometry}.\n * @param options - Maximum approximation error and flattening work limits. See\n * {@link FlattenPathOptions} .\n * @returns Independent geometry with curves replaced by line segments. See {@link PathGeometry}.\n *\n * @see {@link PathGeometry}\n * @see {@link FlattenPathOptions}\n */\nexport function flattenPathWang(path: PathGeometry, options: Readonly<FlattenPathOptions>): PathGeometry {\n  const tolerance = requiredPositive(options.tolerance, 'tolerance');\n  const output = collector(options.maxSegments);\n  let current: Point = [0, 0];\n  let start: Point = [0, 0];\n  for (const segment of path) {\n    switch (segment.type) {\n      case 'move': current = start = [segment.x, segment.y]; output.add(segment); break;\n      case 'line': current = [segment.x, segment.y]; output.add(segment); break;\n      case 'close': current = start; output.add(segment); break;\n      case 'quadratic': {\n        const end: Point = [segment.x, segment.y];\n        flattenQuadratic(current, [segment.cpx, segment.cpy], end, tolerance, output);\n        current = end;\n        break;\n      }\n      case 'cubic': {\n        const end: Point = [segment.x, segment.y];\n        flattenCubic(current, [segment.cp1x, segment.cp1y], [segment.cp2x, segment.cp2y], end, tolerance, output);\n        current = end;\n        break;\n      }\n      case 'arc': {\n        const arcStart = arcPoint(segment, segment.startAngle);\n        if (!samePoint(current, arcStart)) output.add(line(arcStart));\n        flattenArc(segment, tolerance, output);\n        current = arcPoint(segment, segment.startAngle + segment.sweep);\n        break;\n      }\n    }\n  }\n  return output.finish();\n}\n\nfunction flattenQuadratic(a: Point, b: Point, c: Point, tolerance: number, output: ReturnType<typeof collector>): void {\n  const n = segmentsForSecondDifference(secondDifference(a, b, c), 2, tolerance);\n  output.reserve(n);\n  for (let i = 1; i <= n; i++) output.add(line(i === n ? c : evaluateQuadratic(a, b, c, i / n)));\n}\n\nfunction flattenCubic(a: Point, b: Point, c: Point, d: Point, tolerance: number, output: ReturnType<typeof collector>): void {\n  const n = Math.max(\n    segmentsForSecondDifference(secondDifference(a, b, c), 3, tolerance),\n    segmentsForSecondDifference(secondDifference(b, c, d), 3, tolerance),\n  );\n  output.reserve(n);\n  for (let i = 1; i <= n; i++) output.add(line(i === n ? d : evaluateCubic(a, b, c, d, i / n)));\n}\n\nfunction flattenArc(arc: ArcSegment, tolerance: number, output: ReturnType<typeof collector>): void {\n  const stretch = operatorNorm(arc.ux, arc.uy, arc.vx, arc.vy);\n  if (!Number.isFinite(stretch)) throw new RangeError('flattenPathWang arc calculation overflowed.');\n  if (stretch === 0 || arc.sweep === 0) {\n    output.add(line(arcPoint(arc, arc.startAngle + arc.sweep)));\n    return;\n  }\n  // The image of a unit-circle chord deviates by no more than its sagitta times\n  // the affine basis' maximum stretch. Restricting each span to pi also handles\n  // complete turns and finite chord distances conservatively.\n  const ratio = Math.min(1, tolerance / stretch);\n  // 1 - cos(x) loses useful precision for small tolerances. The equivalent\n  // sagitta form remains stable: 2 sin^2(span / 4) <= tolerance / stretch.\n  const span = Math.min(Math.PI, 4 * Math.asin(Math.sqrt(ratio / 2)));\n  const n = checkedSegments(Math.ceil(Math.abs(arc.sweep) / span));\n  output.reserve(n);\n  for (let i = 1; i <= n; i++) output.add(line(arcPoint(arc, i === n ? arc.startAngle + arc.sweep : arc.startAngle + arc.sweep * i / n)));\n}\n\nfunction segmentsForSecondDifference(difference: Point, degree: 2 | 3, tolerance: number): number {\n  // Wang's formula: sqrt(|second difference| * n(n - 1) / (8 * tolerance)).\n  const length = Math.hypot(difference[0], difference[1]);\n  if (!Number.isFinite(length)) throw new RangeError('flattenPathWang curve calculation overflowed.');\n  return checkedSegments(Math.max(1, Math.ceil(Math.sqrt(length * degree * (degree - 1) / (8 * tolerance)))));\n}\n\nfunction evaluateQuadratic(a: Point, b: Point, c: Point, t: number): Point {\n  const ab = interpolate(a, b, t), bc = interpolate(b, c, t);\n  return interpolate(ab, bc, t);\n}\n\nfunction evaluateCubic(a: Point, b: Point, c: Point, d: Point, t: number): Point {\n  const ab = interpolate(a, b, t), bc = interpolate(b, c, t), cd = interpolate(c, d, t);\n  return interpolate(interpolate(ab, bc, t), interpolate(bc, cd, t), t);\n}\n\nfunction secondDifference(a: Point, b: Point, c: Point): Point {\n  return [a[0] - 2 * b[0] + c[0], a[1] - 2 * b[1] + c[1]];\n}\n\nfunction operatorNorm(ux: number, uy: number, vx: number, vy: number): number {\n  const scale = Math.max(Math.abs(ux), Math.abs(uy), Math.abs(vx), Math.abs(vy));\n  if (scale === 0) return 0;\n  const a = ux / scale, b = uy / scale, c = vx / scale, d = vy / scale;\n  return scale * Math.sqrt((a * a + b * b + c * c + d * d + Math.hypot(a * a + c * c - b * b - d * d, 2 * (a * b + c * d))) / 2);\n}\n\nfunction collector(maxSegments: number | undefined) {\n  const limit = maxSegments === undefined ? DEFAULT_MAX_SEGMENTS : requiredInteger(maxSegments, 'maxSegments');\n  const segments: PathSegment[] = [];\n  return {\n    reserve(count: number) {\n      if (segments.length + count > limit) throw new RangeError('Path utility output exceeds maxSegments.');\n    },\n    add(segment: PathSegment) {\n      if (segments.length >= limit) throw new RangeError('Path utility output exceeds maxSegments.');\n      segments.push(segment);\n    },\n    finish() {\n      const output = new PathGeometry();\n      if (segments.length) output.spliceSegments(0, 0, segments);\n      return output;\n    },\n  };\n}\n\nfunction checkedSegments(value: number): number {\n  if (!Number.isSafeInteger(value) || value < 1) throw new RangeError('flattenPathWang cannot satisfy tolerance due to numerical nonprogress.');\n  return value;\n}\nfunction requiredPositive(value: number, name: string): number {\n  if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${name} must be a finite positive number.`);\n  return value;\n}\nfunction requiredInteger(value: number, name: string): number {\n  if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`${name} must be a positive integer.`);\n  return value;\n}\nfunction line([x, y]: Point): PathSegment { return { type: 'line', x, y }; }\nfunction interpolate(a: Point, b: Point, t: number): Point { return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]; }\nfunction samePoint(a: Point, b: Point): boolean { return a[0] === b[0] && a[1] === b[1]; }\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,17 @@
+/** @internal Homogeneous Bernstein curves, degree at most six after warping. */
+export interface WarpSpan {
+    x: number[];
+    y: number[];
+    w: number[];
+}
+export type WarpPoint = readonly [number, number];
+export declare function product(a: readonly number[], b: readonly number[]): number[];
+export declare function endpoint(span: WarpSpan, index: number): WarpPoint;
+/** Call-owned workspace; at most 53 frames (degree <= 6), reused across spans. */
+export interface WarpWork {
+    remaining: number;
+    pool: WarpSpan[];
+    depths: number[];
+    scratch: number[];
+}
+export declare function emitSpan(span: WarpSpan, tolerance: number, work: WarpWork, emit: (x: number, y: number) => void): void;