@windmorph/react 0.0.0-stage → 0.1.0

package/dist/shapes/cubic.d.ts

@@ -0,0 +1,52 @@
+import { Point, PointTransformer } from "./point.js";
+//#region src/shapes/cubic.d.ts
+/**
+ * A cubic Bézier curve: two anchor points and two control points, stored as
+ * `[anchor0X, anchor0Y, control0X, control0Y, control1X, control1Y, anchor1X, anchor1Y]`.
+ */
+export declare class Cubic {
+  readonly points: number[];
+  constructor(points?: readonly number[]);
+  static of(anchor0X: number, anchor0Y: number, control0X: number, control0Y: number, control1X: number, control1Y: number, anchor1X: number, anchor1Y: number): Cubic;
+  static fromPoints(anchor0: Point, control0: Point, control1: Point, anchor1: Point): Cubic;
+  get anchor0X(): number;
+  get anchor0Y(): number;
+  get control0X(): number;
+  get control0Y(): number;
+  get control1X(): number;
+  get control1Y(): number;
+  get anchor1X(): number;
+  get anchor1Y(): number;
+  /** The point on the curve at parameter `t` (0..1). */
+  pointOnCurve(t: number): Point;
+  zeroLength(): boolean;
+  convexTo(next: Cubic): boolean;
+  /**
+   * Bounds as `[minX, minY, maxX, maxY]`. `approximate` uses the hull of anchors and controls,
+   * which is cheaper and never smaller than the true bounds.
+   */
+  calculateBounds(bounds?: number[], approximate?: boolean): number[];
+  /** Splits the curve at `t` into two curves. */
+  split(t: number): [Cubic, Cubic];
+  /** The same curve drawn in the opposite direction. */
+  reverse(): Cubic;
+  plus(o: Cubic): Cubic;
+  times(x: number): Cubic;
+  div(x: number): Cubic;
+  equals(other: Cubic): boolean;
+  transformed(f: PointTransformer): Cubic;
+  toString(): string;
+  /** A straight line, as a cubic with controls one and two thirds along it. */
+  static straightLine(x0: number, y0: number, x1: number, y1: number): Cubic;
+  /** A circular arc of up to 180° around (centerX, centerY) from (x0, y0) to (x1, y1). */
+  static circularArc(centerX: number, centerY: number, x0: number, y0: number, x1: number, y1: number): Cubic;
+  /** A zero-length cubic at (x0, y0). */
+  static empty(x0: number, y0: number): Cubic;
+}
+/** A cubic whose points can be rewritten in place (used per animation frame by Morph). */
+export declare class MutableCubic extends Cubic {
+  transform(f: PointTransformer): void;
+  interpolate(c1: Cubic, c2: Cubic, progress: number): void;
+}
+//#endregion
+//# sourceMappingURL=cubic.d.ts.map

package/dist/shapes/cubic.js

@@ -0,0 +1,189 @@
+import { Point, convex, directionVector, distance, interpolate } from "./point.js";
+//#region src/shapes/cubic.ts
+const inUnit = (t) => t >= 0 && t <= 1;
+/**
+* A cubic Bézier curve: two anchor points and two control points, stored as
+* `[anchor0X, anchor0Y, control0X, control0Y, control1X, control1Y, anchor1X, anchor1Y]`.
+*/
+var Cubic = class Cubic {
+	points;
+	constructor(points = new Array(8).fill(0)) {
+		if (points.length !== 8) throw new Error("Points array size should be 8");
+		this.points = [...points];
+	}
+	static of(anchor0X, anchor0Y, control0X, control0Y, control1X, control1Y, anchor1X, anchor1Y) {
+		return new Cubic([
+			anchor0X,
+			anchor0Y,
+			control0X,
+			control0Y,
+			control1X,
+			control1Y,
+			anchor1X,
+			anchor1Y
+		]);
+	}
+	static fromPoints(anchor0, control0, control1, anchor1) {
+		return Cubic.of(anchor0.x, anchor0.y, control0.x, control0.y, control1.x, control1.y, anchor1.x, anchor1.y);
+	}
+	get anchor0X() {
+		return this.points[0];
+	}
+	get anchor0Y() {
+		return this.points[1];
+	}
+	get control0X() {
+		return this.points[2];
+	}
+	get control0Y() {
+		return this.points[3];
+	}
+	get control1X() {
+		return this.points[4];
+	}
+	get control1Y() {
+		return this.points[5];
+	}
+	get anchor1X() {
+		return this.points[6];
+	}
+	get anchor1Y() {
+		return this.points[7];
+	}
+	/** The point on the curve at parameter `t` (0..1). */
+	pointOnCurve(t) {
+		const u = 1 - t;
+		return new Point(this.anchor0X * (u * u * u) + this.control0X * (3 * t * u * u) + this.control1X * (3 * t * t * u) + this.anchor1X * (t * t * t), this.anchor0Y * (u * u * u) + this.control0Y * (3 * t * u * u) + this.control1Y * (3 * t * t * u) + this.anchor1Y * (t * t * t));
+	}
+	zeroLength() {
+		return Math.abs(this.anchor0X - this.anchor1X) < 1e-4 && Math.abs(this.anchor0Y - this.anchor1Y) < 1e-4;
+	}
+	convexTo(next) {
+		return convex(new Point(this.anchor0X, this.anchor0Y), new Point(this.anchor1X, this.anchor1Y), new Point(next.anchor1X, next.anchor1Y));
+	}
+	/**
+	* Bounds as `[minX, minY, maxX, maxY]`. `approximate` uses the hull of anchors and controls,
+	* which is cheaper and never smaller than the true bounds.
+	*/
+	calculateBounds(bounds = new Array(4).fill(0), approximate = false) {
+		if (this.zeroLength()) {
+			bounds[0] = this.anchor0X;
+			bounds[1] = this.anchor0Y;
+			bounds[2] = this.anchor0X;
+			bounds[3] = this.anchor0Y;
+			return bounds;
+		}
+		let minX = Math.min(this.anchor0X, this.anchor1X);
+		let minY = Math.min(this.anchor0Y, this.anchor1Y);
+		let maxX = Math.max(this.anchor0X, this.anchor1X);
+		let maxY = Math.max(this.anchor0Y, this.anchor1Y);
+		if (approximate) {
+			bounds[0] = Math.min(minX, Math.min(this.control0X, this.control1X));
+			bounds[1] = Math.min(minY, Math.min(this.control0Y, this.control1Y));
+			bounds[2] = Math.max(maxX, Math.max(this.control0X, this.control1X));
+			bounds[3] = Math.max(maxY, Math.max(this.control0Y, this.control1Y));
+			return bounds;
+		}
+		const extremaTs = (p0, c0, c1, p1) => {
+			const a = -p0 + 3 * c0 - 3 * c1 + p1;
+			const b = 2 * p0 - 4 * c0 + 2 * c1;
+			const c = -p0 + c0;
+			if (Math.abs(a) < 1e-4) {
+				if (b !== 0) {
+					const t = 2 * c / (-2 * b);
+					return inUnit(t) ? [t] : [];
+				}
+				return [];
+			}
+			const s = b * b - 4 * a * c;
+			if (s < 0) return [];
+			return [(-b + Math.sqrt(s)) / (2 * a), (-b - Math.sqrt(s)) / (2 * a)].filter(inUnit);
+		};
+		for (const t of extremaTs(this.anchor0X, this.control0X, this.control1X, this.anchor1X)) {
+			const x = this.pointOnCurve(t).x;
+			if (x < minX) minX = x;
+			if (x > maxX) maxX = x;
+		}
+		for (const t of extremaTs(this.anchor0Y, this.control0Y, this.control1Y, this.anchor1Y)) {
+			const y = this.pointOnCurve(t).y;
+			if (y < minY) minY = y;
+			if (y > maxY) maxY = y;
+		}
+		bounds[0] = minX;
+		bounds[1] = minY;
+		bounds[2] = maxX;
+		bounds[3] = maxY;
+		return bounds;
+	}
+	/** Splits the curve at `t` into two curves. */
+	split(t) {
+		const u = 1 - t;
+		const p = this.pointOnCurve(t);
+		return [Cubic.of(this.anchor0X, this.anchor0Y, this.anchor0X * u + this.control0X * t, this.anchor0Y * u + this.control0Y * t, this.anchor0X * (u * u) + this.control0X * (2 * u * t) + this.control1X * (t * t), this.anchor0Y * (u * u) + this.control0Y * (2 * u * t) + this.control1Y * (t * t), p.x, p.y), Cubic.of(p.x, p.y, this.control0X * (u * u) + this.control1X * (2 * u * t) + this.anchor1X * (t * t), this.control0Y * (u * u) + this.control1Y * (2 * u * t) + this.anchor1Y * (t * t), this.control1X * u + this.anchor1X * t, this.control1Y * u + this.anchor1Y * t, this.anchor1X, this.anchor1Y)];
+	}
+	/** The same curve drawn in the opposite direction. */
+	reverse() {
+		return Cubic.of(this.anchor1X, this.anchor1Y, this.control1X, this.control1Y, this.control0X, this.control0Y, this.anchor0X, this.anchor0Y);
+	}
+	plus(o) {
+		return new Cubic(this.points.map((v, i) => v + o.points[i]));
+	}
+	times(x) {
+		return new Cubic(this.points.map((v) => v * x));
+	}
+	div(x) {
+		return this.times(1 / x);
+	}
+	equals(other) {
+		return this.points.every((v, i) => v === other.points[i]);
+	}
+	transformed(f) {
+		const points = [...this.points];
+		for (let i = 0; i < 8; i += 2) {
+			const [x, y] = f(points[i], points[i + 1]);
+			points[i] = x;
+			points[i + 1] = y;
+		}
+		return new Cubic(points);
+	}
+	toString() {
+		return `anchor0: (${this.anchor0X}, ${this.anchor0Y}) control0: (${this.control0X}, ${this.control0Y}), control1: (${this.control1X}, ${this.control1Y}), anchor1: (${this.anchor1X}, ${this.anchor1Y})`;
+	}
+	/** A straight line, as a cubic with controls one and two thirds along it. */
+	static straightLine(x0, y0, x1, y1) {
+		return Cubic.of(x0, y0, interpolate(x0, x1, 1 / 3), interpolate(y0, y1, 1 / 3), interpolate(x0, x1, 2 / 3), interpolate(y0, y1, 2 / 3), x1, y1);
+	}
+	/** A circular arc of up to 180° around (centerX, centerY) from (x0, y0) to (x1, y1). */
+	static circularArc(centerX, centerY, x0, y0, x1, y1) {
+		const p0d = directionVector(x0 - centerX, y0 - centerY);
+		const p1d = directionVector(x1 - centerX, y1 - centerY);
+		const rotatedP0 = p0d.rotate90();
+		const rotatedP1 = p1d.rotate90();
+		const clockwise = rotatedP0.dotProductXY(x1 - centerX, y1 - centerY) >= 0;
+		const cosa = p0d.dotProduct(p1d);
+		if (cosa > .999) return Cubic.straightLine(x0, y0, x1, y1);
+		const k = distance(x0 - centerX, y0 - centerY) * 4 / 3 * (Math.sqrt(2 * (1 - cosa)) - Math.sqrt(1 - cosa * cosa)) / (1 - cosa) * (clockwise ? 1 : -1);
+		return Cubic.of(x0, y0, x0 + rotatedP0.x * k, y0 + rotatedP0.y * k, x1 - rotatedP1.x * k, y1 - rotatedP1.y * k, x1, y1);
+	}
+	/** A zero-length cubic at (x0, y0). */
+	static empty(x0, y0) {
+		return Cubic.of(x0, y0, x0, y0, x0, y0, x0, y0);
+	}
+};
+/** A cubic whose points can be rewritten in place (used per animation frame by Morph). */
+var MutableCubic = class extends Cubic {
+	transform(f) {
+		for (let i = 0; i < 8; i += 2) {
+			const [x, y] = f(this.points[i], this.points[i + 1]);
+			this.points[i] = x;
+			this.points[i + 1] = y;
+		}
+	}
+	interpolate(c1, c2, progress) {
+		for (let i = 0; i < 8; i++) this.points[i] = interpolate(c1.points[i], c2.points[i], progress);
+	}
+};
+//#endregion
+export { Cubic, MutableCubic };
+
+//# sourceMappingURL=cubic.js.map

package/dist/shapes/cubic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cubic.js","names":[],"sources":["../../src/shapes/cubic.ts"],"sourcesContent":["/*\n * Port of androidx.graphics.shapes Cubic.kt (Apache-2.0, see LICENSE-androidx.md).\n */\nimport {\n  DistanceEpsilon,\n  Point,\n  convex,\n  directionVector,\n  distance,\n  interpolate,\n  type PointTransformer,\n} from './point';\n\nconst inUnit = (t: number) => t >= 0 && t <= 1;\n\n/**\n * A cubic Bézier curve: two anchor points and two control points, stored as\n * `[anchor0X, anchor0Y, control0X, control0Y, control1X, control1Y, anchor1X, anchor1Y]`.\n */\nexport class Cubic {\n  readonly points: number[];\n\n  constructor(points: readonly number[] = new Array(8).fill(0)) {\n    if (points.length !== 8) throw new Error('Points array size should be 8');\n    this.points = [...points];\n  }\n\n  static of(\n    anchor0X: number,\n    anchor0Y: number,\n    control0X: number,\n    control0Y: number,\n    control1X: number,\n    control1Y: number,\n    anchor1X: number,\n    anchor1Y: number,\n  ): Cubic {\n    return new Cubic([\n      anchor0X,\n      anchor0Y,\n      control0X,\n      control0Y,\n      control1X,\n      control1Y,\n      anchor1X,\n      anchor1Y,\n    ]);\n  }\n\n  static fromPoints(anchor0: Point, control0: Point, control1: Point, anchor1: Point): Cubic {\n    return Cubic.of(\n      anchor0.x,\n      anchor0.y,\n      control0.x,\n      control0.y,\n      control1.x,\n      control1.y,\n      anchor1.x,\n      anchor1.y,\n    );\n  }\n\n  get anchor0X() {\n    return this.points[0]!;\n  }\n  get anchor0Y() {\n    return this.points[1]!;\n  }\n  get control0X() {\n    return this.points[2]!;\n  }\n  get control0Y() {\n    return this.points[3]!;\n  }\n  get control1X() {\n    return this.points[4]!;\n  }\n  get control1Y() {\n    return this.points[5]!;\n  }\n  get anchor1X() {\n    return this.points[6]!;\n  }\n  get anchor1Y() {\n    return this.points[7]!;\n  }\n\n  /** The point on the curve at parameter `t` (0..1). */\n  pointOnCurve(t: number): Point {\n    const u = 1 - t;\n    return new Point(\n      this.anchor0X * (u * u * u) +\n        this.control0X * (3 * t * u * u) +\n        this.control1X * (3 * t * t * u) +\n        this.anchor1X * (t * t * t),\n      this.anchor0Y * (u * u * u) +\n        this.control0Y * (3 * t * u * u) +\n        this.control1Y * (3 * t * t * u) +\n        this.anchor1Y * (t * t * t),\n    );\n  }\n\n  zeroLength(): boolean {\n    return (\n      Math.abs(this.anchor0X - this.anchor1X) < DistanceEpsilon &&\n      Math.abs(this.anchor0Y - this.anchor1Y) < DistanceEpsilon\n    );\n  }\n\n  convexTo(next: Cubic): boolean {\n    return convex(\n      new Point(this.anchor0X, this.anchor0Y),\n      new Point(this.anchor1X, this.anchor1Y),\n      new Point(next.anchor1X, next.anchor1Y),\n    );\n  }\n\n  /**\n   * Bounds as `[minX, minY, maxX, maxY]`. `approximate` uses the hull of anchors and controls,\n   * which is cheaper and never smaller than the true bounds.\n   */\n  calculateBounds(bounds: number[] = new Array(4).fill(0), approximate = false): number[] {\n    // A curve might be of zero-length, with both anchors co-located: return the point itself.\n    if (this.zeroLength()) {\n      bounds[0] = this.anchor0X;\n      bounds[1] = this.anchor0Y;\n      bounds[2] = this.anchor0X;\n      bounds[3] = this.anchor0Y;\n      return bounds;\n    }\n    let minX = Math.min(this.anchor0X, this.anchor1X);\n    let minY = Math.min(this.anchor0Y, this.anchor1Y);\n    let maxX = Math.max(this.anchor0X, this.anchor1X);\n    let maxY = Math.max(this.anchor0Y, this.anchor1Y);\n    if (approximate) {\n      bounds[0] = Math.min(minX, Math.min(this.control0X, this.control1X));\n      bounds[1] = Math.min(minY, Math.min(this.control0Y, this.control1Y));\n      bounds[2] = Math.max(maxX, Math.max(this.control0X, this.control1X));\n      bounds[3] = Math.max(maxY, Math.max(this.control0Y, this.control1Y));\n      return bounds;\n    }\n\n    // The derivative is a quadratic Bézier; solve for t with the quadratic formula.\n    const extremaTs = (p0: number, c0: number, c1: number, p1: number): number[] => {\n      const a = -p0 + 3 * c0 - 3 * c1 + p1;\n      const b = 2 * p0 - 4 * c0 + 2 * c1;\n      const c = -p0 + c0;\n      if (Math.abs(a) < DistanceEpsilon) {\n        // A single root when a is 0.\n        if (b !== 0) {\n          const t = (2 * c) / (-2 * b);\n          return inUnit(t) ? [t] : [];\n        }\n        return [];\n      }\n      const s = b * b - 4 * a * c;\n      if (s < 0) return [];\n      return [(-b + Math.sqrt(s)) / (2 * a), (-b - Math.sqrt(s)) / (2 * a)].filter(inUnit);\n    };\n\n    for (const t of extremaTs(this.anchor0X, this.control0X, this.control1X, this.anchor1X)) {\n      const x = this.pointOnCurve(t).x;\n      if (x < minX) minX = x;\n      if (x > maxX) maxX = x;\n    }\n    for (const t of extremaTs(this.anchor0Y, this.control0Y, this.control1Y, this.anchor1Y)) {\n      const y = this.pointOnCurve(t).y;\n      if (y < minY) minY = y;\n      if (y > maxY) maxY = y;\n    }\n    bounds[0] = minX;\n    bounds[1] = minY;\n    bounds[2] = maxX;\n    bounds[3] = maxY;\n    return bounds;\n  }\n\n  /** Splits the curve at `t` into two curves. */\n  split(t: number): [Cubic, Cubic] {\n    const u = 1 - t;\n    const p = this.pointOnCurve(t);\n    return [\n      Cubic.of(\n        this.anchor0X,\n        this.anchor0Y,\n        this.anchor0X * u + this.control0X * t,\n        this.anchor0Y * u + this.control0Y * t,\n        this.anchor0X * (u * u) + this.control0X * (2 * u * t) + this.control1X * (t * t),\n        this.anchor0Y * (u * u) + this.control0Y * (2 * u * t) + this.control1Y * (t * t),\n        p.x,\n        p.y,\n      ),\n      Cubic.of(\n        p.x,\n        p.y,\n        this.control0X * (u * u) + this.control1X * (2 * u * t) + this.anchor1X * (t * t),\n        this.control0Y * (u * u) + this.control1Y * (2 * u * t) + this.anchor1Y * (t * t),\n        this.control1X * u + this.anchor1X * t,\n        this.control1Y * u + this.anchor1Y * t,\n        this.anchor1X,\n        this.anchor1Y,\n      ),\n    ];\n  }\n\n  /** The same curve drawn in the opposite direction. */\n  reverse(): Cubic {\n    return Cubic.of(\n      this.anchor1X,\n      this.anchor1Y,\n      this.control1X,\n      this.control1Y,\n      this.control0X,\n      this.control0Y,\n      this.anchor0X,\n      this.anchor0Y,\n    );\n  }\n\n  plus(o: Cubic): Cubic {\n    return new Cubic(this.points.map((v, i) => v + o.points[i]!));\n  }\n\n  times(x: number): Cubic {\n    return new Cubic(this.points.map((v) => v * x));\n  }\n\n  div(x: number): Cubic {\n    return this.times(1 / x);\n  }\n\n  equals(other: Cubic): boolean {\n    return this.points.every((v, i) => v === other.points[i]);\n  }\n\n  transformed(f: PointTransformer): Cubic {\n    const points = [...this.points];\n    for (let i = 0; i < 8; i += 2) {\n      const [x, y] = f(points[i]!, points[i + 1]!);\n      points[i] = x;\n      points[i + 1] = y;\n    }\n    return new Cubic(points);\n  }\n\n  toString(): string {\n    return `anchor0: (${this.anchor0X}, ${this.anchor0Y}) control0: (${this.control0X}, ${this.control0Y}), control1: (${this.control1X}, ${this.control1Y}), anchor1: (${this.anchor1X}, ${this.anchor1Y})`;\n  }\n\n  /** A straight line, as a cubic with controls one and two thirds along it. */\n  static straightLine(x0: number, y0: number, x1: number, y1: number): Cubic {\n    return Cubic.of(\n      x0,\n      y0,\n      interpolate(x0, x1, 1 / 3),\n      interpolate(y0, y1, 1 / 3),\n      interpolate(x0, x1, 2 / 3),\n      interpolate(y0, y1, 2 / 3),\n      x1,\n      y1,\n    );\n  }\n\n  /** A circular arc of up to 180° around (centerX, centerY) from (x0, y0) to (x1, y1). */\n  static circularArc(\n    centerX: number,\n    centerY: number,\n    x0: number,\n    y0: number,\n    x1: number,\n    y1: number,\n  ): Cubic {\n    const p0d = directionVector(x0 - centerX, y0 - centerY);\n    const p1d = directionVector(x1 - centerX, y1 - centerY);\n    const rotatedP0 = p0d.rotate90();\n    const rotatedP1 = p1d.rotate90();\n    const clockwise = rotatedP0.dotProductXY(x1 - centerX, y1 - centerY) >= 0;\n    const cosa = p0d.dotProduct(p1d);\n    if (cosa > 0.999) return Cubic.straightLine(x0, y0, x1, y1); // p0 ~= p1\n    const k =\n      ((((distance(x0 - centerX, y0 - centerY) * 4) / 3) *\n        (Math.sqrt(2 * (1 - cosa)) - Math.sqrt(1 - cosa * cosa))) /\n        (1 - cosa)) *\n      (clockwise ? 1 : -1);\n    return Cubic.of(\n      x0,\n      y0,\n      x0 + rotatedP0.x * k,\n      y0 + rotatedP0.y * k,\n      x1 - rotatedP1.x * k,\n      y1 - rotatedP1.y * k,\n      x1,\n      y1,\n    );\n  }\n\n  /** A zero-length cubic at (x0, y0). */\n  static empty(x0: number, y0: number): Cubic {\n    return Cubic.of(x0, y0, x0, y0, x0, y0, x0, y0);\n  }\n}\n\n/** A cubic whose points can be rewritten in place (used per animation frame by Morph). */\nexport class MutableCubic extends Cubic {\n  transform(f: PointTransformer): void {\n    for (let i = 0; i < 8; i += 2) {\n      const [x, y] = f(this.points[i]!, this.points[i + 1]!);\n      this.points[i] = x;\n      this.points[i + 1] = y;\n    }\n  }\n\n  interpolate(c1: Cubic, c2: Cubic, progress: number): void {\n    for (let i = 0; i < 8; i++) {\n      this.points[i] = interpolate(c1.points[i]!, c2.points[i]!, progress);\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/shapes/feature-mapping.js

@@ -0,0 +1,80 @@
+import { Point } from "./point.js";
+import { Corner } from "./features.js";
+import { DoubleMapper, progressDistance, progressInRange } from "./float-mapping.js";
+//#region src/shapes/feature-mapping.ts
+/** Maps outline progress between two shapes by pairing their closest corners. */
+function featureMapper(features1, features2) {
+	const corners1 = features1.filter((f) => f.feature instanceof Corner);
+	const corners2 = features2.filter((f) => f.feature instanceof Corner);
+	return new DoubleMapper(...doMapping(corners1, corners2));
+}
+const IdentityMapping = [[0, 0], [.5, .5]];
+function doMapping(features1, features2) {
+	const candidates = [];
+	for (const f1 of features1) for (const f2 of features2) {
+		const d = featureDistSquared(f1.feature, f2.feature);
+		if (d !== Infinity) candidates.push({
+			distance: d,
+			f1,
+			f2
+		});
+	}
+	candidates.sort((a, b) => a.distance - b.distance);
+	if (candidates.length === 0) return IdentityMapping;
+	if (candidates.length === 1) {
+		const p1 = candidates[0].f1.progress;
+		const p2 = candidates[0].f2.progress;
+		return [[p1, p2], [(p1 + .5) % 1, (p2 + .5) % 1]];
+	}
+	const helper = new MappingHelper();
+	for (const { f1, f2 } of candidates) helper.addMapping(f1, f2);
+	return helper.mapping;
+}
+var MappingHelper = class {
+	/** Start-shape to end-shape progress pairs, sorted by start progress. */
+	mapping = [];
+	usedF1 = /* @__PURE__ */ new Set();
+	usedF2 = /* @__PURE__ */ new Set();
+	addMapping(f1, f2) {
+		if (this.usedF1.has(f1) || this.usedF2.has(f2)) return;
+		const index = binarySearchBy(this.mapping, f1.progress);
+		if (index >= 0) throw new Error("There can't be two features with the same progress");
+		const insertionIndex = -index - 1;
+		const n = this.mapping.length;
+		if (n >= 1) {
+			const [before1, before2] = this.mapping[(insertionIndex + n - 1) % n];
+			const [after1, after2] = this.mapping[insertionIndex % n];
+			if (progressDistance(f1.progress, before1) < 1e-4 || progressDistance(f1.progress, after1) < 1e-4 || progressDistance(f2.progress, before2) < 1e-4 || progressDistance(f2.progress, after2) < 1e-4) return;
+			if (n > 1 && !progressInRange(f2.progress, before2, after2)) return;
+		}
+		this.mapping.splice(insertionIndex, 0, [f1.progress, f2.progress]);
+		this.usedF1.add(f1);
+		this.usedF2.add(f2);
+	}
+};
+/** Kotlin's `binarySearchBy` on the first element: the index, or `-(insertion point) - 1`. */
+function binarySearchBy(list, key) {
+	let low = 0;
+	let high = list.length - 1;
+	while (low <= high) {
+		const mid = low + high >>> 1;
+		const value = list[mid][0];
+		if (value < key) low = mid + 1;
+		else if (value > key) high = mid - 1;
+		else return mid;
+	}
+	return -(low + 1);
+}
+function featureDistSquared(f1, f2) {
+	if (f1 instanceof Corner && f2 instanceof Corner && f1.convex !== f2.convex) return Infinity;
+	return featureRepresentativePoint(f1).minus(featureRepresentativePoint(f2)).getDistanceSquared();
+}
+function featureRepresentativePoint(feature) {
+	const first = feature.cubics[0];
+	const last = feature.cubics[feature.cubics.length - 1];
+	return new Point((first.anchor0X + last.anchor1X) / 2, (first.anchor0Y + last.anchor1Y) / 2);
+}
+//#endregion
+export { doMapping, featureDistSquared, featureMapper, featureRepresentativePoint };
+
+//# sourceMappingURL=feature-mapping.js.map

package/dist/shapes/feature-mapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-mapping.js","names":[],"sources":["../../src/shapes/feature-mapping.ts"],"sourcesContent":["/*\n * Port of androidx.graphics.shapes FeatureMapping.kt (Apache-2.0, see LICENSE-androidx.md).\n */\nimport { DoubleMapper, progressDistance, progressInRange } from './float-mapping';\nimport { Corner, type Feature } from './features';\nimport { DistanceEpsilon, Point } from './point';\nimport type { ProgressableFeature } from './polygon-measure';\n\ntype Mapping = readonly [number, number];\n\n/** Maps outline progress between two shapes by pairing their closest corners. */\nexport function featureMapper(\n  features1: readonly ProgressableFeature[],\n  features2: readonly ProgressableFeature[],\n): DoubleMapper {\n  // Only corners take part in the mapping.\n  const corners1 = features1.filter((f) => f.feature instanceof Corner);\n  const corners2 = features2.filter((f) => f.feature instanceof Corner);\n  return new DoubleMapper(...doMapping(corners1, corners2));\n}\n\nconst IdentityMapping: readonly Mapping[] = [\n  [0, 0],\n  [0.5, 0.5],\n];\n\nexport function doMapping(\n  features1: readonly ProgressableFeature[],\n  features2: readonly ProgressableFeature[],\n): readonly Mapping[] {\n  const candidates: { distance: number; f1: ProgressableFeature; f2: ProgressableFeature }[] = [];\n  for (const f1 of features1) {\n    for (const f2 of features2) {\n      const d = featureDistSquared(f1.feature, f2.feature);\n      if (d !== Infinity) candidates.push({ distance: d, f1, f2 });\n    }\n  }\n  // Array.prototype.sort is stable, matching Kotlin's sortedBy.\n  candidates.sort((a, b) => a.distance - b.distance);\n\n  if (candidates.length === 0) return IdentityMapping;\n  if (candidates.length === 1) {\n    const p1 = candidates[0]!.f1.progress;\n    const p2 = candidates[0]!.f2.progress;\n    return [\n      [p1, p2],\n      [(p1 + 0.5) % 1, (p2 + 0.5) % 1],\n    ];\n  }\n  const helper = new MappingHelper();\n  for (const { f1, f2 } of candidates) helper.addMapping(f1, f2);\n  return helper.mapping;\n}\n\nclass MappingHelper {\n  /** Start-shape to end-shape progress pairs, sorted by start progress. */\n  readonly mapping: Mapping[] = [];\n  private readonly usedF1 = new Set<ProgressableFeature>();\n  private readonly usedF2 = new Set<ProgressableFeature>();\n\n  addMapping(f1: ProgressableFeature, f2: ProgressableFeature): void {\n    // Map each feature at most once.\n    if (this.usedF1.has(f1) || this.usedF2.has(f2)) return;\n\n    const index = binarySearchBy(this.mapping, f1.progress);\n    if (index >= 0) throw new Error(\"There can't be two features with the same progress\");\n    const insertionIndex = -index - 1;\n    const n = this.mapping.length;\n    if (n >= 1) {\n      const [before1, before2] = this.mapping[(insertionIndex + n - 1) % n]!;\n      const [after1, after2] = this.mapping[insertionIndex % n]!;\n      // Features too close to their neighbours would make the DoubleMapper unstable.\n      if (\n        progressDistance(f1.progress, before1) < DistanceEpsilon ||\n        progressDistance(f1.progress, after1) < DistanceEpsilon ||\n        progressDistance(f2.progress, before2) < DistanceEpsilon ||\n        progressDistance(f2.progress, after2) < DistanceEpsilon\n      ) {\n        return;\n      }\n      // With two or more mappings, don't add crossings.\n      if (n > 1 && !progressInRange(f2.progress, before2, after2)) return;\n    }\n    this.mapping.splice(insertionIndex, 0, [f1.progress, f2.progress]);\n    this.usedF1.add(f1);\n    this.usedF2.add(f2);\n  }\n}\n\n/** Kotlin's `binarySearchBy` on the first element: the index, or `-(insertion point) - 1`. */\nfunction binarySearchBy(list: readonly Mapping[], key: number): number {\n  let low = 0;\n  let high = list.length - 1;\n  while (low <= high) {\n    const mid = (low + high) >>> 1;\n    const value = list[mid]![0];\n    if (value < key) low = mid + 1;\n    else if (value > key) high = mid - 1;\n    else return mid;\n  }\n  return -(low + 1);\n}\n\nexport function featureDistSquared(f1: Feature, f2: Feature): number {\n  // Corners only map to corners of the same concavity.\n  if (f1 instanceof Corner && f2 instanceof Corner && f1.convex !== f2.convex) return Infinity;\n  return featureRepresentativePoint(f1).minus(featureRepresentativePoint(f2)).getDistanceSquared();\n}\n\nexport function featureRepresentativePoint(feature: Feature): Point {\n  const first = feature.cubics[0]!;\n  const last = feature.cubics[feature.cubics.length - 1]!;\n  return new Point((first.anchor0X + last.anchor1X) / 2, (first.anchor0Y + last.anchor1Y) / 2);\n}\n"],"mappings":"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"}

package/dist/shapes/features.d.ts

@@ -0,0 +1,23 @@
+import { PointTransformer } from "./point.js";
+import { Cubic } from "./cubic.js";
+//#region src/shapes/features.d.ts
+/**
+ * A part of a polygon outline: an edge, or a convex or concave corner. Morphing matches
+ * corresponding features (corners) between two shapes.
+ */
+export declare abstract class Feature {
+  readonly cubics: readonly Cubic[];
+  constructor(cubics: readonly Cubic[]);
+  abstract transformed(f: PointTransformer): Feature;
+  abstract reversed(): Feature;
+  abstract readonly isIgnorableFeature: boolean;
+  abstract readonly isEdge: boolean;
+  abstract readonly isConvexCorner: boolean;
+  abstract readonly isConcaveCorner: boolean;
+  static buildIgnorableFeature(cubics: readonly Cubic[]): Feature;
+  static buildEdge(cubic: Cubic): Feature;
+  static buildConvexCorner(cubics: readonly Cubic[]): Feature;
+  static buildConcaveCorner(cubics: readonly Cubic[]): Feature;
+}
+//#endregion
+//# sourceMappingURL=features.d.ts.map

package/dist/shapes/features.js

@@ -0,0 +1,82 @@
+import "./point.js";
+//#region src/shapes/features.ts
+/**
+* A part of a polygon outline: an edge, or a convex or concave corner. Morphing matches
+* corresponding features (corners) between two shapes.
+*/
+var Feature = class {
+	cubics;
+	constructor(cubics) {
+		this.cubics = cubics;
+	}
+	static buildIgnorableFeature(cubics) {
+		return validated(new Edge(cubics));
+	}
+	static buildEdge(cubic) {
+		return new Edge([cubic]);
+	}
+	static buildConvexCorner(cubics) {
+		return validated(new Corner(cubics, true));
+	}
+	static buildConcaveCorner(cubics) {
+		return validated(new Corner(cubics, false));
+	}
+};
+function isContinuous(feature) {
+	let prev = feature.cubics[0];
+	for (let i = 1; i < feature.cubics.length; i++) {
+		const cubic = feature.cubics[i];
+		if (Math.abs(cubic.anchor0X - prev.anchor1X) > 1e-4 || Math.abs(cubic.anchor0Y - prev.anchor1Y) > 1e-4) return false;
+		prev = cubic;
+	}
+	return true;
+}
+function validated(feature) {
+	if (feature.cubics.length === 0) throw new Error("Features need at least one cubic.");
+	if (!isContinuous(feature)) throw new Error("Feature must be continuous, with the anchor points of all cubics matching the anchor points of the preceding and succeeding cubics");
+	return feature;
+}
+const reverseCubics = (cubics) => [...cubics].reverse().map((cubic) => cubic.reverse());
+var Edge = class Edge extends Feature {
+	isIgnorableFeature = true;
+	isEdge = true;
+	isConvexCorner = false;
+	isConcaveCorner = false;
+	transformed(f) {
+		return new Edge(this.cubics.map((cubic) => cubic.transformed(f)));
+	}
+	reversed() {
+		return new Edge(reverseCubics(this.cubics));
+	}
+	toString() {
+		return "Edge";
+	}
+};
+var Corner = class Corner extends Feature {
+	convex;
+	isIgnorableFeature = false;
+	isEdge = false;
+	constructor(cubics, convex = true) {
+		super(cubics);
+		this.convex = convex;
+	}
+	get isConvexCorner() {
+		return this.convex;
+	}
+	get isConcaveCorner() {
+		return !this.convex;
+	}
+	transformed(f) {
+		return new Corner(this.cubics.map((cubic) => cubic.transformed(f)), this.convex);
+	}
+	reversed() {
+		return new Corner(reverseCubics(this.cubics), !this.convex);
+	}
+	toString() {
+		return `Corner: cubics=${this.cubics.map((c) => `[${c}]`).join(", ")} convex=${this.convex}`;
+	}
+};
+//#endregion
+export { Corner, Edge, Feature };
+
+//# sourceMappingURL=features.js.map

package/dist/shapes/features.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features.js","names":[],"sources":["../../src/shapes/features.ts"],"sourcesContent":["/*\n * Port of androidx.graphics.shapes Features.kt (Apache-2.0, see LICENSE-androidx.md).\n */\nimport type { Cubic } from './cubic';\nimport { DistanceEpsilon, type PointTransformer } from './point';\n\n/**\n * A part of a polygon outline: an edge, or a convex or concave corner. Morphing matches\n * corresponding features (corners) between two shapes.\n */\nexport abstract class Feature {\n  constructor(readonly cubics: readonly Cubic[]) {}\n\n  abstract transformed(f: PointTransformer): Feature;\n  abstract reversed(): Feature;\n  abstract readonly isIgnorableFeature: boolean;\n  abstract readonly isEdge: boolean;\n  abstract readonly isConvexCorner: boolean;\n  abstract readonly isConcaveCorner: boolean;\n\n  static buildIgnorableFeature(cubics: readonly Cubic[]): Feature {\n    return validated(new Edge(cubics));\n  }\n\n  static buildEdge(cubic: Cubic): Feature {\n    return new Edge([cubic]);\n  }\n\n  static buildConvexCorner(cubics: readonly Cubic[]): Feature {\n    return validated(new Corner(cubics, true));\n  }\n\n  static buildConcaveCorner(cubics: readonly Cubic[]): Feature {\n    return validated(new Corner(cubics, false));\n  }\n}\n\nfunction isContinuous(feature: Feature): boolean {\n  let prev = feature.cubics[0]!;\n  for (let i = 1; i < feature.cubics.length; i++) {\n    const cubic = feature.cubics[i]!;\n    if (\n      Math.abs(cubic.anchor0X - prev.anchor1X) > DistanceEpsilon ||\n      Math.abs(cubic.anchor0Y - prev.anchor1Y) > DistanceEpsilon\n    ) {\n      return false;\n    }\n    prev = cubic;\n  }\n  return true;\n}\n\nfunction validated(feature: Feature): Feature {\n  if (feature.cubics.length === 0) throw new Error('Features need at least one cubic.');\n  if (!isContinuous(feature)) {\n    throw new Error(\n      'Feature must be continuous, with the anchor points of all cubics matching the anchor points of the preceding and succeeding cubics',\n    );\n  }\n  return feature;\n}\n\nconst reverseCubics = (cubics: readonly Cubic[]) =>\n  [...cubics].reverse().map((cubic) => cubic.reverse());\n\nexport class Edge extends Feature {\n  readonly isIgnorableFeature = true;\n  readonly isEdge = true;\n  readonly isConvexCorner = false;\n  readonly isConcaveCorner = false;\n\n  transformed(f: PointTransformer): Edge {\n    return new Edge(this.cubics.map((cubic) => cubic.transformed(f)));\n  }\n\n  reversed(): Edge {\n    return new Edge(reverseCubics(this.cubics));\n  }\n\n  override toString(): string {\n    return 'Edge';\n  }\n}\n\nexport class Corner extends Feature {\n  readonly isIgnorableFeature = false;\n  readonly isEdge = false;\n\n  constructor(\n    cubics: readonly Cubic[],\n    readonly convex = true,\n  ) {\n    super(cubics);\n  }\n\n  get isConvexCorner(): boolean {\n    return this.convex;\n  }\n\n  get isConcaveCorner(): boolean {\n    return !this.convex;\n  }\n\n  transformed(f: PointTransformer): Corner {\n    return new Corner(\n      this.cubics.map((cubic) => cubic.transformed(f)),\n      this.convex,\n    );\n  }\n\n  reversed(): Corner {\n    // androidx b/369320447: the flag is negated until RoundedPolygon ignores orientation.\n    return new Corner(reverseCubics(this.cubics), !this.convex);\n  }\n\n  override toString(): string {\n    return `Corner: cubics=${this.cubics.map((c) => `[${c}]`).join(', ')} convex=${this.convex}`;\n  }\n}\n"],"mappings":";;;;;;AAUA,IAAsB,UAAtB,MAA8B;CACP;CAArB,YAAY,QAAmC;EAA1B,KAAA,SAAA;CAA2B;CAShD,OAAO,sBAAsB,QAAmC;EAC9D,OAAO,UAAU,IAAI,KAAK,MAAM,CAAC;CACnC;CAEA,OAAO,UAAU,OAAuB;EACtC,OAAO,IAAI,KAAK,CAAC,KAAK,CAAC;CACzB;CAEA,OAAO,kBAAkB,QAAmC;EAC1D,OAAO,UAAU,IAAI,OAAO,QAAQ,IAAI,CAAC;CAC3C;CAEA,OAAO,mBAAmB,QAAmC;EAC3D,OAAO,UAAU,IAAI,OAAO,QAAQ,KAAK,CAAC;CAC5C;AACF;AAEA,SAAS,aAAa,SAA2B;CAC/C,IAAI,OAAO,QAAQ,OAAO;CAC1B,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,OAAO,QAAQ,KAAK;EAC9C,MAAM,QAAQ,QAAQ,OAAO;EAC7B,IACE,KAAK,IAAI,MAAM,WAAW,KAAK,QAAQ,IAAA,QACvC,KAAK,IAAI,MAAM,WAAW,KAAK,QAAQ,IAAA,MAEvC,OAAO;EAET,OAAO;CACT;CACA,OAAO;AACT;AAEA,SAAS,UAAU,SAA2B;CAC5C,IAAI,QAAQ,OAAO,WAAW,GAAG,MAAM,IAAI,MAAM,mCAAmC;CACpF,IAAI,CAAC,aAAa,OAAO,GACvB,MAAM,IAAI,MACR,oIACF;CAEF,OAAO;AACT;AAEA,MAAM,iBAAiB,WACrB,CAAC,GAAG,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,UAAU,MAAM,QAAQ,CAAC;AAEtD,IAAa,OAAb,MAAa,aAAa,QAAQ;CAChC,qBAA8B;CAC9B,SAAkB;CAClB,iBAA0B;CAC1B,kBAA2B;CAE3B,YAAY,GAA2B;EACrC,OAAO,IAAI,KAAK,KAAK,OAAO,KAAK,UAAU,MAAM,YAAY,CAAC,CAAC,CAAC;CAClE;CAEA,WAAiB;EACf,OAAO,IAAI,KAAK,cAAc,KAAK,MAAM,CAAC;CAC5C;CAEA,WAA4B;EAC1B,OAAO;CACT;AACF;AAEA,IAAa,SAAb,MAAa,eAAe,QAAQ;CAMvB;CALX,qBAA8B;CAC9B,SAAkB;CAElB,YACE,QACA,SAAkB,MAClB;EACA,MAAM,MAAM;EAFH,KAAA,SAAA;CAGX;CAEA,IAAI,iBAA0B;EAC5B,OAAO,KAAK;CACd;CAEA,IAAI,kBAA2B;EAC7B,OAAO,CAAC,KAAK;CACf;CAEA,YAAY,GAA6B;EACvC,OAAO,IAAI,OACT,KAAK,OAAO,KAAK,UAAU,MAAM,YAAY,CAAC,CAAC,GAC/C,KAAK,MACP;CACF;CAEA,WAAmB;EAEjB,OAAO,IAAI,OAAO,cAAc,KAAK,MAAM,GAAG,CAAC,KAAK,MAAM;CAC5D;CAEA,WAA4B;EAC1B,OAAO,kBAAkB,KAAK,OAAO,KAAK,MAAM,IAAI,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,EAAE,UAAU,KAAK;CACtF;AACF"}

package/dist/shapes/float-mapping.js

@@ -0,0 +1,65 @@
+import { positiveModulo } from "./point.js";
+//#region src/shapes/float-mapping.ts
+/** Whether `progress` lies in `[from, to]`, where the range may wrap around 1. */
+function progressInRange(progress, from, to) {
+	return to >= from ? progress >= from && progress <= to : progress >= from || progress <= to;
+}
+/** Maps `x` through the piecewise-linear, wrapping function given by the two value lists. */
+function linearMap(xValues, yValues, x) {
+	if (!(x >= 0 && x <= 1)) throw new Error(`Invalid progress: ${x}`);
+	const n = xValues.length;
+	const segmentStartIndex = xValues.findIndex((_, i) => progressInRange(x, xValues[i], xValues[(i + 1) % n]));
+	const segmentEndIndex = (segmentStartIndex + 1) % n;
+	const segmentSizeX = positiveModulo(xValues[segmentEndIndex] - xValues[segmentStartIndex], 1);
+	const segmentSizeY = positiveModulo(yValues[segmentEndIndex] - yValues[segmentStartIndex], 1);
+	const positionInSegment = segmentSizeX < .001 ? .5 : positiveModulo(x - xValues[segmentStartIndex], 1) / segmentSizeX;
+	return positiveModulo(yValues[segmentStartIndex] + segmentSizeY * positionInSegment, 1);
+}
+/**
+* A bidirectional mapping between two progress spaces, both `[0, 1)` and wrapping. Each
+* mapping pair anchors one source progress to one target progress.
+*/
+var DoubleMapper = class DoubleMapper {
+	static Identity = new DoubleMapper([0, 0], [.5, .5]);
+	sourceValues;
+	targetValues;
+	constructor(...mappings) {
+		this.sourceValues = mappings.map(([source]) => source);
+		this.targetValues = mappings.map(([, target]) => target);
+		validateProgress(this.sourceValues);
+		validateProgress(this.targetValues);
+	}
+	map(x) {
+		return linearMap(this.sourceValues, this.targetValues, x);
+	}
+	mapBack(x) {
+		return linearMap(this.targetValues, this.sourceValues, x);
+	}
+};
+/**
+* Checks that every progress value is in `[0, 1)` and that the list (including the last to
+* first pair) increases monotonically, wrapping at most once. `(0.3, 0.6, 0)` is valid;
+* `(0.5, 0, 0.7)` is not.
+*/
+function validateProgress(p) {
+	let prev = p[p.length - 1];
+	let wraps = 0;
+	for (const curr of p) {
+		if (!(curr >= 0 && curr < 1)) throw new Error(`FloatMapping - Progress outside of range: ${p.join(", ")}`);
+		if (!(progressDistance(curr, prev) > 1e-4)) throw new Error(`FloatMapping - Progress repeats a value: ${p.join(", ")}`);
+		if (curr < prev) {
+			wraps++;
+			if (wraps > 1) throw new Error(`FloatMapping - Progress wraps more than once: ${p.join(", ")}`);
+		}
+		prev = curr;
+	}
+}
+/** Distance between two wrapping progress values: 0.99 and 0 are 0.01 apart. */
+function progressDistance(p1, p2) {
+	const d = Math.abs(p1 - p2);
+	return Math.min(d, 1 - d);
+}
+//#endregion
+export { DoubleMapper, linearMap, progressDistance, progressInRange, validateProgress };
+
+//# sourceMappingURL=float-mapping.js.map

package/dist/shapes/float-mapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"float-mapping.js","names":[],"sources":["../../src/shapes/float-mapping.ts"],"sourcesContent":["/*\n * Port of androidx.graphics.shapes FloatMapping.kt (Apache-2.0, see LICENSE-androidx.md).\n */\nimport { DistanceEpsilon, positiveModulo } from './point';\n\n/** Whether `progress` lies in `[from, to]`, where the range may wrap around 1. */\nexport function progressInRange(progress: number, from: number, to: number): boolean {\n  return to >= from ? progress >= from && progress <= to : progress >= from || progress <= to;\n}\n\n/** Maps `x` through the piecewise-linear, wrapping function given by the two value lists. */\nexport function linearMap(\n  xValues: readonly number[],\n  yValues: readonly number[],\n  x: number,\n): number {\n  if (!(x >= 0 && x <= 1)) throw new Error(`Invalid progress: ${x}`);\n  const n = xValues.length;\n  const segmentStartIndex = xValues.findIndex((_, i) =>\n    progressInRange(x, xValues[i]!, xValues[(i + 1) % n]!),\n  );\n  const segmentEndIndex = (segmentStartIndex + 1) % n;\n  const segmentSizeX = positiveModulo(xValues[segmentEndIndex]! - xValues[segmentStartIndex]!, 1);\n  const segmentSizeY = positiveModulo(yValues[segmentEndIndex]! - yValues[segmentStartIndex]!, 1);\n  const positionInSegment =\n    segmentSizeX < 0.001 ? 0.5 : positiveModulo(x - xValues[segmentStartIndex]!, 1) / segmentSizeX;\n  return positiveModulo(yValues[segmentStartIndex]! + segmentSizeY * positionInSegment, 1);\n}\n\n/**\n * A bidirectional mapping between two progress spaces, both `[0, 1)` and wrapping. Each\n * mapping pair anchors one source progress to one target progress.\n */\nexport class DoubleMapper {\n  static readonly Identity = new DoubleMapper([0, 0], [0.5, 0.5]);\n\n  private readonly sourceValues: number[];\n  private readonly targetValues: number[];\n\n  constructor(...mappings: readonly (readonly [number, number])[]) {\n    this.sourceValues = mappings.map(([source]) => source);\n    this.targetValues = mappings.map(([, target]) => target);\n    // Both lists must increase monotonically, except for at most one wrap-around.\n    validateProgress(this.sourceValues);\n    validateProgress(this.targetValues);\n  }\n\n  map(x: number): number {\n    return linearMap(this.sourceValues, this.targetValues, x);\n  }\n\n  mapBack(x: number): number {\n    return linearMap(this.targetValues, this.sourceValues, x);\n  }\n}\n\n/**\n * Checks that every progress value is in `[0, 1)` and that the list (including the last to\n * first pair) increases monotonically, wrapping at most once. `(0.3, 0.6, 0)` is valid;\n * `(0.5, 0, 0.7)` is not.\n */\nexport function validateProgress(p: readonly number[]): void {\n  let prev = p[p.length - 1]!;\n  let wraps = 0;\n  for (const curr of p) {\n    if (!(curr >= 0 && curr < 1)) {\n      throw new Error(`FloatMapping - Progress outside of range: ${p.join(', ')}`);\n    }\n    if (!(progressDistance(curr, prev) > DistanceEpsilon)) {\n      throw new Error(`FloatMapping - Progress repeats a value: ${p.join(', ')}`);\n    }\n    if (curr < prev) {\n      wraps++;\n      if (wraps > 1) {\n        throw new Error(`FloatMapping - Progress wraps more than once: ${p.join(', ')}`);\n      }\n    }\n    prev = curr;\n  }\n}\n\n/** Distance between two wrapping progress values: 0.99 and 0 are 0.01 apart. */\nexport function progressDistance(p1: number, p2: number): number {\n  const d = Math.abs(p1 - p2);\n  return Math.min(d, 1 - d);\n}\n"],"mappings":";;;AAMA,SAAgB,gBAAgB,UAAkB,MAAc,IAAqB;CACnF,OAAO,MAAM,OAAO,YAAY,QAAQ,YAAY,KAAK,YAAY,QAAQ,YAAY;AAC3F;;AAGA,SAAgB,UACd,SACA,SACA,GACQ;CACR,IAAI,EAAE,KAAK,KAAK,KAAK,IAAI,MAAM,IAAI,MAAM,qBAAqB,GAAG;CACjE,MAAM,IAAI,QAAQ;CAClB,MAAM,oBAAoB,QAAQ,WAAW,GAAG,MAC9C,gBAAgB,GAAG,QAAQ,IAAK,SAAS,IAAI,KAAK,EAAG,CACvD;CACA,MAAM,mBAAmB,oBAAoB,KAAK;CAClD,MAAM,eAAe,eAAe,QAAQ,mBAAoB,QAAQ,oBAAqB,CAAC;CAC9F,MAAM,eAAe,eAAe,QAAQ,mBAAoB,QAAQ,oBAAqB,CAAC;CAC9F,MAAM,oBACJ,eAAe,OAAQ,KAAM,eAAe,IAAI,QAAQ,oBAAqB,CAAC,IAAI;CACpF,OAAO,eAAe,QAAQ,qBAAsB,eAAe,mBAAmB,CAAC;AACzF;;;;;AAMA,IAAa,eAAb,MAAa,aAAa;CACxB,OAAgB,WAAW,IAAI,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,IAAK,EAAG,CAAC;CAE9D;CACA;CAEA,YAAY,GAAG,UAAkD;EAC/D,KAAK,eAAe,SAAS,KAAK,CAAC,YAAY,MAAM;EACrD,KAAK,eAAe,SAAS,KAAK,GAAG,YAAY,MAAM;EAEvD,iBAAiB,KAAK,YAAY;EAClC,iBAAiB,KAAK,YAAY;CACpC;CAEA,IAAI,GAAmB;EACrB,OAAO,UAAU,KAAK,cAAc,KAAK,cAAc,CAAC;CAC1D;CAEA,QAAQ,GAAmB;EACzB,OAAO,UAAU,KAAK,cAAc,KAAK,cAAc,CAAC;CAC1D;AACF;;;;;;AAOA,SAAgB,iBAAiB,GAA4B;CAC3D,IAAI,OAAO,EAAE,EAAE,SAAS;CACxB,IAAI,QAAQ;CACZ,KAAK,MAAM,QAAQ,GAAG;EACpB,IAAI,EAAE,QAAQ,KAAK,OAAO,IACxB,MAAM,IAAI,MAAM,6CAA6C,EAAE,KAAK,IAAI,GAAG;EAE7E,IAAI,EAAE,iBAAiB,MAAM,IAAI,IAAA,OAC/B,MAAM,IAAI,MAAM,4CAA4C,EAAE,KAAK,IAAI,GAAG;EAE5E,IAAI,OAAO,MAAM;GACf;GACA,IAAI,QAAQ,GACV,MAAM,IAAI,MAAM,iDAAiD,EAAE,KAAK,IAAI,GAAG;EAEnF;EACA,OAAO;CACT;AACF;;AAGA,SAAgB,iBAAiB,IAAY,IAAoB;CAC/D,MAAM,IAAI,KAAK,IAAI,KAAK,EAAE;CAC1B,OAAO,KAAK,IAAI,GAAG,IAAI,CAAC;AAC1B"}

package/dist/shapes/generated/material-shape-path-record.d.ts

@@ -0,0 +1,11 @@
+import { MaterialShapePath } from "../shape-path.js";
+import { MaterialShapeName } from "./material-shape-paths.js";
+//#region src/shapes/generated/material-shape-path-record.d.ts
+/**
+ * Every M3 Expressive shape's precomputed outline by name, for a shape gallery or picker.
+ * Importing it costs all 35 outlines (about 11 kB gzipped once minified); to draw one shape, import its
+ * constant (`cookie12SidedShape`) instead.
+ */
+export declare const materialShapePaths: Readonly<Record<MaterialShapeName, MaterialShapePath>>;
+//#endregion
+//# sourceMappingURL=material-shape-path-record.d.ts.map

package/dist/shapes/generated/material-shape-path-record.js

@@ -0,0 +1,48 @@
+import { archShape, arrowShape, boomShape, bunShape, burstShape, circleShape, clamShellShape, clover4LeafShape, clover8LeafShape, cookie12SidedShape, cookie4SidedShape, cookie6SidedShape, cookie7SidedShape, cookie9SidedShape, diamondShape, fanShape, flowerShape, gemShape, ghostishShape, heartShape, ovalShape, pentagonShape, pillShape, pixelCircleShape, pixelTriangleShape, puffyDiamondShape, puffyShape, semiCircleShape, slantedShape, softBoomShape, softBurstShape, squareShape, sunnyShape, triangleShape, verySunnyShape } from "./material-shape-paths.js";
+//#region src/shapes/generated/material-shape-path-record.ts
+/**
+* Every M3 Expressive shape's precomputed outline by name, for a shape gallery or picker.
+* Importing it costs all 35 outlines (about 11 kB gzipped once minified); to draw one shape, import its
+* constant (`cookie12SidedShape`) instead.
+*/
+const materialShapePaths = {
+	Circle: circleShape,
+	Square: squareShape,
+	Slanted: slantedShape,
+	Arch: archShape,
+	Fan: fanShape,
+	Arrow: arrowShape,
+	SemiCircle: semiCircleShape,
+	Oval: ovalShape,
+	Pill: pillShape,
+	Triangle: triangleShape,
+	Diamond: diamondShape,
+	ClamShell: clamShellShape,
+	Pentagon: pentagonShape,
+	Gem: gemShape,
+	Sunny: sunnyShape,
+	VerySunny: verySunnyShape,
+	Cookie4Sided: cookie4SidedShape,
+	Cookie6Sided: cookie6SidedShape,
+	Cookie7Sided: cookie7SidedShape,
+	Cookie9Sided: cookie9SidedShape,
+	Cookie12Sided: cookie12SidedShape,
+	Ghostish: ghostishShape,
+	Clover4Leaf: clover4LeafShape,
+	Clover8Leaf: clover8LeafShape,
+	Burst: burstShape,
+	SoftBurst: softBurstShape,
+	Boom: boomShape,
+	SoftBoom: softBoomShape,
+	Flower: flowerShape,
+	Puffy: puffyShape,
+	PuffyDiamond: puffyDiamondShape,
+	PixelCircle: pixelCircleShape,
+	PixelTriangle: pixelTriangleShape,
+	Bun: bunShape,
+	Heart: heartShape
+};
+//#endregion
+export { materialShapePaths };
+
+//# sourceMappingURL=material-shape-path-record.js.map

package/dist/shapes/generated/material-shape-path-record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"material-shape-path-record.js","names":[],"sources":["../../../src/shapes/generated/material-shape-path-record.ts"],"sourcesContent":["/* Generated by @windmorph/react from src/shapes/material-shapes.ts (pnpm generate). Do not edit by hand. */\nimport type { MaterialShapePath } from '../shape-path';\nimport {\n  circleShape,\n  squareShape,\n  slantedShape,\n  archShape,\n  fanShape,\n  arrowShape,\n  semiCircleShape,\n  ovalShape,\n  pillShape,\n  triangleShape,\n  diamondShape,\n  clamShellShape,\n  pentagonShape,\n  gemShape,\n  sunnyShape,\n  verySunnyShape,\n  cookie4SidedShape,\n  cookie6SidedShape,\n  cookie7SidedShape,\n  cookie9SidedShape,\n  cookie12SidedShape,\n  ghostishShape,\n  clover4LeafShape,\n  clover8LeafShape,\n  burstShape,\n  softBurstShape,\n  boomShape,\n  softBoomShape,\n  flowerShape,\n  puffyShape,\n  puffyDiamondShape,\n  pixelCircleShape,\n  pixelTriangleShape,\n  bunShape,\n  heartShape,\n  type MaterialShapeName,\n} from './material-shape-paths';\n\n/**\n * Every M3 Expressive shape's precomputed outline by name, for a shape gallery or picker.\n * Importing it costs all 35 outlines (about 11 kB gzipped once minified); to draw one shape, import its\n * constant (`cookie12SidedShape`) instead.\n */\nexport const materialShapePaths: Readonly<Record<MaterialShapeName, MaterialShapePath>> = {\n  Circle: circleShape,\n  Square: squareShape,\n  Slanted: slantedShape,\n  Arch: archShape,\n  Fan: fanShape,\n  Arrow: arrowShape,\n  SemiCircle: semiCircleShape,\n  Oval: ovalShape,\n  Pill: pillShape,\n  Triangle: triangleShape,\n  Diamond: diamondShape,\n  ClamShell: clamShellShape,\n  Pentagon: pentagonShape,\n  Gem: gemShape,\n  Sunny: sunnyShape,\n  VerySunny: verySunnyShape,\n  Cookie4Sided: cookie4SidedShape,\n  Cookie6Sided: cookie6SidedShape,\n  Cookie7Sided: cookie7SidedShape,\n  Cookie9Sided: cookie9SidedShape,\n  Cookie12Sided: cookie12SidedShape,\n  Ghostish: ghostishShape,\n  Clover4Leaf: clover4LeafShape,\n  Clover8Leaf: clover8LeafShape,\n  Burst: burstShape,\n  SoftBurst: softBurstShape,\n  Boom: boomShape,\n  SoftBoom: softBoomShape,\n  Flower: flowerShape,\n  Puffy: puffyShape,\n  PuffyDiamond: puffyDiamondShape,\n  PixelCircle: pixelCircleShape,\n  PixelTriangle: pixelTriangleShape,\n  Bun: bunShape,\n  Heart: heartShape,\n};\n"],"mappings":";;;;;;;AA8CA,MAAa,qBAA6E;CACxF,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,MAAM;CACN,KAAK;CACL,OAAO;CACP,YAAY;CACZ,MAAM;CACN,MAAM;CACN,UAAU;CACV,SAAS;CACT,WAAW;CACX,UAAU;CACV,KAAK;CACL,OAAO;CACP,WAAW;CACX,cAAc;CACd,cAAc;CACd,cAAc;CACd,cAAc;CACd,eAAe;CACf,UAAU;CACV,aAAa;CACb,aAAa;CACb,OAAO;CACP,WAAW;CACX,MAAM;CACN,UAAU;CACV,QAAQ;CACR,OAAO;CACP,cAAc;CACd,aAAa;CACb,eAAe;CACf,KAAK;CACL,OAAO;AACT"}