@voila.dev/motion 0.0.0-stage → 5.0.113

package/dist/interpolate/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../src/interpolate/number.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE5E"}

package/dist/interpolate/number.js

@@ -0,0 +1,7 @@
+function mixNumber(from, to, progress) {
+  return from + (to - from) * progress;
+}
+export {
+  mixNumber
+};
+//# sourceMappingURL=number.js.map

package/dist/interpolate/number.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/interpolate/number.ts"],
+  "sourcesContent": ["export function mixNumber(from: number, to: number, progress: number): number {\n\treturn from + (to - from) * progress;\n}\n"],
+  "mappings": "AAAO,SAAS,UAAU,MAAc,IAAY,UAA0B;AAC7E,SAAO,QAAQ,KAAK,QAAQ;AAC7B;",
+  "names": []
+}

package/dist/interpolate/object.d.ts

@@ -0,0 +1,5 @@
+type Record_ = Readonly<Record<string, unknown>>;
+/** Key by key over the target's keys; a key the start lacks starts at its target. */
+export declare function mixObject<T extends Record_>(from: T, to: T): (progress: number) => T;
+export {};
+//# sourceMappingURL=object.d.ts.map

package/dist/interpolate/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../src/interpolate/object.ts"],"names":[],"mappings":"AAEA,KAAK,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAEjD,qFAAqF;AACrF,wBAAgB,SAAS,CAAC,CAAC,SAAS,OAAO,EAC1C,IAAI,EAAE,CAAC,EACP,EAAE,EAAE,CAAC,GACH,CAAC,QAAQ,EAAE,MAAM,KAAK,CAAC,CAWzB"}

package/dist/interpolate/object.js

@@ -0,0 +1,17 @@
+import { mix } from "./mix.js";
+function mixObject(from, to) {
+  const mixers = Object.keys(to).map(
+    (key) => [key, mix(key in from ? from[key] : to[key], to[key])]
+  );
+  return (progress) => {
+    const result = {};
+    for (const [key, mixer] of mixers) {
+      result[key] = mixer(progress);
+    }
+    return result;
+  };
+}
+export {
+  mixObject
+};
+//# sourceMappingURL=object.js.map

package/dist/interpolate/object.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/interpolate/object.ts"],
+  "sourcesContent": ["import { mix } from \"#/interpolate/mix.ts\";\n\ntype Record_ = Readonly<Record<string, unknown>>;\n\n/** Key by key over the target's keys; a key the start lacks starts at its target. */\nexport function mixObject<T extends Record_>(\n\tfrom: T,\n\tto: T,\n): (progress: number) => T {\n\tconst mixers = Object.keys(to).map(\n\t\t(key) => [key, mix(key in from ? from[key] : to[key], to[key])] as const,\n\t);\n\treturn (progress) => {\n\t\tconst result: Record<string, unknown> = {};\n\t\tfor (const [key, mixer] of mixers) {\n\t\t\tresult[key] = mixer(progress);\n\t\t}\n\t\treturn result as T;\n\t};\n}\n"],
+  "mappings": "AAAA,SAAS,WAAW;AAKb,SAAS,UACf,MACA,IAC0B;AAC1B,QAAM,SAAS,OAAO,KAAK,EAAE,EAAE;AAAA,IAC9B,CAAC,QAAQ,CAAC,KAAK,IAAI,OAAO,OAAO,KAAK,GAAG,IAAI,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;AAAA,EAC/D;AACA,SAAO,CAAC,aAAa;AACpB,UAAM,SAAkC,CAAC;AACzC,eAAW,CAAC,KAAK,KAAK,KAAK,QAAQ;AAClC,aAAO,GAAG,IAAI,MAAM,QAAQ;AAAA,IAC7B;AACA,WAAO;AAAA,EACR;AACD;",
+  "names": []
+}

package/dist/interpolate/path/flatten.d.ts

@@ -0,0 +1,10 @@
+import type { PathCommand } from "./parse.js";
+export type Point = readonly [number, number];
+/** One subpath as a polyline. */
+export interface Ring {
+    readonly points: readonly Point[];
+    readonly closed: boolean;
+}
+/** Every subpath of a parsed path as a polyline; `tolerance` in path units. */
+export declare function flattenPath(commands: readonly PathCommand[], tolerance?: number): Ring[];
+//# sourceMappingURL=flatten.d.ts.map

package/dist/interpolate/path/flatten.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten.d.ts","sourceRoot":"","sources":["../../../src/interpolate/path/flatten.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE/D,MAAM,MAAM,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE9C,iCAAiC;AACjC,MAAM,WAAW,IAAI;IACpB,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CACzB;AAwID,+EAA+E;AAC/E,wBAAgB,WAAW,CAC1B,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,SAAS,SAAO,GACd,IAAI,EAAE,CAoCR"}

package/dist/interpolate/path/flatten.js

@@ -0,0 +1,135 @@
+const MAX_SEGMENTS = 256;
+function segmentsFor(bend, tolerance) {
+  return Math.min(
+    MAX_SEGMENTS,
+    Math.max(1, Math.ceil(Math.sqrt(0.75 * bend / tolerance)))
+  );
+}
+function cubic(from, values, tolerance) {
+  const [x1, y1, x2, y2, x, y] = values;
+  const [x0, y0] = from;
+  const bend = Math.max(
+    Math.hypot(x0 - 2 * x1 + x2, y0 - 2 * y1 + y2),
+    Math.hypot(x1 - 2 * x2 + x, y1 - 2 * y2 + y)
+  );
+  const count = segmentsFor(bend, tolerance);
+  return Array.from({ length: count }, (_unused, index) => {
+    const t = (index + 1) / count;
+    const u = 1 - t;
+    const [a, b, c, d] = [u * u * u, 3 * u * u * t, 3 * u * t * t, t * t * t];
+    return [a * x0 + b * x1 + c * x2 + d * x, a * y0 + b * y1 + c * y2 + d * y];
+  });
+}
+function quadratic(from, values, tolerance) {
+  const [x1, y1, x, y] = values;
+  const [x0, y0] = from;
+  const count = segmentsFor(
+    Math.hypot(x0 - 2 * x1 + x, y0 - 2 * y1 + y) / 3,
+    tolerance
+  );
+  return Array.from({ length: count }, (_unused, index) => {
+    const t = (index + 1) / count;
+    const u = 1 - t;
+    return [
+      u * u * x0 + 2 * u * t * x1 + t * t * x,
+      u * u * y0 + 2 * u * t * y1 + t * t * y
+    ];
+  });
+}
+function angleBetween(ux, uy, vx, vy) {
+  return Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+}
+function arc(from, values, tolerance) {
+  const [rxIn, ryIn, degrees, large, sweep, x2, y2] = values;
+  const [x1, y1] = from;
+  if (rxIn === 0 || ryIn === 0) {
+    return [[x2, y2]];
+  }
+  const phi = degrees * Math.PI / 180;
+  const [cos, sin] = [Math.cos(phi), Math.sin(phi)];
+  const dx = (x1 - x2) / 2;
+  const dy = (y1 - y2) / 2;
+  const x1p = cos * dx + sin * dy;
+  const y1p = -sin * dx + cos * dy;
+  const scale = Math.max(
+    1,
+    Math.sqrt(x1p * x1p / (rxIn * rxIn) + y1p * y1p / (ryIn * ryIn))
+  );
+  const rx = Math.abs(rxIn) * scale;
+  const ry = Math.abs(ryIn) * scale;
+  const numerator = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
+  const denominator = rx * rx * y1p * y1p + ry * ry * x1p * x1p;
+  const coefficient = (large === sweep ? -1 : 1) * Math.sqrt(Math.max(0, numerator / (denominator || 1)));
+  const cxp = coefficient * rx * y1p / ry;
+  const cyp = -coefficient * ry * x1p / rx;
+  const cx = cos * cxp - sin * cyp + (x1 + x2) / 2;
+  const cy = sin * cxp + cos * cyp + (y1 + y2) / 2;
+  const start = angleBetween(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry);
+  let delta = angleBetween(
+    (x1p - cxp) / rx,
+    (y1p - cyp) / ry,
+    (-x1p - cxp) / rx,
+    (-y1p - cyp) / ry
+  );
+  if (sweep === 0 && delta > 0) {
+    delta -= 2 * Math.PI;
+  }
+  if (sweep === 1 && delta < 0) {
+    delta += 2 * Math.PI;
+  }
+  const radius = Math.max(rx, ry);
+  const step = 2 * Math.acos(Math.max(-1, 1 - tolerance / radius));
+  const count = Math.min(
+    MAX_SEGMENTS,
+    Math.max(1, Math.ceil(Math.abs(delta) / step))
+  );
+  return Array.from({ length: count }, (_unused, index) => {
+    if (index === count - 1) {
+      return [x2, y2];
+    }
+    const theta = start + delta * (index + 1) / count;
+    const [c, s] = [Math.cos(theta), Math.sin(theta)];
+    return [cx + rx * c * cos - ry * s * sin, cy + rx * c * sin + ry * s * cos];
+  });
+}
+const CURVES = { C: cubic, Q: quadratic, A: arc };
+function flattenPath(commands, tolerance = 0.25) {
+  const rings = [];
+  let current = {
+    points: [],
+    closed: false
+  };
+  let start = [0, 0];
+  for (const command of commands) {
+    if (command.type === "M" || current.closed) {
+      start = command.type === "M" ? command.values : start;
+      current = { points: [start], closed: false };
+      rings.push(current);
+    }
+    const last = current.points[current.points.length - 1];
+    switch (command.type) {
+      case "M":
+        break;
+      case "L":
+        current.points.push(command.values);
+        break;
+      case "Z":
+        current.closed = true;
+        break;
+      default:
+        current.points.push(
+          ...CURVES[command.type](last, command.values, tolerance)
+        );
+    }
+  }
+  return rings.map(({ points, closed }) => {
+    const first = points[0];
+    const end = points[points.length - 1];
+    const repeats = closed && points.length > 1 && first[0] === end[0] && first[1] === end[1];
+    return { points: repeats ? points.slice(0, -1) : points, closed };
+  });
+}
+export {
+  flattenPath
+};
+//# sourceMappingURL=flatten.js.map

package/dist/interpolate/path/flatten.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/interpolate/path/flatten.ts"],
+  "sourcesContent": ["import type { PathCommand } from \"#/interpolate/path/parse.ts\";\n\nexport type Point = readonly [number, number];\n\n/** One subpath as a polyline. */\nexport interface Ring {\n\treadonly points: readonly Point[];\n\treadonly closed: boolean;\n}\n\nconst MAX_SEGMENTS = 256;\n\n/** Enough segments that no chord strays more than `tolerance` from its curve. */\nfunction segmentsFor(bend: number, tolerance: number): number {\n\treturn Math.min(\n\t\tMAX_SEGMENTS,\n\t\tMath.max(1, Math.ceil(Math.sqrt((0.75 * bend) / tolerance))),\n\t);\n}\n\nfunction cubic(\n\tfrom: Point,\n\tvalues: readonly number[],\n\ttolerance: number,\n): Point[] {\n\tconst [x1, y1, x2, y2, x, y] = values as [\n\t\tnumber,\n\t\tnumber,\n\t\tnumber,\n\t\tnumber,\n\t\tnumber,\n\t\tnumber,\n\t];\n\tconst [x0, y0] = from;\n\tconst bend = Math.max(\n\t\tMath.hypot(x0 - 2 * x1 + x2, y0 - 2 * y1 + y2),\n\t\tMath.hypot(x1 - 2 * x2 + x, y1 - 2 * y2 + y),\n\t);\n\tconst count = segmentsFor(bend, tolerance);\n\treturn Array.from({ length: count }, (_unused, index) => {\n\t\tconst t = (index + 1) / count;\n\t\tconst u = 1 - t;\n\t\tconst [a, b, c, d] = [u * u * u, 3 * u * u * t, 3 * u * t * t, t * t * t];\n\t\treturn [a * x0 + b * x1 + c * x2 + d * x, a * y0 + b * y1 + c * y2 + d * y];\n\t});\n}\n\nfunction quadratic(\n\tfrom: Point,\n\tvalues: readonly number[],\n\ttolerance: number,\n): Point[] {\n\tconst [x1, y1, x, y] = values as [number, number, number, number];\n\tconst [x0, y0] = from;\n\tconst count = segmentsFor(\n\t\tMath.hypot(x0 - 2 * x1 + x, y0 - 2 * y1 + y) / 3,\n\t\ttolerance,\n\t);\n\treturn Array.from({ length: count }, (_unused, index) => {\n\t\tconst t = (index + 1) / count;\n\t\tconst u = 1 - t;\n\t\treturn [\n\t\t\tu * u * x0 + 2 * u * t * x1 + t * t * x,\n\t\t\tu * u * y0 + 2 * u * t * y1 + t * t * y,\n\t\t];\n\t});\n}\n\nfunction angleBetween(ux: number, uy: number, vx: number, vy: number): number {\n\treturn Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);\n}\n\n/** SVG's endpoint arc, converted to its centre form (SVG 1.1, appendix F.6.5). */\nfunction arc(\n\tfrom: Point,\n\tvalues: readonly number[],\n\ttolerance: number,\n): Point[] {\n\tconst [rxIn, ryIn, degrees, large, sweep, x2, y2] = values as [\n\t\tnumber,\n\t\tnumber,\n\t\tnumber,\n\t\tnumber,\n\t\tnumber,\n\t\tnumber,\n\t\tnumber,\n\t];\n\tconst [x1, y1] = from;\n\tif (rxIn === 0 || ryIn === 0) {\n\t\treturn [[x2, y2]];\n\t}\n\tconst phi = (degrees * Math.PI) / 180;\n\tconst [cos, sin] = [Math.cos(phi), Math.sin(phi)];\n\tconst dx = (x1 - x2) / 2;\n\tconst dy = (y1 - y2) / 2;\n\tconst x1p = cos * dx + sin * dy;\n\tconst y1p = -sin * dx + cos * dy;\n\tconst scale = Math.max(\n\t\t1,\n\t\tMath.sqrt((x1p * x1p) / (rxIn * rxIn) + (y1p * y1p) / (ryIn * ryIn)),\n\t);\n\tconst rx = Math.abs(rxIn) * scale;\n\tconst ry = Math.abs(ryIn) * scale;\n\tconst numerator =\n\t\trx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;\n\tconst denominator = rx * rx * y1p * y1p + ry * ry * x1p * x1p;\n\tconst coefficient =\n\t\t(large === sweep ? -1 : 1) *\n\t\tMath.sqrt(Math.max(0, numerator / (denominator || 1)));\n\tconst cxp = (coefficient * rx * y1p) / ry;\n\tconst cyp = (-coefficient * ry * x1p) / rx;\n\tconst cx = cos * cxp - sin * cyp + (x1 + x2) / 2;\n\tconst cy = sin * cxp + cos * cyp + (y1 + y2) / 2;\n\tconst start = angleBetween(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry);\n\tlet delta = angleBetween(\n\t\t(x1p - cxp) / rx,\n\t\t(y1p - cyp) / ry,\n\t\t(-x1p - cxp) / rx,\n\t\t(-y1p - cyp) / ry,\n\t);\n\tif (sweep === 0 && delta > 0) {\n\t\tdelta -= 2 * Math.PI;\n\t}\n\tif (sweep === 1 && delta < 0) {\n\t\tdelta += 2 * Math.PI;\n\t}\n\tconst radius = Math.max(rx, ry);\n\tconst step = 2 * Math.acos(Math.max(-1, 1 - tolerance / radius));\n\tconst count = Math.min(\n\t\tMAX_SEGMENTS,\n\t\tMath.max(1, Math.ceil(Math.abs(delta) / step)),\n\t);\n\treturn Array.from({ length: count }, (_unused, index): Point => {\n\t\tif (index === count - 1) {\n\t\t\treturn [x2, y2];\n\t\t}\n\t\tconst theta = start + (delta * (index + 1)) / count;\n\t\tconst [c, s] = [Math.cos(theta), Math.sin(theta)];\n\t\treturn [cx + rx * c * cos - ry * s * sin, cy + rx * c * sin + ry * s * cos];\n\t});\n}\n\nconst CURVES = { C: cubic, Q: quadratic, A: arc } as const;\n\n/** Every subpath of a parsed path as a polyline; `tolerance` in path units. */\nexport function flattenPath(\n\tcommands: readonly PathCommand[],\n\ttolerance = 0.25,\n): Ring[] {\n\tconst rings: { points: Point[]; closed: boolean }[] = [];\n\tlet current: { points: Point[]; closed: boolean } = {\n\t\tpoints: [],\n\t\tclosed: false,\n\t};\n\tlet start: Point = [0, 0];\n\tfor (const command of commands) {\n\t\tif (command.type === \"M\" || current.closed) {\n\t\t\tstart = command.type === \"M\" ? command.values : start;\n\t\t\tcurrent = { points: [start], closed: false };\n\t\t\trings.push(current);\n\t\t}\n\t\tconst last = current.points[current.points.length - 1] as Point;\n\t\tswitch (command.type) {\n\t\t\tcase \"M\":\n\t\t\t\tbreak;\n\t\t\tcase \"L\":\n\t\t\t\tcurrent.points.push(command.values);\n\t\t\t\tbreak;\n\t\t\tcase \"Z\":\n\t\t\t\tcurrent.closed = true;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tcurrent.points.push(\n\t\t\t\t\t...CURVES[command.type](last, command.values, tolerance),\n\t\t\t\t);\n\t\t}\n\t}\n\treturn rings.map(({ points, closed }) => {\n\t\tconst first = points[0] as Point;\n\t\tconst end = points[points.length - 1] as Point;\n\t\tconst repeats =\n\t\t\tclosed && points.length > 1 && first[0] === end[0] && first[1] === end[1];\n\t\treturn { points: repeats ? points.slice(0, -1) : points, closed };\n\t});\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/interpolate/path/morph.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A path between two paths. Same commands: the numbers mix, exactly. Any
+ * other pair is flattened to polylines, each subpath resampled to a shared
+ * point count by arc length, paired with its nearest counterpart and turned
+ * to line up with it, so every frame is a valid path that moves as little as
+ * it can. The ends are the input strings themselves.
+ */
+export declare function mixPath(from: string, to: string): (progress: number) => string;
+//# sourceMappingURL=morph.d.ts.map

package/dist/interpolate/path/morph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"morph.d.ts","sourceRoot":"","sources":["../../../src/interpolate/path/morph.ts"],"names":[],"mappings":"AAmEA;;;;;;GAMG;AACH,wBAAgB,OAAO,CACtB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACR,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAsB9B"}

package/dist/interpolate/path/morph.js

@@ -0,0 +1,72 @@
+import { mixComplex } from "../complex.js";
+import {
+  flattenPath
+} from "./flatten.js";
+import { parsePath } from "./parse.js";
+import {
+  alignRing,
+  centroid,
+  matchRings,
+  resample
+} from "./rings.js";
+const MIN_POINTS = 16;
+const MAX_POINTS = 512;
+function round(value) {
+  return Math.round(value * 100) / 100;
+}
+function collapsed(ring, count) {
+  return Array.from({ length: count }, () => centroid(ring.points));
+}
+function track(from, to) {
+  const reference = from ?? to;
+  const count = Math.min(
+    MAX_POINTS,
+    Math.max(MIN_POINTS, from?.points.length ?? 0, to?.points.length ?? 0)
+  );
+  const start = from === void 0 ? collapsed(reference, count) : resample(from, count);
+  const end = to === void 0 ? collapsed(reference, count) : resample(to, count);
+  const closed = (from?.closed ?? true) && (to?.closed ?? true);
+  return {
+    from: start,
+    to: alignRing(start, end, closed),
+    closedFrom: from?.closed ?? reference.closed,
+    closedTo: to?.closed ?? reference.closed
+  };
+}
+function draw(tracks, progress) {
+  return tracks.map(({ from, to, closedFrom, closedTo }) => {
+    const points = from.map((point, index) => {
+      const other = to[index];
+      const x = round(point[0] + (other[0] - point[0]) * progress);
+      const y = round(point[1] + (other[1] - point[1]) * progress);
+      return `${x},${y}`;
+    });
+    const closed = progress < 0.5 ? closedFrom : closedTo;
+    return `M${points.join("L")}${closed ? "Z" : ""}`;
+  }).join("");
+}
+function mixPath(from, to) {
+  const hasArcs = /a/i.test(from) || /a/i.test(to);
+  const same = from === to ? () => from : hasArcs ? void 0 : mixComplex(from, to);
+  if (same !== void 0) {
+    return same;
+  }
+  const start = parsePath(from);
+  const end = parsePath(to);
+  if (start === void 0 || end === void 0) {
+    return (progress) => progress < 0.5 ? from : to;
+  }
+  const tracks = matchRings(flattenPath(start), flattenPath(end)).map(
+    ([a, b]) => track(a, b)
+  );
+  return (progress) => {
+    if (progress === 0) {
+      return from;
+    }
+    return progress === 1 ? to : draw(tracks, progress);
+  };
+}
+export {
+  mixPath
+};
+//# sourceMappingURL=morph.js.map

package/dist/interpolate/path/morph.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/interpolate/path/morph.ts"],
+  "sourcesContent": ["import { mixComplex } from \"#/interpolate/complex.ts\";\nimport {\n\tflattenPath,\n\ttype Point,\n\ttype Ring,\n} from \"#/interpolate/path/flatten.ts\";\nimport { parsePath } from \"#/interpolate/path/parse.ts\";\nimport {\n\talignRing,\n\tcentroid,\n\tmatchRings,\n\tresample,\n} from \"#/interpolate/path/rings.ts\";\n\nconst MIN_POINTS = 16;\nconst MAX_POINTS = 512;\n\ninterface Track {\n\treadonly from: readonly Point[];\n\treadonly to: readonly Point[];\n\treadonly closedFrom: boolean;\n\treadonly closedTo: boolean;\n}\n\nfunction round(value: number): number {\n\treturn Math.round(value * 100) / 100;\n}\n\n/** A ring that does not exist on one side is that side's centroid, repeated. */\nfunction collapsed(ring: Ring, count: number): Point[] {\n\treturn Array.from({ length: count }, () => centroid(ring.points));\n}\n\nfunction track(from: Ring | undefined, to: Ring | undefined): Track {\n\tconst reference = (from ?? to) as Ring;\n\tconst count = Math.min(\n\t\tMAX_POINTS,\n\t\tMath.max(MIN_POINTS, from?.points.length ?? 0, to?.points.length ?? 0),\n\t);\n\tconst start =\n\t\tfrom === undefined ? collapsed(reference, count) : resample(from, count);\n\tconst end =\n\t\tto === undefined ? collapsed(reference, count) : resample(to, count);\n\tconst closed = (from?.closed ?? true) && (to?.closed ?? true);\n\treturn {\n\t\tfrom: start,\n\t\tto: alignRing(start, end, closed),\n\t\tclosedFrom: from?.closed ?? reference.closed,\n\t\tclosedTo: to?.closed ?? reference.closed,\n\t};\n}\n\nfunction draw(tracks: readonly Track[], progress: number): string {\n\treturn tracks\n\t\t.map(({ from, to, closedFrom, closedTo }) => {\n\t\t\tconst points = from.map((point, index) => {\n\t\t\t\tconst other = to[index] as Point;\n\t\t\t\tconst x = round(point[0] + (other[0] - point[0]) * progress);\n\t\t\t\tconst y = round(point[1] + (other[1] - point[1]) * progress);\n\t\t\t\treturn `${x},${y}`;\n\t\t\t});\n\t\t\tconst closed = progress < 0.5 ? closedFrom : closedTo;\n\t\t\treturn `M${points.join(\"L\")}${closed ? \"Z\" : \"\"}`;\n\t\t})\n\t\t.join(\"\");\n}\n\n/**\n * A path between two paths. Same commands: the numbers mix, exactly. Any\n * other pair is flattened to polylines, each subpath resampled to a shared\n * point count by arc length, paired with its nearest counterpart and turned\n * to line up with it, so every frame is a valid path that moves as little as\n * it can. The ends are the input strings themselves.\n */\nexport function mixPath(\n\tfrom: string,\n\tto: string,\n): (progress: number) => string {\n\t// Arc flags are 0 or 1: mixed as numbers, they would pass through 0.5.\n\tconst hasArcs = /a/i.test(from) || /a/i.test(to);\n\tconst same =\n\t\tfrom === to ? () => from : hasArcs ? undefined : mixComplex(from, to);\n\tif (same !== undefined) {\n\t\treturn same;\n\t}\n\tconst start = parsePath(from);\n\tconst end = parsePath(to);\n\tif (start === undefined || end === undefined) {\n\t\treturn (progress) => (progress < 0.5 ? from : to);\n\t}\n\tconst tracks = matchRings(flattenPath(start), flattenPath(end)).map(\n\t\t([a, b]) => track(a, b),\n\t);\n\treturn (progress) => {\n\t\tif (progress === 0) {\n\t\t\treturn from;\n\t\t}\n\t\treturn progress === 1 ? to : draw(tracks, progress);\n\t};\n}\n"],
+  "mappings": "AAAA,SAAS,kBAAkB;AAC3B;AAAA,EACC;AAAA,OAGM;AACP,SAAS,iBAAiB;AAC1B;AAAA,EACC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACM;AAEP,MAAM,aAAa;AACnB,MAAM,aAAa;AASnB,SAAS,MAAM,OAAuB;AACrC,SAAO,KAAK,MAAM,QAAQ,GAAG,IAAI;AAClC;AAGA,SAAS,UAAU,MAAY,OAAwB;AACtD,SAAO,MAAM,KAAK,EAAE,QAAQ,MAAM,GAAG,MAAM,SAAS,KAAK,MAAM,CAAC;AACjE;AAEA,SAAS,MAAM,MAAwB,IAA6B;AACnE,QAAM,YAAa,QAAQ;AAC3B,QAAM,QAAQ,KAAK;AAAA,IAClB;AAAA,IACA,KAAK,IAAI,YAAY,MAAM,OAAO,UAAU,GAAG,IAAI,OAAO,UAAU,CAAC;AAAA,EACtE;AACA,QAAM,QACL,SAAS,SAAY,UAAU,WAAW,KAAK,IAAI,SAAS,MAAM,KAAK;AACxE,QAAM,MACL,OAAO,SAAY,UAAU,WAAW,KAAK,IAAI,SAAS,IAAI,KAAK;AACpE,QAAM,UAAU,MAAM,UAAU,UAAU,IAAI,UAAU;AACxD,SAAO;AAAA,IACN,MAAM;AAAA,IACN,IAAI,UAAU,OAAO,KAAK,MAAM;AAAA,IAChC,YAAY,MAAM,UAAU,UAAU;AAAA,IACtC,UAAU,IAAI,UAAU,UAAU;AAAA,EACnC;AACD;AAEA,SAAS,KAAK,QAA0B,UAA0B;AACjE,SAAO,OACL,IAAI,CAAC,EAAE,MAAM,IAAI,YAAY,SAAS,MAAM;AAC5C,UAAM,SAAS,KAAK,IAAI,CAAC,OAAO,UAAU;AACzC,YAAM,QAAQ,GAAG,KAAK;AACtB,YAAM,IAAI,MAAM,MAAM,CAAC,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,KAAK,QAAQ;AAC3D,YAAM,IAAI,MAAM,MAAM,CAAC,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,KAAK,QAAQ;AAC3D,aAAO,GAAG,CAAC,IAAI,CAAC;AAAA,IACjB,CAAC;AACD,UAAM,SAAS,WAAW,MAAM,aAAa;AAC7C,WAAO,IAAI,OAAO,KAAK,GAAG,CAAC,GAAG,SAAS,MAAM,EAAE;AAAA,EAChD,CAAC,EACA,KAAK,EAAE;AACV;AASO,SAAS,QACf,MACA,IAC+B;AAE/B,QAAM,UAAU,KAAK,KAAK,IAAI,KAAK,KAAK,KAAK,EAAE;AAC/C,QAAM,OACL,SAAS,KAAK,MAAM,OAAO,UAAU,SAAY,WAAW,MAAM,EAAE;AACrE,MAAI,SAAS,QAAW;AACvB,WAAO;AAAA,EACR;AACA,QAAM,QAAQ,UAAU,IAAI;AAC5B,QAAM,MAAM,UAAU,EAAE;AACxB,MAAI,UAAU,UAAa,QAAQ,QAAW;AAC7C,WAAO,CAAC,aAAc,WAAW,MAAM,OAAO;AAAA,EAC/C;AACA,QAAM,SAAS,WAAW,YAAY,KAAK,GAAG,YAAY,GAAG,CAAC,EAAE;AAAA,IAC/D,CAAC,CAAC,GAAG,CAAC,MAAM,MAAM,GAAG,CAAC;AAAA,EACvB;AACA,SAAO,CAAC,aAAa;AACpB,QAAI,aAAa,GAAG;AACnB,aAAO;AAAA,IACR;AACA,WAAO,aAAa,IAAI,KAAK,KAAK,QAAQ,QAAQ;AAAA,EACnD;AACD;",
+  "names": []
+}

package/dist/interpolate/path/parse.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A path in four commands, all absolute: H and V become L, S and T their full
+ * curves with the reflected control point, so the flattening downstream only
+ * ever meets lines, curves, arcs and closes.
+ */
+export type PathCommand = {
+    readonly type: "M" | "L";
+    readonly values: readonly [number, number];
+} | {
+    readonly type: "C";
+    readonly values: readonly number[];
+} | {
+    readonly type: "Q";
+    readonly values: readonly number[];
+} | {
+    readonly type: "A";
+    readonly values: readonly number[];
+} | {
+    readonly type: "Z";
+    readonly values: readonly [];
+};
+/** Parses `d` to absolute commands; `undefined` when it is not a valid path. */
+export declare function parsePath(d: string): PathCommand[] | undefined;
+//# sourceMappingURL=parse.d.ts.map

package/dist/interpolate/path/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../src/interpolate/path/parse.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,WAAW,GACpB;IAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GACxE;IAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAC1D;IAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAC1D;IAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAC1D;IAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,CAAA;CAAE,CAAC;AA8GxD,gFAAgF;AAChF,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE,GAAG,SAAS,CAwC9D"}

package/dist/interpolate/path/parse.js

@@ -0,0 +1,125 @@
+const ARGUMENTS = {
+  M: 2,
+  L: 2,
+  H: 1,
+  V: 1,
+  C: 6,
+  S: 4,
+  Q: 4,
+  T: 2,
+  A: 7,
+  Z: 0
+};
+const NUMBER = /\s*,?\s*(-?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?)/iy;
+const FLAG = /\s*,?\s*([01])/y;
+const COMMAND = /\s*,?\s*([MLHVCSQTAZ])/iy;
+function reflect(state, curve) {
+  return state.previous === curve ? [2 * state.x - state.controlX, 2 * state.y - state.controlY] : [state.x, state.y];
+}
+function moveTo(state, x, y) {
+  state.x = x;
+  state.y = y;
+}
+const HANDLERS = {
+  M: ([x, y], state) => {
+    moveTo(state, x, y);
+    state.startX = state.x;
+    state.startY = state.y;
+    return { type: "M", values: [state.x, state.y] };
+  },
+  L: ([x, y], state) => {
+    moveTo(state, x, y);
+    return { type: "L", values: [state.x, state.y] };
+  },
+  H: ([x], state) => HANDLERS.L?.([x, state.y], state),
+  V: ([y], state) => HANDLERS.L?.([state.x, y], state),
+  C: (args, state) => {
+    [state.controlX, state.controlY] = [args[2], args[3]];
+    moveTo(state, args[4], args[5]);
+    return { type: "C", values: args };
+  },
+  S: (args, state) => HANDLERS.C?.([...reflect(state, "C"), ...args], state),
+  Q: (args, state) => {
+    [state.controlX, state.controlY] = [args[0], args[1]];
+    moveTo(state, args[2], args[3]);
+    return { type: "Q", values: args };
+  },
+  T: (args, state) => HANDLERS.Q?.([...reflect(state, "Q"), ...args], state),
+  A: (args, state) => {
+    moveTo(state, args[5], args[6]);
+    return { type: "A", values: args };
+  },
+  Z: (_args, state) => {
+    moveTo(state, state.startX, state.startY);
+    return { type: "Z", values: [] };
+  }
+};
+const AXES = {
+  M: [0, 1],
+  L: [0, 1],
+  H: [0],
+  V: [1],
+  C: [0, 1, 0, 1, 0, 1],
+  S: [0, 1, 0, 1],
+  Q: [0, 1, 0, 1],
+  T: [0, 1],
+  A: [-1, -1, -1, -1, -1, 0, 1],
+  Z: []
+};
+const CURVE_FAMILY = { S: "C", T: "Q" };
+function absolute(type, args, state) {
+  const axes = AXES[type];
+  return args.map((value, index) => {
+    const axis = axes[index];
+    return axis === -1 ? value : value + (axis === 0 ? state.x : state.y);
+  });
+}
+function read(pattern, text, at) {
+  pattern.lastIndex = at;
+  const match = pattern.exec(text);
+  return match === null ? void 0 : { value: match[1], end: pattern.lastIndex };
+}
+function parsePath(d) {
+  const state = {
+    x: 0,
+    y: 0,
+    startX: 0,
+    startY: 0,
+    controlX: 0,
+    controlY: 0,
+    previous: ""
+  };
+  const commands = [];
+  let at = 0;
+  let command = read(COMMAND, d, at);
+  if (command === void 0 || command.value.toUpperCase() !== "M") {
+    return void 0;
+  }
+  while (command !== void 0) {
+    at = command.end;
+    let letter = command.value;
+    do {
+      const type = letter.toUpperCase();
+      const args = [];
+      for (let index = 0; index < ARGUMENTS[type]; index += 1) {
+        const flag = type === "A" && (index === 3 || index === 4);
+        const token = read(flag ? FLAG : NUMBER, d, at);
+        if (token === void 0) {
+          return void 0;
+        }
+        args.push(Number(token.value));
+        at = token.end;
+      }
+      const values = letter === type ? args : absolute(type, args, state);
+      commands.push(HANDLERS[type](values, state));
+      state.previous = CURVE_FAMILY[type] ?? type;
+      letter = type === "M" ? letter === "M" ? "L" : "l" : letter;
+    } while (letter.toUpperCase() !== "Z" && read(NUMBER, d, at) !== void 0);
+    command = read(COMMAND, d, at);
+  }
+  return /^\s*$/.test(d.slice(at)) ? commands : void 0;
+}
+export {
+  parsePath
+};
+//# sourceMappingURL=parse.js.map

package/dist/interpolate/path/parse.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/interpolate/path/parse.ts"],
+  "sourcesContent": ["/**\n * A path in four commands, all absolute: H and V become L, S and T their full\n * curves with the reflected control point, so the flattening downstream only\n * ever meets lines, curves, arcs and closes.\n */\nexport type PathCommand =\n\t| { readonly type: \"M\" | \"L\"; readonly values: readonly [number, number] }\n\t| { readonly type: \"C\"; readonly values: readonly number[] }\n\t| { readonly type: \"Q\"; readonly values: readonly number[] }\n\t| { readonly type: \"A\"; readonly values: readonly number[] }\n\t| { readonly type: \"Z\"; readonly values: readonly [] };\n\ninterface State {\n\tx: number;\n\ty: number;\n\tstartX: number;\n\tstartY: number;\n\t/** The last curve's second control point, for S and T to reflect. */\n\tcontrolX: number;\n\tcontrolY: number;\n\tprevious: string;\n}\n\ntype Handler = (args: number[], state: State) => PathCommand;\n\nconst ARGUMENTS: Readonly<Record<string, number>> = {\n\tM: 2,\n\tL: 2,\n\tH: 1,\n\tV: 1,\n\tC: 6,\n\tS: 4,\n\tQ: 4,\n\tT: 2,\n\tA: 7,\n\tZ: 0,\n};\nconst NUMBER = /\\s*,?\\s*(-?(?:\\d+\\.?\\d*|\\.\\d+)(?:e[-+]?\\d+)?)/iy;\nconst FLAG = /\\s*,?\\s*([01])/y;\nconst COMMAND = /\\s*,?\\s*([MLHVCSQTAZ])/iy;\n\nfunction reflect(state: State, curve: string): [number, number] {\n\treturn state.previous === curve\n\t\t? [2 * state.x - state.controlX, 2 * state.y - state.controlY]\n\t\t: [state.x, state.y];\n}\n\nfunction moveTo(state: State, x: number, y: number) {\n\tstate.x = x;\n\tstate.y = y;\n}\n\nconst HANDLERS: Readonly<Record<string, Handler>> = {\n\tM: ([x, y], state) => {\n\t\tmoveTo(state, x as number, y as number);\n\t\tstate.startX = state.x;\n\t\tstate.startY = state.y;\n\t\treturn { type: \"M\", values: [state.x, state.y] };\n\t},\n\tL: ([x, y], state) => {\n\t\tmoveTo(state, x as number, y as number);\n\t\treturn { type: \"L\", values: [state.x, state.y] };\n\t},\n\tH: ([x], state) => HANDLERS.L?.([x as number, state.y], state) as PathCommand,\n\tV: ([y], state) => HANDLERS.L?.([state.x, y as number], state) as PathCommand,\n\tC: (args, state) => {\n\t\t[state.controlX, state.controlY] = [args[2] as number, args[3] as number];\n\t\tmoveTo(state, args[4] as number, args[5] as number);\n\t\treturn { type: \"C\", values: args };\n\t},\n\tS: (args, state) =>\n\t\tHANDLERS.C?.([...reflect(state, \"C\"), ...args], state) as PathCommand,\n\tQ: (args, state) => {\n\t\t[state.controlX, state.controlY] = [args[0] as number, args[1] as number];\n\t\tmoveTo(state, args[2] as number, args[3] as number);\n\t\treturn { type: \"Q\", values: args };\n\t},\n\tT: (args, state) =>\n\t\tHANDLERS.Q?.([...reflect(state, \"Q\"), ...args], state) as PathCommand,\n\tA: (args, state) => {\n\t\tmoveTo(state, args[5] as number, args[6] as number);\n\t\treturn { type: \"A\", values: args };\n\t},\n\tZ: (_args, state) => {\n\t\tmoveTo(state, state.startX, state.startY);\n\t\treturn { type: \"Z\", values: [] };\n\t},\n};\n\n/** Each argument's axis when relative: 0 adds x, 1 adds y, -1 is not a coordinate. */\nconst AXES: Readonly<Record<string, readonly number[]>> = {\n\tM: [0, 1],\n\tL: [0, 1],\n\tH: [0],\n\tV: [1],\n\tC: [0, 1, 0, 1, 0, 1],\n\tS: [0, 1, 0, 1],\n\tQ: [0, 1, 0, 1],\n\tT: [0, 1],\n\tA: [-1, -1, -1, -1, -1, 0, 1],\n\tZ: [],\n};\nconst CURVE_FAMILY: Readonly<Record<string, string>> = { S: \"C\", T: \"Q\" };\n\nfunction absolute(type: string, args: number[], state: State): number[] {\n\tconst axes = AXES[type] as readonly number[];\n\treturn args.map((value, index) => {\n\t\tconst axis = axes[index];\n\t\treturn axis === -1 ? value : value + (axis === 0 ? state.x : state.y);\n\t});\n}\n\nfunction read(pattern: RegExp, text: string, at: number) {\n\tpattern.lastIndex = at;\n\tconst match = pattern.exec(text);\n\treturn match === null\n\t\t? undefined\n\t\t: { value: match[1] as string, end: pattern.lastIndex };\n}\n\n/** Parses `d` to absolute commands; `undefined` when it is not a valid path. */\nexport function parsePath(d: string): PathCommand[] | undefined {\n\tconst state: State = {\n\t\tx: 0,\n\t\ty: 0,\n\t\tstartX: 0,\n\t\tstartY: 0,\n\t\tcontrolX: 0,\n\t\tcontrolY: 0,\n\t\tprevious: \"\",\n\t};\n\tconst commands: PathCommand[] = [];\n\tlet at = 0;\n\tlet command = read(COMMAND, d, at);\n\tif (command === undefined || command.value.toUpperCase() !== \"M\") {\n\t\treturn undefined;\n\t}\n\twhile (command !== undefined) {\n\t\tat = command.end;\n\t\tlet letter = command.value;\n\t\tdo {\n\t\t\tconst type = letter.toUpperCase();\n\t\t\tconst args: number[] = [];\n\t\t\tfor (let index = 0; index < (ARGUMENTS[type] as number); index += 1) {\n\t\t\t\tconst flag = type === \"A\" && (index === 3 || index === 4);\n\t\t\t\tconst token = read(flag ? FLAG : NUMBER, d, at);\n\t\t\t\tif (token === undefined) {\n\t\t\t\t\treturn undefined;\n\t\t\t\t}\n\t\t\t\targs.push(Number(token.value));\n\t\t\t\tat = token.end;\n\t\t\t}\n\t\t\tconst values = letter === type ? args : absolute(type, args, state);\n\t\t\tcommands.push((HANDLERS[type] as Handler)(values, state));\n\t\t\tstate.previous = CURVE_FAMILY[type] ?? type;\n\t\t\t// After a moveto, further pairs are implicit linetos.\n\t\t\tletter = type === \"M\" ? (letter === \"M\" ? \"L\" : \"l\") : letter;\n\t\t} while (letter.toUpperCase() !== \"Z\" && read(NUMBER, d, at) !== undefined);\n\t\tcommand = read(COMMAND, d, at);\n\t}\n\treturn /^\\s*$/.test(d.slice(at)) ? commands : undefined;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/interpolate/path/rings.d.ts

@@ -0,0 +1,13 @@
+import type { Point, Ring } from "./flatten.js";
+/** `count` points evenly spaced by arc length; a closed ring includes its closing edge. */
+export declare function resample(ring: Ring, count: number): Point[];
+export declare function area(points: readonly Point[]): number;
+export declare function centroid(points: readonly Point[]): Point;
+/**
+ * `to` rearranged so each point travels as little as it can to its partner
+ * in `from`: a closed ring may start anywhere and run either way round, an
+ * open one may only run backwards. Both have the same length.
+ */
+export declare function alignRing(from: readonly Point[], to: readonly Point[], closed: boolean): Point[];
+export declare function matchRings(from: readonly Ring[], to: readonly Ring[]): [Ring | undefined, Ring | undefined][];
+//# sourceMappingURL=rings.d.ts.map

package/dist/interpolate/path/rings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rings.d.ts","sourceRoot":"","sources":["../../../src/interpolate/path/rings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,+BAA+B,CAAC;AAMjE,2FAA2F;AAC3F,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,CAkC3D;AAED,wBAAgB,IAAI,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,MAAM,CAOrD;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,KAAK,CAMxD;AAgBD;;;;GAIG;AACH,wBAAgB,SAAS,CACxB,IAAI,EAAE,SAAS,KAAK,EAAE,EACtB,EAAE,EAAE,SAAS,KAAK,EAAE,EACpB,MAAM,EAAE,OAAO,GACb,KAAK,EAAE,CAoBT;AAWD,wBAAgB,UAAU,CACzB,IAAI,EAAE,SAAS,IAAI,EAAE,EACrB,EAAE,EAAE,SAAS,IAAI,EAAE,GACjB,CAAC,IAAI,GAAG,SAAS,EAAE,IAAI,GAAG,SAAS,CAAC,EAAE,CAiCxC"}

package/dist/interpolate/path/rings.js

@@ -0,0 +1,117 @@
+function distance(a, b) {
+  return Math.hypot(a[0] - b[0], a[1] - b[1]);
+}
+function resample(ring, count) {
+  const points = ring.closed ? [...ring.points, ring.points[0]] : ring.points;
+  const lengths = [0];
+  for (let index = 1; index < points.length; index += 1) {
+    lengths.push(
+      lengths[index - 1] + distance(points[index - 1], points[index])
+    );
+  }
+  const total = lengths[lengths.length - 1];
+  if (points.length < 2 || total === 0) {
+    return Array.from({ length: count }, () => points[0]);
+  }
+  const step = total / (ring.closed ? count : Math.max(1, count - 1));
+  const result = [];
+  let segment = 1;
+  for (let index = 0; index < count; index += 1) {
+    const along = Math.min(total, index * step);
+    while (segment < points.length - 1 && lengths[segment] < along) {
+      segment += 1;
+    }
+    const [a, b] = [points[segment - 1], points[segment]];
+    const span = lengths[segment] - lengths[segment - 1];
+    const t = span === 0 ? 0 : (along - lengths[segment - 1]) / span;
+    result.push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]);
+  }
+  return result;
+}
+function area(points) {
+  let sum = 0;
+  points.forEach((point, index) => {
+    const next = points[(index + 1) % points.length];
+    sum += point[0] * next[1] - next[0] * point[1];
+  });
+  return sum / 2;
+}
+function centroid(points) {
+  const sum = points.reduce(
+    (total, [x, y]) => [total[0] + x, total[1] + y],
+    [0, 0]
+  );
+  return [sum[0] / points.length, sum[1] / points.length];
+}
+function cost(a, b, offset) {
+  let sum = 0;
+  for (let index = 0; index < a.length; index += 1) {
+    const other = b[(index + offset) % b.length];
+    const point = a[index];
+    sum += (point[0] - other[0]) ** 2 + (point[1] - other[1]) ** 2;
+  }
+  return sum;
+}
+function alignRing(from, to, closed) {
+  const candidates = [to, [...to].reverse()];
+  let best = {
+    points: to,
+    offset: 0,
+    cost: Number.POSITIVE_INFINITY
+  };
+  for (const points of candidates) {
+    const offsets = closed ? points.length : 1;
+    for (let offset = 0; offset < offsets; offset += 1) {
+      const value = cost(from, points, offset);
+      if (value < best.cost) {
+        best = { points, offset, cost: value };
+      }
+    }
+  }
+  return best.points.map(
+    (_point, index) => best.points[(index + best.offset) % best.points.length]
+  );
+}
+function describe(ring) {
+  return { centre: centroid(ring.points), size: Math.abs(area(ring.points)) };
+}
+function matchRings(from, to) {
+  const starts = from.map(describe);
+  const ends = to.map(describe);
+  const pairs = starts.flatMap(
+    (start, i) => ends.map((end, j) => {
+      const scale = Math.sqrt(Math.max(start.size, end.size, 1));
+      return {
+        i,
+        j,
+        score: distance(start.centre, end.centre) / scale + Math.abs(Math.log((start.size + 1) / (end.size + 1)))
+      };
+    })
+  );
+  pairs.sort((a, b) => a.score - b.score);
+  const usedFrom = /* @__PURE__ */ new Set();
+  const usedTo = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const { i, j } of pairs) {
+    if (!usedFrom.has(i) && !usedTo.has(j)) {
+      usedFrom.add(i);
+      usedTo.add(j);
+      result.push([from[i], to[j]]);
+    }
+  }
+  for (const [i, ring] of from.entries()) {
+    if (!usedFrom.has(i)) result.push([ring, void 0]);
+  }
+  for (const [j, ring] of to.entries()) {
+    if (!usedTo.has(j)) result.push([void 0, ring]);
+  }
+  return result;
+}
+export {
+  alignRing,
+  area,
+  centroid,
+  matchRings,
+  resample
+};
+//# sourceMappingURL=rings.js.map