@pibbl/core 0.0.1

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

@@ -0,0 +1,202 @@
+import { PathGeometry } from "./path-geometry.js";
+import { TAU } from "./path-arc.js";
+import { bendSpanBounds, bendSpanPoint, bendSpans, splitBendSpan } from "./path-bend-spans.js";
+import { measureBendGuide, prepareBendGuide } from "./path-bend-guide.js";
+const MAX_WORK = 2e6;
+const MAX_DEPTH = 52;
+function bendPathAlongArc(source, options) {
+  if (!(source instanceof PathGeometry)) throw new TypeError("source must be a PathGeometry.");
+  object(options, "options");
+  const input = options.arc;
+  object(input, "arc");
+  const startAngle = finite(input.startAngle, "arc.startAngle");
+  const arc = {
+    cx: finite(input.cx, "arc.cx"),
+    cy: finite(input.cy, "arc.cy"),
+    radius: positive(input.radius, "arc.radius"),
+    startAngle: startAngle % TAU,
+    sweep: finite(input.sweep, "arc.sweep")
+  };
+  if (!arc.sweep || Math.abs(arc.sweep) > TAU) throw new RangeError("arc.sweep must be nonzero and at most one revolution.");
+  const p = placement(options, positive(arc.radius * Math.abs(arc.sweep), "guide length"));
+  if (p.overflow === "wrap" && Math.abs(arc.sweep) !== TAU) throw new RangeError("wrap requires a closed guide.");
+  const direction = Math.sign(arc.sweep);
+  const distance = (x) => p.shift + p.scale * (x - p.x);
+  const displacement = (y) => y - p.baseline + p.normal;
+  const map = ([x, y]) => {
+    const s = finite(distance(x), "mapped guide distance"), d = finite(displacement(y), "normal displacement");
+    if (p.overflow === "error" && (s < 0 || s > p.length)) throw new RangeError("Source geometry extends beyond the guide.");
+    const onGuide = p.overflow === "extend" ? Math.max(0, Math.min(p.length, s)) : s;
+    const theta = arc.startAngle + direction * (onGuide / arc.radius % TAU);
+    const cos = Math.cos(theta), sin = Math.sin(theta);
+    const radial = arc.radius - direction * d, extension = s - onGuide;
+    checkPrecision(Math.max(Math.abs(startAngle), Math.abs(onGuide / arc.radius)) * Math.max(Math.abs(radial), Math.abs(extension)), p.tolerance);
+    return [
+      finite(arc.cx + radial * cos - direction * extension * sin, "bent x"),
+      finite(arc.cy + radial * sin + direction * extension * cos, "bent y")
+    ];
+  };
+  const bound = (b) => {
+    const low = distance(b.xmin), high = distance(b.xmax);
+    if (p.overflow === "error" && (low < 0 || high > p.length)) return Infinity;
+    const d = Math.max(Math.abs(displacement(b.ymin)), Math.abs(displacement(b.ymax)));
+    const dx = p.scale * b.dx, ddx = p.scale * b.ddx;
+    if (p.overflow === "extend") {
+      if (high <= 0 || low >= p.length) return Math.hypot(ddx, b.ddy) / 8;
+      if (low < 0 || high > p.length) return (b.dy + (1 + d / arc.radius) * dx) / 2;
+    }
+    const theta1 = dx / arc.radius, theta2 = ddx / arc.radius;
+    const radial = Math.max(Math.abs(arc.radius - direction * displacement(b.ymin)), Math.abs(arc.radius - direction * displacement(b.ymax)));
+    return (b.ddy + 2 * b.dy * theta1 + radial * (theta1 * theta1 + theta2)) / 8;
+  };
+  const scale = Math.max(Math.abs(arc.cx), Math.abs(arc.cy), arc.radius, p.length);
+  return approximate(source, p, map, bound, scale);
+}
+function bendPathAlongPath(source, guide, options) {
+  if (!(source instanceof PathGeometry) || !(guide instanceof PathGeometry)) throw new TypeError("source and guide must be PathGeometry values.");
+  object(options, "options");
+  const input = placement(options, 1);
+  const prepared = prepareBendGuide(guide);
+  if (input.overflow === "wrap" && !prepared.closed) throw new RangeError("wrap requires an explicitly closed guide.");
+  let xmin = Infinity, xmax = -Infinity, displacement = 0;
+  const normalDistance = (y) => y - input.baseline + input.normal;
+  for (const item of bendSpans(source)) {
+    if (item.type === "close") continue;
+    const b = item.type === "move" ? { xmin: item.point[0], xmax: item.point[0], ymin: item.point[1], ymax: item.point[1] } : bendSpanBounds(item.span);
+    xmin = Math.min(xmin, b.xmin);
+    xmax = Math.max(xmax, b.xmax);
+    displacement = Math.max(displacement, Math.abs(normalDistance(b.ymin)), Math.abs(normalDistance(b.ymax)));
+  }
+  if (xmin === Infinity) xmin = xmax = input.x;
+  finite(displacement, "normal displacement");
+  const atLength = (length) => {
+    const scale = input.fit === "stretch" ? positive(length / input.width, "fit scale") : 1;
+    return { ...input, length, scale, shift: input.anchor * (length - scale * input.width) + input.offset };
+  };
+  const distance = (p2, x) => p2.shift + p2.scale * (x - p2.x);
+  const measured = measureBendGuide(prepared, input.tolerance, displacement, (length) => {
+    const p2 = atLength(length);
+    const sensitivity = input.fit === "stretch" ? Math.max(Math.abs((xmin - input.x) / input.width), Math.abs((xmax - input.x) / input.width)) : input.anchor;
+    const laps = input.overflow === "wrap" ? Math.ceil(Math.max(Math.abs(distance(p2, xmin)), Math.abs(distance(p2, xmax))) / length) : 0;
+    return finite(2 + sensitivity + laps, "guide distance sensitivity");
+  });
+  const p = atLength(measured.length), upper = atLength(measured.length + measured.uncertainty);
+  const wrap = p.overflow === "wrap";
+  const rangeCertified = (x) => {
+    const d = distance(p, x), u = distance(upper, x);
+    const roundoff = Number.EPSILON * 64 * Math.max(Math.abs(d), Math.abs(u), p.length);
+    return Math.min(d, u) >= -roundoff && Math.min(p.length - d, upper.length - u) >= -roundoff;
+  };
+  const map = ([x, y]) => {
+    if (p.overflow === "error" && !rangeCertified(x)) throw new RangeError("Source geometry exceeds the guide or its range cannot be certified.");
+    const field = measured.field(distance(p, x), wrap), d = normalDistance(y);
+    return [finite(field.point[0] + d * field.normal[0], "bent x"), finite(field.point[1] + d * field.normal[1], "bent y")];
+  };
+  const bound = (b, span) => {
+    if (p.overflow === "error" && (!rangeCertified(b.xmin) || !rangeCertified(b.xmax))) return Infinity;
+    const s0 = distance(p, bendSpanPoint(span, 0)[0]), s1 = distance(p, bendSpanPoint(span, 1)[0]);
+    const d = Math.max(Math.abs(normalDistance(b.ymin)), Math.abs(normalDistance(b.ymax)));
+    return measured.chordError(distance(p, b.xmin), distance(p, b.xmax), s0, s1, d, p.scale * b.dx, p.scale * b.ddx, b.dy, b.ddy, wrap);
+  };
+  return approximate(source, p, map, bound, Math.max(prepared.scale, p.length));
+}
+function approximate(source, p, map, bound, scale) {
+  const output = [];
+  let work = 0;
+  const add = (segment) => {
+    if (output.length >= p.maxSegments) throw new RangeError("Path bending exceeds maxSegments.");
+    output.push(segment);
+  };
+  for (const item of bendSpans(source)) {
+    if (item.type === "move") {
+      const [x, y] = map(item.point);
+      checkPrecision(Math.max(scale, Math.abs(x), Math.abs(y), ...item.point.map(Math.abs)), p.tolerance);
+      add({ type: "move", x, y });
+    } else if (item.type === "close") {
+      add({ type: "close" });
+    } else {
+      const stack = [[item.span, 0]];
+      while (stack.length) {
+        if (++work > MAX_WORK) throw new RangeError("Path bending exceeded its work budget.");
+        const [span, depth] = stack.pop();
+        const b = bendSpanBounds(span);
+        const end = map(bendSpanPoint(span, 1));
+        map(bendSpanPoint(span, 0));
+        const roundoff = checkPrecision(Math.max(scale, Math.abs(b.xmin), Math.abs(b.xmax), Math.abs(b.ymin), Math.abs(b.ymax), ...end.map(Math.abs)), p.tolerance);
+        const error = bound(b, span);
+        if (Number.isFinite(error) && error + roundoff <= p.tolerance) {
+          add({ type: "line", x: end[0], y: end[1] });
+          continue;
+        }
+        if (depth >= MAX_DEPTH) throw new RangeError("Path bending cannot certify tolerance or guide range due to numerical nonprogress.");
+        const [left, right] = splitBendSpan(span);
+        stack.push([right, depth + 1], [left, depth + 1]);
+      }
+    }
+  }
+  const result = new PathGeometry();
+  if (output.length) result.spliceSegments(0, 0, output);
+  return result;
+}
+function placement(options, length) {
+  const frame = options.source;
+  object(frame, "source frame");
+  const x = finite(frame.x, "source.x"), y = finite(frame.y, "source.y");
+  const width = positive(frame.width, "source.width"), height = finite(frame.height, "source.height");
+  if (height < 0) throw new RangeError("source.height must be nonnegative.");
+  const align = option(options.align, ["start", "center", "end"], "start", "align");
+  const fit = option(options.fit, ["none", "stretch"], "none", "fit");
+  const overflow = option(options.overflow, ["error", "extend", "wrap"], "error", "overflow");
+  const rawBaseline = options.baseline;
+  const inputBaseline = rawBaseline === void 0 ? "center" : rawBaseline;
+  const baseline = typeof inputBaseline === "number" ? finite(inputBaseline, "baseline") : y + height * { top: 0, center: 0.5, bottom: 1 }[option(inputBaseline, ["top", "center", "bottom"], "center", "baseline")];
+  const scale = fit === "stretch" ? positive(length / width, "fit scale") : 1;
+  const rawOffset = options.offset, rawNormal = options.normalOffset, rawMaxSegments = options.maxSegments;
+  const anchor = { start: 0, center: 0.5, end: 1 }[align], offset = finite(rawOffset === void 0 ? 0 : rawOffset, "offset");
+  const shift = finite(anchor * (length - scale * width) + offset, "alignment");
+  const maxSegments = rawMaxSegments === void 0 ? 1e6 : rawMaxSegments;
+  if (!Number.isSafeInteger(maxSegments) || maxSegments <= 0) throw new RangeError("maxSegments must be a positive safe integer.");
+  return {
+    x,
+    width,
+    fit,
+    anchor,
+    offset,
+    baseline: finite(baseline, "resolved baseline"),
+    normal: finite(rawNormal === void 0 ? 0 : rawNormal, "normalOffset"),
+    shift,
+    scale,
+    length,
+    tolerance: positive(options.tolerance, "tolerance"),
+    maxSegments,
+    overflow
+  };
+}
+function checkPrecision(scale, tolerance) {
+  const roundoff = scale * Number.EPSILON * 64;
+  if (!Number.isFinite(roundoff) || roundoff >= tolerance / 4) throw new RangeError("Path bending cannot certify tolerance at this coordinate scale.");
+  return roundoff;
+}
+function object(value, name) {
+  if (value === null || typeof value !== "object") throw new TypeError(`${name} must be an object.`);
+}
+function finite(value, name) {
+  if (typeof value !== "number") throw new TypeError(`${name} must be a number.`);
+  if (!Number.isFinite(value)) throw new RangeError(`${name} must be finite.`);
+  return value;
+}
+function positive(value, name) {
+  finite(value, name);
+  if (value <= 0) throw new RangeError(`${name} must be positive.`);
+  return value;
+}
+function option(value, allowed, fallback, name) {
+  const resolved = value === void 0 ? fallback : value;
+  if (!allowed.includes(resolved)) throw new TypeError(`Invalid path bending ${name}.`);
+  return resolved;
+}
+export {
+  bendPathAlongArc,
+  bendPathAlongPath
+};
+//# sourceMappingURL=path-bending.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/path-bending.ts"],
+  "sourcesContent": ["import type { ArcBendTransformOptions, BendTransformOptions } from './transform-bend.js';\nimport { PathGeometry, type PathSegment } from './path-geometry.js';\nimport { TAU } from './path-arc.js';\nimport { bendSpanBounds, bendSpanPoint, bendSpans, splitBendSpan, type BendBounds, type BendPoint, type BendSpan } from './path-bend-spans.js';\nimport { measureBendGuide, prepareBendGuide } from './path-bend-guide.js';\n\nexport interface PathBendFrame {\n  readonly x: number; readonly y: number; readonly width: number; readonly height: number;\n}\n/**\n * Circular guide geometry used when bending a path along an arc.\n *\n * @see {@link ArcBendTransformOptions}\n */\nexport interface PathBendArc {\n  /** Horizontal coordinate of the center. See {@link PathBendArc}. */\n  readonly cx: number;\n  /** Vertical coordinate of the center. See {@link PathBendArc}. */\n  readonly cy: number;\n  /** Radius in the coordinate system of this geometry or effect. See {@link PathBendArc}. */\n  readonly radius: number;\n  /** Angle at which the arc or slice begins. See {@link PathBendArc}. */\n  readonly startAngle: number;\n  /** Angular extent of the arc. See {@link PathBendArc}. */\n  readonly sweep: number;\n}\n/**\n * Placement of the source along the beginning, center, or end of a bending guide.\n *\n * @see {@link BendTransformOptions}\n */\nexport type PathBendAlign = 'start' | 'center' | 'end';\n/**\n * The source baseline used for bending: an edge, center, or explicit coordinate.\n *\n * @see {@link BendTransformOptions}\n */\nexport type PathBendBaseline = 'center' | 'top' | 'bottom' | number;\n/**\n * Whether bending preserves source length or stretches it to the guide.\n *\n * @see {@link BendTransformOptions}\n */\nexport type PathBendFit = 'none' | 'stretch';\n/**\n * Policy for source geometry extending beyond a bending guide.\n *\n * @see {@link BendTransformOptions}\n */\nexport type PathBendOverflow = 'error' | 'extend' | 'wrap';\n/**\n * Source bounds, guide alignment, baseline, fitting, overflow, and approximation limits for path bending.\n *\n * @see {@link PathBendAlign}\n * @see {@link PathBendBaseline}\n * @see {@link PathBendFit}\n * @see {@link PathBendOverflow}\n */\nexport interface PathBendOptions {\n  /**\n   * Source coordinate frame used to normalize the geometry before bending. See\n   * {@link PathBendFrame}.\n   */\n  readonly source: PathBendFrame;\n  /** Placement of the source length along the guide. See {@link PathBendAlign}. */\n  readonly align?: PathBendAlign;\n  /** Source baseline mapped onto the guide. See {@link PathBendBaseline}. */\n  readonly baseline?: PathBendBaseline;\n  /** Policy for fitting content within its available box. See {@link PathBendFit}. */\n  readonly fit?: PathBendFit;\n  /** Offset along the guide. See {@link PathBendOptions}. */\n  readonly offset?: number;\n  /** Offset perpendicular to the guide. See {@link PathBendOptions}. */\n  readonly normalOffset?: number;\n  /**\n   * Policy for geometry extending beyond the guide's available length. See\n   * {@link PathBendOverflow}.\n   */\n  readonly overflow?: PathBendOverflow;\n  /** Positive maximum geometric approximation error. See {@link PathBendOptions}. */\n  readonly tolerance: number;\n  /** Upper bound on the number of output path segments. See {@link PathBendOptions}. */\n  readonly maxSegments?: number;\n}\nexport interface BendPathAlongArcOptions extends PathBendOptions { readonly arc: PathBendArc }\n\n// Work limits bound failed certification attempts, not just successful output.\nconst MAX_WORK = 2_000_000;\nconst MAX_DEPTH = 52;\ninterface Placement {\n  readonly x: number; readonly baseline: number; readonly normal: number;\n  readonly shift: number; readonly scale: number; readonly length: number;\n  readonly tolerance: number; readonly maxSegments: number; readonly overflow: PathBendOverflow;\n  readonly width: number; readonly fit: PathBendFit; readonly anchor: number; readonly offset: number;\n}\n\n/** Bends continuous geometry along an analytic circle; returns independent line geometry. */\nexport function bendPathAlongArc(source: PathGeometry, options: Readonly<BendPathAlongArcOptions>): PathGeometry {\n  if (!(source instanceof PathGeometry)) throw new TypeError('source must be a PathGeometry.');\n  object(options, 'options');\n  const input = options.arc;\n  object(input, 'arc');\n  const startAngle = finite(input.startAngle, 'arc.startAngle');\n  const arc: PathBendArc = {\n    cx: finite(input.cx, 'arc.cx'), cy: finite(input.cy, 'arc.cy'),\n    radius: positive(input.radius, 'arc.radius'), startAngle: startAngle % TAU,\n    sweep: finite(input.sweep, 'arc.sweep'),\n  };\n  if (!arc.sweep || Math.abs(arc.sweep) > TAU) throw new RangeError('arc.sweep must be nonzero and at most one revolution.');\n  const p = placement(options, positive(arc.radius * Math.abs(arc.sweep), 'guide length'));\n  if (p.overflow === 'wrap' && Math.abs(arc.sweep) !== TAU) throw new RangeError('wrap requires a closed guide.');\n  const direction = Math.sign(arc.sweep);\n  const distance = (x: number) => p.shift + p.scale * (x - p.x);\n  const displacement = (y: number) => y - p.baseline + p.normal;\n  const map = ([x, y]: BendPoint): BendPoint => {\n    const s = finite(distance(x), 'mapped guide distance'), d = finite(displacement(y), 'normal displacement');\n    if (p.overflow === 'error' && (s < 0 || s > p.length)) throw new RangeError('Source geometry extends beyond the guide.');\n    const onGuide = p.overflow === 'extend' ? Math.max(0, Math.min(p.length, s)) : s;\n    const theta = arc.startAngle + direction * ((onGuide / arc.radius) % TAU);\n    const cos = Math.cos(theta), sin = Math.sin(theta);\n    const radial = arc.radius - direction * d, extension = s - onGuide;\n    // Division/modulo can lose the phase of enormous unwrapped angles. Its\n    // output effect scales with the displaced radius (not just the guide radius).\n    checkPrecision(Math.max(Math.abs(startAngle), Math.abs(onGuide / arc.radius)) * Math.max(Math.abs(radial), Math.abs(extension)), p.tolerance);\n    return [\n      finite(arc.cx + radial * cos - direction * extension * sin, 'bent x'),\n      finite(arc.cy + radial * sin + direction * extension * cos, 'bent y'),\n    ];\n  };\n  const bound = (b: BendBounds): number => {\n    const low = distance(b.xmin), high = distance(b.xmax);\n    if (p.overflow === 'error' && (low < 0 || high > p.length)) return Infinity;\n    const d = Math.max(Math.abs(displacement(b.ymin)), Math.abs(displacement(b.ymax)));\n    const dx = p.scale * b.dx, ddx = p.scale * b.ddx;\n    if (p.overflow === 'extend') {\n      if (high <= 0 || low >= p.length) return Math.hypot(ddx, b.ddy) / 8;\n      // The normal is continuous at extension boundaries, but the derivative\n      // may jump. A Lipschitz bound remains valid across the boundary.\n      if (low < 0 || high > p.length) return (b.dy + (1 + d / arc.radius) * dx) / 2;\n    }\n    const theta1 = dx / arc.radius, theta2 = ddx / arc.radius;\n    const radial = Math.max(Math.abs(arc.radius - direction * displacement(b.ymin)), Math.abs(arc.radius - direction * displacement(b.ymax)));\n    // For F = center + rho * unit(theta), ||F''|| <= |rho''|\n    // + 2|rho'||theta'| + |rho|(|theta'|\u00B2 + |theta''|).\n    // Linear interpolation on [0,1] has error at most sup ||F''|| / 8.\n    return (b.ddy + 2 * b.dy * theta1 + radial * (theta1 * theta1 + theta2)) / 8;\n  };\n  const scale = Math.max(Math.abs(arc.cx), Math.abs(arc.cy), arc.radius, p.length);\n  return approximate(source, p, map, bound, scale);\n}\n\n/** Bends geometry by distance along one smooth guide contour. */\nexport function bendPathAlongPath(source: PathGeometry, guide: PathGeometry, options: Readonly<PathBendOptions>): PathGeometry {\n  if (!(source instanceof PathGeometry) || !(guide instanceof PathGeometry)) throw new TypeError('source and guide must be PathGeometry values.');\n  object(options, 'options');\n  const input = placement(options, 1); // Snapshot options once; guide measurement supplies length later.\n  const prepared = prepareBendGuide(guide);\n  if (input.overflow === 'wrap' && !prepared.closed) throw new RangeError('wrap requires an explicitly closed guide.');\n  let xmin = Infinity, xmax = -Infinity, displacement = 0;\n  const normalDistance = (y: number) => y - input.baseline + input.normal;\n  for (const item of bendSpans(source)) {\n    if (item.type === 'close') continue;\n    const b = item.type === 'move' ? { xmin: item.point[0], xmax: item.point[0], ymin: item.point[1], ymax: item.point[1] } : bendSpanBounds(item.span);\n    xmin = Math.min(xmin, b.xmin); xmax = Math.max(xmax, b.xmax);\n    displacement = Math.max(displacement, Math.abs(normalDistance(b.ymin)), Math.abs(normalDistance(b.ymax)));\n  }\n  if (xmin === Infinity) xmin = xmax = input.x;\n  finite(displacement, 'normal displacement');\n  const atLength = (length: number): Placement => {\n    const scale = input.fit === 'stretch' ? positive(length / input.width, 'fit scale') : 1;\n    return { ...input, length, scale, shift: input.anchor * (length - scale * input.width) + input.offset };\n  };\n  const distance = (p: Placement, x: number) => p.shift + p.scale * (x - p.x);\n  const measured = measureBendGuide(prepared, input.tolerance, displacement, length => {\n    const p = atLength(length);\n    const sensitivity = input.fit === 'stretch' ? Math.max(Math.abs((xmin - input.x) / input.width), Math.abs((xmax - input.x) / input.width)) : input.anchor;\n    const laps = input.overflow === 'wrap' ? Math.ceil(Math.max(Math.abs(distance(p, xmin)), Math.abs(distance(p, xmax))) / length) : 0;\n    return finite(2 + sensitivity + laps, 'guide distance sensitivity');\n  });\n  const p = atLength(measured.length), upper = atLength(measured.length + measured.uncertainty);\n  const wrap = p.overflow === 'wrap';\n  const rangeCertified = (x: number) => {\n    const d = distance(p, x), u = distance(upper, x);\n    const roundoff = Number.EPSILON * 64 * Math.max(Math.abs(d), Math.abs(u), p.length);\n    return Math.min(d, u) >= -roundoff && Math.min(p.length - d, upper.length - u) >= -roundoff;\n  };\n  const map = ([x, y]: BendPoint): BendPoint => {\n    if (p.overflow === 'error' && !rangeCertified(x)) throw new RangeError('Source geometry exceeds the guide or its range cannot be certified.');\n    const field = measured.field(distance(p, x), wrap), d = normalDistance(y);\n    return [finite(field.point[0] + d * field.normal[0], 'bent x'), finite(field.point[1] + d * field.normal[1], 'bent y')];\n  };\n  const bound = (b: BendBounds, span: BendSpan): number => {\n    if (p.overflow === 'error' && (!rangeCertified(b.xmin) || !rangeCertified(b.xmax))) return Infinity;\n    const s0 = distance(p, bendSpanPoint(span, 0)[0]), s1 = distance(p, bendSpanPoint(span, 1)[0]);\n    const d = Math.max(Math.abs(normalDistance(b.ymin)), Math.abs(normalDistance(b.ymax)));\n    return measured.chordError(distance(p, b.xmin), distance(p, b.xmax), s0, s1, d, p.scale * b.dx, p.scale * b.ddx, b.dy, b.ddy, wrap);\n  };\n  return approximate(source, p, map, bound, Math.max(prepared.scale, p.length));\n}\n\nfunction approximate(source: PathGeometry, p: Placement, map: (point: BendPoint) => BendPoint, bound: (bounds: BendBounds, span: BendSpan) => number, scale: number): PathGeometry {\n  const output: PathSegment[] = [];\n  let work = 0;\n  const add = (segment: PathSegment) => {\n    if (output.length >= p.maxSegments) throw new RangeError('Path bending exceeds maxSegments.');\n    output.push(segment);\n  };\n  for (const item of bendSpans(source)) {\n    if (item.type === 'move') {\n      const [x, y] = map(item.point);\n      checkPrecision(Math.max(scale, Math.abs(x), Math.abs(y), ...item.point.map(Math.abs)), p.tolerance);\n      add({ type: 'move', x, y });\n    } else if (item.type === 'close') {\n      add({ type: 'close' });\n    } else {\n      const stack: Array<readonly [BendSpan, number]> = [[item.span, 0]];\n      while (stack.length) {\n        if (++work > MAX_WORK) throw new RangeError('Path bending exceeded its work budget.');\n        const [span, depth] = stack.pop()!;\n        const b = bendSpanBounds(span);\n        const end = map(bendSpanPoint(span, 1));\n        map(bendSpanPoint(span, 0));\n        const roundoff = checkPrecision(Math.max(scale, Math.abs(b.xmin), Math.abs(b.xmax), Math.abs(b.ymin), Math.abs(b.ymax), ...end.map(Math.abs)), p.tolerance);\n        const error = bound(b, span);\n        if (Number.isFinite(error) && error + roundoff <= p.tolerance) {\n          add({ type: 'line', x: end[0], y: end[1] });\n          continue;\n        }\n        if (depth >= MAX_DEPTH) throw new RangeError('Path bending cannot certify tolerance or guide range due to numerical nonprogress.');\n        const [left, right] = splitBendSpan(span);\n        stack.push([right, depth + 1], [left, depth + 1]);\n      }\n    }\n  }\n  const result = new PathGeometry();\n  if (output.length) result.spliceSegments(0, 0, output);\n  return result;\n}\n\nfunction placement(options: Readonly<PathBendOptions>, length: number): Placement {\n  const frame = options.source;\n  object(frame, 'source frame');\n  const x = finite(frame.x, 'source.x'), y = finite(frame.y, 'source.y');\n  const width = positive(frame.width, 'source.width'), height = finite(frame.height, 'source.height');\n  if (height < 0) throw new RangeError('source.height must be nonnegative.');\n  const align = option(options.align, ['start', 'center', 'end'], 'start', 'align');\n  const fit = option(options.fit, ['none', 'stretch'], 'none', 'fit');\n  const overflow = option(options.overflow, ['error', 'extend', 'wrap'], 'error', 'overflow');\n  const rawBaseline = options.baseline;\n  const inputBaseline = rawBaseline === undefined ? 'center' : rawBaseline;\n  const baseline = typeof inputBaseline === 'number' ? finite(inputBaseline, 'baseline')\n    : y + height * ({ top: 0, center: 0.5, bottom: 1 }[option(inputBaseline, ['top', 'center', 'bottom'], 'center', 'baseline')]);\n  const scale = fit === 'stretch' ? positive(length / width, 'fit scale') : 1;\n  const rawOffset = options.offset, rawNormal = options.normalOffset, rawMaxSegments = options.maxSegments;\n  const anchor = { start: 0, center: 0.5, end: 1 }[align], offset = finite(rawOffset === undefined ? 0 : rawOffset, 'offset');\n  const shift = finite(anchor * (length - scale * width) + offset, 'alignment');\n  const maxSegments = rawMaxSegments === undefined ? 1_000_000 : rawMaxSegments;\n  if (!Number.isSafeInteger(maxSegments) || maxSegments <= 0) throw new RangeError('maxSegments must be a positive safe integer.');\n  return {\n    x, width, fit, anchor, offset, baseline: finite(baseline, 'resolved baseline'), normal: finite(rawNormal === undefined ? 0 : rawNormal, 'normalOffset'),\n    shift, scale, length, tolerance: positive(options.tolerance, 'tolerance'), maxSegments, overflow,\n  };\n}\nfunction checkPrecision(scale: number, tolerance: number): number {\n  const roundoff = scale * Number.EPSILON * 64;\n  if (!Number.isFinite(roundoff) || roundoff >= tolerance / 4) throw new RangeError('Path bending cannot certify tolerance at this coordinate scale.');\n  return roundoff;\n}\nfunction object(value: unknown, name: string): asserts value is Record<string, unknown> {\n  if (value === null || typeof value !== 'object') throw new TypeError(`${name} must be an object.`);\n}\nfunction finite(value: number, name: string): number {\n  if (typeof value !== 'number') throw new TypeError(`${name} must be a number.`);\n  if (!Number.isFinite(value)) throw new RangeError(`${name} must be finite.`);\n  return value;\n}\nfunction positive(value: number, name: string): number {\n  finite(value, name);\n  if (value <= 0) throw new RangeError(`${name} must be positive.`);\n  return value;\n}\nfunction option<T extends string>(value: T | undefined, allowed: readonly T[], fallback: T, name: string): T {\n  const resolved = value === undefined ? fallback : value;\n  if (!allowed.includes(resolved)) throw new TypeError(`Invalid path bending ${name}.`);\n  return resolved;\n}\n"],
+  "mappings": "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",
+  "names": ["p"]
+}

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

@@ -0,0 +1,19 @@
+import { PathGeometry } from './path-geometry.js';
+/**
+ * Creates a fresh caller-owned native snapshot; never returns a shared cache.
+ *
+ * @param geometry - Pibbl geometry to convert. See {@link PathGeometry}.
+ * @returns A native Canvas path representing the geometry.
+ *
+ * @see {@link PathGeometry}
+ */
+export declare function toPath2D(geometry: PathGeometry): Path2D;
+/**
+ * Serializes independent absolute SVG path data without implicit rounding.
+ *
+ * @param geometry - Pibbl geometry to serialize. See {@link PathGeometry}.
+ * @returns SVG path data representing the geometry.
+ *
+ * @see {@link PathGeometry}
+ */
+export declare function toSvgPathData(geometry: PathGeometry): string;

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

@@ -0,0 +1,114 @@
+import { arcPoint, ellipseParameters, singularArcPoints } from "./path-arc.js";
+import { visitPathGeometry } from "./path-geometry.js";
+function toPath2D(geometry) {
+  const path = new Path2D();
+  visitPathGeometry(geometry, (type, data, i) => {
+    switch (type) {
+      case 0:
+        path.moveTo(data[i], data[i + 1]);
+        break;
+      case 1:
+        path.lineTo(data[i], data[i + 1]);
+        break;
+      case 2:
+        path.quadraticCurveTo(data[i], data[i + 1], data[i + 2], data[i + 3]);
+        break;
+      case 3:
+        path.bezierCurveTo(data[i], data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5]);
+        break;
+      case 4:
+        path.closePath();
+        break;
+      case 5: {
+        const arc = readArc(data, i);
+        const ellipse = ellipseParameters(arc);
+        if (ellipse) {
+          path.ellipse(
+            arc.cx,
+            arc.cy,
+            ellipse.radiusX,
+            ellipse.radiusY,
+            ellipse.rotation,
+            ellipse.start,
+            ellipse.start + ellipse.sweep,
+            ellipse.sweep < 0
+          );
+        } else {
+          const start = arcPoint(arc, arc.startAngle);
+          path.lineTo(start[0], start[1]);
+          for (const [x, y] of singularArcPoints(arc)) path.lineTo(x, y);
+        }
+        break;
+      }
+    }
+  });
+  return path;
+}
+function toSvgPathData(geometry) {
+  const parts = [];
+  const commands = ["M", "L", "Q", "C", "Z"];
+  const widths = [2, 2, 4, 6, 0];
+  let currentX = 0, currentY = 0, startX = 0, startY = 0;
+  visitPathGeometry(geometry, (type, data, i) => {
+    if (type === 5) {
+      const arc = readArc(data, i);
+      const arcStart = arcPoint(arc, arc.startAngle);
+      if (currentX !== arcStart[0] || currentY !== arcStart[1]) {
+        parts.push("L", String(arcStart[0]), String(arcStart[1]));
+      }
+      [currentX, currentY] = arcPoint(arc, arc.startAngle + arc.sweep);
+      const ellipse = ellipseParameters(arc);
+      if (!ellipse) {
+        for (const [x, y] of singularArcPoints(arc)) parts.push("L", String(x), String(y));
+      } else if (arc.sweep !== 0) {
+        const count = Math.ceil(Math.abs(arc.sweep) / Math.PI);
+        for (let step = 1; step <= count; step++) {
+          const [x, y] = arcPoint(arc, arc.startAngle + arc.sweep * step / count);
+          parts.push(
+            "A",
+            String(ellipse.radiusX),
+            String(ellipse.radiusY),
+            String(ellipse.rotation * 180 / Math.PI),
+            "0",
+            ellipse.sweep < 0 ? "0" : "1",
+            String(x),
+            String(y)
+          );
+        }
+      }
+      return;
+    }
+    parts.push(commands[type]);
+    for (let j = 0; j < widths[type]; j++) parts.push(String(data[i + j]));
+    if (type === 4) {
+      currentX = startX;
+      currentY = startY;
+    } else {
+      currentX = data[i + widths[type] - 2];
+      currentY = data[i + widths[type] - 1];
+      if (type === 0) {
+        startX = currentX;
+        startY = currentY;
+      }
+    }
+  });
+  return parts.join(" ");
+}
+function readArc(data, i) {
+  return {
+    type: "arc",
+    cx: data[i],
+    cy: data[i + 1],
+    ux: data[i + 2],
+    uy: data[i + 3],
+    vx: data[i + 4],
+    vy: data[i + 5],
+    startAngle: data[i + 6],
+    sweep: data[i + 7]
+  };
+}
+export {
+  toPath2D,
+  toSvgPathData
+};
+//# sourceMappingURL=path-conversion.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/path-conversion.ts"],
+  "sourcesContent": ["import { arcPoint, ellipseParameters, singularArcPoints, type ArcSegment } from './path-arc.js';\nimport { PathGeometry, visitPathGeometry } from './path-geometry.js';\n\n/**\n * Creates a fresh caller-owned native snapshot; never returns a shared cache.\n *\n * @param geometry - Pibbl geometry to convert. See {@link PathGeometry}.\n * @returns A native Canvas path representing the geometry.\n *\n * @see {@link PathGeometry}\n */\nexport function toPath2D(geometry: PathGeometry): Path2D {\n  const path = new Path2D();\n  visitPathGeometry(geometry, (type, data, i) => {\n    switch (type) {\n      case 0: path.moveTo(data[i], data[i + 1]); break;\n      case 1: path.lineTo(data[i], data[i + 1]); break;\n      case 2: path.quadraticCurveTo(data[i], data[i + 1], data[i + 2], data[i + 3]); break;\n      case 3: path.bezierCurveTo(data[i], data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5]); break;\n      case 4: path.closePath(); break;\n      case 5: {\n        const arc = readArc(data, i);\n        const ellipse = ellipseParameters(arc);\n        if (ellipse) {\n          path.ellipse(arc.cx, arc.cy, ellipse.radiusX, ellipse.radiusY, ellipse.rotation,\n            ellipse.start, ellipse.start + ellipse.sweep, ellipse.sweep < 0);\n        } else {\n          const start = arcPoint(arc, arc.startAngle);\n          path.lineTo(start[0], start[1]);\n          for (const [x, y] of singularArcPoints(arc)) path.lineTo(x, y);\n        }\n        break;\n      }\n    }\n  });\n  return path;\n}\n\n/**\n * Serializes independent absolute SVG path data without implicit rounding.\n *\n * @param geometry - Pibbl geometry to serialize. See {@link PathGeometry}.\n * @returns SVG path data representing the geometry.\n *\n * @see {@link PathGeometry}\n */\nexport function toSvgPathData(geometry: PathGeometry): string {\n  const parts: string[] = [];\n  const commands = ['M', 'L', 'Q', 'C', 'Z'];\n  const widths = [2, 2, 4, 6, 0];\n  let currentX = 0, currentY = 0, startX = 0, startY = 0;\n  visitPathGeometry(geometry, (type, data, i) => {\n    if (type === 5) {\n      const arc = readArc(data, i);\n      const arcStart = arcPoint(arc, arc.startAngle);\n      if (currentX !== arcStart[0] || currentY !== arcStart[1]) {\n        parts.push('L', String(arcStart[0]), String(arcStart[1]));\n      }\n      [currentX, currentY] = arcPoint(arc, arc.startAngle + arc.sweep);\n      const ellipse = ellipseParameters(arc);\n      if (!ellipse) {\n        for (const [x, y] of singularArcPoints(arc)) parts.push('L', String(x), String(y));\n      } else if (arc.sweep !== 0) {\n        // Splitting into at most half-turns handles full circles and avoids SVG's\n        // ambiguous coincident endpoints. No flattening is involved.\n        const count = Math.ceil(Math.abs(arc.sweep) / Math.PI);\n        for (let step = 1; step <= count; step++) {\n          const [x, y] = arcPoint(arc, arc.startAngle + arc.sweep * step / count);\n          parts.push('A', String(ellipse.radiusX), String(ellipse.radiusY),\n            String(ellipse.rotation * 180 / Math.PI), '0', ellipse.sweep < 0 ? '0' : '1', String(x), String(y));\n        }\n      }\n      return;\n    }\n    parts.push(commands[type]);\n    for (let j = 0; j < widths[type]; j++) parts.push(String(data[i + j]));\n    if (type === 4) { currentX = startX; currentY = startY; }\n    else {\n      currentX = data[i + widths[type] - 2]; currentY = data[i + widths[type] - 1];\n      if (type === 0) { startX = currentX; startY = currentY; }\n    }\n  });\n  return parts.join(' ');\n}\n\nfunction readArc(data: Float64Array, i: number): ArcSegment {\n  return { type: 'arc', cx: data[i], cy: data[i + 1], ux: data[i + 2], uy: data[i + 3],\n    vx: data[i + 4], vy: data[i + 5], startAngle: data[i + 6], sweep: data[i + 7] };\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,218 @@
+import { type ArcSegment } from './path-arc.js';
+/**
+ * A canonical, independently editable path segment.
+ *
+ * @see {@link PathGeometry}
+ */
+export type PathSegment = {
+    /** Selects `"move"`, `"line"` for type. See {@link PathSegment}. */
+    type: 'move' | 'line';
+    /**
+     * Horizontal coordinate or displacement in the containing coordinate system. See
+     * {@link PathSegment}.
+     */
+    x: number;
+    /**
+     * Vertical coordinate or displacement in the containing coordinate system. See
+     * {@link PathSegment}.
+     */
+    y: number;
+} | {
+    /** The literal "quadratic" identifying this variant. See {@link PathSegment}. */
+    type: 'quadratic';
+    /** Horizontal coordinate of the quadratic control point. See {@link PathSegment}. */
+    cpx: number;
+    /** Vertical coordinate of the quadratic control point. See {@link PathSegment}. */
+    cpy: number;
+    /**
+     * Horizontal coordinate or displacement in the containing coordinate system. See
+     * {@link PathSegment}.
+     */
+    x: number;
+    /**
+     * Vertical coordinate or displacement in the containing coordinate system. See
+     * {@link PathSegment}.
+     */
+    y: number;
+} | {
+    /** The literal "cubic" identifying this variant. See {@link PathSegment}. */
+    type: 'cubic';
+    /** Horizontal coordinate of the first cubic control point. See {@link PathSegment}. */
+    cp1x: number;
+    /** Vertical coordinate of the first cubic control point. See {@link PathSegment}. */
+    cp1y: number;
+    /** Horizontal coordinate of the second cubic control point. See {@link PathSegment}. */
+    cp2x: number;
+    /** Vertical coordinate of the second cubic control point. See {@link PathSegment}. */
+    cp2y: number;
+    /**
+     * Horizontal coordinate or displacement in the containing coordinate system. See
+     * {@link PathSegment}.
+     */
+    x: number;
+    /**
+     * Vertical coordinate or displacement in the containing coordinate system. See
+     * {@link PathSegment}.
+     */
+    y: number;
+} | ArcSegment | {
+    /** The literal "close" identifying this variant. See {@link PathSegment}. */
+    type: 'close';
+};
+/** @internal Borrowed buffers must never escape this synchronous traversal. */
+export declare function visitPathGeometry(path: PathGeometry, visit: (type: number, data: Float64Array, offset: number) => void): void;
+/**
+ * Mutable packed geometry. Mutations do not schedule Pibbl rendering.
+ *
+ * @see {@link PathSegment}
+ */
+export declare class PathGeometry implements Iterable<PathSegment> {
+    #private;
+    /**
+     * Creates empty geometry or an independent copy of the supplied path. See {@link PathGeometry}.
+     * @param source - Optional geometry whose segments are copied; omission creates an empty path.
+     * See {@link PathGeometry} .
+     */
+    constructor(source?: PathGeometry);
+    /**
+     * Monotonic mutation revision; changing geometry does not itself request a Pibbl frame. See
+     * {@link PathGeometry}.
+     * @returns The mutation revision used to invalidate cached representations.
+     */
+    get revision(): number;
+    /**
+     * Number of stored path segments, including move and close commands. See {@link PathGeometry}.
+     * @returns The number of stored path segments.
+     */
+    get segmentCount(): number;
+    /**
+     * Returns an independent copy with its own mutation revision. See {@link PathGeometry}.
+     * @returns An independent copy of this path's segments. See {@link PathGeometry}.
+     */
+    clone(): PathGeometry;
+    /** Removes all segments and resets the current point. See {@link PathGeometry}. */
+    clear(): void;
+    /**
+     * Begins a subpath at the supplied coordinates. See {@link PathGeometry}.
+     * @param x - Horizontal coordinate of the new subpath's starting point.
+     * @param y - Vertical coordinate of the new subpath's starting point.
+     */
+    moveTo(x: number, y: number): void;
+    /**
+     * Appends a straight segment to the supplied coordinates. See {@link PathGeometry}.
+     * @param x - Horizontal coordinate of the line endpoint.
+     * @param y - Vertical coordinate of the line endpoint.
+     */
+    lineTo(x: number, y: number): void;
+    /**
+     * Appends a quadratic curve using one control point and an endpoint. See {@link PathGeometry}.
+     * @param cpx - Horizontal coordinate of the quadratic control point.
+     * @param cpy - Vertical coordinate of the quadratic control point.
+     * @param x - Horizontal coordinate of the curve endpoint.
+     * @param y - Vertical coordinate of the curve endpoint.
+     */
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    /**
+     * Appends a cubic curve using two control points and an endpoint. See {@link PathGeometry}.
+     * @param cp1x - Horizontal coordinate of the first control point.
+     * @param cp1y - Vertical coordinate of the first control point.
+     * @param cp2x - Horizontal coordinate of the second control point.
+     * @param cp2y - Vertical coordinate of the second control point.
+     * @param x - Horizontal coordinate of the curve endpoint.
+     * @param y - Vertical coordinate of the curve endpoint.
+     */
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    /**
+     * Closes the current subpath; an already closed or empty path is unchanged. See
+     * {@link PathGeometry}.
+     */
+    closePath(): void;
+    /**
+     * Appends a circular arc using Canvas-compatible angles in radians. See {@link PathGeometry}.
+     * @param x - Horizontal coordinate of the circle center.
+     * @param y - Vertical coordinate of the circle center.
+     * @param radius - Circle radius in path units.
+     * @param startAngle - Starting angle in radians.
+     * @param endAngle - Ending angle in radians.
+     * @param counterclockwise - Whether the arc runs counterclockwise; defaults to false.
+     */
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
+    /**
+     * Appends an elliptical arc; rotation and arc angles are in radians. See {@link PathGeometry}.
+     * @param x - Horizontal coordinate of the ellipse center.
+     * @param y - Vertical coordinate of the ellipse center.
+     * @param radiusX - Horizontal radius in path units.
+     * @param radiusY - Vertical radius in path units.
+     * @param rotation - Ellipse rotation in radians.
+     * @param startAngle - Starting angle in radians.
+     * @param endAngle - Ending angle in radians.
+     * @param counterclockwise - Whether the arc runs counterclockwise; defaults to false.
+     */
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
+    /**
+     * Appends a circular arc tangent to two lines using Canvas-compatible geometry. See
+     * {@link PathGeometry}.
+     * @param x1 - Horizontal coordinate of the first tangent intersection.
+     * @param y1 - Vertical coordinate of the first tangent intersection.
+     * @param x2 - Horizontal coordinate of the second tangent endpoint.
+     * @param y2 - Vertical coordinate of the second tangent endpoint.
+     * @param radius - Arc radius in path units.
+     */
+    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+    /**
+     * Appends a closed rectangle subpath. See {@link PathGeometry}.
+     * @param x - Horizontal coordinate of the rectangle origin.
+     * @param y - Vertical coordinate of the rectangle origin.
+     * @param width - Signed horizontal extent in path units.
+     * @param height - Signed vertical extent in path units.
+     */
+    rect(x: number, y: number, width: number, height: number): void;
+    /**
+     * Appends a closed rectangle with Canvas-compatible corner radii. See {@link PathGeometry}.
+     * @param x - Horizontal coordinate of the rectangle origin.
+     * @param y - Vertical coordinate of the rectangle origin.
+     * @param width - Signed horizontal extent in path units.
+     * @param height - Signed vertical extent in path units.
+     * @param radii - Circular or elliptical corner radii, using Canvas roundRect ordering; defaults
+     * to zero.
+     */
+    roundRect(x: number, y: number, width: number, height: number, radii?: number | DOMPointInit | (number | DOMPointInit)[]): void;
+    /**
+     * Appends a copy of another path, optionally transformed by a 2D matrix. See
+     * {@link PathGeometry}.
+     * @param other - Geometry whose segments are appended. See {@link PathGeometry}.
+     * @param matrix - Optional affine transform applied to the appended segments; defaults to
+     * identity.
+     */
+    addPath(other: PathGeometry, matrix?: DOMMatrix2DInit): void;
+    /**
+     * Replaces a segment range with validated independent segment values. See {@link PathGeometry}.
+     * @param start - Index at which to begin replacing segments.
+     * @param deleteCount - Number of segments to remove.
+     * @param segments - Replacement segments; defaults to no inserted segments. See
+     * {@link PathSegment} .
+     */
+    spliceSegments(start: number, deleteCount: number, segments?: readonly PathSegment[]): void;
+    /**
+     * Returns an independent segment value at the specified index. See {@link PathSegment}.
+     * @param index - Zero-based segment index.
+     * @returns The segment at the requested index. See {@link PathSegment}.
+     */
+    getSegment(index: number): PathSegment;
+    /**
+     * Replaces one stored segment with a validated independent value. See {@link PathGeometry}.
+     * @param index - Zero-based index of the segment to replace.
+     * @param segment - Replacement segment data. See {@link PathSegment}.
+     */
+    setSegment(index: number, segment: PathSegment): void;
+    /**
+     * Applies a finite 2D affine matrix. Old native conversions remain unchanged.
+     * @param matrix - Affine matrix applied to all segments in this path.
+     */
+    transform(matrix: DOMMatrix2DInit): void;
+    /**
+     * Iterates over independent segment values in source order. See {@link PathSegment}.
+     * @returns An iterator over the path's segments in drawing order. See {@link PathSegment}.
+     */
+    [Symbol.iterator](): IterableIterator<PathSegment>;
+}