@kyralabs/m3e-shapes 0.0.0-stage → 1.0.0

package/dist/index.js

@@ -0,0 +1,2031 @@
+// src/graphics-shapes/corner-rounding.ts
+var CornerRounding = class _CornerRounding {
+  /** [Unrounded] has a rounding radius of zero, producing a sharp corner at a vertex. */
+  static Unrounded = new _CornerRounding();
+  radius;
+  smoothing;
+  /** Both values are Kotlin `Float`s (rounded to float32). */
+  constructor(radius = 0, smoothing = 0) {
+    this.radius = Math.fround(radius);
+    this.smoothing = Math.fround(smoothing);
+  }
+};
+
+// src/graphics-shapes/point.ts
+var f = Math.fround;
+var point = (x, y) => ({ x: f(x), y: f(y) });
+var getDistance = (p) => f(Math.sqrt(getDistanceSquared(p)));
+var getDistanceSquared = (p) => f(f(p.x * p.x) + f(p.y * p.y));
+var dotProduct = (p, other) => f(f(p.x * other.x) + f(p.y * other.y));
+var dotProductXY = (p, otherX, otherY) => f(f(p.x * otherX) + f(p.y * otherY));
+var clockwise = (p, other) => f(f(p.x * other.y) - f(p.y * other.x)) > 0;
+function getDirection(p) {
+  const d = getDistance(p);
+  if (!(d > 0)) throw new Error("Can't get the direction of a 0-length vector");
+  return div(p, d);
+}
+var minus = (p, other) => point(p.x - other.x, p.y - other.y);
+var plus = (p, other) => point(p.x + other.x, p.y + other.y);
+var times = (p, operand) => point(p.x * operand, p.y * operand);
+var div = (p, operand) => point(p.x / operand, p.y / operand);
+var interpolatePoint = (start, stop, fraction) => point(
+  f(f(f(1 - fraction) * start.x) + f(fraction * stop.x)),
+  f(f(f(1 - fraction) * start.y) + f(fraction * stop.y))
+);
+function transformed(p, f4) {
+  const [x, y] = f4(p.x, p.y);
+  return point(x, y);
+}
+
+// src/graphics-shapes/utils.ts
+var f2 = Math.fround;
+var FLOAT_MIN_VALUE = 1401298464324817e-60;
+var FLOAT_MAX_VALUE = 34028234663852886e22;
+var distance = (x, y) => f2(Math.sqrt(f2(f2(x * x) + f2(y * y))));
+var distanceSquared = (x, y) => f2(f2(x * x) + f2(y * y));
+function directionVector(x, y) {
+  const d = distance(x, y);
+  if (!(d > 0)) throw new Error("Required distance greater than zero");
+  return point(f2(x / d), f2(y / d));
+}
+var directionVectorFromAngle = (angleRadians) => point(f2(Math.cos(angleRadians)), f2(Math.sin(angleRadians)));
+var DistanceEpsilon = f2(1e-4);
+var AngleEpsilon = f2(1e-6);
+var Zero = point(0, 0);
+var FloatPi = f2(Math.PI);
+var TwoPi = f2(2 * FloatPi);
+var angle = (x, y) => f2(f2(f2(Math.atan2(y, x)) + TwoPi) % TwoPi);
+var radialToCartesian = (radius, angleRadians, center = Zero) => plus(times(directionVectorFromAngle(angleRadians), radius), center);
+var rotate90 = (p) => point(-p.y, p.x);
+var square = (x) => f2(x * x);
+var interpolate = (start, stop, fraction) => f2(f2(f2(1 - fraction) * start) + f2(fraction * stop));
+var positiveModulo = (num, mod) => f2(f2(f2(num % mod) + mod) % mod);
+function findMinimum(v0, v1, tolerance, fn) {
+  let a = v0;
+  let b = v1;
+  while (f2(b - a) > tolerance) {
+    const c1 = f2(f2(f2(2 * a) + b) / 3);
+    const c2 = f2(f2(f2(2 * b) + a) / 3);
+    if (fn(c1) < fn(c2)) {
+      b = c2;
+    } else {
+      a = c1;
+    }
+  }
+  return f2(f2(a + b) / 2);
+}
+
+// src/graphics-shapes/cubic.ts
+var inUnitRange = (t) => t >= 0 && t <= 1;
+var Cubic = class _Cubic {
+  /** Kotlin `FloatArray`: values are stored as float32. */
+  points;
+  constructor(points = new Float32Array(8)) {
+    if (points.length !== 8) throw new Error("Points array size should be 8");
+    this.points = Float32Array.from(points);
+  }
+  /** Creates a Cubic from its eight coordinates (the top-level Kotlin `Cubic(...)` factory). */
+  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];
+  }
+  pointOnCurve(t) {
+    const u = f2(1 - t);
+    const w0 = f2(f2(u * u) * u);
+    const w1 = f2(f2(f2(3 * t) * u) * u);
+    const w2 = f2(f2(f2(3 * t) * t) * u);
+    const w3 = f2(f2(t * t) * t);
+    return point(
+      f2(
+        f2(f2(f2(this.anchor0X * w0) + f2(this.control0X * w1)) + f2(this.control1X * w2)) + f2(this.anchor1X * w3)
+      ),
+      f2(
+        f2(f2(f2(this.anchor0Y * w0) + f2(this.control0Y * w1)) + f2(this.control1Y * w2)) + f2(this.anchor1Y * w3)
+      )
+    );
+  }
+  zeroLength() {
+    return Math.abs(f2(this.anchor0X - this.anchor1X)) < DistanceEpsilon && Math.abs(f2(this.anchor0Y - this.anchor1Y)) < DistanceEpsilon;
+  }
+  /**
+   * Fills [bounds] with `[minX, minY, maxX, maxY]`. With [approximate], the bounding box of all
+   * anchors and controls; otherwise the exact extrema (solving the derivative quadratic).
+   */
+  calculateBounds(bounds = [0, 0, 0, 0], approximate = false) {
+    if (this.zeroLength()) {
+      bounds[0] = this.anchor0X;
+      bounds[1] = this.anchor0Y;
+      bounds[2] = this.anchor0X;
+      bounds[3] = this.anchor0Y;
+      return;
+    }
+    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;
+    }
+    const zeroIsh = (value) => Math.abs(value) < DistanceEpsilon;
+    const includeX = (t) => {
+      if (!inUnitRange(t)) return;
+      const it = this.pointOnCurve(t).x;
+      if (it < minX) minX = it;
+      if (it > maxX) maxX = it;
+    };
+    const includeY = (t) => {
+      if (!inUnitRange(t)) return;
+      const it = this.pointOnCurve(t).y;
+      if (it < minY) minY = it;
+      if (it > maxY) maxY = it;
+    };
+    const xa = f2(
+      f2(f2(-this.anchor0X + f2(3 * this.control0X)) - f2(3 * this.control1X)) + this.anchor1X
+    );
+    const xb = f2(f2(f2(2 * this.anchor0X) - f2(4 * this.control0X)) + f2(2 * this.control1X));
+    const xc = f2(-this.anchor0X + this.control0X);
+    if (zeroIsh(xa)) {
+      if (xb !== 0) includeX(f2(f2(2 * xc) / f2(-2 * xb)));
+    } else {
+      const xs = f2(f2(xb * xb) - f2(f2(4 * xa) * xc));
+      if (xs >= 0) {
+        includeX(f2(f2(-xb + f2(Math.sqrt(xs))) / f2(2 * xa)));
+        includeX(f2(f2(-xb - f2(Math.sqrt(xs))) / f2(2 * xa)));
+      }
+    }
+    const ya = f2(
+      f2(f2(-this.anchor0Y + f2(3 * this.control0Y)) - f2(3 * this.control1Y)) + this.anchor1Y
+    );
+    const yb = f2(f2(f2(2 * this.anchor0Y) - f2(4 * this.control0Y)) + f2(2 * this.control1Y));
+    const yc = f2(-this.anchor0Y + this.control0Y);
+    if (zeroIsh(ya)) {
+      if (yb !== 0) includeY(f2(f2(2 * yc) / f2(-2 * yb)));
+    } else {
+      const ys = f2(f2(yb * yb) - f2(f2(4 * ya) * yc));
+      if (ys >= 0) {
+        includeY(f2(f2(-yb + f2(Math.sqrt(ys))) / f2(2 * ya)));
+        includeY(f2(f2(-yb - f2(Math.sqrt(ys))) / f2(2 * ya)));
+      }
+    }
+    bounds[0] = minX;
+    bounds[1] = minY;
+    bounds[2] = maxX;
+    bounds[3] = maxY;
+  }
+  /** Returns two Cubics, created by splitting this curve at the given distance of [t]. */
+  split(t) {
+    const u = f2(1 - t);
+    const p = this.pointOnCurve(t);
+    const uu = f2(u * u);
+    const ut2 = f2(f2(2 * u) * t);
+    const tt = f2(t * t);
+    const lerp = (a, b) => f2(f2(a * u) + f2(b * t));
+    const quad = (a, b, c) => f2(f2(f2(a * uu) + f2(b * ut2)) + f2(c * tt));
+    return [
+      _Cubic.of(
+        this.anchor0X,
+        this.anchor0Y,
+        lerp(this.anchor0X, this.control0X),
+        lerp(this.anchor0Y, this.control0Y),
+        quad(this.anchor0X, this.control0X, this.control1X),
+        quad(this.anchor0Y, this.control0Y, this.control1Y),
+        p.x,
+        p.y
+      ),
+      _Cubic.of(
+        p.x,
+        p.y,
+        quad(this.control0X, this.control1X, this.anchor1X),
+        quad(this.control0Y, this.control1Y, this.anchor1Y),
+        lerp(this.control1X, this.anchor1X),
+        lerp(this.control1Y, this.anchor1Y),
+        this.anchor1X,
+        this.anchor1Y
+      )
+    ];
+  }
+  /** Utility function to reverse the control/anchor points for this curve. */
+  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(f2(1 / x));
+  }
+  toString() {
+    const [a0x, a0y, c0x, c0y, c1x, c1y, a1x, a1y] = Array.from(this.points, String);
+    return `anchor0: (${a0x}, ${a0y}) control0: (${c0x}, ${c0y}), control1: (${c1x}, ${c1y}), anchor1: (${a1x}, ${a1y})`;
+  }
+  equals(other) {
+    if (this === other) return true;
+    return other instanceof _Cubic && this.points.every((v, i) => v === other.points[i]);
+  }
+  /** Transforms the points in this [Cubic] with the given [PointTransformer]. */
+  transformed(f4) {
+    const newCubic = new MutableCubic();
+    newCubic.points.set(this.points);
+    newCubic.transform(f4);
+    return newCubic;
+  }
+  /** Generates a bezier curve that is a straight line between the given anchor points. */
+  static straightLine(x0, y0, x1, y1) {
+    return _Cubic.of(
+      x0,
+      y0,
+      interpolate(x0, x1, ONE_THIRD),
+      interpolate(y0, y1, ONE_THIRD),
+      interpolate(x0, x1, TWO_THIRDS),
+      interpolate(y0, y1, TWO_THIRDS),
+      x1,
+      y1
+    );
+  }
+  /**
+   * Generates a bezier curve that approximates a circular arc, with p0 and p1 as the starting and
+   * ending anchor points. The curve generated is the smallest of the two possible arcs around the
+   * entire 360-degree circle. Arcs of greater than 180 degrees should use more than one arc
+   * together. Note that p0 and p1 should be equidistant from the center.
+   */
+  static circularArc(centerX, centerY, x0, y0, x1, y1) {
+    const p0d = directionVector(f2(x0 - centerX), f2(y0 - centerY));
+    const p1d = directionVector(f2(x1 - centerX), f2(y1 - centerY));
+    const rotatedP0 = rotate90(p0d);
+    const rotatedP1 = rotate90(p1d);
+    const clockwise2 = dotProductXY(rotatedP0, f2(x1 - centerX), f2(y1 - centerY)) >= 0;
+    const cosa = dotProduct(p0d, p1d);
+    if (cosa > COS_NEARLY_ZERO_ANGLE) return _Cubic.straightLine(x0, y0, x1, y1);
+    const oneMinusCosa = f2(1 - cosa);
+    const k = f2(
+      f2(
+        f2(
+          f2(f2(distance(f2(x0 - centerX), f2(y0 - centerY)) * 4) / 3) * f2(f2(Math.sqrt(f2(2 * oneMinusCosa))) - f2(Math.sqrt(f2(1 - f2(cosa * cosa)))))
+        ) / oneMinusCosa
+      ) * (clockwise2 ? 1 : -1)
+    );
+    return _Cubic.of(
+      x0,
+      y0,
+      f2(x0 + f2(rotatedP0.x * k)),
+      f2(y0 + f2(rotatedP0.y * k)),
+      f2(x1 - f2(rotatedP1.x * k)),
+      f2(y1 - f2(rotatedP1.y * k)),
+      x1,
+      y1
+    );
+  }
+};
+var COS_NEARLY_ZERO_ANGLE = f2(0.999);
+var ONE_THIRD = f2(1 / 3);
+var TWO_THIRDS = f2(2 / 3);
+var MutableCubic = class extends Cubic {
+  transformOnePoint(f4, ix) {
+    const [x, y] = f4(this.points[ix], this.points[ix + 1]);
+    this.points[ix] = x;
+    this.points[ix + 1] = y;
+  }
+  transform(f4) {
+    this.transformOnePoint(f4, 0);
+    this.transformOnePoint(f4, 2);
+    this.transformOnePoint(f4, 4);
+    this.transformOnePoint(f4, 6);
+  }
+  interpolate(c1, c2, progress) {
+    for (let i = 0; i < 8; i++) {
+      this.points[i] = interpolate(c1.points[i], c2.points[i], progress);
+    }
+  }
+};
+
+// src/graphics-shapes/features.ts
+var Feature = class {
+  constructor(cubics) {
+    this.cubics = cubics;
+  }
+  cubics;
+};
+var Edge = class _Edge extends Feature {
+  transformed(f4) {
+    return new _Edge(this.cubics.map((c) => c.transformed(f4)));
+  }
+  toString() {
+    return "Edge";
+  }
+};
+var Corner = class _Corner extends Feature {
+  constructor(cubics, vertex, roundedCenter, convex = true) {
+    super(cubics);
+    this.vertex = vertex;
+    this.roundedCenter = roundedCenter;
+    this.convex = convex;
+  }
+  vertex;
+  roundedCenter;
+  convex;
+  transformed(f4) {
+    return new _Corner(
+      this.cubics.map((c) => c.transformed(f4)),
+      transformed(this.vertex, f4),
+      transformed(this.roundedCenter, f4),
+      this.convex
+    );
+  }
+  toString() {
+    return `Corner: vertex=(${String(this.vertex.x)}, ${String(this.vertex.y)}), center=(${String(this.roundedCenter.x)}, ${String(this.roundedCenter.y)}), convex=${String(this.convex)}`;
+  }
+};
+
+// src/graphics-shapes/float-mapping.ts
+function progressInRange(progress, progressFrom, progressTo) {
+  return progressTo >= progressFrom ? progress >= progressFrom && progress <= progressTo : progress >= progressFrom || progress <= progressTo;
+}
+function linearMap(xValues, yValues, x) {
+  if (!(x >= 0 && x <= 1)) throw new Error(`Invalid progress: ${String(x)}`);
+  const n = xValues.length;
+  const segmentStartIndex = xValues.findIndex(
+    (_, it) => progressInRange(x, xValues[it], xValues[(it + 1) % n])
+  );
+  if (segmentStartIndex === -1)
+    throw new Error("Collection contains no element matching the predicate.");
+  const segmentEndIndex = (segmentStartIndex + 1) % n;
+  const segmentSizeX = positiveModulo(
+    f2(xValues[segmentEndIndex] - xValues[segmentStartIndex]),
+    1
+  );
+  const segmentSizeY = positiveModulo(
+    f2(yValues[segmentEndIndex] - yValues[segmentStartIndex]),
+    1
+  );
+  const positionInSegment = segmentSizeX < f2(1e-3) ? 0.5 : f2(positiveModulo(f2(x - xValues[segmentStartIndex]), 1) / segmentSizeX);
+  return positiveModulo(f2(yValues[segmentStartIndex] + f2(segmentSizeY * positionInSegment)), 1);
+}
+var DoubleMapper = class _DoubleMapper {
+  sourceValues = [];
+  targetValues = [];
+  constructor(...mappings) {
+    for (const [source, target] of mappings) {
+      this.sourceValues.push(f2(source));
+      this.targetValues.push(f2(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);
+  }
+  static Identity = new _DoubleMapper(
+    // We need any 2 points in the (x, x) diagonal, with x in the [0, 1) range,
+    // We spread them as much as possible to minimize float errors.
+    [0, 0],
+    [0.5, 0.5]
+  );
+};
+function validateProgress(p) {
+  if (!p.every((curr) => curr >= 0 && curr <= 1)) {
+    throw new Error(`FloatMapping - Progress outside of range: ${p.join(", ")}`);
+  }
+  let wraps = 0;
+  for (let it = 1; it < p.length; it++) if (p[it] < p[it - 1]) wraps++;
+  if (wraps > 1) throw new Error(`FloatMapping - Progress wraps more than once: ${p.join(", ")}`);
+}
+
+// src/graphics-shapes/feature-mapping.ts
+function minBy(from, toInclusive, key) {
+  let best = from;
+  let bestKey = key(from);
+  for (let i = from + 1; i <= toInclusive; i++) {
+    const k = key(i);
+    if (k < bestKey) {
+      best = i;
+      bestKey = k;
+    }
+  }
+  return best;
+}
+function featureMapper(features1, features2) {
+  const filteredFeatures1 = features1.filter((f4) => f4.feature instanceof Corner);
+  const filteredFeatures2 = features2.filter((f4) => f4.feature instanceof Corner);
+  const [m1, m2] = filteredFeatures1.length > filteredFeatures2.length ? [doMapping(filteredFeatures2, filteredFeatures1), filteredFeatures2] : [filteredFeatures1, doMapping(filteredFeatures1, filteredFeatures2)];
+  const mm = [];
+  for (let i = 0; i < m1.length; i++) {
+    if (i === m2.length) break;
+    mm.push([m1[i].progress, m2[i].progress]);
+  }
+  return new DoubleMapper(...mm);
+}
+function featureDistSquared(f1, f22) {
+  if (f1 instanceof Corner && f22 instanceof Corner && f1.convex !== f22.convex) {
+    return FLOAT_MAX_VALUE;
+  }
+  const first1 = f1.cubics[0];
+  const last1 = f1.cubics[f1.cubics.length - 1];
+  const first2 = f22.cubics[0];
+  const last2 = f22.cubics[f22.cubics.length - 1];
+  const c1x = f2(f2(first1.anchor0X + last1.anchor1X) / 2);
+  const c1y = f2(f2(first1.anchor0Y + last1.anchor1Y) / 2);
+  const c2x = f2(f2(first2.anchor0X + last2.anchor1X) / 2);
+  const c2y = f2(f2(first2.anchor0Y + last2.anchor1Y) / 2);
+  const dx = f2(c1x - c2x);
+  const dy = f2(c1y - c2y);
+  return f2(f2(dx * dx) + f2(dy * dy));
+}
+function doMapping(f1, f22) {
+  const ix = minBy(0, f22.length - 1, (it) => featureDistSquared(f1[0].feature, f22[it].feature));
+  const m = f1.length;
+  const n = f22.length;
+  const ret = [f22[ix]];
+  let lastPicked = ix;
+  for (let i = 1; i < m; i++) {
+    let last = ix - (m - i);
+    if (!(last > lastPicked)) last += n;
+    const best = minBy(
+      lastPicked + 1,
+      last,
+      (it) => featureDistSquared(f1[i].feature, f22[it % n].feature)
+    );
+    ret.push(f22[best % n]);
+    lastPicked = best;
+  }
+  return ret;
+}
+
+// src/graphics-shapes/polygon-measure.ts
+var ProgressableFeature = class {
+  constructor(progress, feature) {
+    this.progress = progress;
+    this.feature = feature;
+  }
+  progress;
+  feature;
+};
+var AngleMeasurer = class {
+  constructor(centerX, centerY) {
+    this.centerX = centerX;
+    this.centerY = centerY;
+  }
+  centerX;
+  centerY;
+  measureCubic(c) {
+    const it = positiveModulo(
+      f2(
+        angle(f2(c.anchor1X - this.centerX), f2(c.anchor1Y - this.centerY)) - angle(f2(c.anchor0X - this.centerX), f2(c.anchor0Y - this.centerY))
+      ),
+      TwoPi
+    );
+    return it > f2(TwoPi - DistanceEpsilon) ? 0 : it;
+  }
+  findCubicCutPoint(c, m) {
+    const angle0 = angle(f2(c.anchor0X - this.centerX), f2(c.anchor0Y - this.centerY));
+    return findMinimum(0, 1, f2(1e-5), (t) => {
+      const curvePoint = c.pointOnCurve(t);
+      const a = angle(f2(curvePoint.x - this.centerX), f2(curvePoint.y - this.centerY));
+      return Math.abs(f2(positiveModulo(f2(a - angle0), TwoPi) - m));
+    });
+  }
+};
+var MeasuredCubic = class _MeasuredCubic {
+  constructor(measurer, cubic, _startOutlineProgress, _endOutlineProgress) {
+    this.measurer = measurer;
+    this.cubic = cubic;
+    this._startOutlineProgress = _startOutlineProgress;
+    this._endOutlineProgress = _endOutlineProgress;
+    if (!(_endOutlineProgress >= _startOutlineProgress)) {
+      throw new Error(
+        "endOutlineProgress is expected to be equal or greater than startOutlineProgress"
+      );
+    }
+    this.measuredSize = measurer.measureCubic(cubic);
+  }
+  measurer;
+  cubic;
+  _startOutlineProgress;
+  _endOutlineProgress;
+  measuredSize;
+  get startOutlineProgress() {
+    return this._startOutlineProgress;
+  }
+  get endOutlineProgress() {
+    return this._endOutlineProgress;
+  }
+  updateProgressRange(startOutlineProgress = this._startOutlineProgress, endOutlineProgress = this._endOutlineProgress) {
+    if (!(endOutlineProgress >= startOutlineProgress)) {
+      throw new Error(
+        "endOutlineProgress is expected to be equal or greater than startOutlineProgress"
+      );
+    }
+    this._startOutlineProgress = startOutlineProgress;
+    this._endOutlineProgress = endOutlineProgress;
+  }
+  /**
+   * Cut this MeasuredCubic into two MeasuredCubics at the given outline progress value.
+   */
+  cutAtProgress(cutOutlineProgress) {
+    const boundedCutOutlineProgress = Math.min(
+      Math.max(cutOutlineProgress, this._startOutlineProgress),
+      this._endOutlineProgress
+    );
+    const outlineProgressSize = f2(this._endOutlineProgress - this._startOutlineProgress);
+    const progressFromStart = f2(boundedCutOutlineProgress - this._startOutlineProgress);
+    const relativeProgress = f2(progressFromStart / outlineProgressSize);
+    const t = this.measurer.findCubicCutPoint(this.cubic, f2(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._startOutlineProgress, boundedCutOutlineProgress),
+      new _MeasuredCubic(this.measurer, c2, boundedCutOutlineProgress, this._endOutlineProgress)
+    ];
+  }
+  toString() {
+    return `MeasuredCubic(outlineProgress=[${String(this._startOutlineProgress)} .. ${String(this._endOutlineProgress)}], size=${String(this.measuredSize)}, cubic=${String(this.cubic)})`;
+  }
+};
+var MeasuredPolygon = class _MeasuredPolygon {
+  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 measuredCubics = [];
+    let startOutlineProgress = 0;
+    for (let index = 0; index < cubics.length; index++) {
+      if (f2(outlineProgress[index + 1] - outlineProgress[index]) > DistanceEpsilon) {
+        measuredCubics.push(
+          new MeasuredCubic(
+            measurer,
+            cubics[index],
+            startOutlineProgress,
+            outlineProgress[index + 1]
+          )
+        );
+        startOutlineProgress = outlineProgress[index + 1];
+      }
+    }
+    measuredCubics[measuredCubics.length - 1].updateProgressRange(void 0, 1);
+    this.cubics = measuredCubics;
+  }
+  measurer;
+  features;
+  cubics;
+  get size() {
+    return this.cubics.length;
+  }
+  get(index) {
+    const cubic = this.cubics[index];
+    if (!cubic) throw new RangeError(`index ${String(index)} out of range`);
+    return cubic;
+  }
+  [Symbol.iterator]() {
+    return this.cubics[Symbol.iterator]();
+  }
+  /**
+   * Finds the point in the input list of measured cubics that pass the given outline progress, and
+   * generates a new MeasuredPolygon (equivalent to this), that starts at that point. This usually
+   * means cutting the cubic that crosses the outline progress (unless the cut is at one of its
+   * ends) For example, given outline progress 0.4f and measured cubics on these outline progress
+   * ranges: c1 [0 -> 0.2] c2 [0.2 -> 0.5] c3 [0.5 -> 1.0] c2 will be cut in two, at the given
+   * outline progress, we can name these c2a [0.2 -> 0.4] and c2b [0.4 -> 0.5] The return then will
+   * have the following cubics, in this order: c2b, c3, c1, c2a
+   */
+  cutAndShift(cuttingPoint) {
+    if (!(cuttingPoint >= 0 && cuttingPoint <= 1)) {
+      throw new Error("Cutting point is expected to be between 0 and 1");
+    }
+    if (cuttingPoint < DistanceEpsilon) return this;
+    const targetIndex = this.cubics.findIndex(
+      (it) => cuttingPoint >= it.startOutlineProgress && cuttingPoint <= it.endOutlineProgress
+    );
+    const target = this.get(targetIndex);
+    const [b1, b2] = target.cutAtProgress(cuttingPoint);
+    const retCubics = [b2.cubic];
+    for (let i = 1; i < this.cubics.length; i++) {
+      retCubics.push(this.get((i + targetIndex) % this.cubics.length).cubic);
+    }
+    retCubics.push(b1.cubic);
+    const retOutlineProgress = [];
+    for (let index = 0; index < this.cubics.length + 2; index++) {
+      if (index === 0) retOutlineProgress.push(0);
+      else if (index === this.cubics.length + 1) retOutlineProgress.push(1);
+      else {
+        const cubicIndex = (targetIndex + index - 1) % this.cubics.length;
+        retOutlineProgress.push(
+          positiveModulo(f2(this.get(cubicIndex).endOutlineProgress - cuttingPoint), 1)
+        );
+      }
+    }
+    const newFeatures = this.features.map(
+      (it) => new ProgressableFeature(positiveModulo(f2(it.progress - cuttingPoint), 1), it.feature)
+    );
+    return new _MeasuredPolygon(this.measurer, newFeatures, retCubics, retOutlineProgress);
+  }
+  static measurePolygon(measurer, polygon) {
+    const cubics = [];
+    const featureToCubic = [];
+    for (const feature of polygon.features) {
+      for (let cubicIndex = 0; cubicIndex < feature.cubics.length; cubicIndex++) {
+        if (feature instanceof Corner && cubicIndex === Math.trunc(feature.cubics.length / 2)) {
+          featureToCubic.push([feature, cubics.length]);
+        }
+        cubics.push(feature.cubics[cubicIndex]);
+      }
+    }
+    const measures = [0];
+    for (const cubic of cubics) {
+      const m = measurer.measureCubic(cubic);
+      if (!(m >= 0)) throw new Error("Measured cubic is expected to be greater or equal to zero");
+      measures.push(f2(measures[measures.length - 1] + m));
+    }
+    const totalMeasure = measures[measures.length - 1];
+    const outlineProgress = measures.map((m) => f2(m / totalMeasure));
+    const features = featureToCubic.map(
+      ([feature, ix]) => new ProgressableFeature(f2(f2(outlineProgress[ix] + outlineProgress[ix + 1]) / 2), feature)
+    );
+    return new _MeasuredPolygon(measurer, features, cubics, outlineProgress);
+  }
+};
+
+// src/graphics-shapes/morph.ts
+var Morph = class _Morph {
+  constructor(start, end) {
+    this.start = start;
+    this.end = end;
+    this.morphMatch = _Morph.match(start, end);
+  }
+  start;
+  end;
+  /** The structure which holds the actual shape being morphed: matched start/end cubics. */
+  morphMatch;
+  /** Axis-aligned bounds covering both start and end shapes (and so the whole morph). */
+  calculateBounds(bounds = [0, 0, 0, 0], approximate = true) {
+    this.start.calculateBounds(bounds, approximate);
+    const [minX, minY, maxX, maxY] = bounds;
+    this.end.calculateBounds(bounds, approximate);
+    bounds[0] = Math.min(minX, bounds[0]);
+    bounds[1] = Math.min(minY, bounds[1]);
+    bounds[2] = Math.max(maxX, bounds[2]);
+    bounds[3] = Math.max(maxY, bounds[3]);
+    return bounds;
+  }
+  /** A square that holds both shapes in any rotation (see RoundedPolygon.calculateMaxBounds). */
+  calculateMaxBounds(bounds = [0, 0, 0, 0]) {
+    this.start.calculateMaxBounds(bounds);
+    const [minX, minY, maxX, maxY] = bounds;
+    this.end.calculateMaxBounds(bounds);
+    bounds[0] = Math.min(minX, bounds[0]);
+    bounds[1] = Math.min(minY, bounds[1]);
+    bounds[2] = Math.max(maxX, bounds[2]);
+    bounds[3] = Math.max(maxY, bounds[3]);
+    return bounds;
+  }
+  /**
+   * Returns a representation of the morph object at a given [progress] value as a list of Cubics.
+   * Note that this function causes a new list to be created and populated, so there is some
+   * overhead.
+   */
+  asCubics(progress) {
+    const out = [];
+    let firstCubic = null;
+    let lastCubic = null;
+    for (const [first, second] of this.morphMatch) {
+      const cubic = new Cubic(
+        first.points.map((v, it) => interpolate(v, second.points[it], progress))
+      );
+      firstCubic ??= cubic;
+      if (lastCubic !== null) out.push(lastCubic);
+      lastCubic = cubic;
+    }
+    if (lastCubic !== null && firstCubic !== null) {
+      out.push(
+        Cubic.of(
+          lastCubic.anchor0X,
+          lastCubic.anchor0Y,
+          lastCubic.control0X,
+          lastCubic.control0Y,
+          lastCubic.control1X,
+          lastCubic.control1Y,
+          firstCubic.anchor0X,
+          firstCubic.anchor0Y
+        )
+      );
+    }
+    return out;
+  }
+  /**
+   * Calls [callback] for each of the cubics of the morph at [progress], reusing [mutableCubic]
+   * (no per-frame allocation).
+   */
+  forEachCubic(progress, callback, mutableCubic = new MutableCubic()) {
+    for (const [first, second] of this.morphMatch) {
+      mutableCubic.interpolate(first, second, progress);
+      callback(mutableCubic);
+    }
+  }
+  /**
+   * Matches the cubics of two polygons: measures both outlines, maps their corners, cuts and
+   * shifts the end polygon, then walks both, cutting curves so every pair spans the same progress.
+   */
+  static match(p1, p2) {
+    const measuredPolygon1 = MeasuredPolygon.measurePolygon(
+      new AngleMeasurer(p1.centerX, p1.centerY),
+      p1
+    );
+    const measuredPolygon2 = MeasuredPolygon.measurePolygon(
+      new AngleMeasurer(p2.centerX, p2.centerY),
+      p2
+    );
+    const features1 = measuredPolygon1.features;
+    const features2 = measuredPolygon2.features;
+    const doubleMapper = featureMapper(features1, features2);
+    const polygon2CutPoint = doubleMapper.map(0);
+    const bs1 = measuredPolygon1;
+    const bs2 = measuredPolygon2.cutAndShift(polygon2CutPoint);
+    const ret = [];
+    const getOrNull = (p, i) => i < p.size ? p.get(i) : null;
+    let i1 = 0;
+    let i2 = 0;
+    let b1 = getOrNull(bs1, i1++);
+    let b2 = getOrNull(bs2, i2++);
+    while (b1 !== null && b2 !== null) {
+      const b1a = i1 === bs1.size ? 1 : b1.endOutlineProgress;
+      const b2a = i2 === bs2.size ? 1 : doubleMapper.mapBack(positiveModulo(f2(b2.endOutlineProgress + polygon2CutPoint), 1));
+      const minb = Math.min(b1a, b2a);
+      let seg1;
+      let newb1;
+      if (b1a > f2(minb + AngleEpsilon)) {
+        [seg1, newb1] = b1.cutAtProgress(minb);
+      } else {
+        seg1 = b1;
+        newb1 = getOrNull(bs1, i1++);
+      }
+      let seg2;
+      let newb2;
+      if (b2a > f2(minb + AngleEpsilon)) {
+        [seg2, newb2] = b2.cutAtProgress(
+          positiveModulo(f2(doubleMapper.map(minb) - polygon2CutPoint), 1)
+        );
+      } else {
+        seg2 = b2;
+        newb2 = getOrNull(bs2, i2++);
+      }
+      ret.push([seg1.cubic, seg2.cubic]);
+      b1 = newb1;
+      b2 = newb2;
+    }
+    if (!(b1 === null && b2 === null)) {
+      throw new Error("Expected both Polygon's Cubic to be fully matched");
+    }
+    return ret;
+  }
+};
+
+// src/graphics-shapes/rounded-polygon.ts
+var RoundedPolygon = class _RoundedPolygon {
+  constructor(features, centerX, centerY) {
+    this.features = features;
+    this.centerX = f2(centerX);
+    this.centerY = f2(centerY);
+    this.cubics = buildCubics(features);
+    let prevCubic = this.cubics[this.cubics.length - 1];
+    for (const cubic of this.cubics) {
+      if (Math.abs(f2(cubic.anchor0X - prevCubic.anchor1X)) > DistanceEpsilon || Math.abs(f2(cubic.anchor0Y - prevCubic.anchor1Y)) > DistanceEpsilon) {
+        throw new Error(
+          "RoundedPolygon must be contiguous, with the anchor points of all curves matching the anchor points of the preceding and succeeding cubics"
+        );
+      }
+      prevCubic = cubic;
+    }
+  }
+  features;
+  cubics;
+  centerX;
+  centerY;
+  /** Transforms (scales/translates/etc.) this [RoundedPolygon] with the given [PointTransformer]. */
+  transformed(f4) {
+    const center = transformed(point(this.centerX, this.centerY), f4);
+    return new _RoundedPolygon(
+      this.features.map((feature) => feature.transformed(f4)),
+      center.x,
+      center.y
+    );
+  }
+  /**
+   * Creates a new RoundedPolygon, moving and resizing this one, so it is completely inside the
+   * (0, 0) -> (1, 1) square, centered if there extra space in one direction
+   */
+  normalized() {
+    const bounds = this.calculateBounds();
+    const width = f2(bounds[2] - bounds[0]);
+    const height = f2(bounds[3] - bounds[1]);
+    const side = Math.max(width, height);
+    const offsetX = f2(f2(f2(side - width) / 2) - bounds[0]);
+    const offsetY = f2(f2(f2(side - height) / 2) - bounds[1]);
+    return this.transformed((x, y) => [f2(f2(x + offsetX) / side), f2(f2(y + offsetY) / side)]);
+  }
+  toString() {
+    return `[RoundedPolygon. Cubics = ${this.cubics.join(", ")} || Features = ${this.features.join(", ")} || Center = (${String(this.centerX)}, ${String(this.centerY)})]`;
+  }
+  /**
+   * Like [calculateBounds], this function calculates the axis-aligned bounds of the object and
+   * returns that rectangle. But this function determines the max dimension of the shape (by
+   * calculating the distance from its center to the start and midpoint of each curve) and returns
+   * a square which can be used to hold the object in any rotation.
+   */
+  calculateMaxBounds(bounds = [0, 0, 0, 0]) {
+    if (bounds.length < 4) throw new Error("Required bounds size of 4");
+    let maxDistSquared = 0;
+    for (const cubic of this.cubics) {
+      const anchorDistance = distanceSquared(
+        f2(cubic.anchor0X - this.centerX),
+        f2(cubic.anchor0Y - this.centerY)
+      );
+      const middlePoint = cubic.pointOnCurve(0.5);
+      const middleDistance = distanceSquared(
+        f2(middlePoint.x - this.centerX),
+        f2(middlePoint.y - this.centerY)
+      );
+      maxDistSquared = Math.max(maxDistSquared, Math.max(anchorDistance, middleDistance));
+    }
+    const d = f2(Math.sqrt(maxDistSquared));
+    bounds[0] = f2(this.centerX - d);
+    bounds[1] = f2(this.centerY - d);
+    bounds[2] = f2(this.centerX + d);
+    bounds[3] = f2(this.centerY + d);
+    return bounds;
+  }
+  /**
+   * Calculates the axis-aligned bounds of the object. With [approximate] (the default), uses the
+   * bounding box of every anchor and control point.
+   */
+  calculateBounds(bounds = [0, 0, 0, 0], approximate = true) {
+    if (bounds.length < 4) throw new Error("Required bounds size of 4");
+    let minX = FLOAT_MAX_VALUE;
+    let minY = FLOAT_MAX_VALUE;
+    let maxX = FLOAT_MIN_VALUE;
+    let maxY = FLOAT_MIN_VALUE;
+    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;
+  }
+  /** Copy constructor (Kotlin `RoundedPolygon(source)`). */
+  static copy(source) {
+    return new _RoundedPolygon(source.features, source.centerX, source.centerY);
+  }
+  /**
+   * Regular polygon of [numVertices] vertices around ([centerX], [centerY]) at [radius]
+   * (Kotlin `RoundedPolygon(numVertices, …)`).
+   */
+  static fromVertexCount(numVertices, options = {}) {
+    const { radius = 1, centerX = 0, centerY = 0, rounding = CornerRounding.Unrounded } = options;
+    return _RoundedPolygon.fromVertices(
+      verticesFromNumVerts(numVertices, radius, centerX, centerY),
+      {
+        rounding,
+        perVertexRounding: options.perVertexRounding ?? null,
+        centerX,
+        centerY
+      }
+    );
+  }
+  /**
+   * Polygon from an ordered list of `[x0, y0, x1, y1, …]` vertices (Kotlin
+   * `RoundedPolygon(vertices, …)`). Center defaults to the (1.0.1) estimate from the vertices.
+   */
+  static fromVertices(vertices, options = {}) {
+    const {
+      rounding = CornerRounding.Unrounded,
+      perVertexRounding = null,
+      centerX = FLOAT_MIN_VALUE,
+      centerY = FLOAT_MIN_VALUE
+    } = options;
+    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 !== null && 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 v = (i) => f2(vertices[i]);
+    const corners = [];
+    const n = vertices.length / 2;
+    const roundedCorners = [];
+    for (let i = 0; i < n; i++) {
+      const vtxRounding = perVertexRounding?.[i] ?? rounding;
+      const prevIndex = (i + n - 1) % n * 2;
+      const nextIndex = (i + 1) % n * 2;
+      roundedCorners.push(
+        new RoundedCorner(
+          point(v(prevIndex), v(prevIndex + 1)),
+          point(v(i * 2), v(i * 2 + 1)),
+          point(v(nextIndex), v(nextIndex + 1)),
+          vtxRounding
+        )
+      );
+    }
+    const cutAdjusts = [];
+    for (let ix = 0; ix < n; ix++) {
+      const here = roundedCorners[ix];
+      const next = roundedCorners[(ix + 1) % n];
+      const expectedRoundCut = f2(here.expectedRoundCut + next.expectedRoundCut);
+      const expectedCut = f2(here.expectedCut + next.expectedCut);
+      const vtxX = v(ix * 2);
+      const vtxY = v(ix * 2 + 1);
+      const nextVtxX = v((ix + 1) % n * 2);
+      const nextVtxY = v((ix + 1) % n * 2 + 1);
+      const sideSize = distance(f2(vtxX - nextVtxX), f2(vtxY - nextVtxY));
+      if (expectedRoundCut > sideSize) {
+        cutAdjusts.push([f2(sideSize / expectedRoundCut), 0]);
+      } else if (expectedCut > sideSize) {
+        cutAdjusts.push([1, f2(f2(sideSize - expectedRoundCut) / f2(expectedCut - expectedRoundCut))]);
+      } else {
+        cutAdjusts.push([1, 1]);
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      const allowedCuts = [];
+      const corner = roundedCorners[i];
+      for (let delta = 0; delta <= 1; delta++) {
+        const [roundCutRatio, cutRatio] = cutAdjusts[(i + n - 1 + delta) % n];
+        allowedCuts.push(
+          f2(
+            f2(corner.expectedRoundCut * roundCutRatio) + f2(f2(corner.expectedCut - corner.expectedRoundCut) * cutRatio)
+          )
+        );
+      }
+      corners.push(corner.getCubics(allowedCuts[0], allowedCuts[1]));
+    }
+    const tempFeatures = [];
+    for (let i = 0; i < n; i++) {
+      const prevVtxIndex = (i + n - 1) % n;
+      const nextVtxIndex = (i + 1) % n;
+      const currVertex = point(v(i * 2), v(i * 2 + 1));
+      const prevVertex = point(v(prevVtxIndex * 2), v(prevVtxIndex * 2 + 1));
+      const nextVertex = point(v(nextVtxIndex * 2), v(nextVtxIndex * 2 + 1));
+      const convex = clockwise(minus(currVertex, prevVertex), minus(nextVertex, currVertex));
+      tempFeatures.push(new Corner(corners[i], currVertex, roundedCorners[i].center, convex));
+      const last = corners[i][corners[i].length - 1];
+      const first = corners[(i + 1) % n][0];
+      tempFeatures.push(
+        new Edge([
+          Cubic.straightLine(last.anchor1X, last.anchor1Y, first.anchor0X, first.anchor0Y)
+        ])
+      );
+    }
+    const { x: cx, y: cy } = centerX === FLOAT_MIN_VALUE || centerY === FLOAT_MIN_VALUE ? calculateCenter(vertices) : point(f2(centerX), f2(centerY));
+    return new _RoundedPolygon(tempFeatures, cx, cy);
+  }
+};
+function buildCubics(features) {
+  const out = [];
+  let firstCubic = null;
+  let lastCubic = null;
+  let firstFeatureSplitStart = null;
+  let firstFeatureSplitEnd = null;
+  if (features.length > 0 && features[0].cubics.length === 3) {
+    const centerCubic = features[0].cubics[1];
+    const [start, end] = centerCubic.split(0.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 !== null) featureCubics = firstFeatureSplitEnd;
+    else if (i === features.length) {
+      if (firstFeatureSplitStart !== null) featureCubics = firstFeatureSplitStart;
+      else break;
+    } else featureCubics = features[i].cubics;
+    for (const cubic of featureCubics) {
+      if (!cubic.zeroLength()) {
+        if (lastCubic !== null) out.push(lastCubic);
+        lastCubic = cubic;
+        firstCubic ??= cubic;
+      } else if (lastCubic !== null) {
+        lastCubic.points[6] = cubic.anchor1X;
+        lastCubic.points[7] = cubic.anchor1Y;
+      }
+    }
+  }
+  if (lastCubic !== null && firstCubic !== null) {
+    out.push(
+      Cubic.of(
+        lastCubic.anchor0X,
+        lastCubic.anchor0Y,
+        lastCubic.control0X,
+        lastCubic.control0Y,
+        lastCubic.control1X,
+        lastCubic.control1Y,
+        firstCubic.anchor0X,
+        firstCubic.anchor0Y
+      )
+    );
+  }
+  return out;
+}
+function calculateCenter(vertices) {
+  let cumulativeX = 0;
+  let cumulativeY = 0;
+  let index = 0;
+  while (index < vertices.length) {
+    cumulativeX = f2(cumulativeX + f2(vertices[index++]));
+    cumulativeY = f2(cumulativeY + f2(vertices[index++]));
+  }
+  return point(f2(cumulativeX / vertices.length) / 2, f2(cumulativeY / vertices.length) / 2);
+}
+var RoundedCorner = class {
+  constructor(p0, p1, p2, rounding = null) {
+    this.p0 = p0;
+    this.p1 = p1;
+    this.p2 = p2;
+    this.rounding = rounding;
+    this.d1 = getDirection(minus(p0, p1));
+    this.d2 = getDirection(minus(p2, p1));
+    this.cornerRadius = rounding?.radius ?? 0;
+    this.smoothing = rounding?.smoothing ?? 0;
+    this.cosAngle = dotProduct(this.d1, this.d2);
+    this.sinAngle = f2(Math.sqrt(f2(1 - square(this.cosAngle))));
+    this.expectedRoundCut = this.sinAngle > 1e-3 ? f2(f2(this.cornerRadius * f2(this.cosAngle + 1)) / this.sinAngle) : 0;
+  }
+  p0;
+  p1;
+  p2;
+  rounding;
+  d1;
+  d2;
+  cornerRadius;
+  smoothing;
+  cosAngle;
+  sinAngle;
+  expectedRoundCut;
+  /**
+   * the center of the circle approximated by the rounding curve (or the middle of the three
+   * curves if smoothing is requested). The center is the same as p0 if there is no rounding.
+   */
+  center = point(0, 0);
+  /** smoothing changes the actual cut. 0 is same as expectedRoundCut, 1 doubles it */
+  get expectedCut() {
+    return f2(f2(1 + this.smoothing) * this.expectedRoundCut);
+  }
+  getCubics(allowedCut0, allowedCut1 = allowedCut0) {
+    const allowedCut = Math.min(allowedCut0, allowedCut1);
+    if (this.expectedRoundCut < DistanceEpsilon || allowedCut < DistanceEpsilon || this.cornerRadius < DistanceEpsilon) {
+      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 = f2(f2(this.cornerRadius * actualRoundCut) / this.expectedRoundCut);
+    const centerDistance = f2(Math.sqrt(f2(square(actualR) + square(actualRoundCut))));
+    this.center = plus(
+      this.p1,
+      times(getDirection(div(plus(this.d1, this.d2), 2)), centerDistance)
+    );
+    const circleIntersection0 = plus(this.p1, times(this.d1, actualRoundCut));
+    const circleIntersection2 = plus(this.p1, times(this.d2, 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
+    ];
+  }
+  /**
+   * If allowedCut (the amount we are able to cut) is greater than the expected cut (without
+   * smoothing applied yet), then there is room to apply smoothing and we calculate the actual
+   * smoothing value here.
+   */
+  calculateActualSmoothingValue(allowedCut) {
+    if (allowedCut > this.expectedCut) return this.smoothing;
+    if (allowedCut > this.expectedRoundCut) {
+      return f2(
+        f2(this.smoothing * f2(allowedCut - this.expectedRoundCut)) / f2(this.expectedCut - this.expectedRoundCut)
+      );
+    }
+    return 0;
+  }
+  /**
+   * Compute a single flanking curve for this corner: from the side start to the rounding circle,
+   * smoothed by [actualSmoothingValues].
+   */
+  computeFlankingCurve(actualRoundCut, actualSmoothingValues, corner, sideStart, circleSegmentIntersection, otherCircleSegmentIntersection, circleCenter, actualR) {
+    const sideDirection = getDirection(minus(sideStart, corner));
+    const curveStart = plus(
+      corner,
+      times(times(sideDirection, actualRoundCut), f2(1 + actualSmoothingValues))
+    );
+    const p = interpolatePoint(
+      circleSegmentIntersection,
+      div(plus(circleSegmentIntersection, otherCircleSegmentIntersection), 2),
+      actualSmoothingValues
+    );
+    const curveEnd = plus(
+      circleCenter,
+      times(directionVector(f2(p.x - circleCenter.x), f2(p.y - circleCenter.y)), actualR)
+    );
+    const circleTangent = rotate90(minus(curveEnd, circleCenter));
+    const anchorEnd = lineIntersection(sideStart, sideDirection, curveEnd, circleTangent) ?? circleSegmentIntersection;
+    const anchorStart = div(plus(curveStart, times(anchorEnd, 2)), 3);
+    return Cubic.fromPoints(curveStart, anchorStart, anchorEnd, curveEnd);
+  }
+};
+function lineIntersection(p0, d0, p1, d1) {
+  const rotatedD1 = rotate90(d1);
+  const den = dotProduct(d0, rotatedD1);
+  if (Math.abs(den) < DistanceEpsilon) return null;
+  const num = dotProduct(minus(p1, p0), rotatedD1);
+  if (Math.abs(den) < f2(DistanceEpsilon * Math.abs(num))) return null;
+  const k = f2(num / den);
+  return plus(p0, times(d0, k));
+}
+function verticesFromNumVerts(numVertices, radius, centerX, centerY) {
+  const result = [];
+  for (let i = 0; i < numVertices; i++) {
+    const vertex = plus(
+      radialToCartesian(f2(radius), f2(f2(f2(FloatPi / numVertices) * 2) * i)),
+      point(centerX, centerY)
+    );
+    result.push(vertex.x, vertex.y);
+  }
+  return result;
+}
+
+// src/graphics-shapes/shapes.ts
+function circle(options = {}) {
+  const { numVertices = 8 } = options;
+  const radius = f2(options.radius ?? 1);
+  const centerX = f2(options.centerX ?? 0);
+  const centerY = f2(options.centerY ?? 0);
+  if (numVertices < 3) throw new Error("Circle must have at least three vertices");
+  const theta = f2(FloatPi / numVertices);
+  const polygonRadius = f2(radius / f2(Math.cos(theta)));
+  return RoundedPolygon.fromVertexCount(numVertices, {
+    rounding: new CornerRounding(radius),
+    radius: polygonRadius,
+    centerX,
+    centerY
+  });
+}
+function rectangle(options = {}) {
+  const { rounding = CornerRounding.Unrounded, perVertexRounding = null } = options;
+  const width = f2(options.width ?? 2);
+  const height = f2(options.height ?? 2);
+  const centerX = f2(options.centerX ?? 0);
+  const centerY = f2(options.centerY ?? 0);
+  const left = f2(centerX - f2(width / 2));
+  const top = f2(centerY - f2(height / 2));
+  const right = f2(centerX + f2(width / 2));
+  const bottom = f2(centerY + f2(height / 2));
+  return RoundedPolygon.fromVertices([right, bottom, left, bottom, left, top, right, top], {
+    rounding,
+    perVertexRounding,
+    centerX,
+    centerY
+  });
+}
+function star(numVerticesPerRadius, options = {}) {
+  const { rounding = CornerRounding.Unrounded, innerRounding = null } = options;
+  const radius = f2(options.radius ?? 1);
+  const innerRadius = f2(options.innerRadius ?? 0.5);
+  const centerX = f2(options.centerX ?? 0);
+  const centerY = f2(options.centerY ?? 0);
+  if (radius <= 0 || innerRadius <= 0) throw new Error("Star radii must both be greater than 0");
+  if (innerRadius >= radius) throw new Error("innerRadius must be less than radius");
+  let pvRounding = options.perVertexRounding ?? null;
+  if (pvRounding === null && innerRounding !== null) {
+    pvRounding = Array.from({ length: numVerticesPerRadius }, () => [
+      rounding,
+      innerRounding
+    ]).flat();
+  }
+  return RoundedPolygon.fromVertices(
+    starVerticesFromNumVerts(numVerticesPerRadius, radius, innerRadius, centerX, centerY),
+    { rounding, perVertexRounding: pvRounding, centerX, centerY }
+  );
+}
+function pill(options = {}) {
+  const width = f2(options.width ?? 2);
+  const height = f2(options.height ?? 1);
+  const smoothing = f2(options.smoothing ?? 0);
+  const centerX = f2(options.centerX ?? 0);
+  const centerY = f2(options.centerY ?? 0);
+  if (!(width > 0 && height > 0))
+    throw new Error("Pill shapes must have positive width and height");
+  const wHalf = f2(width / 2);
+  const hHalf = f2(height / 2);
+  return RoundedPolygon.fromVertices(
+    [
+      f2(wHalf + centerX),
+      f2(hHalf + centerY),
+      f2(-wHalf + centerX),
+      f2(hHalf + centerY),
+      f2(-wHalf + centerX),
+      f2(-hHalf + centerY),
+      f2(wHalf + centerX),
+      f2(-hHalf + centerY)
+    ],
+    { rounding: new CornerRounding(Math.min(wHalf, hHalf), smoothing), centerX, centerY }
+  );
+}
+function pillStar(options = {}) {
+  const {
+    numVerticesPerRadius = 8,
+    rounding = CornerRounding.Unrounded,
+    innerRounding = null
+  } = options;
+  const width = f2(options.width ?? 2);
+  const height = f2(options.height ?? 1);
+  const innerRadiusRatio = f2(options.innerRadiusRatio ?? 0.5);
+  const vertexSpacing = f2(options.vertexSpacing ?? 0.5);
+  const startLocation = f2(options.startLocation ?? 0);
+  const centerX = f2(options.centerX ?? 0);
+  const centerY = f2(options.centerY ?? 0);
+  if (!(width > 0 && height > 0))
+    throw new Error("Pill shapes must have positive width and height");
+  if (!(innerRadiusRatio > 0 && innerRadiusRatio <= 1)) {
+    throw new Error("innerRadius must be between 0 and 1");
+  }
+  let pvRounding = options.perVertexRounding ?? null;
+  if (pvRounding === null && innerRounding !== null) {
+    pvRounding = Array.from({ length: numVerticesPerRadius }, () => [
+      rounding,
+      innerRounding
+    ]).flat();
+  }
+  return RoundedPolygon.fromVertices(
+    pillStarVerticesFromNumVerts(
+      numVerticesPerRadius,
+      width,
+      height,
+      innerRadiusRatio,
+      vertexSpacing,
+      startLocation,
+      centerX,
+      centerY
+    ),
+    { rounding, perVertexRounding: pvRounding, centerX, centerY }
+  );
+}
+function pillStarVerticesFromNumVerts(numVerticesPerRadius, width, height, innerRadius, vertexSpacing, startLocation, centerX, centerY) {
+  const endcapRadius = Math.min(width, height);
+  const vSegLen = Math.max(f2(height - width), 0);
+  const hSegLen = Math.max(f2(width - height), 0);
+  const vSegHalf = f2(vSegLen / 2);
+  const hSegHalf = f2(hSegLen / 2);
+  const circlePerimeter = f2(f2(TwoPi * endcapRadius) * interpolate(innerRadius, 1, vertexSpacing));
+  const perimeter = f2(f2(f2(2 * hSegLen) + f2(2 * vSegLen)) + circlePerimeter);
+  const sections = new Float32Array(11);
+  const quarter = f2(circlePerimeter / 4);
+  sections[0] = 0;
+  sections[1] = vSegLen / 2;
+  sections[2] = sections[1] + quarter;
+  sections[3] = sections[2] + hSegLen;
+  sections[4] = sections[3] + quarter;
+  sections[5] = sections[4] + vSegLen;
+  sections[6] = sections[5] + quarter;
+  sections[7] = sections[6] + hSegLen;
+  sections[8] = sections[7] + quarter;
+  sections[9] = sections[8] + f2(vSegLen / 2);
+  sections[10] = perimeter;
+  const tPerVertex = f2(perimeter / (2 * numVerticesPerRadius));
+  let inner = false;
+  let currSecIndex = 0;
+  let secStart = 0;
+  let secEnd = sections[1];
+  let t = f2(startLocation * perimeter);
+  const result = [];
+  const rectBR = point(hSegHalf, vSegHalf);
+  const rectBL = point(-hSegHalf, vSegHalf);
+  const rectTL = point(-hSegHalf, -vSegHalf);
+  const rectTR = point(hSegHalf, -vSegHalf);
+  for (let i = 0; i < numVerticesPerRadius * 2; i++) {
+    const boundedT = f2(t % perimeter);
+    if (boundedT < secStart) currSecIndex = 0;
+    while (boundedT >= sections[(currSecIndex + 1) % sections.length]) {
+      currSecIndex = (currSecIndex + 1) % sections.length;
+      secStart = sections[currSecIndex];
+      secEnd = sections[(currSecIndex + 1) % sections.length];
+    }
+    const tInSection = f2(boundedT - secStart);
+    const tProportion = f2(tInSection / f2(secEnd - secStart));
+    const halfArc = f2(f2(tProportion * FloatPi) / 2);
+    const currRadius = inner ? f2(endcapRadius * innerRadius) : endcapRadius;
+    let vertex;
+    switch (currSecIndex) {
+      case 0:
+        vertex = point(currRadius, f2(tProportion * vSegHalf));
+        break;
+      case 1:
+        vertex = plus(radialToCartesian(currRadius, halfArc), rectBR);
+        break;
+      case 2:
+        vertex = point(f2(hSegHalf - f2(tProportion * hSegLen)), currRadius);
+        break;
+      case 3:
+        vertex = plus(radialToCartesian(currRadius, f2(f2(FloatPi / 2) + halfArc)), rectBL);
+        break;
+      case 4:
+        vertex = point(-currRadius, f2(vSegHalf - f2(tProportion * vSegLen)));
+        break;
+      case 5:
+        vertex = plus(radialToCartesian(currRadius, f2(FloatPi + halfArc)), rectTL);
+        break;
+      case 6:
+        vertex = point(f2(-hSegHalf + f2(tProportion * hSegLen)), -currRadius);
+        break;
+      case 7:
+        vertex = plus(radialToCartesian(currRadius, f2(f2(FloatPi * 1.5) + halfArc)), rectTR);
+        break;
+      default:
+        vertex = point(currRadius, f2(-vSegHalf + f2(tProportion * vSegHalf)));
+    }
+    result.push(f2(vertex.x + centerX), f2(vertex.y + centerY));
+    t = f2(t + tPerVertex);
+    inner = !inner;
+  }
+  return result;
+}
+function starVerticesFromNumVerts(numVerticesPerRadius, radius, innerRadius, centerX, centerY) {
+  const result = [];
+  for (let i = 0; i < numVerticesPerRadius; i++) {
+    let vertex = radialToCartesian(radius, f2(f2(f2(FloatPi / numVerticesPerRadius) * 2) * i));
+    result.push(f2(vertex.x + centerX), f2(vertex.y + centerY));
+    vertex = radialToCartesian(innerRadius, f2(f2(FloatPi / numVerticesPerRadius) * (2 * i + 1)));
+    result.push(f2(vertex.x + centerX), f2(vertex.y + centerY));
+  }
+  return result;
+}
+
+// src/matrix.ts
+var f3 = Math.fround;
+var Matrix = class {
+  values = new Float32Array([
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    1
+  ]);
+  get(row, column) {
+    return this.values[row * 4 + column] ?? 0;
+  }
+  set(row, column, v) {
+    this.values[row * 4 + column] = v;
+  }
+  /** Does the 3D transform on the point and returns its `x` and `y` values. */
+  map(x, y) {
+    const v00 = this.get(0, 0);
+    const v01 = this.get(0, 1);
+    const v03 = this.get(0, 3);
+    const v10 = this.get(1, 0);
+    const v11 = this.get(1, 1);
+    const v13 = this.get(1, 3);
+    const v30 = this.get(3, 0);
+    const v31 = this.get(3, 1);
+    const v33 = this.get(3, 3);
+    const z = f3(f3(f3(v03 * x) + f3(v13 * y)) + v33);
+    const inverseZ = f3(1 / z);
+    const pZ = Number.isFinite(inverseZ) ? inverseZ : 0;
+    return [
+      f3(pZ * f3(f3(f3(v00 * x) + f3(v10 * y)) + v30)),
+      f3(pZ * f3(f3(f3(v01 * x) + f3(v11 * y)) + v31))
+    ];
+  }
+  /** Applies a rotation of [degrees] around Z to `this`. */
+  rotateZ(degrees) {
+    const r = f3(degrees) * (Math.PI / 180);
+    const s = Math.fround(Math.sin(r));
+    const c = Math.fround(Math.cos(r));
+    for (let column = 0; column < 4; column++) {
+      const a0 = this.get(0, column);
+      const a1 = this.get(1, column);
+      this.set(0, column, f3(c * a0) + f3(s * a1));
+      this.set(1, column, f3(-s * a0) + f3(c * a1));
+    }
+    return this;
+  }
+  /** Scales this matrix by [x], [y], [z]. */
+  scale(x = 1, y = 1, z = 1) {
+    for (let column = 0; column < 4; column++) {
+      this.set(0, column, this.get(0, column) * f3(x));
+      this.set(1, column, this.get(1, column) * f3(y));
+      this.set(2, column, this.get(2, column) * f3(z));
+    }
+    return this;
+  }
+};
+
+// src/path.ts
+var mapPoints = (command, f4) => {
+  switch (command[0]) {
+    case "M":
+    case "L":
+      return [command[0], ...f4(command[1], command[2])];
+    case "C":
+      return [
+        "C",
+        ...f4(command[1], command[2]),
+        ...f4(command[3], command[4]),
+        ...f4(command[5], command[6])
+      ];
+    case "Z":
+      return command;
+  }
+};
+var transformPath = (path, matrix) => path.map((command) => mapPoints(command, (x, y) => matrix.map(x, y)));
+var translatePath = (path, dx, dy) => path.map((command) => mapPoints(command, (x, y) => [x + dx, y + dy]));
+function pathBounds(path) {
+  let left = Infinity;
+  let top = Infinity;
+  let right = -Infinity;
+  let bottom = -Infinity;
+  for (const command of path) {
+    for (let i = 1; i + 1 < command.length; i += 2) {
+      const x = command[i];
+      const y = command[i + 1];
+      left = Math.min(left, x);
+      top = Math.min(top, y);
+      right = Math.max(right, x);
+      bottom = Math.max(bottom, y);
+    }
+  }
+  return left === Infinity ? [0, 0, 0, 0] : [left, top, right, bottom];
+}
+var formatNumber = (value, fractionDigits) => {
+  const fixed = value.toFixed(fractionDigits);
+  const text = fixed.includes(".") ? fixed.replace(/\.?0+$/, "") : fixed;
+  return text === "-0" ? "0" : text;
+};
+function toSvgPathData(path, fractionDigits = 4) {
+  return path.map(
+    ([verb, ...values]) => values.length === 0 ? verb : `${verb}${values.map((v) => formatNumber(v, fractionDigits)).join(" ")}`
+  ).join("");
+}
+
+// src/shape-util.ts
+var transformedByMatrix = (polygon, matrix) => polygon.transformed((x, y) => matrix.map(x, y));
+function polygonToPath(polygon, options = {}) {
+  const { startAngle = 0, repeatPath = false, closePath = true } = options;
+  return pathFromCubics(
+    startAngle,
+    repeatPath,
+    closePath,
+    polygon.cubics,
+    polygon.centerX,
+    polygon.centerY
+  );
+}
+function morphToPath(morph, progress, options = {}) {
+  const {
+    startAngle = 0,
+    repeatPath = false,
+    closePath = true,
+    rotationPivotX = 0,
+    rotationPivotY = 0
+  } = options;
+  return pathFromCubics(
+    startAngle,
+    repeatPath,
+    closePath,
+    morph.asCubics(progress),
+    rotationPivotX,
+    rotationPivotY
+  );
+}
+function pathFromCubics(startAngle, repeatPath, closePath, cubics, rotationPivotX, rotationPivotY) {
+  const path = [];
+  const first = cubics[0];
+  if (first !== void 0) path.push(["M", first.anchor0X, first.anchor0Y]);
+  const addCubics = () => {
+    for (const it of cubics) {
+      path.push([
+        "C",
+        it.control0X,
+        it.control0Y,
+        it.control1X,
+        it.control1Y,
+        it.anchor1X,
+        it.anchor1Y
+      ]);
+    }
+  };
+  addCubics();
+  if (repeatPath && first !== void 0) {
+    path.push(["L", first.anchor0X, first.anchor0Y]);
+    addCubics();
+  }
+  if (closePath) path.push(["Z"]);
+  if (startAngle !== 0 && first !== void 0) {
+    const f4 = Math.fround;
+    const angleToFirstCubic = radiansToDegrees(
+      f4(Math.atan2(f4(first.anchor0Y - rotationPivotY), f4(first.anchor0X - rotationPivotX)))
+    );
+    return transformPath(path, new Matrix().rotateZ(f4(-angleToFirstCubic + startAngle)));
+  }
+  return path;
+}
+var radiansToDegrees = (radians) => Math.fround(radians * 180 / Math.PI);
+
+// src/material-shapes.ts
+function toShapeOutline(polygon, width, height, startAngle = 0) {
+  const shapePath = polygonToPath(polygon, { startAngle });
+  const path = transformPath(shapePath, new Matrix().scale(width, height));
+  const [left, top, right, bottom] = pathBounds(path);
+  return translatePath(path, width / 2 - (left + right) / 2, height / 2 - (top + bottom) / 2);
+}
+var cornerRound15 = new CornerRounding(f2(0.15));
+var cornerRound20 = new CornerRounding(f2(0.2));
+var cornerRound30 = new CornerRounding(f2(0.3));
+var cornerRound50 = new CornerRounding(f2(0.5));
+var cornerRound100 = new CornerRounding(1);
+var rotateNeg45 = new Matrix().rotateZ(-45);
+var rotateNeg90 = new Matrix().rotateZ(-90);
+var rotateNeg135 = new Matrix().rotateZ(-135);
+var pnr = (x, y, r = CornerRounding.Unrounded) => ({
+  x: f2(x),
+  y: f2(y),
+  r
+});
+var cr = (radius, smoothing = 0) => new CornerRounding(radius, smoothing);
+var toRadians = (degrees) => f2(f2(f2(degrees / 360) * 2) * FloatPi);
+var angleDegrees = (x, y) => f2(f2(f2(Math.atan2(y, x)) * 180) / FloatPi);
+function rotateDegrees(p, angle2, centerX, centerY) {
+  const a = toRadians(angle2);
+  const cos = f2(Math.cos(a));
+  const sin = f2(Math.sin(a));
+  const offX = f2(p.x - centerX);
+  const offY = f2(p.y - centerY);
+  return {
+    x: f2(f2(f2(offX * cos) - f2(offY * sin)) + centerX),
+    y: f2(f2(f2(offX * sin) + f2(offY * cos)) + centerY),
+    r: p.r
+  };
+}
+function doRepeat(points, reps, centerX, centerY, mirroring) {
+  const out = [];
+  if (mirroring) {
+    const angles = points.map((it) => angleDegrees(f2(it.x - centerX), f2(it.y - centerY)));
+    const distances = points.map((it) => {
+      const x = f2(it.x - centerX);
+      const y = f2(it.y - centerY);
+      return f2(Math.sqrt(f2(f2(x * x) + f2(y * y))));
+    });
+    const actualReps = reps * 2;
+    const sectionAngle = f2(360 / actualReps);
+    for (let it = 0; it < actualReps; it++) {
+      for (let index = 0; index < points.length; index++) {
+        const i = it % 2 === 0 ? index : points.length - 1 - index;
+        if (i > 0 || it % 2 === 0) {
+          const angle2 = angles[i] ?? 0;
+          const a = toRadians(
+            f2(
+              f2(sectionAngle * it) + (it % 2 === 0 ? angle2 : f2(f2(sectionAngle - angle2) + f2(2 * (angles[0] ?? 0))))
+            )
+          );
+          const distance2 = distances[i] ?? 0;
+          out.push({
+            x: f2(f2(f2(Math.cos(a)) * distance2) + centerX),
+            y: f2(f2(f2(Math.sin(a)) * distance2) + centerY),
+            r: points[i]?.r ?? CornerRounding.Unrounded
+          });
+        }
+      }
+    }
+  } else {
+    const np = points.length;
+    for (let it = 0; it < np * reps; it++) {
+      const p = points[it % np];
+      if (p) out.push(rotateDegrees(p, f2(Math.trunc(it / np) * 360 / reps), centerX, centerY));
+    }
+  }
+  return out;
+}
+function customPolygon(points, reps, mirroring = false) {
+  const centerX = 0.5;
+  const centerY = 0.5;
+  const actualPoints = doRepeat(points, reps, centerX, centerY, mirroring);
+  return RoundedPolygon.fromVertices(
+    actualPoints.flatMap((p) => [p.x, p.y]),
+    { perVertexRounding: actualPoints.map((p) => p.r), centerX, centerY }
+  );
+}
+var builders = {
+  Circle: () => circle({ numVertices: 10 }),
+  Square: () => rectangle({ width: 1, height: 1, rounding: cornerRound30 }),
+  Slanted: () => customPolygon([pnr(0.926, 0.97, cr(0.189, 0.811)), pnr(-0.021, 0.967, cr(0.187, 0.057))], 2),
+  Arch: () => transformedByMatrix(
+    RoundedPolygon.fromVertexCount(4, {
+      perVertexRounding: [cornerRound100, cornerRound100, cornerRound20, cornerRound20]
+    }),
+    rotateNeg135
+  ),
+  Fan: () => customPolygon(
+    [
+      pnr(1.004, 1, cr(0.148, 0.417)),
+      pnr(0, 1, cr(0.151)),
+      pnr(0, -3e-3, cr(0.148)),
+      pnr(0.978, 0.02, cr(0.803))
+    ],
+    1
+  ),
+  Arrow: () => customPolygon(
+    [
+      pnr(0.5, 0.892, cr(0.313)),
+      pnr(-0.216, 1.05, cr(0.207)),
+      pnr(0.499, -0.16, cr(0.215, 1)),
+      pnr(1.225, 1.06, cr(0.211))
+    ],
+    1
+  ),
+  SemiCircle: () => rectangle({
+    width: f2(1.6),
+    height: 1,
+    perVertexRounding: [cornerRound20, cornerRound20, cornerRound100, cornerRound100]
+  }),
+  Oval: () => transformedByMatrix(transformedByMatrix(circle(), new Matrix().scale(1, f2(0.64))), rotateNeg45),
+  Pill: () => customPolygon(
+    [pnr(0.961, 0.039, cr(0.426)), pnr(1.001, 0.428), pnr(1, 0.609, cr(1))],
+    2,
+    true
+  ),
+  Triangle: () => transformedByMatrix(
+    RoundedPolygon.fromVertexCount(3, { rounding: cornerRound20 }),
+    rotateNeg90
+  ),
+  Diamond: () => customPolygon([pnr(0.5, 1.096, cr(0.151, 0.524)), pnr(0.04, 0.5, cr(0.159))], 2),
+  ClamShell: () => customPolygon(
+    [pnr(0.171, 0.841, cr(0.159)), pnr(-0.02, 0.5, cr(0.14)), pnr(0.17, 0.159, cr(0.159))],
+    2
+  ),
+  Pentagon: () => customPolygon(
+    [pnr(0.5, -9e-3, cr(0.172)), pnr(1.03, 0.365, cr(0.164)), pnr(0.828, 0.97, cr(0.169))],
+    1,
+    true
+  ),
+  Gem: () => customPolygon(
+    [
+      pnr(0.499, 1.023, cr(0.241, 0.778)),
+      pnr(-5e-3, 0.792, cr(0.208)),
+      pnr(0.073, 0.258, cr(0.228)),
+      pnr(0.433, -0, cr(0.491))
+    ],
+    1,
+    true
+  ),
+  Sunny: () => star(8, { innerRadius: f2(0.8), rounding: cornerRound15 }),
+  VerySunny: () => customPolygon([pnr(0.5, 1.08, cr(0.085)), pnr(0.358, 0.843, cr(0.085))], 8),
+  Cookie4Sided: () => customPolygon([pnr(1.237, 1.236, cr(0.258)), pnr(0.5, 0.918, cr(0.233))], 4),
+  // 6-point cookie
+  Cookie6Sided: () => customPolygon([pnr(0.723, 0.884, cr(0.394)), pnr(0.5, 1.099, cr(0.398))], 6),
+  // 7-point cookie
+  Cookie7Sided: () => transformedByMatrix(star(7, { innerRadius: f2(0.75), rounding: cornerRound50 }), rotateNeg90),
+  Cookie9Sided: () => transformedByMatrix(star(9, { innerRadius: f2(0.8), rounding: cornerRound50 }), rotateNeg90),
+  Cookie12Sided: () => transformedByMatrix(star(12, { innerRadius: f2(0.8), rounding: cornerRound50 }), rotateNeg90),
+  Ghostish: () => customPolygon(
+    [
+      pnr(0.5, 0, cr(1)),
+      pnr(1, 0, cr(1)),
+      pnr(1, 1.14, cr(0.254, 0.106)),
+      pnr(0.575, 0.906, cr(0.253))
+    ],
+    1,
+    true
+  ),
+  Clover4Leaf: () => customPolygon([pnr(0.5, 0.074), pnr(0.725, -0.099, cr(0.476))], 4, true),
+  Clover8Leaf: () => customPolygon([pnr(0.5, 0.036), pnr(0.758, -0.101, cr(0.209))], 8),
+  Burst: () => customPolygon([pnr(0.5, -6e-3, cr(6e-3)), pnr(0.592, 0.158, cr(6e-3))], 12),
+  SoftBurst: () => customPolygon([pnr(0.193, 0.277, cr(0.053)), pnr(0.176, 0.055, cr(0.053))], 10),
+  Boom: () => customPolygon([pnr(0.457, 0.296, cr(7e-3)), pnr(0.5, -0.051, cr(7e-3))], 15),
+  SoftBoom: () => customPolygon(
+    [
+      pnr(0.733, 0.454),
+      pnr(0.839, 0.437, cr(0.532)),
+      pnr(0.949, 0.449, cr(0.439, 1)),
+      pnr(0.998, 0.478, cr(0.174))
+    ],
+    16,
+    true
+  ),
+  Flower: () => customPolygon(
+    [pnr(0.37, 0.187), pnr(0.416, 0.049, cr(0.381)), pnr(0.479, 1e-3, cr(0.095))],
+    8,
+    true
+  ),
+  Puffy: () => transformedByMatrix(
+    customPolygon(
+      [
+        pnr(0.5, 0.053),
+        pnr(0.545, -0.04, cr(0.405)),
+        pnr(0.67, -0.035, cr(0.426)),
+        pnr(0.717, 0.066, cr(0.574)),
+        pnr(0.722, 0.128),
+        pnr(0.777, 2e-3, cr(0.36)),
+        pnr(0.914, 0.149, cr(0.66)),
+        pnr(0.926, 0.289, cr(0.66)),
+        pnr(0.881, 0.346),
+        pnr(0.94, 0.344, cr(0.126)),
+        pnr(1.003, 0.437, cr(0.255))
+      ],
+      2,
+      true
+    ),
+    new Matrix().scale(1, f2(0.742))
+  ),
+  PuffyDiamond: () => customPolygon(
+    [pnr(0.87, 0.13, cr(0.146)), pnr(0.818, 0.357), pnr(1, 0.332, cr(0.853))],
+    4,
+    true
+  ),
+  PixelCircle: () => customPolygon(
+    [
+      pnr(0.5, 0),
+      pnr(0.704, 0),
+      pnr(0.704, 0.065),
+      pnr(0.843, 0.065),
+      pnr(0.843, 0.148),
+      pnr(0.926, 0.148),
+      pnr(0.926, 0.296),
+      pnr(1, 0.296)
+    ],
+    2,
+    true
+  ),
+  PixelTriangle: () => customPolygon(
+    [
+      pnr(0.11, 0.5),
+      pnr(0.113, 0),
+      pnr(0.287, 0),
+      pnr(0.287, 0.087),
+      pnr(0.421, 0.087),
+      pnr(0.421, 0.17),
+      pnr(0.56, 0.17),
+      pnr(0.56, 0.265),
+      pnr(0.674, 0.265),
+      pnr(0.675, 0.344),
+      pnr(0.789, 0.344),
+      pnr(0.789, 0.439),
+      pnr(0.888, 0.439)
+    ],
+    1,
+    true
+  ),
+  Bun: () => customPolygon(
+    [pnr(0.796, 0.5), pnr(0.853, 0.518, cr(1)), pnr(0.992, 0.631, cr(1)), pnr(0.968, 1, cr(1))],
+    2,
+    true
+  ),
+  Heart: () => customPolygon(
+    [
+      pnr(0.5, 0.268, cr(0.016)),
+      pnr(0.792, -0.066, cr(0.958)),
+      pnr(1.064, 0.276, cr(1)),
+      pnr(0.501, 0.946, cr(0.129))
+    ],
+    1,
+    true
+  )
+};
+var materialShapeNames = Object.keys(builders);
+var cache = /* @__PURE__ */ new Map();
+function materialShape(name) {
+  let polygon = cache.get(name);
+  if (polygon === void 0) {
+    polygon = builders[name]().normalized();
+    cache.set(name, polygon);
+  }
+  return polygon;
+}
+
+// src/loading-indicator.ts
+var INDETERMINATE = [
+  "SoftBurst",
+  "Cookie9Sided",
+  "Pentagon",
+  "Pill",
+  "Sunny",
+  "Cookie4Sided",
+  "Oval"
+];
+var indeterminateIndicatorPolygons = () => INDETERMINATE.map(materialShape);
+var determinateIndicatorPolygons = () => [
+  transformedByMatrix(materialShape("Circle"), new Matrix().rotateZ(f2(360 / 20))),
+  materialShape("SoftBurst")
+];
+function morphSequence(polygons, circularSequence) {
+  const morphs = [];
+  for (let i = 0; i < polygons.length; i++) {
+    if (i + 1 < polygons.length) {
+      morphs.push(new Morph(polygons[i].normalized(), polygons[i + 1].normalized()));
+    } else if (circularSequence) {
+      morphs.push(new Morph(polygons[i].normalized(), polygons[0].normalized()));
+    }
+  }
+  return morphs;
+}
+function calculateScaleFactor(polygons) {
+  let scaleFactor = 1;
+  const bounds = [0, 0, 0, 0];
+  const maxBounds = [0, 0, 0, 0];
+  for (const polygon of polygons) {
+    polygon.calculateBounds(bounds);
+    polygon.calculateMaxBounds(maxBounds);
+    const scaleX = f2(f2(bounds[2] - bounds[0]) / f2(maxBounds[2] - maxBounds[0]));
+    const scaleY = f2(f2(bounds[3] - bounds[1]) / f2(maxBounds[3] - maxBounds[1]));
+    scaleFactor = Math.min(scaleFactor, Math.max(scaleX, scaleY));
+  }
+  return scaleFactor;
+}
+function processPath(path, width, height, scaleFactor) {
+  const scaled = transformPath(
+    path,
+    new Matrix().scale(f2(width * scaleFactor), f2(height * scaleFactor))
+  );
+  const [left, top, right, bottom] = pathBounds(scaled);
+  const dx = f2(f2(width / 2) - f2(left + f2(f2(right - left) / 2)));
+  const dy = f2(f2(height / 2) - f2(top + f2(f2(bottom - top) / 2)));
+  return scaled.map((command) => {
+    switch (command[0]) {
+      case "M":
+      case "L":
+        return [command[0], f2(command[1] + dx), f2(command[2] + dy)];
+      case "C":
+        return [
+          "C",
+          f2(command[1] + dx),
+          f2(command[2] + dy),
+          f2(command[3] + dx),
+          f2(command[4] + dy),
+          f2(command[5] + dx),
+          f2(command[6] + dy)
+        ];
+      case "Z":
+        return command;
+    }
+  });
+}
+function determinateFrame(progress, morphCount) {
+  const value = Number.isNaN(progress) ? 0 : Math.min(Math.max(f2(progress), 0), 1);
+  const scaled = f2(morphCount * value);
+  const morphIndex = Math.min(Math.trunc(scaled), morphCount - 1);
+  const morphProgress = value === 1 && morphIndex === morphCount - 1 ? 1 : scaled % 1;
+  return { morphIndex, morphProgress, rotation: f2(-value * 180) };
+}
+var LoadingIndicatorShapes = class {
+  morphs;
+  scaleFactor;
+  constructor(polygons, circularSequence, activeIndicatorScale) {
+    if (polygons.length < 2) {
+      throw new Error("indicatorPolygons should have, at least, two RoundedPolygons");
+    }
+    this.morphs = morphSequence(polygons, circularSequence);
+    this.scaleFactor = f2(calculateScaleFactor(polygons) * f2(activeIndicatorScale));
+  }
+  /** The processed path of morph [morphIndex] at [progress] in a [size]-sided square. */
+  path(morphIndex, progress, size) {
+    const morph = this.morphs[morphIndex];
+    return processPath(
+      morphToPath(morph, progress, { startAngle: 0 }),
+      size,
+      size,
+      this.scaleFactor
+    );
+  }
+  /** {@link path} as an SVG `d` attribute. */
+  pathData(morphIndex, progress, size) {
+    return toSvgPathData(this.path(morphIndex, progress, size));
+  }
+};
+var defaultShapes = /* @__PURE__ */ new Map();
+var customShapes = /* @__PURE__ */ new WeakMap();
+function loadingIndicatorShapes(polygons, indeterminate, activeIndicatorScale) {
+  const key = `${String(indeterminate)}:${String(activeIndicatorScale)}`;
+  let cache2 = defaultShapes;
+  if (polygons) {
+    cache2 = customShapes.get(polygons) ?? /* @__PURE__ */ new Map();
+    customShapes.set(polygons, cache2);
+  }
+  let shapes = cache2.get(key);
+  if (!shapes) {
+    const list = polygons ?? (indeterminate ? indeterminateIndicatorPolygons() : determinateIndicatorPolygons());
+    shapes = new LoadingIndicatorShapes(list, indeterminate, activeIndicatorScale);
+    cache2.set(key, shapes);
+  }
+  return shapes;
+}
+
+export { Corner, CornerRounding, Cubic, Edge, Feature, LoadingIndicatorShapes, Morph, MutableCubic, RoundedPolygon, calculateScaleFactor, circle, determinateFrame, determinateIndicatorPolygons, indeterminateIndicatorPolygons, loadingIndicatorShapes, materialShape, materialShapeNames, morphSequence, morphToPath, pathBounds, pill, pillStar, polygonToPath, processPath, rectangle, star, toShapeOutline, toSvgPathData, translatePath };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map