@pibbl/core 0.0.1

package/dist/lib/geometry/transform-bend.js

@@ -0,0 +1,219 @@
+import {
+  constant,
+  add,
+  sub,
+  scale,
+  mul,
+  trig,
+  absI
+} from "./transform-math.js";
+import { evaluatePolyline } from "./transform-guide.js";
+import { prepareBendGuide, measureBendGuide } from "./path-bend-guide.js";
+import {
+  bendPathAlongArc,
+  bendPathAlongPath
+} from "./path-bending.js";
+import { PathGeometry } from "./path-geometry.js";
+import {
+  make,
+  coordinate,
+  positive,
+  mergePairs
+} from "./path-transforms.js";
+function placement(input) {
+  const frame = input.source;
+  const source = {
+    x: coordinate(frame?.x),
+    y: coordinate(frame?.y),
+    width: positive(frame?.width, "source.width"),
+    height: coordinate(frame?.height)
+  };
+  if (source.height < 0)
+    throw new RangeError("source.height must be nonnegative.");
+  const align = input.align ?? "start", fit = input.fit ?? "none", overflow = input.overflow ?? "error";
+  if (!["start", "center", "end"].includes(align) || !["none", "stretch"].includes(fit) || !["error", "extend", "wrap"].includes(overflow))
+    throw new TypeError("Invalid bend placement option.");
+  const raw = input.baseline ?? "center";
+  if (typeof raw !== "number" && !["top", "center", "bottom"].includes(raw))
+    throw new TypeError("Invalid bend baseline.");
+  const baseline = typeof raw === "number" ? coordinate(raw) : source.y + source.height * { top: 0, center: 0.5, bottom: 1 }[raw];
+  return {
+    source,
+    baseline,
+    fit,
+    overflow,
+    anchor: { start: 0, center: 0.5, end: 1 }[align],
+    offset: coordinate(input.offset ?? 0),
+    normal: coordinate(input.normalOffset ?? 0)
+  };
+}
+function distances(p, length, input) {
+  const factor = p.fit === "stretch" ? length / p.source.width : 1;
+  return [
+    add(
+      scale(sub(input[0], constant(p.source.x)), factor),
+      constant(p.anchor * (length - factor * p.source.width) + p.offset)
+    ),
+    add(sub(input[1], constant(p.baseline)), constant(p.normal))
+  ];
+}
+function arcBendTransform(options) {
+  const p = placement(options), arc = { ...options.arc };
+  const saved = { ...options, source: { ...options.source }, arc };
+  bendPathAlongArc(new PathGeometry(), {
+    ...options,
+    source: { ...options.source },
+    arc,
+    tolerance: 1
+  });
+  const length = positive(arc.radius * Math.abs(arc.sweep), "guide length"), direction = Math.sign(arc.sweep);
+  const curve = (s, d, extension = constant(0)) => {
+    const theta = add(
+      scale(s, direction / arc.radius),
+      constant(arc.startAngle % (2 * Math.PI))
+    );
+    const radius = sub(constant(arc.radius), scale(d, direction));
+    return [
+      sub(
+        add(constant(arc.cx), mul(radius, trig(theta, true))),
+        scale(mul(extension, trig(theta)), direction)
+      ),
+      add(
+        add(constant(arc.cy), mul(radius, trig(theta))),
+        scale(mul(extension, trig(theta, true)), direction)
+      )
+    ];
+  };
+  return make([
+    () => ({
+      apply: (path, quality) => bendPathAlongArc(path, {
+        ...saved,
+        tolerance: quality.tolerance,
+        maxSegments: quality.maxSegments
+      }),
+      error: (input) => {
+        const [s, d] = distances(p, length, input);
+        return Number.EPSILON * 64 * (1 + Math.abs(arc.startAngle) + absI(s.v) / arc.radius) * (arc.radius + absI(d.v) + (p.overflow === "extend" ? absI(s.v) : 0));
+      },
+      domain: (input, margin) => {
+        const [s] = distances(p, length, input);
+        return p.overflow !== "error" || s.v[0] >= -margin && s.v[1] <= length + margin;
+      },
+      evaluate: (input) => {
+        const [s, d] = distances(p, length, input);
+        if (p.overflow !== "extend") return curve(s, d);
+        const parts = [];
+        if (s.v[0] < 0) {
+          const before = { ...s, v: [s.v[0], Math.min(0, s.v[1])] };
+          parts.push(curve(constant(0), d, before));
+        }
+        if (s.v[1] >= 0 && s.v[0] <= length)
+          parts.push(
+            curve(
+              { ...s, v: [Math.max(0, s.v[0]), Math.min(length, s.v[1])] },
+              d
+            )
+          );
+        if (s.v[1] > length) {
+          const after = {
+            ...s,
+            v: [Math.max(length, s.v[0]), s.v[1]]
+          };
+          parts.push(curve(constant(length), d, sub(after, constant(length))));
+        }
+        return parts.length === 1 ? parts[0] : mergePairs(parts);
+      }
+    })
+  ]);
+}
+function pathBendTransform(options) {
+  const p = placement(options);
+  if (!(options.guide instanceof PathGeometry))
+    throw new TypeError("guide must be PathGeometry.");
+  const guide = options.guide.clone();
+  const saved = { ...options, source: { ...options.source }, guide };
+  const prepared = prepareBendGuide(guide);
+  if (p.overflow === "wrap" && !prepared.closed)
+    throw new RangeError("wrap requires a closed guide.");
+  return make([
+    (accuracy) => {
+      const measured = measureBendGuide(prepared, accuracy * 4, 1, () => 2);
+      const { length, knots } = measured;
+      const coordinates = knots.map((k) => k.distance), points = knots.map((k) => k.point), normals = knots.map((k) => k.normal);
+      const field = (s) => {
+        if (s.v[0] >= 0 && s.v[1] <= length)
+          return [
+            evaluatePolyline(coordinates, points, s),
+            evaluatePolyline(coordinates, normals, s)
+          ];
+        const positions = [...points], directions = [...normals], distances2 = [...coordinates];
+        if (s.v[0] < 0) {
+          const n = normals[0], q = points[0], d = s.v[0];
+          distances2.unshift(d);
+          positions.unshift([q[0] + d * n[1], q[1] - d * n[0]]);
+          directions.unshift(n);
+        }
+        if (s.v[1] > length) {
+          const n = normals.at(-1), q = points.at(-1), d = s.v[1] - length;
+          distances2.push(s.v[1]);
+          positions.push([q[0] + d * n[1], q[1] - d * n[0]]);
+          directions.push(n);
+        }
+        return [
+          evaluatePolyline(distances2, positions, s),
+          evaluatePolyline(distances2, directions, s)
+        ];
+      };
+      const sample = (s, d) => {
+        const [q, n] = field(s);
+        return [add(q[0], mul(d, n[0])), add(q[1], mul(d, n[1]))];
+      };
+      return {
+        apply: (path, quality) => bendPathAlongPath(path, guide, {
+          ...saved,
+          tolerance: quality.tolerance,
+          maxSegments: quality.maxSegments
+        }),
+        // The measured error bounds unit normal displacement and two units of
+        // length uncertainty. Enlarge for placement, displacement, and wrapped laps.
+        error: (input) => {
+          const [s, d] = distances(p, length, input);
+          return measured.error * (1 + absI(d.v)) * (2 + absI(s.v) / length + absI(
+            scale(sub(input[0], constant(p.source.x)), 1 / p.source.width).v
+          ));
+        },
+        domain: (input, margin) => {
+          const [s] = distances(p, length, input);
+          return p.overflow !== "error" || s.v[0] >= -margin && s.v[1] <= length + margin;
+        },
+        evaluate: (input) => {
+          const [s, d] = distances(p, length, input);
+          if (p.overflow !== "wrap") return sample(s, d);
+          const first = Math.floor(s.v[0] / length), last = Math.floor(s.v[1] / length);
+          if (!Number.isSafeInteger(first) || !Number.isSafeInteger(last) || last - first > 1024)
+            throw new RangeError("Wrapped bend exceeds its lap budget.");
+          const parts = [];
+          for (let lap = first; lap <= last; lap++)
+            parts.push(
+              sample(
+                {
+                  ...s,
+                  v: [
+                    Math.max(0, s.v[0] - lap * length),
+                    Math.min(length, s.v[1] - lap * length)
+                  ]
+                },
+                d
+              )
+            );
+          return parts.length === 1 ? parts[0] : mergePairs(parts);
+        }
+      };
+    }
+  ]);
+}
+export {
+  arcBendTransform,
+  pathBendTransform
+};
+//# sourceMappingURL=transform-bend.js.map

package/dist/lib/geometry/transform-bend.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/transform-bend.ts"],
+  "sourcesContent": ["import {\n  constant,\n  add,\n  sub,\n  scale,\n  mul,\n  trig,\n  absI,\n  type Pair,\n  type Jet,\n} from './transform-math.js';\nimport { evaluatePolyline } from './transform-guide.js';\nimport { prepareBendGuide, measureBendGuide } from './path-bend-guide.js';\nimport {\n  bendPathAlongArc,\n  bendPathAlongPath,\n  type PathBendOptions,\n  type BendPathAlongArcOptions,\n} from './path-bending.js';\nimport { PathGeometry } from './path-geometry.js';\nimport {\n  make,\n  coordinate,\n  positive,\n  mergePairs,\n  type PathTransform,\n} from './path-transforms.js';\n\n/**\n * Alignment, fitting, baseline, and overflow controls shared by reusable bend transforms.\n *\n * @see {@link PathBendTransformOptions}\n */\nexport type BendTransformOptions = Omit<\n  PathBendOptions,\n  'tolerance' | 'maxSegments'\n>;\n/**\n * Circular bending parameters for a reusable arc transform; accuracy is supplied when applying it.\n *\n * @see {@link arcBendTransform}\n */\nexport type ArcBendTransformOptions = Omit<\n  BendPathAlongArcOptions,\n  'tolerance' | 'maxSegments'\n>;\n/**\n * Guide path and bending parameters for a reusable path transform.\n *\n * @see {@link PathGeometry}\n * @see {@link pathBendTransform}\n */\nexport type PathBendTransformOptions = Omit<\n  PathBendOptions,\n  'tolerance' | 'maxSegments'\n> & {\n  /** Path used as the bending guide. See {@link PathGeometry}. */\n  readonly guide: PathGeometry;\n};\nfunction placement(input: Omit<PathBendOptions, 'tolerance' | 'maxSegments'>) {\n  const frame = input.source;\n  const source = {\n    x: coordinate(frame?.x),\n    y: coordinate(frame?.y),\n    width: positive(frame?.width, 'source.width'),\n    height: coordinate(frame?.height),\n  };\n  if (source.height < 0)\n    throw new RangeError('source.height must be nonnegative.');\n  const align = input.align ?? 'start',\n    fit = input.fit ?? 'none',\n    overflow = input.overflow ?? 'error';\n  if (\n    !['start', 'center', 'end'].includes(align) ||\n    !['none', 'stretch'].includes(fit) ||\n    !['error', 'extend', 'wrap'].includes(overflow)\n  )\n    throw new TypeError('Invalid bend placement option.');\n  const raw = input.baseline ?? 'center';\n  if (typeof raw !== 'number' && !['top', 'center', 'bottom'].includes(raw))\n    throw new TypeError('Invalid bend baseline.');\n  const baseline =\n    typeof raw === 'number'\n      ? coordinate(raw)\n      : source.y + source.height * { top: 0, center: 0.5, bottom: 1 }[raw];\n  return {\n    source,\n    baseline,\n    fit,\n    overflow,\n    anchor: { start: 0, center: 0.5, end: 1 }[align],\n    offset: coordinate(input.offset ?? 0),\n    normal: coordinate(input.normalOffset ?? 0),\n  };\n}\nfunction distances(\n  p: ReturnType<typeof placement>,\n  length: number,\n  input: Pair,\n): Pair {\n  const factor = p.fit === 'stretch' ? length / p.source.width : 1;\n  return [\n    add(\n      scale(sub(input[0], constant(p.source.x)), factor),\n      constant(p.anchor * (length - factor * p.source.width) + p.offset),\n    ),\n    add(sub(input[1], constant(p.baseline)), constant(p.normal)),\n  ];\n}\n/**\n * Creates a reusable mapping that bends source geometry around a circular arc.\n *\n * @param options - Source bounds and circular bend geometry. See {@link ArcBendTransformOptions}.\n * @returns A point mapping that bends the source along a circular arc. See {@link PathTransform}.\n *\n * @see {@link ArcBendTransformOptions}\n * @see {@link PathTransform}\n */\nexport function arcBendTransform(\n  options: ArcBendTransformOptions,\n): PathTransform {\n  const p = placement(options),\n    arc = { ...options.arc };\n  const saved = { ...options, source: { ...options.source }, arc };\n  // Keep the established arc validation and wrapping contract.\n  bendPathAlongArc(new PathGeometry(), {\n    ...options,\n    source: { ...options.source },\n    arc,\n    tolerance: 1,\n  });\n  const length = positive(arc.radius * Math.abs(arc.sweep), 'guide length'),\n    direction = Math.sign(arc.sweep);\n  const curve = (s: Jet, d: Jet, extension = constant(0)): Pair => {\n    const theta = add(\n      scale(s, direction / arc.radius),\n      constant(arc.startAngle % (2 * Math.PI)),\n    );\n    const radius = sub(constant(arc.radius), scale(d, direction));\n    return [\n      sub(\n        add(constant(arc.cx), mul(radius, trig(theta, true))),\n        scale(mul(extension, trig(theta)), direction),\n      ),\n      add(\n        add(constant(arc.cy), mul(radius, trig(theta))),\n        scale(mul(extension, trig(theta, true)), direction),\n      ),\n    ];\n  };\n  return make([\n    () => ({\n      apply: (path, quality) =>\n        bendPathAlongArc(path, {\n          ...saved,\n          tolerance: quality.tolerance,\n          maxSegments: quality.maxSegments,\n        }),\n      error: (input) => {\n        const [s, d] = distances(p, length, input);\n        return (\n          Number.EPSILON *\n          64 *\n          (1 + Math.abs(arc.startAngle) + absI(s.v) / arc.radius) *\n          (arc.radius + absI(d.v) + (p.overflow === 'extend' ? absI(s.v) : 0))\n        );\n      },\n      domain: (input, margin) => {\n        const [s] = distances(p, length, input);\n        return (\n          p.overflow !== 'error' ||\n          (s.v[0] >= -margin && s.v[1] <= length + margin)\n        );\n      },\n      evaluate: (input) => {\n        const [s, d] = distances(p, length, input);\n        if (p.overflow !== 'extend') return curve(s, d);\n        const parts: Pair[] = [];\n        if (s.v[0] < 0) {\n          const before = { ...s, v: [s.v[0], Math.min(0, s.v[1])] as const };\n          parts.push(curve(constant(0), d, before));\n        }\n        if (s.v[1] >= 0 && s.v[0] <= length)\n          parts.push(\n            curve(\n              { ...s, v: [Math.max(0, s.v[0]), Math.min(length, s.v[1])] },\n              d,\n            ),\n          );\n        if (s.v[1] > length) {\n          const after = {\n            ...s,\n            v: [Math.max(length, s.v[0]), s.v[1]] as const,\n          };\n          parts.push(curve(constant(length), d, sub(after, constant(length))));\n        }\n        return parts.length === 1 ? parts[0] : mergePairs(parts);\n      },\n    }),\n  ]);\n}\n/**\n * Creates a reusable mapping that bends source geometry along a guide path.\n *\n * @param options - Source bounds, target guide, and alignment along that guide. See\n * {@link PathBendTransformOptions} .\n * @returns A point mapping that bends the source along the target path. See {@link PathTransform}.\n *\n * @see {@link PathBendTransformOptions}\n * @see {@link PathTransform}\n */\nexport function pathBendTransform(\n  options: PathBendTransformOptions,\n): PathTransform {\n  const p = placement(options);\n  if (!(options.guide instanceof PathGeometry))\n    throw new TypeError('guide must be PathGeometry.');\n  const guide = options.guide.clone();\n  const saved = { ...options, source: { ...options.source }, guide };\n  const prepared = prepareBendGuide(guide);\n  if (p.overflow === 'wrap' && !prepared.closed)\n    throw new RangeError('wrap requires a closed guide.');\n  return make([\n    (accuracy) => {\n      const measured = measureBendGuide(prepared, accuracy * 4, 1, () => 2);\n      const { length, knots } = measured;\n      const coordinates = knots.map((k) => k.distance),\n        points = knots.map((k) => k.point),\n        normals = knots.map((k) => k.normal);\n      const field = (s: Jet): readonly [Pair, Pair] => {\n        if (s.v[0] >= 0 && s.v[1] <= length)\n          return [\n            evaluatePolyline(coordinates, points, s),\n            evaluatePolyline(coordinates, normals, s),\n          ];\n        const positions = [...points],\n          directions = [...normals],\n          distances = [...coordinates];\n        if (s.v[0] < 0) {\n          const n = normals[0],\n            q = points[0],\n            d = s.v[0];\n          distances.unshift(d);\n          positions.unshift([q[0] + d * n[1], q[1] - d * n[0]]);\n          directions.unshift(n);\n        }\n        if (s.v[1] > length) {\n          const n = normals.at(-1)!,\n            q = points.at(-1)!,\n            d = s.v[1] - length;\n          distances.push(s.v[1]);\n          positions.push([q[0] + d * n[1], q[1] - d * n[0]]);\n          directions.push(n);\n        }\n        return [\n          evaluatePolyline(distances, positions, s),\n          evaluatePolyline(distances, directions, s),\n        ];\n      };\n      const sample = (s: Jet, d: Jet): Pair => {\n        const [q, n] = field(s);\n        return [add(q[0], mul(d, n[0])), add(q[1], mul(d, n[1]))];\n      };\n      return {\n        apply: (path, quality) =>\n          bendPathAlongPath(path, guide, {\n            ...saved,\n            tolerance: quality.tolerance,\n            maxSegments: quality.maxSegments,\n          }),\n        // The measured error bounds unit normal displacement and two units of\n        // length uncertainty. Enlarge for placement, displacement, and wrapped laps.\n        error: (input) => {\n          const [s, d] = distances(p, length, input);\n          return (\n            measured.error *\n            (1 + absI(d.v)) *\n            (2 +\n              absI(s.v) / length +\n              absI(\n                scale(sub(input[0], constant(p.source.x)), 1 / p.source.width)\n                  .v,\n              ))\n          );\n        },\n        domain: (input, margin) => {\n          const [s] = distances(p, length, input);\n          return (\n            p.overflow !== 'error' ||\n            (s.v[0] >= -margin && s.v[1] <= length + margin)\n          );\n        },\n        evaluate: (input) => {\n          const [s, d] = distances(p, length, input);\n          if (p.overflow !== 'wrap') return sample(s, d);\n          const first = Math.floor(s.v[0] / length),\n            last = Math.floor(s.v[1] / length);\n          if (\n            !Number.isSafeInteger(first) ||\n            !Number.isSafeInteger(last) ||\n            last - first > 1024\n          )\n            throw new RangeError('Wrapped bend exceeds its lap budget.');\n          const parts: Pair[] = [];\n          for (let lap = first; lap <= last; lap++)\n            parts.push(\n              sample(\n                {\n                  ...s,\n                  v: [\n                    Math.max(0, s.v[0] - lap * length),\n                    Math.min(length, s.v[1] - lap * length),\n                  ],\n                },\n                d,\n              ),\n            );\n          return parts.length === 1 ? parts[0] : mergePairs(parts);\n        },\n      };\n    },\n  ]);\n}\n"],
+  "mappings": "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",
+  "names": ["distances"]
+}

package/dist/lib/geometry/transform-guide.d.ts

@@ -0,0 +1,57 @@
+import type { MeshTransformOptions } from "./transform-mesh.js";
+import type { EnvelopeGuide, EnvelopeTransformOptions } from "./path-transforms.js";
+import { PathGeometry } from './path-geometry.js';
+import { type BendSpan, type BendPoint } from './path-bend-spans.js';
+import { type Jet, type Pair } from './transform-math.js';
+/**
+ * A station mapping normalized guide position to normalized arc-length distance along its path.
+ *
+ * @see {@link PathGuideOptions}
+ */
+export interface PathGuideStation {
+    /** Normalized station position. See {@link PathGuideStation}. */
+    readonly at: number;
+    /** Normalized arc-length distance from 0 to 1. See {@link PathGuideStation}. */
+    readonly distance: number;
+}
+/**
+ * Geometry and stations that define how a transformation samples a guide.
+ *
+ * @see {@link PathGeometry}
+ * @see {@link PathGuideStation}
+ * @see {@link PathGuide}
+ */
+export interface PathGuideOptions {
+    /** Path geometry used by this operation. See {@link PathGeometry}. */
+    readonly path: PathGeometry;
+    /** Whether to reverse the direction of the mapping or guide. See {@link PathGuideOptions}. */
+    readonly reverse?: boolean;
+    /**
+     * Explicit correspondence between normalized stations and guide distance. See
+     * {@link PathGuideStation}.
+     */
+    readonly stations?: readonly PathGuideStation[];
+}
+/**
+ * A geometry path or a path with explicit guide-sampling configuration.
+ *
+ * @see {@link PathGeometry}
+ * @see {@link PathGuideOptions}
+ * @see {@link MeshTransformOptions}
+ * @see {@link EnvelopeTransformOptions}
+ * @see {@link EnvelopeGuide}
+ */
+export type PathGuide = PathGeometry | PathGuideOptions;
+export interface GuideSnapshot {
+    readonly spans: readonly BendSpan[];
+    readonly reverse: boolean;
+    readonly stations: readonly PathGuideStation[];
+}
+export interface SampledGuide {
+    readonly error: number;
+    readonly length: number;
+    evaluate(t: Jet): Pair;
+}
+export declare function snapshotGuide(input: PathGuide): GuideSnapshot;
+export declare function sampleGuide(snapshot: GuideSnapshot, accuracy: number): SampledGuide;
+export declare function evaluatePolyline(knots: readonly number[], points: readonly BendPoint[], t: Jet): Pair;

package/dist/lib/geometry/transform-guide.js

@@ -0,0 +1,157 @@
+import { PathGeometry } from "./path-geometry.js";
+import {
+  bendSpans,
+  bendSpanPoint,
+  bendSpanBounds,
+  splitBendSpan
+} from "./path-bend-spans.js";
+import {
+  mulI,
+  addI,
+  interval
+} from "./transform-math.js";
+function snapshotGuide(input) {
+  const options = input instanceof PathGeometry ? { path: input } : input;
+  if (!(options?.path instanceof PathGeometry))
+    throw new TypeError("A guide requires PathGeometry.");
+  if (options.reverse !== void 0 && typeof options.reverse !== "boolean")
+    throw new TypeError("reverse must be boolean.");
+  const spans = [];
+  let moves = 0;
+  for (const item of bendSpans(options.path)) {
+    if (item.type === "move") moves++;
+    else if (item.type === "close")
+      throw new RangeError("A guide must be one open contour.");
+    else spans.push(item.span);
+  }
+  if (moves !== 1 || !spans.length)
+    throw new RangeError("A guide must be one nonempty open contour.");
+  const stations = (options.stations ?? [
+    { at: 0, distance: 0 },
+    { at: 1, distance: 1 }
+  ]).map((s) => ({ at: s.at, distance: s.distance }));
+  if (stations.length < 2 || stations[0].at !== 0 || stations[0].distance !== 0 || stations.at(-1).at !== 1 || stations.at(-1).distance !== 1 || stations.some(
+    (s, i) => !Number.isFinite(s.at) || !Number.isFinite(s.distance) || i > 0 && (s.at <= stations[i - 1].at || s.distance <= stations[i - 1].distance)
+  )) {
+    throw new RangeError(
+      "Guide stations must strictly increase from (0,0) to (1,1)."
+    );
+  }
+  return { spans, reverse: options.reverse ?? false, stations };
+}
+function leaf(span) {
+  const a = bendSpanPoint(span, 0), b = bendSpanPoint(span, 1), chord = Math.hypot(b[0] - a[0], b[1] - a[1]);
+  let upper;
+  if ("points" in span)
+    upper = span.points.slice(1).reduce(
+      (n, p, i) => n + Math.hypot(p[0] - span.points[i][0], p[1] - span.points[i][1]),
+      0
+    );
+  else {
+    const arc = span.arc, mid = arc.startAngle + arc.sweep / 2;
+    const speed = Math.abs(arc.sweep) * Math.hypot(
+      -arc.ux * Math.sin(mid) + arc.vx * Math.cos(mid),
+      -arc.uy * Math.sin(mid) + arc.vy * Math.cos(mid)
+    );
+    const bounds = bendSpanBounds(span);
+    upper = speed + Math.hypot(bounds.ddx, bounds.ddy) / 4;
+  }
+  const gap = Math.max(0, upper - chord);
+  const sag = Math.sqrt(gap * (upper + chord)) / 2;
+  return { span, a, b, chord, gap, sag };
+}
+function sampleGuide(snapshot, accuracy) {
+  let leaves = snapshot.spans.map(leaf);
+  let gap, sag;
+  for (let depth = 0; ; depth++) {
+    gap = leaves.reduce((sum, p) => sum + p.gap, 0);
+    sag = leaves.reduce((max, p) => Math.max(max, p.sag), 0);
+    if (sag + 3 * gap <= accuracy) break;
+    if (depth >= 30 || leaves.length > 32768)
+      throw new RangeError("Guide approximation exceeded its work limit.");
+    const share = accuracy / (12 * leaves.length);
+    leaves = leaves.flatMap(
+      (p) => p.gap > share || p.sag > accuracy / 4 ? splitBendSpan(p.span).map(leaf) : [p]
+    );
+  }
+  const length = leaves.reduce((sum, p) => sum + p.chord, 0);
+  if (!(length > 0) || !Number.isFinite(length))
+    throw new RangeError("Guide length must be finite and nonzero.");
+  let distance = 0;
+  const points = [leaves[0].a], knots = [0];
+  for (const p of leaves) {
+    if (!p.chord) continue;
+    distance += p.chord;
+    points.push(p.b);
+    knots.push(distance / length);
+  }
+  knots[knots.length - 1] = 1;
+  if (snapshot.reverse) {
+    points.reverse();
+    knots.reverse();
+    for (let i = 0; i < knots.length; i++) knots[i] = 1 - knots[i];
+  }
+  const stations = snapshot.stations;
+  const remap = (d) => {
+    let i = 0;
+    while (i < stations.length - 2 && d > stations[i + 1].distance) i++;
+    const a = stations[i], b = stations[i + 1];
+    return a.at + (d - a.distance) * (b.at - a.at) / (b.distance - a.distance);
+  };
+  const parameters = [...knots.map(remap), ...stations.map((s) => s.at)].sort((a, b) => a - b).filter((v, i, a) => !i || v !== a[i - 1]);
+  const values = parameters.map((t) => {
+    let j = 0;
+    while (j < stations.length - 2 && t > stations[j + 1].at) j++;
+    const a = stations[j], b = stations[j + 1];
+    const d = a.distance + (t - a.at) * (b.distance - a.distance) / (b.at - a.at);
+    const i = locate(knots, d), f = (d - knots[i]) / (knots[i + 1] - knots[i]);
+    return [
+      points[i][0] + (points[i + 1][0] - points[i][0]) * f,
+      points[i][1] + (points[i + 1][1] - points[i][1]) * f
+    ];
+  });
+  return {
+    error: sag + 3 * gap,
+    length,
+    evaluate: (t) => evaluatePolyline(parameters, values, t)
+  };
+}
+function locate(knots, t) {
+  let lo = 0, hi = knots.length - 1;
+  while (hi - lo > 1) {
+    const mid = lo + hi >>> 1;
+    if (knots[mid] <= t) lo = mid;
+    else hi = mid;
+  }
+  return Math.min(lo, knots.length - 2);
+}
+function evaluatePolyline(knots, points, t) {
+  const first = locate(knots, t.v[0]), last = locate(knots, t.v[1]);
+  return [0, 1].map((axis) => {
+    let low = Infinity, high = -Infinity, slopeLow = Infinity, slopeHigh = -Infinity;
+    for (let i = first; i <= last; i++) {
+      const slope = (points[i + 1][axis] - points[i][axis]) / (knots[i + 1] - knots[i]);
+      const a = i === first ? t.v[0] : knots[i], b = i === last ? t.v[1] : knots[i + 1];
+      const va = points[i][axis] + (a - knots[i]) * slope, vb = points[i][axis] + (b - knots[i]) * slope;
+      low = Math.min(low, va, vb);
+      high = Math.max(high, va, vb);
+      slopeLow = Math.min(slopeLow, slope);
+      slopeHigh = Math.max(slopeHigh, slope);
+    }
+    const slopes = [slopeLow, slopeHigh];
+    return {
+      v: [low, high],
+      d: mulI(slopes, t.d),
+      dd: addI(
+        mulI(slopes, t.dd),
+        first === last || slopeLow === slopeHigh ? interval(0) : [-Infinity, Infinity]
+      )
+    };
+  });
+}
+export {
+  evaluatePolyline,
+  sampleGuide,
+  snapshotGuide
+};
+//# sourceMappingURL=transform-guide.js.map

package/dist/lib/geometry/transform-guide.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/transform-guide.ts"],
+  "sourcesContent": ["import type { MeshTransformOptions } from './transform-mesh.js';\nimport type { EnvelopeGuide, EnvelopeTransformOptions } from './path-transforms.js';\nimport { PathGeometry } from './path-geometry.js';\nimport {\n  bendSpans,\n  bendSpanPoint,\n  bendSpanBounds,\n  splitBendSpan,\n  type BendSpan,\n  type BendPoint,\n} from './path-bend-spans.js';\nimport {\n  type Jet,\n  type Pair,\n  type Interval,\n  mulI,\n  addI,\n  interval,\n} from './transform-math.js';\n\n/**\n * A station mapping normalized guide position to normalized arc-length distance along its path.\n *\n * @see {@link PathGuideOptions}\n */\nexport interface PathGuideStation {\n  /** Normalized station position. See {@link PathGuideStation}. */\n  readonly at: number;\n  /** Normalized arc-length distance from 0 to 1. See {@link PathGuideStation}. */\n  readonly distance: number;\n}\n/**\n * Geometry and stations that define how a transformation samples a guide.\n *\n * @see {@link PathGeometry}\n * @see {@link PathGuideStation}\n * @see {@link PathGuide}\n */\nexport interface PathGuideOptions {\n  /** Path geometry used by this operation. See {@link PathGeometry}. */\n  readonly path: PathGeometry;\n  /** Whether to reverse the direction of the mapping or guide. See {@link PathGuideOptions}. */\n  readonly reverse?: boolean;\n  /**\n   * Explicit correspondence between normalized stations and guide distance. See\n   * {@link PathGuideStation}.\n   */\n  readonly stations?: readonly PathGuideStation[];\n}\n/**\n * A geometry path or a path with explicit guide-sampling configuration.\n *\n * @see {@link PathGeometry}\n * @see {@link PathGuideOptions}\n * @see {@link MeshTransformOptions}\n * @see {@link EnvelopeTransformOptions}\n * @see {@link EnvelopeGuide}\n */\nexport type PathGuide = PathGeometry | PathGuideOptions;\nexport interface GuideSnapshot {\n  readonly spans: readonly BendSpan[];\n  readonly reverse: boolean;\n  readonly stations: readonly PathGuideStation[];\n}\nexport interface SampledGuide {\n  readonly error: number;\n  readonly length: number;\n  evaluate(t: Jet): Pair;\n}\nexport function snapshotGuide(input: PathGuide): GuideSnapshot {\n  const options = input instanceof PathGeometry ? { path: input } : input;\n  if (!(options?.path instanceof PathGeometry))\n    throw new TypeError('A guide requires PathGeometry.');\n  if (options.reverse !== undefined && typeof options.reverse !== 'boolean')\n    throw new TypeError('reverse must be boolean.');\n  const spans: BendSpan[] = [];\n  let moves = 0;\n  for (const item of bendSpans(options.path)) {\n    if (item.type === 'move') moves++;\n    else if (item.type === 'close')\n      throw new RangeError('A guide must be one open contour.');\n    else spans.push(item.span);\n  }\n  if (moves !== 1 || !spans.length)\n    throw new RangeError('A guide must be one nonempty open contour.');\n  const stations = (\n    options.stations ?? [\n      { at: 0, distance: 0 },\n      { at: 1, distance: 1 },\n    ]\n  ).map((s) => ({ at: s.at, distance: s.distance }));\n  if (\n    stations.length < 2 ||\n    stations[0].at !== 0 ||\n    stations[0].distance !== 0 ||\n    stations.at(-1)!.at !== 1 ||\n    stations.at(-1)!.distance !== 1 ||\n    stations.some(\n      (s, i) =>\n        !Number.isFinite(s.at) ||\n        !Number.isFinite(s.distance) ||\n        (i > 0 &&\n          (s.at <= stations[i - 1].at ||\n            s.distance <= stations[i - 1].distance)),\n    )\n  ) {\n    throw new RangeError(\n      'Guide stations must strictly increase from (0,0) to (1,1).',\n    );\n  }\n  return { spans, reverse: options.reverse ?? false, stations };\n}\n\ninterface Leaf {\n  span: BendSpan;\n  a: BendPoint;\n  b: BendPoint;\n  chord: number;\n  gap: number;\n  sag: number;\n}\nfunction leaf(span: BendSpan): Leaf {\n  const a = bendSpanPoint(span, 0),\n    b = bendSpanPoint(span, 1),\n    chord = Math.hypot(b[0] - a[0], b[1] - a[1]);\n  let upper: number;\n  if ('points' in span)\n    upper = span.points\n      .slice(1)\n      .reduce(\n        (n, p, i) =>\n          n + Math.hypot(p[0] - span.points[i][0], p[1] - span.points[i][1]),\n        0,\n      );\n  else {\n    const arc = span.arc,\n      mid = arc.startAngle + arc.sweep / 2;\n    const speed =\n      Math.abs(arc.sweep) *\n      Math.hypot(\n        -arc.ux * Math.sin(mid) + arc.vx * Math.cos(mid),\n        -arc.uy * Math.sin(mid) + arc.vy * Math.cos(mid),\n      );\n    const bounds = bendSpanBounds(span);\n    upper = speed + Math.hypot(bounds.ddx, bounds.ddy) / 4;\n  }\n  const gap = Math.max(0, upper - chord);\n  // Every point lies in the ellipse with these endpoints and total distance <= upper.\n  const sag = Math.sqrt(gap * (upper + chord)) / 2;\n  return { span, a, b, chord, gap, sag };\n}\n\nexport function sampleGuide(\n  snapshot: GuideSnapshot,\n  accuracy: number,\n): SampledGuide {\n  let leaves = snapshot.spans.map(leaf);\n  let gap: number, sag: number;\n  for (let depth = 0; ; depth++) {\n    gap = leaves.reduce((sum, p) => sum + p.gap, 0);\n    sag = leaves.reduce((max, p) => Math.max(max, p.sag), 0);\n    if (sag + 3 * gap <= accuracy) break;\n    if (depth >= 30 || leaves.length > 32768)\n      throw new RangeError('Guide approximation exceeded its work limit.');\n    const share = accuracy / (12 * leaves.length);\n    leaves = leaves.flatMap((p) =>\n      p.gap > share || p.sag > accuracy / 4\n        ? splitBendSpan(p.span).map(leaf)\n        : [p],\n    );\n  }\n  const length = leaves.reduce((sum, p) => sum + p.chord, 0);\n  if (!(length > 0) || !Number.isFinite(length))\n    throw new RangeError('Guide length must be finite and nonzero.');\n  let distance = 0;\n  const points: BendPoint[] = [leaves[0].a],\n    knots = [0];\n  for (const p of leaves) {\n    if (!p.chord) continue;\n    distance += p.chord;\n    points.push(p.b);\n    knots.push(distance / length);\n  }\n  knots[knots.length - 1] = 1;\n  if (snapshot.reverse) {\n    points.reverse();\n    knots.reverse();\n    for (let i = 0; i < knots.length; i++) knots[i] = 1 - knots[i];\n  }\n  const stations = snapshot.stations;\n  const remap = (d: number) => {\n    let i = 0;\n    while (i < stations.length - 2 && d > stations[i + 1].distance) i++;\n    const a = stations[i],\n      b = stations[i + 1];\n    return (\n      a.at + ((d - a.distance) * (b.at - a.at)) / (b.distance - a.distance)\n    );\n  };\n  // Include correspondence breaks, not just geometric polyline vertices.\n  const parameters = [...knots.map(remap), ...stations.map((s) => s.at)]\n    .sort((a, b) => a - b)\n    .filter((v, i, a) => !i || v !== a[i - 1]);\n  const values = parameters.map((t) => {\n    let j = 0;\n    while (j < stations.length - 2 && t > stations[j + 1].at) j++;\n    const a = stations[j],\n      b = stations[j + 1];\n    const d =\n      a.distance + ((t - a.at) * (b.distance - a.distance)) / (b.at - a.at);\n    const i = locate(knots, d),\n      f = (d - knots[i]) / (knots[i + 1] - knots[i]);\n    return [\n      points[i][0] + (points[i + 1][0] - points[i][0]) * f,\n      points[i][1] + (points[i + 1][1] - points[i][1]) * f,\n    ] as BendPoint;\n  });\n  return {\n    error: sag + 3 * gap,\n    length,\n    evaluate: (t) => evaluatePolyline(parameters, values, t),\n  };\n}\nfunction locate(knots: readonly number[], t: number): number {\n  let lo = 0,\n    hi = knots.length - 1;\n  while (hi - lo > 1) {\n    const mid = (lo + hi) >>> 1;\n    if (knots[mid] <= t) lo = mid;\n    else hi = mid;\n  }\n  return Math.min(lo, knots.length - 2);\n}\nexport function evaluatePolyline(\n  knots: readonly number[],\n  points: readonly BendPoint[],\n  t: Jet,\n): Pair {\n  const first = locate(knots, t.v[0]),\n    last = locate(knots, t.v[1]);\n  return [0, 1].map((axis) => {\n    let low = Infinity,\n      high = -Infinity,\n      slopeLow = Infinity,\n      slopeHigh = -Infinity;\n    for (let i = first; i <= last; i++) {\n      const slope =\n        (points[i + 1][axis] - points[i][axis]) / (knots[i + 1] - knots[i]);\n      const a = i === first ? t.v[0] : knots[i],\n        b = i === last ? t.v[1] : knots[i + 1];\n      const va = points[i][axis] + (a - knots[i]) * slope,\n        vb = points[i][axis] + (b - knots[i]) * slope;\n      low = Math.min(low, va, vb);\n      high = Math.max(high, va, vb);\n      slopeLow = Math.min(slopeLow, slope);\n      slopeHigh = Math.max(slopeHigh, slope);\n    }\n    const slopes: Interval = [slopeLow, slopeHigh];\n    return {\n      v: [low, high] as Interval,\n      d: mulI(slopes, t.d),\n      dd: addI(\n        mulI(slopes, t.dd),\n        first === last || slopeLow === slopeHigh\n          ? interval(0)\n          : [-Infinity, Infinity],\n      ),\n    };\n  }) as unknown as Pair;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/geometry/transform-math.d.ts

@@ -0,0 +1,21 @@
+/** Interval automatic differentiation of an approximating map, along a source span. */
+export type Interval = readonly [number, number];
+export interface Jet {
+    v: Interval;
+    d: Interval;
+    dd: Interval;
+}
+export type Pair = readonly [Jet, Jet];
+export declare const interval: (n: number) => Interval;
+export declare const addI: (a: Interval, b: Interval) => Interval;
+export declare const negI: (a: Interval) => Interval;
+export declare const mulI: (a: Interval, b: Interval) => Interval;
+export declare const absI: (a: Interval) => number;
+export declare const constant: (n: number) => Jet;
+export declare const add: (a: Jet, b: Jet) => Jet;
+export declare const scale: (a: Jet, n: number) => Jet;
+export declare const sub: (a: Jet, b: Jet) => Jet;
+export declare const mul: (a: Jet, b: Jet) => Jet;
+export declare const lerp: (a: Jet, b: Jet, t: Jet) => Jet;
+export declare function reciprocal(a: Jet): Jet;
+export declare function trig(a: Jet, cosine?: boolean): Jet;

package/dist/lib/geometry/transform-math.js

@@ -0,0 +1,91 @@
+const interval = (n) => [n, n];
+const addI = (a, b) => [
+  a[0] + b[0],
+  a[1] + b[1]
+];
+const negI = (a) => [-a[1], -a[0]];
+const mulI = (a, b) => {
+  if (a[0] === 0 && a[1] === 0 || b[0] === 0 && b[1] === 0) return [0, 0];
+  const product = (x, y) => x === 0 || y === 0 ? 0 : x * y;
+  const p = [
+    product(a[0], b[0]),
+    product(a[0], b[1]),
+    product(a[1], b[0]),
+    product(a[1], b[1])
+  ];
+  return [Math.min(...p), Math.max(...p)];
+};
+const absI = (a) => Math.max(Math.abs(a[0]), Math.abs(a[1]));
+const constant = (n) => ({
+  v: interval(n),
+  d: interval(0),
+  dd: interval(0)
+});
+const add = (a, b) => ({
+  v: addI(a.v, b.v),
+  d: addI(a.d, b.d),
+  dd: addI(a.dd, b.dd)
+});
+const scale = (a, n) => ({
+  v: mulI(a.v, interval(n)),
+  d: mulI(a.d, interval(n)),
+  dd: mulI(a.dd, interval(n))
+});
+const sub = (a, b) => add(a, scale(b, -1));
+const mul = (a, b) => ({
+  v: mulI(a.v, b.v),
+  d: addI(mulI(a.d, b.v), mulI(a.v, b.d)),
+  dd: addI(
+    addI(mulI(a.dd, b.v), mulI(a.v, b.dd)),
+    mulI(interval(2), mulI(a.d, b.d))
+  )
+});
+const lerp = (a, b, t) => add(a, mul(sub(b, a), t));
+function reciprocal(a) {
+  if (a.v[0] <= 0 && a.v[1] >= 0)
+    return {
+      v: [-Infinity, Infinity],
+      d: [-Infinity, Infinity],
+      dd: [-Infinity, Infinity]
+    };
+  const r = [1 / a.v[1], 1 / a.v[0]];
+  const r2 = mulI(r, r), r3 = mulI(r2, r);
+  return {
+    v: r,
+    d: negI(mulI(a.d, r2)),
+    dd: addI(mulI(interval(2), mulI(mulI(a.d, a.d), r3)), negI(mulI(a.dd, r2)))
+  };
+}
+function trig(a, cosine = false) {
+  function range(v2, cos) {
+    if (!v2.every(Number.isFinite) || v2[1] - v2[0] >= Math.PI * 2 || absI(v2) > 2 ** 48)
+      return [-1, 1];
+    const f = cos ? Math.cos : Math.sin, offset = cos ? 0 : Math.PI / 2;
+    const values = [f(v2[0]), f(v2[1])];
+    for (let k = Math.ceil((v2[0] - offset) / Math.PI); k <= Math.floor((v2[1] - offset) / Math.PI); k++)
+      values.push(k % 2 ? -1 : 1);
+    return [Math.min(...values), Math.max(...values)];
+  }
+  const v = range(a.v, cosine), first = cosine ? negI(range(a.v, false)) : range(a.v, true);
+  return {
+    v,
+    d: mulI(first, a.d),
+    dd: addI(mulI(negI(v), mulI(a.d, a.d)), mulI(first, a.dd))
+  };
+}
+export {
+  absI,
+  add,
+  addI,
+  constant,
+  interval,
+  lerp,
+  mul,
+  mulI,
+  negI,
+  reciprocal,
+  scale,
+  sub,
+  trig
+};
+//# sourceMappingURL=transform-math.js.map

package/dist/lib/geometry/transform-math.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/geometry/transform-math.ts"],
+  "sourcesContent": ["/** Interval automatic differentiation of an approximating map, along a source span. */\nexport type Interval = readonly [number, number];\nexport interface Jet {\n  v: Interval;\n  d: Interval;\n  dd: Interval;\n}\nexport type Pair = readonly [Jet, Jet];\nexport const interval = (n: number): Interval => [n, n];\nexport const addI = (a: Interval, b: Interval): Interval => [\n  a[0] + b[0],\n  a[1] + b[1],\n];\nexport const negI = (a: Interval): Interval => [-a[1], -a[0]];\nexport const mulI = (a: Interval, b: Interval): Interval => {\n  if ((a[0] === 0 && a[1] === 0) || (b[0] === 0 && b[1] === 0)) return [0, 0];\n  const product = (x: number, y: number) => (x === 0 || y === 0 ? 0 : x * y);\n  const p = [\n    product(a[0], b[0]),\n    product(a[0], b[1]),\n    product(a[1], b[0]),\n    product(a[1], b[1]),\n  ];\n  return [Math.min(...p), Math.max(...p)];\n};\nexport const absI = (a: Interval) => Math.max(Math.abs(a[0]), Math.abs(a[1]));\nexport const constant = (n: number): Jet => ({\n  v: interval(n),\n  d: interval(0),\n  dd: interval(0),\n});\nexport const add = (a: Jet, b: Jet): Jet => ({\n  v: addI(a.v, b.v),\n  d: addI(a.d, b.d),\n  dd: addI(a.dd, b.dd),\n});\nexport const scale = (a: Jet, n: number): Jet => ({\n  v: mulI(a.v, interval(n)),\n  d: mulI(a.d, interval(n)),\n  dd: mulI(a.dd, interval(n)),\n});\nexport const sub = (a: Jet, b: Jet) => add(a, scale(b, -1));\nexport const mul = (a: Jet, b: Jet): Jet => ({\n  v: mulI(a.v, b.v),\n  d: addI(mulI(a.d, b.v), mulI(a.v, b.d)),\n  dd: addI(\n    addI(mulI(a.dd, b.v), mulI(a.v, b.dd)),\n    mulI(interval(2), mulI(a.d, b.d)),\n  ),\n});\nexport const lerp = (a: Jet, b: Jet, t: Jet) => add(a, mul(sub(b, a), t));\nexport function reciprocal(a: Jet): Jet {\n  if (a.v[0] <= 0 && a.v[1] >= 0)\n    return {\n      v: [-Infinity, Infinity],\n      d: [-Infinity, Infinity],\n      dd: [-Infinity, Infinity],\n    };\n  const r: Interval = [1 / a.v[1], 1 / a.v[0]];\n  const r2 = mulI(r, r),\n    r3 = mulI(r2, r);\n  return {\n    v: r,\n    d: negI(mulI(a.d, r2)),\n    dd: addI(mulI(interval(2), mulI(mulI(a.d, a.d), r3)), negI(mulI(a.dd, r2))),\n  };\n}\nexport function trig(a: Jet, cosine = false): Jet {\n  function range(v: Interval, cos: boolean): Interval {\n    if (\n      !v.every(Number.isFinite) ||\n      v[1] - v[0] >= Math.PI * 2 ||\n      absI(v) > 2 ** 48\n    )\n      return [-1, 1];\n    const f = cos ? Math.cos : Math.sin,\n      offset = cos ? 0 : Math.PI / 2;\n    const values = [f(v[0]), f(v[1])];\n    for (\n      let k = Math.ceil((v[0] - offset) / Math.PI);\n      k <= Math.floor((v[1] - offset) / Math.PI);\n      k++\n    )\n      values.push(k % 2 ? -1 : 1);\n    return [Math.min(...values), Math.max(...values)];\n  }\n  const v = range(a.v, cosine),\n    first = cosine ? negI(range(a.v, false)) : range(a.v, true);\n  return {\n    v,\n    d: mulI(first, a.d),\n    dd: addI(mulI(negI(v), mulI(a.d, a.d)), mulI(first, a.dd)),\n  };\n}\n"],
+  "mappings": "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",
+  "names": ["v"]
+}