@windmorph/react 0.0.0-stage → 0.1.1

package/dist/shapes/point.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"point.js","names":[],"sources":["../../src/shapes/point.ts"],"sourcesContent":["/*\n * Port of androidx.graphics.shapes Point.kt and Utils.kt (Apache-2.0, see LICENSE-androidx.md).\n */\n\n/** An immutable 2D point or vector. */\nexport class Point {\n  constructor(\n    readonly x: number,\n    readonly y: number,\n  ) {}\n\n  /** Distance from (0, 0). */\n  getDistance(): number {\n    return Math.sqrt(this.x * this.x + this.y * this.y);\n  }\n\n  getDistanceSquared(): number {\n    return this.x * this.x + this.y * this.y;\n  }\n\n  dotProduct(other: Point): number {\n    return this.x * other.x + this.y * other.y;\n  }\n\n  dotProductXY(otherX: number, otherY: number): number {\n    return this.x * otherX + this.y * otherY;\n  }\n\n  /** Whether `other` turns clockwise from this vector (z of the cross product > 0). */\n  clockwise(other: Point): boolean {\n    return this.x * other.y - this.y * other.x > 0;\n  }\n\n  /** Unit vector in this direction. */\n  getDirection(): Point {\n    const d = this.getDistance();\n    if (!(d > 0)) throw new Error(\"Can't get the direction of a 0-length vector\");\n    return this.div(d);\n  }\n\n  negate(): Point {\n    return new Point(-this.x, -this.y);\n  }\n\n  minus(other: Point): Point {\n    return new Point(this.x - other.x, this.y - other.y);\n  }\n\n  plus(other: Point): Point {\n    return new Point(this.x + other.x, this.y + other.y);\n  }\n\n  times(operand: number): Point {\n    return new Point(this.x * operand, this.y * operand);\n  }\n\n  div(operand: number): Point {\n    return new Point(this.x / operand, this.y / operand);\n  }\n\n  rem(operand: number): Point {\n    return new Point(this.x % operand, this.y % operand);\n  }\n\n  rotate90(): Point {\n    return new Point(-this.y, this.x);\n  }\n\n  transformed(f: PointTransformer): Point {\n    const [x, y] = f(this.x, this.y);\n    return new Point(x, y);\n  }\n}\n\n/** Maps a point to a new point, e.g. to scale or rotate a shape. */\nexport type PointTransformer = (x: number, y: number) => readonly [number, number];\n\nexport const Zero = new Point(0, 0);\n\n/*\n * These epsilon values are used internally to determine when two points are the same, within\n * some reasonable roundoff error. The distance epsilon is smaller, with the intention that the\n * roundoff should not be larger than a pixel on any reasonable sized display.\n */\nexport const DistanceEpsilon = 1e-4;\nexport const AngleEpsilon = 1e-6;\n/**\n * People see e.g. collinearity much more relaxed than what is mathematically correct; use this\n * for operations that allow higher tolerances.\n */\nexport const RelaxedDistanceEpsilon = 5e-3;\n\nexport const FloatPi = Math.PI;\nexport const TwoPi = 2 * Math.PI;\n\nexport function distance(x: number, y: number): number {\n  return Math.sqrt(x * x + y * y);\n}\n\nexport function distanceSquared(x: number, y: number): number {\n  return x * x + y * y;\n}\n\n/** Unit vector in the direction of (x, y). */\nexport function directionVector(x: number, y: number): Point {\n  const d = distance(x, y);\n  if (!(d > 0)) throw new Error('Required distance greater than zero');\n  return new Point(x / d, y / d);\n}\n\nexport function directionVectorFromAngle(angleRadians: number): Point {\n  return new Point(Math.cos(angleRadians), Math.sin(angleRadians));\n}\n\nexport function radialToCartesian(\n  radius: number,\n  angleRadians: number,\n  center: Point = Zero,\n): Point {\n  return directionVectorFromAngle(angleRadians).times(radius).plus(center);\n}\n\nexport function square(x: number): number {\n  return x * x;\n}\n\n/** Linearly interpolates between `start` and `stop`. */\nexport function interpolate(start: number, stop: number, fraction: number): number {\n  return (1 - fraction) * start + fraction * stop;\n}\n\nexport function interpolatePoint(start: Point, stop: Point, fraction: number): Point {\n  return new Point(interpolate(start.x, stop.x, fraction), interpolate(start.y, stop.y, fraction));\n}\n\n/** Like `num % mod`, but always positive: positiveModulo(-4, 3) = 2. */\nexport function positiveModulo(num: number, mod: number): number {\n  return ((num % mod) + mod) % mod;\n}\n\n/** Whether C is on the line through A and B, within `tolerance`. */\nexport function collinearIsh(\n  aX: number,\n  aY: number,\n  bX: number,\n  bY: number,\n  cX: number,\n  cY: number,\n  tolerance: number = DistanceEpsilon,\n): boolean {\n  // The dot product of a perpendicular angle is 0. By rotating one of the vectors,\n  // we save the calculations to convert the dot product to degrees afterwards.\n  const ab = new Point(bX - aX, bY - aY).rotate90();\n  const ac = new Point(cX - aX, cY - aY);\n  const dotProduct = Math.abs(ab.dotProduct(ac));\n  const relativeTolerance = tolerance * ab.getDistance() * ac.getDistance();\n  return dotProduct < tolerance || dotProduct < relativeTolerance;\n}\n\n/** Approximates whether the corner at `current` is convex. */\nexport function convex(previous: Point, current: Point, next: Point): boolean {\n  // (androidx b/369320447: fast, but not reliable.)\n  return current.minus(previous).clockwise(next.minus(current));\n}\n\n/** Ternary search for the minimum of `f` between `v0` and `v1`. */\nexport function findMinimum(\n  v0: number,\n  v1: number,\n  tolerance: number,\n  f: (value: number) => number,\n): number {\n  let a = v0;\n  let b = v1;\n  while (b - a > tolerance) {\n    const c1 = (2 * a + b) / 3;\n    const c2 = (2 * b + a) / 3;\n    if (f(c1) < f(c2)) b = c2;\n    else a = c1;\n  }\n  return (a + b) / 2;\n}\n"],"mappings":"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"}

package/dist/shapes/polygon-measure.js

@@ -0,0 +1,140 @@
+import { Point, positiveModulo } from "./point.js";
+import { Corner } from "./features.js";
+//#region src/shapes/polygon-measure.ts
+/** Approximates arc length with a 3-segment polyline (≥ 98.5% of the true length). */
+var LengthMeasurer = class {
+	segments = 3;
+	measureCubic(c) {
+		return this.closestProgressTo(c, Infinity)[1];
+	}
+	findCubicCutPoint(c, m) {
+		return this.closestProgressTo(c, m)[0];
+	}
+	closestProgressTo(cubic, threshold) {
+		let total = 0;
+		let remainder = threshold;
+		let prev = new Point(cubic.anchor0X, cubic.anchor0Y);
+		for (let i = 1; i <= this.segments; i++) {
+			const progress = i / this.segments;
+			const point = cubic.pointOnCurve(progress);
+			const segment = point.minus(prev).getDistance();
+			if (segment >= remainder) return [progress - (1 - remainder / segment) / this.segments, threshold];
+			remainder -= segment;
+			total += segment;
+			prev = point;
+		}
+		return [1, total];
+	}
+};
+/** A cubic with its `[start, end]` progress range along the polygon outline. */
+var MeasuredCubic = class MeasuredCubic {
+	measurer;
+	cubic;
+	start;
+	end;
+	measuredSize;
+	constructor(measurer, cubic, start, end) {
+		this.measurer = measurer;
+		this.cubic = cubic;
+		this.start = start;
+		this.end = end;
+		if (!(end >= start)) throw new Error("endOutlineProgress is expected to be equal or greater than startOutlineProgress");
+		this.measuredSize = measurer.measureCubic(cubic);
+	}
+	get startOutlineProgress() {
+		return this.start;
+	}
+	get endOutlineProgress() {
+		return this.end;
+	}
+	updateProgressRange(start = this.start, end = this.end) {
+		if (!(end >= start)) throw new Error("endOutlineProgress is expected to be equal or greater than startOutlineProgress");
+		this.start = start;
+		this.end = end;
+	}
+	cutAtProgress(cutOutlineProgress) {
+		const bounded = Math.min(Math.max(cutOutlineProgress, this.start), this.end);
+		const relativeProgress = (bounded - this.start) / (this.end - this.start);
+		const t = this.measurer.findCubicCutPoint(this.cubic, relativeProgress * this.measuredSize);
+		if (!(t >= 0 && t <= 1)) throw new Error("Cubic cut point is expected to be between 0 and 1");
+		const [c1, c2] = this.cubic.split(t);
+		return [new MeasuredCubic(this.measurer, c1, this.start, bounded), new MeasuredCubic(this.measurer, c2, bounded, this.end)];
+	}
+	toString() {
+		return `MeasuredCubic(outlineProgress=[${this.start} .. ${this.end}], size=${this.measuredSize}, cubic=${this.cubic})`;
+	}
+};
+/** A polygon's cubics, measured and mapped to outline progress in `[0, 1]`. */
+var MeasuredPolygon = class MeasuredPolygon {
+	measurer;
+	features;
+	cubics;
+	constructor(measurer, features, cubics, outlineProgress) {
+		this.measurer = measurer;
+		this.features = features;
+		if (outlineProgress.length !== cubics.length + 1) throw new Error("Outline progress size is expected to be the cubics size + 1");
+		if (outlineProgress[0] !== 0) throw new Error("First outline progress value is expected to be zero");
+		if (outlineProgress[outlineProgress.length - 1] !== 1) throw new Error("Last outline progress value is expected to be one");
+		const measured = [];
+		let startOutlineProgress = 0;
+		for (let i = 0; i < cubics.length; i++) if (outlineProgress[i + 1] - outlineProgress[i] > 1e-4) {
+			measured.push(new MeasuredCubic(measurer, cubics[i], startOutlineProgress, outlineProgress[i + 1]));
+			startOutlineProgress = outlineProgress[i + 1];
+		}
+		measured[measured.length - 1].updateProgressRange(void 0, 1);
+		this.cubics = measured;
+	}
+	get size() {
+		return this.cubics.length;
+	}
+	get(index) {
+		return this.cubics[index];
+	}
+	/** Cuts the outline at `cuttingPoint` and shifts it so that point becomes progress 0. */
+	cutAndShift(cuttingPoint) {
+		if (!(cuttingPoint >= 0 && cuttingPoint <= 1)) throw new Error("Cutting point is expected to be between 0 and 1");
+		if (cuttingPoint < 1e-4) return this;
+		const n = this.cubics.length;
+		const targetIndex = this.cubics.findIndex((c) => cuttingPoint >= c.startOutlineProgress && cuttingPoint <= c.endOutlineProgress);
+		const [b1, b2] = this.cubics[targetIndex].cutAtProgress(cuttingPoint);
+		const retCubics = [b2.cubic];
+		for (let i = 1; i < n; i++) retCubics.push(this.cubics[(i + targetIndex) % n].cubic);
+		retCubics.push(b1.cubic);
+		const retOutlineProgress = [0];
+		for (let index = 1; index <= n; index++) {
+			const cubicIndex = (targetIndex + index - 1) % n;
+			retOutlineProgress.push(positiveModulo(this.cubics[cubicIndex].endOutlineProgress - cuttingPoint, 1));
+		}
+		retOutlineProgress.push(1);
+		const newFeatures = this.features.map((f) => ({
+			progress: positiveModulo(f.progress - cuttingPoint, 1),
+			feature: f.feature
+		}));
+		return new MeasuredPolygon(this.measurer, newFeatures, retCubics, retOutlineProgress);
+	}
+	static measurePolygon(measurer, polygon) {
+		const cubics = [];
+		const featureToCubic = [];
+		for (const feature of polygon.features) feature.cubics.forEach((cubic, cubicIndex) => {
+			if (feature instanceof Corner && cubicIndex === Math.floor(feature.cubics.length / 2)) featureToCubic.push([feature, cubics.length]);
+			cubics.push(cubic);
+		});
+		const measures = [0];
+		for (const cubic of cubics) {
+			const size = measurer.measureCubic(cubic);
+			if (!(size >= 0)) throw new Error("Measured cubic is expected to be greater or equal to zero");
+			measures.push(measures[measures.length - 1] + size);
+		}
+		const totalMeasure = measures[measures.length - 1];
+		const outlineProgress = measures.map((m) => m / totalMeasure);
+		const features = featureToCubic.map(([feature, ix]) => ({
+			progress: positiveModulo((outlineProgress[ix] + outlineProgress[ix + 1]) / 2, 1),
+			feature
+		}));
+		return new MeasuredPolygon(measurer, features, cubics, outlineProgress);
+	}
+};
+//#endregion
+export { LengthMeasurer, MeasuredCubic, MeasuredPolygon };
+
+//# sourceMappingURL=polygon-measure.js.map

package/dist/shapes/polygon-measure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-measure.js","names":[],"sources":["../../src/shapes/polygon-measure.ts"],"sourcesContent":["/*\n * Port of androidx.graphics.shapes PolygonMeasure.kt (Apache-2.0, see LICENSE-androidx.md).\n */\nimport type { Cubic } from './cubic';\nimport { Corner, type Feature } from './features';\nimport { DistanceEpsilon, Point, positiveModulo } from './point';\nimport type { RoundedPolygon } from './rounded-polygon';\n\n/** A feature together with its progress along the polygon outline. */\nexport interface ProgressableFeature {\n  readonly progress: number;\n  readonly feature: Feature;\n}\n\nexport interface Measurer {\n  /** A non-negative measure of the cubic, e.g. its length. */\n  measureCubic(c: Cubic): number;\n  /** The `t` at which the cubic's measure from its start reaches `m`. */\n  findCubicCutPoint(c: Cubic, m: number): number;\n}\n\n/** Approximates arc length with a 3-segment polyline (≥ 98.5% of the true length). */\nexport class LengthMeasurer implements Measurer {\n  private readonly segments = 3;\n\n  measureCubic(c: Cubic): number {\n    return this.closestProgressTo(c, Infinity)[1];\n  }\n\n  findCubicCutPoint(c: Cubic, m: number): number {\n    return this.closestProgressTo(c, m)[0];\n  }\n\n  private closestProgressTo(cubic: Cubic, threshold: number): [number, number] {\n    let total = 0;\n    let remainder = threshold;\n    let prev = new Point(cubic.anchor0X, cubic.anchor0Y);\n    for (let i = 1; i <= this.segments; i++) {\n      const progress = i / this.segments;\n      const point = cubic.pointOnCurve(progress);\n      const segment = point.minus(prev).getDistance();\n      if (segment >= remainder) {\n        return [progress - (1 - remainder / segment) / this.segments, threshold];\n      }\n      remainder -= segment;\n      total += segment;\n      prev = point;\n    }\n    return [1, total];\n  }\n}\n\n/** A cubic with its `[start, end]` progress range along the polygon outline. */\nexport class MeasuredCubic {\n  readonly measuredSize: number;\n\n  constructor(\n    private readonly measurer: Measurer,\n    readonly cubic: Cubic,\n    private start: number,\n    private end: number,\n  ) {\n    if (!(end >= start)) {\n      throw new Error(\n        'endOutlineProgress is expected to be equal or greater than startOutlineProgress',\n      );\n    }\n    this.measuredSize = measurer.measureCubic(cubic);\n  }\n\n  get startOutlineProgress(): number {\n    return this.start;\n  }\n\n  get endOutlineProgress(): number {\n    return this.end;\n  }\n\n  updateProgressRange(start = this.start, end = this.end): void {\n    if (!(end >= start)) {\n      throw new Error(\n        'endOutlineProgress is expected to be equal or greater than startOutlineProgress',\n      );\n    }\n    this.start = start;\n    this.end = end;\n  }\n\n  cutAtProgress(cutOutlineProgress: number): [MeasuredCubic, MeasuredCubic] {\n    // Float error upstream can land the cut just outside this cubic; clamp it.\n    const bounded = Math.min(Math.max(cutOutlineProgress, this.start), this.end);\n    const relativeProgress = (bounded - this.start) / (this.end - this.start);\n    const t = this.measurer.findCubicCutPoint(this.cubic, relativeProgress * this.measuredSize);\n    if (!(t >= 0 && t <= 1)) throw new Error('Cubic cut point is expected to be between 0 and 1');\n    const [c1, c2] = this.cubic.split(t);\n    return [\n      new MeasuredCubic(this.measurer, c1, this.start, bounded),\n      new MeasuredCubic(this.measurer, c2, bounded, this.end),\n    ];\n  }\n\n  toString(): string {\n    return `MeasuredCubic(outlineProgress=[${this.start} .. ${this.end}], size=${this.measuredSize}, cubic=${this.cubic})`;\n  }\n}\n\n/** A polygon's cubics, measured and mapped to outline progress in `[0, 1]`. */\nexport class MeasuredPolygon {\n  private readonly cubics: readonly MeasuredCubic[];\n\n  private constructor(\n    private readonly measurer: Measurer,\n    readonly features: readonly ProgressableFeature[],\n    cubics: readonly Cubic[],\n    outlineProgress: readonly number[],\n  ) {\n    if (outlineProgress.length !== cubics.length + 1) {\n      throw new Error('Outline progress size is expected to be the cubics size + 1');\n    }\n    if (outlineProgress[0] !== 0) {\n      throw new Error('First outline progress value is expected to be zero');\n    }\n    if (outlineProgress[outlineProgress.length - 1] !== 1) {\n      throw new Error('Last outline progress value is expected to be one');\n    }\n    const measured: MeasuredCubic[] = [];\n    let startOutlineProgress = 0;\n    for (let i = 0; i < cubics.length; i++) {\n      // Filter out \"empty\" cubics.\n      if (outlineProgress[i + 1]! - outlineProgress[i]! > DistanceEpsilon) {\n        measured.push(\n          new MeasuredCubic(measurer, cubics[i]!, startOutlineProgress, outlineProgress[i + 1]!),\n        );\n        startOutlineProgress = outlineProgress[i + 1]!;\n      }\n    }\n    // Empty cubics may have been dropped at the end; the last one must still end at 1.\n    measured[measured.length - 1]!.updateProgressRange(undefined, 1);\n    this.cubics = measured;\n  }\n\n  get size(): number {\n    return this.cubics.length;\n  }\n\n  get(index: number): MeasuredCubic | undefined {\n    return this.cubics[index];\n  }\n\n  /** Cuts the outline at `cuttingPoint` and shifts it so that point becomes progress 0. */\n  cutAndShift(cuttingPoint: number): MeasuredPolygon {\n    if (!(cuttingPoint >= 0 && cuttingPoint <= 1)) {\n      throw new Error('Cutting point is expected to be between 0 and 1');\n    }\n    if (cuttingPoint < DistanceEpsilon) return this;\n    const n = this.cubics.length;\n    const targetIndex = this.cubics.findIndex(\n      (c) => cuttingPoint >= c.startOutlineProgress && cuttingPoint <= c.endOutlineProgress,\n    );\n    const [b1, b2] = this.cubics[targetIndex]!.cutAtProgress(cuttingPoint);\n\n    // The tail of the cut cubic, every other cubic in order, then the head of the cut cubic.\n    const retCubics = [b2.cubic];\n    for (let i = 1; i < n; i++) retCubics.push(this.cubics[(i + targetIndex) % n]!.cubic);\n    retCubics.push(b1.cubic);\n\n    const retOutlineProgress: number[] = [0];\n    for (let index = 1; index <= n; index++) {\n      const cubicIndex = (targetIndex + index - 1) % n;\n      retOutlineProgress.push(\n        positiveModulo(this.cubics[cubicIndex]!.endOutlineProgress - cuttingPoint, 1),\n      );\n    }\n    retOutlineProgress.push(1);\n\n    const newFeatures = this.features.map((f) => ({\n      progress: positiveModulo(f.progress - cuttingPoint, 1),\n      feature: f.feature,\n    }));\n    return new MeasuredPolygon(this.measurer, newFeatures, retCubics, retOutlineProgress);\n  }\n\n  static measurePolygon(measurer: Measurer, polygon: RoundedPolygon): MeasuredPolygon {\n    const cubics: Cubic[] = [];\n    const featureToCubic: [Feature, number][] = [];\n    // Collect the cubics; each corner is represented by its middle cubic.\n    for (const feature of polygon.features) {\n      feature.cubics.forEach((cubic, cubicIndex) => {\n        if (feature instanceof Corner && cubicIndex === Math.floor(feature.cubics.length / 2)) {\n          featureToCubic.push([feature, cubics.length]);\n        }\n        cubics.push(cubic);\n      });\n    }\n\n    const measures = [0];\n    for (const cubic of cubics) {\n      const size = measurer.measureCubic(cubic);\n      if (!(size >= 0))\n        throw new Error('Measured cubic is expected to be greater or equal to zero');\n      measures.push(measures[measures.length - 1]! + size);\n    }\n    const totalMeasure = measures[measures.length - 1]!;\n    const outlineProgress = measures.map((m) => m / totalMeasure);\n\n    const features = featureToCubic.map(([feature, ix]) => ({\n      progress: positiveModulo((outlineProgress[ix]! + outlineProgress[ix + 1]!) / 2, 1),\n      feature,\n    }));\n    return new MeasuredPolygon(measurer, features, cubics, outlineProgress);\n  }\n}\n"],"mappings":"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"}

package/dist/shapes/rounded-polygon.d.ts

@@ -0,0 +1,44 @@
+import { CornerRounding } from "./corner-rounding.js";
+import { Point, PointTransformer } from "./point.js";
+import { Cubic } from "./cubic.js";
+import { Feature } from "./features.js";
+//#region src/shapes/rounded-polygon.d.ts
+/**
+ * A closed shape made of cubic Bézier curves, built from vertices with optional per-corner
+ * rounding (or from features). Its `features` (corners and edges) drive morph matching.
+ */
+export declare class RoundedPolygon {
+  readonly features: readonly Feature[];
+  readonly center: Point;
+  readonly cubics: readonly Cubic[];
+  constructor(features: readonly Feature[], center: Point);
+  get centerX(): number;
+  get centerY(): number;
+  /** A regular polygon with `numVertices` vertices on a circle of `radius`. */
+  static fromNumVertices(numVertices: number, { radius, centerX, centerY, rounding, perVertexRounding }?: {
+    radius?: number;
+    centerX?: number;
+    centerY?: number;
+    rounding?: CornerRounding;
+    perVertexRounding?: readonly CornerRounding[];
+  }): RoundedPolygon;
+  /** A polygon through `vertices` (`[x0, y0, x1, y1, …]`), with optional corner rounding. */
+  static fromVertices(vertices: readonly number[], { rounding, perVertexRounding, centerX, centerY }?: {
+    rounding?: CornerRounding;
+    perVertexRounding?: readonly CornerRounding[];
+    centerX?: number;
+    centerY?: number;
+  }): RoundedPolygon;
+  /** A polygon from existing features; the center defaults to the average of their anchors. */
+  static fromFeatures(features: readonly Feature[], centerX?: number, centerY?: number): RoundedPolygon;
+  transformed(f: PointTransformer): RoundedPolygon;
+  /** Scales and translates the shape into the unit square (0..1), centred if not square. */
+  normalized(): RoundedPolygon;
+  /** Bounds of a circle around the center that contains the shape at any rotation. */
+  calculateMaxBounds(bounds?: number[]): number[];
+  /** `[minX, minY, maxX, maxY]`; `approximate` (default) uses control-point hulls. */
+  calculateBounds(bounds?: number[], approximate?: boolean): number[];
+  toString(): string;
+}
+//#endregion
+//# sourceMappingURL=rounded-polygon.d.ts.map

package/dist/shapes/rounded-polygon.js

@@ -0,0 +1,278 @@
+import { CornerRounding } from "./corner-rounding.js";
+import { Point, convex, directionVector, distance, distanceSquared, interpolatePoint, radialToCartesian, square } from "./point.js";
+import { Cubic } from "./cubic.js";
+import { Corner, Edge } from "./features.js";
+//#region src/shapes/rounded-polygon.ts
+/**
+* A closed shape made of cubic Bézier curves, built from vertices with optional per-corner
+* rounding (or from features). Its `features` (corners and edges) drive morph matching.
+*/
+var RoundedPolygon = class RoundedPolygon {
+	features;
+	center;
+	cubics;
+	constructor(features, center) {
+		this.features = features;
+		this.center = center;
+		this.cubics = buildCubics(features, center);
+		let prev = this.cubics[this.cubics.length - 1];
+		for (const cubic of this.cubics) {
+			if (Math.abs(cubic.anchor0X - prev.anchor1X) > 1e-4 || Math.abs(cubic.anchor0Y - prev.anchor1Y) > 1e-4) throw new Error("RoundedPolygon must be contiguous, with the anchor points of all curves matching the anchor points of the preceding and succeeding cubics");
+			prev = cubic;
+		}
+	}
+	get centerX() {
+		return this.center.x;
+	}
+	get centerY() {
+		return this.center.y;
+	}
+	/** A regular polygon with `numVertices` vertices on a circle of `radius`. */
+	static fromNumVertices(numVertices, { radius = 1, centerX = 0, centerY = 0, rounding = CornerRounding.Unrounded, perVertexRounding } = {}) {
+		return RoundedPolygon.fromVertices(verticesFromNumVerts(numVertices, radius, centerX, centerY), {
+			rounding,
+			perVertexRounding,
+			centerX,
+			centerY
+		});
+	}
+	/** A polygon through `vertices` (`[x0, y0, x1, y1, …]`), with optional corner rounding. */
+	static fromVertices(vertices, { rounding = CornerRounding.Unrounded, perVertexRounding, centerX, centerY } = {}) {
+		if (vertices.length < 6) throw new Error("Polygons must have at least 3 vertices");
+		if (vertices.length % 2 === 1) throw new Error("The vertices array should have even size");
+		if (perVertexRounding && perVertexRounding.length * 2 !== vertices.length) throw new Error("perVertexRounding list should be either null or the same size as the number of vertices (vertices.size / 2)");
+		const n = vertices.length / 2;
+		const vertex = (i) => new Point(vertices[i * 2], vertices[i * 2 + 1]);
+		const roundedCorners = [];
+		for (let i = 0; i < n; i++) roundedCorners.push(new RoundedCorner(vertex((i + n - 1) % n), vertex(i), vertex((i + 1) % n), perVertexRounding?.[i] ?? rounding));
+		const cutAdjusts = roundedCorners.map((corner, ix) => {
+			const next = roundedCorners[(ix + 1) % n];
+			const expectedRoundCut = corner.expectedRoundCut + next.expectedRoundCut;
+			const expectedCut = corner.expectedCut + next.expectedCut;
+			const a = vertex(ix);
+			const b = vertex((ix + 1) % n);
+			const sideSize = distance(a.x - b.x, a.y - b.y);
+			if (expectedRoundCut > sideSize) return [sideSize / expectedRoundCut, 0];
+			if (expectedCut > sideSize) return [1, (sideSize - expectedRoundCut) / (expectedCut - expectedRoundCut)];
+			return [1, 1];
+		});
+		const corners = roundedCorners.map((corner, i) => {
+			const allowedCuts = [0, 1].map((delta) => {
+				const [roundCutRatio, cutRatio] = cutAdjusts[(i + n - 1 + delta) % n];
+				return corner.expectedRoundCut * roundCutRatio + (corner.expectedCut - corner.expectedRoundCut) * cutRatio;
+			});
+			return corner.getCubics(allowedCuts[0], allowedCuts[1]);
+		});
+		const features = [];
+		for (let i = 0; i < n; i++) {
+			const isConvex = convex(vertex((i + n - 1) % n), vertex(i), vertex((i + 1) % n));
+			features.push(new Corner(corners[i], isConvex));
+			const end = corners[i][corners[i].length - 1];
+			const start = corners[(i + 1) % n][0];
+			features.push(new Edge([Cubic.straightLine(end.anchor1X, end.anchor1Y, start.anchor0X, start.anchor0Y)]));
+		}
+		const center = centerX === void 0 || centerY === void 0 ? calculateCenter(vertices) : new Point(centerX, centerY);
+		return new RoundedPolygon(features, center);
+	}
+	/** A polygon from existing features; the center defaults to the average of their anchors. */
+	static fromFeatures(features, centerX, centerY) {
+		if (features.length < 2) throw new Error("Polygons must have at least 2 features");
+		const vertices = [];
+		for (const feature of features) for (const cubic of feature.cubics) vertices.push(cubic.anchor0X, cubic.anchor0Y);
+		const computed = calculateCenter(vertices);
+		return new RoundedPolygon(features, new Point(centerX === void 0 || Number.isNaN(centerX) ? computed.x : centerX, centerY === void 0 || Number.isNaN(centerY) ? computed.y : centerY));
+	}
+	transformed(f) {
+		return new RoundedPolygon(this.features.map((feature) => feature.transformed(f)), this.center.transformed(f));
+	}
+	/** Scales and translates the shape into the unit square (0..1), centred if not square. */
+	normalized() {
+		const bounds = this.calculateBounds();
+		const width = bounds[2] - bounds[0];
+		const height = bounds[3] - bounds[1];
+		const side = Math.max(width, height);
+		const offsetX = (side - width) / 2 - bounds[0];
+		const offsetY = (side - height) / 2 - bounds[1];
+		return this.transformed((x, y) => [(x + offsetX) / side, (y + offsetY) / side]);
+	}
+	/** Bounds of a circle around the center that contains the shape at any rotation. */
+	calculateMaxBounds(bounds = new Array(4).fill(0)) {
+		let maxDistSquared = 0;
+		for (const cubic of this.cubics) {
+			const anchorDistance = distanceSquared(cubic.anchor0X - this.centerX, cubic.anchor0Y - this.centerY);
+			const middle = cubic.pointOnCurve(.5);
+			const middleDistance = distanceSquared(middle.x - this.centerX, middle.y - this.centerY);
+			maxDistSquared = Math.max(maxDistSquared, anchorDistance, middleDistance);
+		}
+		const d = Math.sqrt(maxDistSquared);
+		bounds[0] = this.centerX - d;
+		bounds[1] = this.centerY - d;
+		bounds[2] = this.centerX + d;
+		bounds[3] = this.centerY + d;
+		return bounds;
+	}
+	/** `[minX, minY, maxX, maxY]`; `approximate` (default) uses control-point hulls. */
+	calculateBounds(bounds = new Array(4).fill(0), approximate = true) {
+		let minX = Number.POSITIVE_INFINITY;
+		let minY = Number.POSITIVE_INFINITY;
+		let maxX = Number.NEGATIVE_INFINITY;
+		let maxY = Number.NEGATIVE_INFINITY;
+		for (const cubic of this.cubics) {
+			cubic.calculateBounds(bounds, approximate);
+			minX = Math.min(minX, bounds[0]);
+			minY = Math.min(minY, bounds[1]);
+			maxX = Math.max(maxX, bounds[2]);
+			maxY = Math.max(maxY, bounds[3]);
+		}
+		bounds[0] = minX;
+		bounds[1] = minY;
+		bounds[2] = maxX;
+		bounds[3] = maxY;
+		return bounds;
+	}
+	toString() {
+		return `[RoundedPolygon. Cubics = ${this.cubics.join(", ")} || Features = ${this.features.join(", ")} || Center = (${this.centerX}, ${this.centerY})]`;
+	}
+};
+function buildCubics(features, center) {
+	const result = [];
+	let firstCubic;
+	let lastCubic;
+	let firstFeatureSplitStart;
+	let firstFeatureSplitEnd;
+	if (features.length > 0 && features[0].cubics.length === 3) {
+		const [start, end] = features[0].cubics[1].split(.5);
+		firstFeatureSplitStart = [features[0].cubics[0], start];
+		firstFeatureSplitEnd = [end, features[0].cubics[2]];
+	}
+	for (let i = 0; i <= features.length; i++) {
+		let featureCubics;
+		if (i === 0 && firstFeatureSplitEnd) featureCubics = firstFeatureSplitEnd;
+		else if (i === features.length) {
+			if (firstFeatureSplitStart) featureCubics = firstFeatureSplitStart;
+			else break;
+		} else featureCubics = features[i].cubics;
+		for (const cubic of featureCubics) if (!cubic.zeroLength()) {
+			if (lastCubic) result.push(lastCubic);
+			lastCubic = cubic;
+			firstCubic ??= cubic;
+		} else if (lastCubic) {
+			const points = [...lastCubic.points];
+			points[6] = cubic.anchor1X;
+			points[7] = cubic.anchor1Y;
+			lastCubic = new Cubic(points);
+		}
+	}
+	if (lastCubic && firstCubic) result.push(Cubic.of(lastCubic.anchor0X, lastCubic.anchor0Y, lastCubic.control0X, lastCubic.control0Y, lastCubic.control1X, lastCubic.control1Y, firstCubic.anchor0X, firstCubic.anchor0Y));
+	else result.push(Cubic.empty(center.x, center.y));
+	return result;
+}
+function calculateCenter(vertices) {
+	let cumulativeX = 0;
+	let cumulativeY = 0;
+	for (let i = 0; i < vertices.length; i += 2) {
+		cumulativeX += vertices[i];
+		cumulativeY += vertices[i + 1];
+	}
+	return new Point(cumulativeX / (vertices.length / 2), cumulativeY / (vertices.length / 2));
+}
+function verticesFromNumVerts(numVertices, radius, centerX, centerY) {
+	const result = [];
+	for (let i = 0; i < numVertices; i++) {
+		const vertex = radialToCartesian(radius, Math.PI / numVertices * 2 * i).plus(new Point(centerX, centerY));
+		result.push(vertex.x, vertex.y);
+	}
+	return result;
+}
+var RoundedCorner = class {
+	p0;
+	p1;
+	p2;
+	d1;
+	d2;
+	cornerRadius;
+	smoothing;
+	cosAngle;
+	sinAngle;
+	expectedRoundCut;
+	/** Center of the rounding circle; equals p1 when there is no rounding. */
+	center = new Point(0, 0);
+	constructor(p0, p1, p2, rounding) {
+		this.p0 = p0;
+		this.p1 = p1;
+		this.p2 = p2;
+		const v01 = p0.minus(p1);
+		const v21 = p2.minus(p1);
+		const d01 = v01.getDistance();
+		const d21 = v21.getDistance();
+		if (d01 > 0 && d21 > 0) {
+			this.d1 = v01.div(d01);
+			this.d2 = v21.div(d21);
+			this.cornerRadius = rounding?.radius ?? 0;
+			this.smoothing = rounding?.smoothing ?? 0;
+			this.cosAngle = this.d1.dotProduct(this.d2);
+			this.sinAngle = Math.sqrt(1 - square(this.cosAngle));
+			this.expectedRoundCut = this.sinAngle > .001 ? this.cornerRadius * (this.cosAngle + 1) / this.sinAngle : 0;
+		} else {
+			this.d1 = new Point(0, 0);
+			this.d2 = new Point(0, 0);
+			this.cornerRadius = 0;
+			this.smoothing = 0;
+			this.cosAngle = 0;
+			this.sinAngle = 0;
+			this.expectedRoundCut = 0;
+		}
+	}
+	/** Smoothing lengthens the cut: 0 equals expectedRoundCut, 1 doubles it. */
+	get expectedCut() {
+		return (1 + this.smoothing) * this.expectedRoundCut;
+	}
+	getCubics(allowedCut0, allowedCut1 = allowedCut0) {
+		const allowedCut = Math.min(allowedCut0, allowedCut1);
+		if (this.expectedRoundCut < 1e-4 || allowedCut < 1e-4 || this.cornerRadius < 1e-4) {
+			this.center = this.p1;
+			return [Cubic.straightLine(this.p1.x, this.p1.y, this.p1.x, this.p1.y)];
+		}
+		const actualRoundCut = Math.min(allowedCut, this.expectedRoundCut);
+		const actualSmoothing0 = this.calculateActualSmoothingValue(allowedCut0);
+		const actualSmoothing1 = this.calculateActualSmoothingValue(allowedCut1);
+		const actualR = this.cornerRadius * actualRoundCut / this.expectedRoundCut;
+		const centerDistance = Math.sqrt(square(actualR) + square(actualRoundCut));
+		this.center = this.p1.plus(this.d1.plus(this.d2).div(2).getDirection().times(centerDistance));
+		const circleIntersection0 = this.p1.plus(this.d1.times(actualRoundCut));
+		const circleIntersection2 = this.p1.plus(this.d2.times(actualRoundCut));
+		const flanking0 = this.computeFlankingCurve(actualRoundCut, actualSmoothing0, this.p1, this.p0, circleIntersection0, circleIntersection2, this.center, actualR);
+		const flanking2 = this.computeFlankingCurve(actualRoundCut, actualSmoothing1, this.p1, this.p2, circleIntersection2, circleIntersection0, this.center, actualR).reverse();
+		return [
+			flanking0,
+			Cubic.circularArc(this.center.x, this.center.y, flanking0.anchor1X, flanking0.anchor1Y, flanking2.anchor0X, flanking2.anchor0Y),
+			flanking2
+		];
+	}
+	calculateActualSmoothingValue(allowedCut) {
+		if (allowedCut > this.expectedCut) return this.smoothing;
+		if (allowedCut > this.expectedRoundCut) return this.smoothing * (allowedCut - this.expectedRoundCut) / (this.expectedCut - this.expectedRoundCut);
+		return 0;
+	}
+	computeFlankingCurve(actualRoundCut, actualSmoothingValues, corner, sideStart, circleSegmentIntersection, otherCircleSegmentIntersection, circleCenter, actualR) {
+		const sideDirection = sideStart.minus(corner).getDirection();
+		const curveStart = corner.plus(sideDirection.times(actualRoundCut * (1 + actualSmoothingValues)));
+		const p = interpolatePoint(circleSegmentIntersection, circleSegmentIntersection.plus(otherCircleSegmentIntersection).div(2), actualSmoothingValues);
+		const curveEnd = circleCenter.plus(directionVector(p.x - circleCenter.x, p.y - circleCenter.y).times(actualR));
+		const anchorEnd = lineIntersection(sideStart, sideDirection, curveEnd, curveEnd.minus(circleCenter).rotate90()) ?? circleSegmentIntersection;
+		const anchorStart = curveStart.plus(anchorEnd.times(2)).div(3);
+		return Cubic.fromPoints(curveStart, anchorStart, anchorEnd, curveEnd);
+	}
+};
+function lineIntersection(p0, d0, p1, d1) {
+	const rotatedD1 = d1.rotate90();
+	const den = d0.dotProduct(rotatedD1);
+	if (Math.abs(den) < 1e-4) return void 0;
+	const num = p1.minus(p0).dotProduct(rotatedD1);
+	if (Math.abs(den) < 1e-4 * Math.abs(num)) return void 0;
+	return p0.plus(d0.times(num / den));
+}
+//#endregion
+export { RoundedPolygon, calculateCenter };
+
+//# sourceMappingURL=rounded-polygon.js.map

package/dist/shapes/rounded-polygon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rounded-polygon.js","names":[],"sources":["../../src/shapes/rounded-polygon.ts"],"sourcesContent":["/*\n * Port of androidx.graphics.shapes RoundedPolygon.kt (Apache-2.0, see LICENSE-androidx.md).\n */\nimport { CornerRounding } from './corner-rounding';\nimport { Cubic } from './cubic';\nimport { Corner, Edge, type Feature } from './features';\nimport {\n  DistanceEpsilon,\n  Point,\n  convex,\n  directionVector,\n  distance,\n  distanceSquared,\n  interpolatePoint,\n  radialToCartesian,\n  square,\n  type PointTransformer,\n} from './point';\n\n/**\n * A closed shape made of cubic Bézier curves, built from vertices with optional per-corner\n * rounding (or from features). Its `features` (corners and edges) drive morph matching.\n */\nexport class RoundedPolygon {\n  readonly cubics: readonly Cubic[];\n\n  constructor(\n    readonly features: readonly Feature[],\n    readonly center: Point,\n  ) {\n    this.cubics = buildCubics(features, center);\n    let prev = this.cubics[this.cubics.length - 1]!;\n    for (const cubic of this.cubics) {\n      if (\n        Math.abs(cubic.anchor0X - prev.anchor1X) > DistanceEpsilon ||\n        Math.abs(cubic.anchor0Y - prev.anchor1Y) > DistanceEpsilon\n      ) {\n        throw new Error(\n          'RoundedPolygon must be contiguous, with the anchor points of all curves matching the anchor points of the preceding and succeeding cubics',\n        );\n      }\n      prev = cubic;\n    }\n  }\n\n  get centerX(): number {\n    return this.center.x;\n  }\n\n  get centerY(): number {\n    return this.center.y;\n  }\n\n  /** A regular polygon with `numVertices` vertices on a circle of `radius`. */\n  static fromNumVertices(\n    numVertices: number,\n    {\n      radius = 1,\n      centerX = 0,\n      centerY = 0,\n      rounding = CornerRounding.Unrounded,\n      perVertexRounding,\n    }: {\n      radius?: number;\n      centerX?: number;\n      centerY?: number;\n      rounding?: CornerRounding;\n      perVertexRounding?: readonly CornerRounding[];\n    } = {},\n  ): RoundedPolygon {\n    return RoundedPolygon.fromVertices(\n      verticesFromNumVerts(numVertices, radius, centerX, centerY),\n      {\n        rounding,\n        perVertexRounding,\n        centerX,\n        centerY,\n      },\n    );\n  }\n\n  /** A polygon through `vertices` (`[x0, y0, x1, y1, …]`), with optional corner rounding. */\n  static fromVertices(\n    vertices: readonly number[],\n    {\n      rounding = CornerRounding.Unrounded,\n      perVertexRounding,\n      centerX,\n      centerY,\n    }: {\n      rounding?: CornerRounding;\n      perVertexRounding?: readonly CornerRounding[];\n      centerX?: number;\n      centerY?: number;\n    } = {},\n  ): RoundedPolygon {\n    if (vertices.length < 6) throw new Error('Polygons must have at least 3 vertices');\n    if (vertices.length % 2 === 1) throw new Error('The vertices array should have even size');\n    if (perVertexRounding && perVertexRounding.length * 2 !== vertices.length) {\n      throw new Error(\n        'perVertexRounding list should be either null or the same size as the number of vertices (vertices.size / 2)',\n      );\n    }\n    const n = vertices.length / 2;\n    const vertex = (i: number) => new Point(vertices[i * 2]!, vertices[i * 2 + 1]!);\n    const roundedCorners: RoundedCorner[] = [];\n    for (let i = 0; i < n; i++) {\n      roundedCorners.push(\n        new RoundedCorner(\n          vertex((i + n - 1) % n),\n          vertex(i),\n          vertex((i + 1) % n),\n          perVertexRounding?.[i] ?? rounding,\n        ),\n      );\n    }\n\n    // For each side, check if there is enough space for the cuts; if not, split the space,\n    // first for round cuts, then for smoothing. Each entry is [how much of expectedRoundCut,\n    // how much of expectedCut] the side from corner i to corner i+1 allows.\n    const cutAdjusts = roundedCorners.map((corner, ix) => {\n      const next = roundedCorners[(ix + 1) % n]!;\n      const expectedRoundCut = corner.expectedRoundCut + next.expectedRoundCut;\n      const expectedCut = corner.expectedCut + next.expectedCut;\n      const a = vertex(ix);\n      const b = vertex((ix + 1) % n);\n      const sideSize = distance(a.x - b.x, a.y - b.y);\n      if (expectedRoundCut > sideSize) return [sideSize / expectedRoundCut, 0] as const;\n      if (expectedCut > sideSize) {\n        return [1, (sideSize - expectedRoundCut) / (expectedCut - expectedRoundCut)] as const;\n      }\n      return [1, 1] as const;\n    });\n\n    const corners = roundedCorners.map((corner, i) => {\n      // allowedCuts[0]: side from the previous corner; allowedCuts[1]: side to the next one.\n      const allowedCuts = [0, 1].map((delta) => {\n        const [roundCutRatio, cutRatio] = cutAdjusts[(i + n - 1 + delta) % n]!;\n        return (\n          corner.expectedRoundCut * roundCutRatio +\n          (corner.expectedCut - corner.expectedRoundCut) * cutRatio\n        );\n      });\n      return corner.getCubics(allowedCuts[0]!, allowedCuts[1]!);\n    });\n\n    const features: Feature[] = [];\n    for (let i = 0; i < n; i++) {\n      const isConvex = convex(vertex((i + n - 1) % n), vertex(i), vertex((i + 1) % n));\n      features.push(new Corner(corners[i]!, isConvex));\n      const end = corners[i]![corners[i]!.length - 1]!;\n      const start = corners[(i + 1) % n]![0]!;\n      features.push(\n        new Edge([Cubic.straightLine(end.anchor1X, end.anchor1Y, start.anchor0X, start.anchor0Y)]),\n      );\n    }\n\n    const center =\n      centerX === undefined || centerY === undefined\n        ? calculateCenter(vertices)\n        : new Point(centerX, centerY);\n    return new RoundedPolygon(features, center);\n  }\n\n  /** A polygon from existing features; the center defaults to the average of their anchors. */\n  static fromFeatures(\n    features: readonly Feature[],\n    centerX?: number,\n    centerY?: number,\n  ): RoundedPolygon {\n    if (features.length < 2) throw new Error('Polygons must have at least 2 features');\n    const vertices: number[] = [];\n    for (const feature of features) {\n      for (const cubic of feature.cubics) vertices.push(cubic.anchor0X, cubic.anchor0Y);\n    }\n    const computed = calculateCenter(vertices);\n    return new RoundedPolygon(\n      features,\n      new Point(\n        centerX === undefined || Number.isNaN(centerX) ? computed.x : centerX,\n        centerY === undefined || Number.isNaN(centerY) ? computed.y : centerY,\n      ),\n    );\n  }\n\n  transformed(f: PointTransformer): RoundedPolygon {\n    return new RoundedPolygon(\n      this.features.map((feature) => feature.transformed(f)),\n      this.center.transformed(f),\n    );\n  }\n\n  /** Scales and translates the shape into the unit square (0..1), centred if not square. */\n  normalized(): RoundedPolygon {\n    const bounds = this.calculateBounds();\n    const width = bounds[2]! - bounds[0]!;\n    const height = bounds[3]! - bounds[1]!;\n    const side = Math.max(width, height);\n    // Center the shape if bounds are not a square.\n    const offsetX = (side - width) / 2 - bounds[0]!;\n    const offsetY = (side - height) / 2 - bounds[1]!;\n    return this.transformed((x, y) => [(x + offsetX) / side, (y + offsetY) / side]);\n  }\n\n  /** Bounds of a circle around the center that contains the shape at any rotation. */\n  calculateMaxBounds(bounds: number[] = new Array(4).fill(0)): number[] {\n    let maxDistSquared = 0;\n    for (const cubic of this.cubics) {\n      const anchorDistance = distanceSquared(\n        cubic.anchor0X - this.centerX,\n        cubic.anchor0Y - this.centerY,\n      );\n      const middle = cubic.pointOnCurve(0.5);\n      const middleDistance = distanceSquared(middle.x - this.centerX, middle.y - this.centerY);\n      maxDistSquared = Math.max(maxDistSquared, anchorDistance, middleDistance);\n    }\n    const d = Math.sqrt(maxDistSquared);\n    bounds[0] = this.centerX - d;\n    bounds[1] = this.centerY - d;\n    bounds[2] = this.centerX + d;\n    bounds[3] = this.centerY + d;\n    return bounds;\n  }\n\n  /** `[minX, minY, maxX, maxY]`; `approximate` (default) uses control-point hulls. */\n  calculateBounds(bounds: number[] = new Array(4).fill(0), approximate = true): number[] {\n    // Kotlin seeds the maxima with Float.MIN_VALUE (the smallest positive float), which is wrong\n    // for shapes entirely in negative space; -Infinity is used instead.\n    let minX = Number.POSITIVE_INFINITY;\n    let minY = Number.POSITIVE_INFINITY;\n    let maxX = Number.NEGATIVE_INFINITY;\n    let maxY = Number.NEGATIVE_INFINITY;\n    for (const cubic of this.cubics) {\n      cubic.calculateBounds(bounds, approximate);\n      minX = Math.min(minX, bounds[0]!);\n      minY = Math.min(minY, bounds[1]!);\n      maxX = Math.max(maxX, bounds[2]!);\n      maxY = Math.max(maxY, bounds[3]!);\n    }\n    bounds[0] = minX;\n    bounds[1] = minY;\n    bounds[2] = maxX;\n    bounds[3] = maxY;\n    return bounds;\n  }\n\n  toString(): string {\n    return `[RoundedPolygon. Cubics = ${this.cubics.join(', ')} || Features = ${this.features.join(', ')} || Center = (${this.centerX}, ${this.centerY})]`;\n  }\n}\n\nfunction buildCubics(features: readonly Feature[], center: Point): Cubic[] {\n  // The first/last mechanism ensures that the final anchor point exactly matches the first:\n  // points even slightly off can introduce rendering artifacts.\n  const result: Cubic[] = [];\n  let firstCubic: Cubic | undefined;\n  let lastCubic: Cubic | undefined;\n  let firstFeatureSplitStart: Cubic[] | undefined;\n  let firstFeatureSplitEnd: Cubic[] | undefined;\n  if (features.length > 0 && features[0]!.cubics.length === 3) {\n    const [start, end] = features[0]!.cubics[1]!.split(0.5);\n    firstFeatureSplitStart = [features[0]!.cubics[0]!, start];\n    firstFeatureSplitEnd = [end, features[0]!.cubics[2]!];\n  }\n  // Iterating one past the features allows inserting the initial split cubic, if any.\n  for (let i = 0; i <= features.length; i++) {\n    let featureCubics: readonly Cubic[];\n    if (i === 0 && firstFeatureSplitEnd) featureCubics = firstFeatureSplitEnd;\n    else if (i === features.length) {\n      if (firstFeatureSplitStart) featureCubics = firstFeatureSplitStart;\n      else break;\n    } else featureCubics = features[i]!.cubics;\n\n    for (const cubic of featureCubics) {\n      // Skip zero-length curves; they add nothing and can trigger rendering artifacts.\n      if (!cubic.zeroLength()) {\n        if (lastCubic) result.push(lastCubic);\n        lastCubic = cubic;\n        firstCubic ??= cubic;\n      } else if (lastCubic) {\n        // Dropping several near-zero curves in a row can add enough discontinuity to throw\n        // later, so the last cubic always takes the latest anchor point.\n        const points = [...lastCubic.points];\n        points[6] = cubic.anchor1X;\n        points[7] = cubic.anchor1Y;\n        lastCubic = new Cubic(points);\n      }\n    }\n  }\n  if (lastCubic && firstCubic) {\n    result.push(\n      Cubic.of(\n        lastCubic.anchor0X,\n        lastCubic.anchor0Y,\n        lastCubic.control0X,\n        lastCubic.control0Y,\n        lastCubic.control1X,\n        lastCubic.control1Y,\n        firstCubic.anchor0X,\n        firstCubic.anchor0Y,\n      ),\n    );\n  } else {\n    // Empty / 0-sized polygon.\n    result.push(Cubic.empty(center.x, center.y));\n  }\n  return result;\n}\n\nexport function calculateCenter(vertices: readonly number[]): Point {\n  let cumulativeX = 0;\n  let cumulativeY = 0;\n  for (let i = 0; i < vertices.length; i += 2) {\n    cumulativeX += vertices[i]!;\n    cumulativeY += vertices[i + 1]!;\n  }\n  return new Point(cumulativeX / (vertices.length / 2), cumulativeY / (vertices.length / 2));\n}\n\nfunction verticesFromNumVerts(\n  numVertices: number,\n  radius: number,\n  centerX: number,\n  centerY: number,\n): number[] {\n  const result: number[] = [];\n  for (let i = 0; i < numVertices; i++) {\n    const vertex = radialToCartesian(radius, (Math.PI / numVertices) * 2 * i).plus(\n      new Point(centerX, centerY),\n    );\n    result.push(vertex.x, vertex.y);\n  }\n  return result;\n}\n\nclass RoundedCorner {\n  readonly d1: Point;\n  readonly d2: Point;\n  readonly cornerRadius: number;\n  readonly smoothing: number;\n  readonly cosAngle: number;\n  readonly sinAngle: number;\n  readonly expectedRoundCut: number;\n  /** Center of the rounding circle; equals p1 when there is no rounding. */\n  center = new Point(0, 0);\n\n  constructor(\n    readonly p0: Point,\n    readonly p1: Point,\n    readonly p2: Point,\n    rounding?: CornerRounding,\n  ) {\n    const v01 = p0.minus(p1);\n    const v21 = p2.minus(p1);\n    const d01 = v01.getDistance();\n    const d21 = v21.getDistance();\n    if (d01 > 0 && d21 > 0) {\n      this.d1 = v01.div(d01);\n      this.d2 = v21.div(d21);\n      this.cornerRadius = rounding?.radius ?? 0;\n      this.smoothing = rounding?.smoothing ?? 0;\n      // Cosine of the angle at p1: dot product of unit vectors to the other two vertices.\n      this.cosAngle = this.d1.dotProduct(this.d2);\n      this.sinAngle = Math.sqrt(1 - square(this.cosAngle));\n      // How much to cut, measured on a side, to get the required radius:\n      // tan(A/2) = sinA / (1 + cosA), where tan(A/2) = radius / cut.\n      this.expectedRoundCut =\n        this.sinAngle > 1e-3 ? (this.cornerRadius * (this.cosAngle + 1)) / this.sinAngle : 0;\n    } else {\n      // One (or both) of the sides is empty.\n      this.d1 = new Point(0, 0);\n      this.d2 = new Point(0, 0);\n      this.cornerRadius = 0;\n      this.smoothing = 0;\n      this.cosAngle = 0;\n      this.sinAngle = 0;\n      this.expectedRoundCut = 0;\n    }\n  }\n\n  /** Smoothing lengthens the cut: 0 equals expectedRoundCut, 1 doubles it. */\n  get expectedCut(): number {\n    return (1 + this.smoothing) * this.expectedRoundCut;\n  }\n\n  getCubics(allowedCut0: number, allowedCut1: number = allowedCut0): Cubic[] {\n    // The smaller cut sets the radius; extra space on one side can go to smoothing.\n    const allowedCut = Math.min(allowedCut0, allowedCut1);\n    if (\n      this.expectedRoundCut < DistanceEpsilon ||\n      allowedCut < DistanceEpsilon ||\n      this.cornerRadius < DistanceEpsilon\n    ) {\n      this.center = this.p1;\n      return [Cubic.straightLine(this.p1.x, this.p1.y, this.p1.x, this.p1.y)];\n    }\n    const actualRoundCut = Math.min(allowedCut, this.expectedRoundCut);\n    const actualSmoothing0 = this.calculateActualSmoothingValue(allowedCut0);\n    const actualSmoothing1 = this.calculateActualSmoothingValue(allowedCut1);\n    const actualR = (this.cornerRadius * actualRoundCut) / this.expectedRoundCut;\n    const centerDistance = Math.sqrt(square(actualR) + square(actualRoundCut));\n    this.center = this.p1.plus(this.d1.plus(this.d2).div(2).getDirection().times(centerDistance));\n    const circleIntersection0 = this.p1.plus(this.d1.times(actualRoundCut));\n    const circleIntersection2 = this.p1.plus(this.d2.times(actualRoundCut));\n    const flanking0 = this.computeFlankingCurve(\n      actualRoundCut,\n      actualSmoothing0,\n      this.p1,\n      this.p0,\n      circleIntersection0,\n      circleIntersection2,\n      this.center,\n      actualR,\n    );\n    const flanking2 = this.computeFlankingCurve(\n      actualRoundCut,\n      actualSmoothing1,\n      this.p1,\n      this.p2,\n      circleIntersection2,\n      circleIntersection0,\n      this.center,\n      actualR,\n    ).reverse();\n    return [\n      flanking0,\n      Cubic.circularArc(\n        this.center.x,\n        this.center.y,\n        flanking0.anchor1X,\n        flanking0.anchor1Y,\n        flanking2.anchor0X,\n        flanking2.anchor0Y,\n      ),\n      flanking2,\n    ];\n  }\n\n  private calculateActualSmoothingValue(allowedCut: number): number {\n    if (allowedCut > this.expectedCut) return this.smoothing;\n    if (allowedCut > this.expectedRoundCut) {\n      return (\n        (this.smoothing * (allowedCut - this.expectedRoundCut)) /\n        (this.expectedCut - this.expectedRoundCut)\n      );\n    }\n    return 0;\n  }\n\n  private computeFlankingCurve(\n    actualRoundCut: number,\n    actualSmoothingValues: number,\n    corner: Point,\n    sideStart: Point,\n    circleSegmentIntersection: Point,\n    otherCircleSegmentIntersection: Point,\n    circleCenter: Point,\n    actualR: number,\n  ): Cubic {\n    const sideDirection = sideStart.minus(corner).getDirection();\n    const curveStart = corner.plus(\n      sideDirection.times(actualRoundCut * (1 + actualSmoothingValues)),\n    );\n    // Cut a part of the circle section proportional to 1 - smooth (full section at 0).\n    const p = interpolatePoint(\n      circleSegmentIntersection,\n      circleSegmentIntersection.plus(otherCircleSegmentIntersection).div(2),\n      actualSmoothingValues,\n    );\n    // The flanking curve ends on the circle.\n    const curveEnd = circleCenter.plus(\n      directionVector(p.x - circleCenter.x, p.y - circleCenter.y).times(actualR),\n    );\n    // The control on the circle side is where the tangent at curveEnd meets the side.\n    const circleTangent = curveEnd.minus(circleCenter).rotate90();\n    const anchorEnd =\n      lineIntersection(sideStart, sideDirection, curveEnd, circleTangent) ??\n      circleSegmentIntersection;\n    // 2/3 comes from design tools.\n    const anchorStart = curveStart.plus(anchorEnd.times(2)).div(3);\n    return Cubic.fromPoints(curveStart, anchorStart, anchorEnd, curveEnd);\n  }\n}\n\nfunction lineIntersection(p0: Point, d0: Point, p1: Point, d1: Point): Point | undefined {\n  const rotatedD1 = d1.rotate90();\n  const den = d0.dotProduct(rotatedD1);\n  if (Math.abs(den) < DistanceEpsilon) return undefined;\n  const num = p1.minus(p0).dotProduct(rotatedD1);\n  // Equivalent to abs(den / num) < DistanceEpsilon without dividing.\n  if (Math.abs(den) < DistanceEpsilon * Math.abs(num)) return undefined;\n  return p0.plus(d0.times(num / den));\n}\n"],"mappings":";;;;;;;;;AAuBA,IAAa,iBAAb,MAAa,eAAe;CAIf;CACA;CAJX;CAEA,YACE,UACA,QACA;EAFS,KAAA,WAAA;EACA,KAAA,SAAA;EAET,KAAK,SAAS,YAAY,UAAU,MAAM;EAC1C,IAAI,OAAO,KAAK,OAAO,KAAK,OAAO,SAAS;EAC5C,KAAK,MAAM,SAAS,KAAK,QAAQ;GAC/B,IACE,KAAK,IAAI,MAAM,WAAW,KAAK,QAAQ,IAAA,QACvC,KAAK,IAAI,MAAM,WAAW,KAAK,QAAQ,IAAA,MAEvC,MAAM,IAAI,MACR,2IACF;GAEF,OAAO;EACT;CACF;CAEA,IAAI,UAAkB;EACpB,OAAO,KAAK,OAAO;CACrB;CAEA,IAAI,UAAkB;EACpB,OAAO,KAAK,OAAO;CACrB;;CAGA,OAAO,gBACL,aACA,EACE,SAAS,GACT,UAAU,GACV,UAAU,GACV,WAAW,eAAe,WAC1B,sBAOE,CAAC,GACW;EAChB,OAAO,eAAe,aACpB,qBAAqB,aAAa,QAAQ,SAAS,OAAO,GAC1D;GACE;GACA;GACA;GACA;EACF,CACF;CACF;;CAGA,OAAO,aACL,UACA,EACE,WAAW,eAAe,WAC1B,mBACA,SACA,YAME,CAAC,GACW;EAChB,IAAI,SAAS,SAAS,GAAG,MAAM,IAAI,MAAM,wCAAwC;EACjF,IAAI,SAAS,SAAS,MAAM,GAAG,MAAM,IAAI,MAAM,0CAA0C;EACzF,IAAI,qBAAqB,kBAAkB,SAAS,MAAM,SAAS,QACjE,MAAM,IAAI,MACR,6GACF;EAEF,MAAM,IAAI,SAAS,SAAS;EAC5B,MAAM,UAAU,MAAc,IAAI,MAAM,SAAS,IAAI,IAAK,SAAS,IAAI,IAAI,EAAG;EAC9E,MAAM,iBAAkC,CAAC;EACzC,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KACrB,eAAe,KACb,IAAI,cACF,QAAQ,IAAI,IAAI,KAAK,CAAC,GACtB,OAAO,CAAC,GACR,QAAQ,IAAI,KAAK,CAAC,GAClB,oBAAoB,MAAM,QAC5B,CACF;EAMF,MAAM,aAAa,eAAe,KAAK,QAAQ,OAAO;GACpD,MAAM,OAAO,gBAAgB,KAAK,KAAK;GACvC,MAAM,mBAAmB,OAAO,mBAAmB,KAAK;GACxD,MAAM,cAAc,OAAO,cAAc,KAAK;GAC9C,MAAM,IAAI,OAAO,EAAE;GACnB,MAAM,IAAI,QAAQ,KAAK,KAAK,CAAC;GAC7B,MAAM,WAAW,SAAS,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC;GAC9C,IAAI,mBAAmB,UAAU,OAAO,CAAC,WAAW,kBAAkB,CAAC;GACvE,IAAI,cAAc,UAChB,OAAO,CAAC,IAAI,WAAW,qBAAqB,cAAc,iBAAiB;GAE7E,OAAO,CAAC,GAAG,CAAC;EACd,CAAC;EAED,MAAM,UAAU,eAAe,KAAK,QAAQ,MAAM;GAEhD,MAAM,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,UAAU;IACxC,MAAM,CAAC,eAAe,YAAY,YAAY,IAAI,IAAI,IAAI,SAAS;IACnE,OACE,OAAO,mBAAmB,iBACzB,OAAO,cAAc,OAAO,oBAAoB;GAErD,CAAC;GACD,OAAO,OAAO,UAAU,YAAY,IAAK,YAAY,EAAG;EAC1D,CAAC;EAED,MAAM,WAAsB,CAAC;EAC7B,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;GAC1B,MAAM,WAAW,OAAO,QAAQ,IAAI,IAAI,KAAK,CAAC,GAAG,OAAO,CAAC,GAAG,QAAQ,IAAI,KAAK,CAAC,CAAC;GAC/E,SAAS,KAAK,IAAI,OAAO,QAAQ,IAAK,QAAQ,CAAC;GAC/C,MAAM,MAAM,QAAQ,EAAE,CAAE,QAAQ,EAAE,CAAE,SAAS;GAC7C,MAAM,QAAQ,SAAS,IAAI,KAAK,EAAE,CAAE;GACpC,SAAS,KACP,IAAI,KAAK,CAAC,MAAM,aAAa,IAAI,UAAU,IAAI,UAAU,MAAM,UAAU,MAAM,QAAQ,CAAC,CAAC,CAC3F;EACF;EAEA,MAAM,SACJ,YAAY,KAAA,KAAa,YAAY,KAAA,IACjC,gBAAgB,QAAQ,IACxB,IAAI,MAAM,SAAS,OAAO;EAChC,OAAO,IAAI,eAAe,UAAU,MAAM;CAC5C;;CAGA,OAAO,aACL,UACA,SACA,SACgB;EAChB,IAAI,SAAS,SAAS,GAAG,MAAM,IAAI,MAAM,wCAAwC;EACjF,MAAM,WAAqB,CAAC;EAC5B,KAAK,MAAM,WAAW,UACpB,KAAK,MAAM,SAAS,QAAQ,QAAQ,SAAS,KAAK,MAAM,UAAU,MAAM,QAAQ;EAElF,MAAM,WAAW,gBAAgB,QAAQ;EACzC,OAAO,IAAI,eACT,UACA,IAAI,MACF,YAAY,KAAA,KAAa,OAAO,MAAM,OAAO,IAAI,SAAS,IAAI,SAC9D,YAAY,KAAA,KAAa,OAAO,MAAM,OAAO,IAAI,SAAS,IAAI,OAChE,CACF;CACF;CAEA,YAAY,GAAqC;EAC/C,OAAO,IAAI,eACT,KAAK,SAAS,KAAK,YAAY,QAAQ,YAAY,CAAC,CAAC,GACrD,KAAK,OAAO,YAAY,CAAC,CAC3B;CACF;;CAGA,aAA6B;EAC3B,MAAM,SAAS,KAAK,gBAAgB;EACpC,MAAM,QAAQ,OAAO,KAAM,OAAO;EAClC,MAAM,SAAS,OAAO,KAAM,OAAO;EACnC,MAAM,OAAO,KAAK,IAAI,OAAO,MAAM;EAEnC,MAAM,WAAW,OAAO,SAAS,IAAI,OAAO;EAC5C,MAAM,WAAW,OAAO,UAAU,IAAI,OAAO;EAC7C,OAAO,KAAK,aAAa,GAAG,MAAM,EAAE,IAAI,WAAW,OAAO,IAAI,WAAW,IAAI,CAAC;CAChF;;CAGA,mBAAmB,SAAmB,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,GAAa;EACpE,IAAI,iBAAiB;EACrB,KAAK,MAAM,SAAS,KAAK,QAAQ;GAC/B,MAAM,iBAAiB,gBACrB,MAAM,WAAW,KAAK,SACtB,MAAM,WAAW,KAAK,OACxB;GACA,MAAM,SAAS,MAAM,aAAa,EAAG;GACrC,MAAM,iBAAiB,gBAAgB,OAAO,IAAI,KAAK,SAAS,OAAO,IAAI,KAAK,OAAO;GACvF,iBAAiB,KAAK,IAAI,gBAAgB,gBAAgB,cAAc;EAC1E;EACA,MAAM,IAAI,KAAK,KAAK,cAAc;EAClC,OAAO,KAAK,KAAK,UAAU;EAC3B,OAAO,KAAK,KAAK,UAAU;EAC3B,OAAO,KAAK,KAAK,UAAU;EAC3B,OAAO,KAAK,KAAK,UAAU;EAC3B,OAAO;CACT;;CAGA,gBAAgB,SAAmB,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,cAAc,MAAgB;EAGrF,IAAI,OAAO,OAAO;EAClB,IAAI,OAAO,OAAO;EAClB,IAAI,OAAO,OAAO;EAClB,IAAI,OAAO,OAAO;EAClB,KAAK,MAAM,SAAS,KAAK,QAAQ;GAC/B,MAAM,gBAAgB,QAAQ,WAAW;GACzC,OAAO,KAAK,IAAI,MAAM,OAAO,EAAG;GAChC,OAAO,KAAK,IAAI,MAAM,OAAO,EAAG;GAChC,OAAO,KAAK,IAAI,MAAM,OAAO,EAAG;GAChC,OAAO,KAAK,IAAI,MAAM,OAAO,EAAG;EAClC;EACA,OAAO,KAAK;EACZ,OAAO,KAAK;EACZ,OAAO,KAAK;EACZ,OAAO,KAAK;EACZ,OAAO;CACT;CAEA,WAAmB;EACjB,OAAO,6BAA6B,KAAK,OAAO,KAAK,IAAI,EAAE,iBAAiB,KAAK,SAAS,KAAK,IAAI,EAAE,gBAAgB,KAAK,QAAQ,IAAI,KAAK,QAAQ;CACrJ;AACF;AAEA,SAAS,YAAY,UAA8B,QAAwB;CAGzE,MAAM,SAAkB,CAAC;CACzB,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI,SAAS,SAAS,KAAK,SAAS,EAAE,CAAE,OAAO,WAAW,GAAG;EAC3D,MAAM,CAAC,OAAO,OAAO,SAAS,EAAE,CAAE,OAAO,EAAE,CAAE,MAAM,EAAG;EACtD,yBAAyB,CAAC,SAAS,EAAE,CAAE,OAAO,IAAK,KAAK;EACxD,uBAAuB,CAAC,KAAK,SAAS,EAAE,CAAE,OAAO,EAAG;CACtD;CAEA,KAAK,IAAI,IAAI,GAAG,KAAK,SAAS,QAAQ,KAAK;EACzC,IAAI;EACJ,IAAI,MAAM,KAAK,sBAAsB,gBAAgB;OAChD,IAAI,MAAM,SAAS,QAAQ;GAC9B,IAAI,wBAAwB,gBAAgB;QACvC;EACP,OAAO,gBAAgB,SAAS,EAAE,CAAE;EAEpC,KAAK,MAAM,SAAS,eAElB,IAAI,CAAC,MAAM,WAAW,GAAG;GACvB,IAAI,WAAW,OAAO,KAAK,SAAS;GACpC,YAAY;GACZ,eAAe;EACjB,OAAO,IAAI,WAAW;GAGpB,MAAM,SAAS,CAAC,GAAG,UAAU,MAAM;GACnC,OAAO,KAAK,MAAM;GAClB,OAAO,KAAK,MAAM;GAClB,YAAY,IAAI,MAAM,MAAM;EAC9B;CAEJ;CACA,IAAI,aAAa,YACf,OAAO,KACL,MAAM,GACJ,UAAU,UACV,UAAU,UACV,UAAU,WACV,UAAU,WACV,UAAU,WACV,UAAU,WACV,WAAW,UACX,WAAW,QACb,CACF;MAGA,OAAO,KAAK,MAAM,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC;CAE7C,OAAO;AACT;AAEA,SAAgB,gBAAgB,UAAoC;CAClE,IAAI,cAAc;CAClB,IAAI,cAAc;CAClB,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK,GAAG;EAC3C,eAAe,SAAS;EACxB,eAAe,SAAS,IAAI;CAC9B;CACA,OAAO,IAAI,MAAM,eAAe,SAAS,SAAS,IAAI,eAAe,SAAS,SAAS,EAAE;AAC3F;AAEA,SAAS,qBACP,aACA,QACA,SACA,SACU;CACV,MAAM,SAAmB,CAAC;CAC1B,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,KAAK;EACpC,MAAM,SAAS,kBAAkB,QAAS,KAAK,KAAK,cAAe,IAAI,CAAC,CAAC,CAAC,KACxE,IAAI,MAAM,SAAS,OAAO,CAC5B;EACA,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC;CAChC;CACA,OAAO;AACT;AAEA,IAAM,gBAAN,MAAoB;CAYP;CACA;CACA;CAbX;CACA;CACA;CACA;CACA;CACA;CACA;;CAEA,SAAS,IAAI,MAAM,GAAG,CAAC;CAEvB,YACE,IACA,IACA,IACA,UACA;EAJS,KAAA,KAAA;EACA,KAAA,KAAA;EACA,KAAA,KAAA;EAGT,MAAM,MAAM,GAAG,MAAM,EAAE;EACvB,MAAM,MAAM,GAAG,MAAM,EAAE;EACvB,MAAM,MAAM,IAAI,YAAY;EAC5B,MAAM,MAAM,IAAI,YAAY;EAC5B,IAAI,MAAM,KAAK,MAAM,GAAG;GACtB,KAAK,KAAK,IAAI,IAAI,GAAG;GACrB,KAAK,KAAK,IAAI,IAAI,GAAG;GACrB,KAAK,eAAe,UAAU,UAAU;GACxC,KAAK,YAAY,UAAU,aAAa;GAExC,KAAK,WAAW,KAAK,GAAG,WAAW,KAAK,EAAE;GAC1C,KAAK,WAAW,KAAK,KAAK,IAAI,OAAO,KAAK,QAAQ,CAAC;GAGnD,KAAK,mBACH,KAAK,WAAW,OAAQ,KAAK,gBAAgB,KAAK,WAAW,KAAM,KAAK,WAAW;EACvF,OAAO;GAEL,KAAK,KAAK,IAAI,MAAM,GAAG,CAAC;GACxB,KAAK,KAAK,IAAI,MAAM,GAAG,CAAC;GACxB,KAAK,eAAe;GACpB,KAAK,YAAY;GACjB,KAAK,WAAW;GAChB,KAAK,WAAW;GAChB,KAAK,mBAAmB;EAC1B;CACF;;CAGA,IAAI,cAAsB;EACxB,QAAQ,IAAI,KAAK,aAAa,KAAK;CACrC;CAEA,UAAU,aAAqB,cAAsB,aAAsB;EAEzE,MAAM,aAAa,KAAK,IAAI,aAAa,WAAW;EACpD,IACE,KAAK,mBAAA,QACL,aAAA,QACA,KAAK,eAAA,MACL;GACA,KAAK,SAAS,KAAK;GACnB,OAAO,CAAC,MAAM,aAAa,KAAK,GAAG,GAAG,KAAK,GAAG,GAAG,KAAK,GAAG,GAAG,KAAK,GAAG,CAAC,CAAC;EACxE;EACA,MAAM,iBAAiB,KAAK,IAAI,YAAY,KAAK,gBAAgB;EACjE,MAAM,mBAAmB,KAAK,8BAA8B,WAAW;EACvE,MAAM,mBAAmB,KAAK,8BAA8B,WAAW;EACvE,MAAM,UAAW,KAAK,eAAe,iBAAkB,KAAK;EAC5D,MAAM,iBAAiB,KAAK,KAAK,OAAO,OAAO,IAAI,OAAO,cAAc,CAAC;EACzE,KAAK,SAAS,KAAK,GAAG,KAAK,KAAK,GAAG,KAAK,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,MAAM,cAAc,CAAC;EAC5F,MAAM,sBAAsB,KAAK,GAAG,KAAK,KAAK,GAAG,MAAM,cAAc,CAAC;EACtE,MAAM,sBAAsB,KAAK,GAAG,KAAK,KAAK,GAAG,MAAM,cAAc,CAAC;EACtE,MAAM,YAAY,KAAK,qBACrB,gBACA,kBACA,KAAK,IACL,KAAK,IACL,qBACA,qBACA,KAAK,QACL,OACF;EACA,MAAM,YAAY,KAAK,qBACrB,gBACA,kBACA,KAAK,IACL,KAAK,IACL,qBACA,qBACA,KAAK,QACL,OACF,CAAC,CAAC,QAAQ;EACV,OAAO;GACL;GACA,MAAM,YACJ,KAAK,OAAO,GACZ,KAAK,OAAO,GACZ,UAAU,UACV,UAAU,UACV,UAAU,UACV,UAAU,QACZ;GACA;EACF;CACF;CAEA,8BAAsC,YAA4B;EAChE,IAAI,aAAa,KAAK,aAAa,OAAO,KAAK;EAC/C,IAAI,aAAa,KAAK,kBACpB,OACG,KAAK,aAAa,aAAa,KAAK,qBACpC,KAAK,cAAc,KAAK;EAG7B,OAAO;CACT;CAEA,qBACE,gBACA,uBACA,QACA,WACA,2BACA,gCACA,cACA,SACO;EACP,MAAM,gBAAgB,UAAU,MAAM,MAAM,CAAC,CAAC,aAAa;EAC3D,MAAM,aAAa,OAAO,KACxB,cAAc,MAAM,kBAAkB,IAAI,sBAAsB,CAClE;EAEA,MAAM,IAAI,iBACR,2BACA,0BAA0B,KAAK,8BAA8B,CAAC,CAAC,IAAI,CAAC,GACpE,qBACF;EAEA,MAAM,WAAW,aAAa,KAC5B,gBAAgB,EAAE,IAAI,aAAa,GAAG,EAAE,IAAI,aAAa,CAAC,CAAC,CAAC,MAAM,OAAO,CAC3E;EAGA,MAAM,YACJ,iBAAiB,WAAW,eAAe,UAFvB,SAAS,MAAM,YAAY,CAAC,CAAC,SAEgB,CAAC,KAClE;EAEF,MAAM,cAAc,WAAW,KAAK,UAAU,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;EAC7D,OAAO,MAAM,WAAW,YAAY,aAAa,WAAW,QAAQ;CACtE;AACF;AAEA,SAAS,iBAAiB,IAAW,IAAW,IAAW,IAA8B;CACvF,MAAM,YAAY,GAAG,SAAS;CAC9B,MAAM,MAAM,GAAG,WAAW,SAAS;CACnC,IAAI,KAAK,IAAI,GAAG,IAAA,MAAqB,OAAO,KAAA;CAC5C,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC,WAAW,SAAS;CAE7C,IAAI,KAAK,IAAI,GAAG,IAAA,OAAsB,KAAK,IAAI,GAAG,GAAG,OAAO,KAAA;CAC5D,OAAO,GAAG,KAAK,GAAG,MAAM,MAAM,GAAG,CAAC;AACpC"}

package/dist/shapes/shape-path.d.ts

@@ -0,0 +1,15 @@
+//#region src/shapes/shape-path.d.ts
+/**
+ * A static shape outline: a closed SVG path in the unit square (0–1 on both axes), drawn
+ * with a CSS mask that scales with the element (`materialShapeMask`). The 35 M3 Expressive
+ * shapes are exported precomputed as `<name>Shape` constants (`cookie12SidedShape`, …), so an
+ * app pays only for the outlines it imports; any outline in the unit square works too.
+ */
+export interface MaterialShapePath {
+  /** The shape's name, which components write to their `data-shape` (e.g. `Cookie12Sided`). */
+  readonly name: string;
+  /** SVG path data in the unit square. The precomputed shapes use 3 decimals. */
+  readonly path: string;
+}
+//#endregion
+//# sourceMappingURL=shape-path.d.ts.map

package/dist/shapes/shapes.d.ts

@@ -0,0 +1,53 @@
+import { CornerRounding } from "./corner-rounding.js";
+import { RoundedPolygon } from "./rounded-polygon.js";
+//#region src/shapes/shapes.d.ts
+/** A circle approximated by a rounded regular polygon with `numVertices` vertices. */
+export declare function circle({ numVertices, radius, centerX, centerY }?: {
+  numVertices?: number;
+  radius?: number;
+  centerX?: number;
+  centerY?: number;
+}): RoundedPolygon;
+/** A rectangle, optionally with rounded corners. */
+export declare function rectangle({ width, height, rounding, perVertexRounding, centerX, centerY }?: {
+  width?: number;
+  height?: number;
+  rounding?: CornerRounding;
+  perVertexRounding?: readonly CornerRounding[];
+  centerX?: number;
+  centerY?: number;
+}): RoundedPolygon;
+/** A star with `numVerticesPerRadius` points, alternating between `radius` and `innerRadius`. */
+export declare function star(numVerticesPerRadius: number, { radius, innerRadius, rounding, innerRounding, perVertexRounding, centerX, centerY }?: {
+  radius?: number;
+  innerRadius?: number;
+  rounding?: CornerRounding;
+  innerRounding?: CornerRounding;
+  perVertexRounding?: readonly CornerRounding[];
+  centerX?: number;
+  centerY?: number;
+}): RoundedPolygon;
+/** A pill: a rectangle with fully rounded ends. */
+export declare function pill({ width, height, smoothing, centerX, centerY }?: {
+  width?: number;
+  height?: number;
+  smoothing?: number;
+  centerX?: number;
+  centerY?: number;
+}): RoundedPolygon;
+/** A star whose vertices lie along a pill outline. */
+export declare function pillStar({ width, height, numVerticesPerRadius, innerRadiusRatio, rounding, innerRounding, perVertexRounding, vertexSpacing, startLocation, centerX, centerY }?: {
+  width?: number;
+  height?: number;
+  numVerticesPerRadius?: number;
+  innerRadiusRatio?: number;
+  rounding?: CornerRounding;
+  innerRounding?: CornerRounding;
+  perVertexRounding?: readonly CornerRounding[];
+  vertexSpacing?: number;
+  startLocation?: number;
+  centerX?: number;
+  centerY?: number;
+}): RoundedPolygon;
+//#endregion
+//# sourceMappingURL=shapes.d.ts.map