@pibbl/core 0.0.1

package/dist/features/physics/lib/2d/collision/support.js

@@ -0,0 +1,155 @@
+import { transformPointInto } from "../math.js";
+import { GEOMETRY_EPSILON } from "../numeric-policy.js";
+function supportMinkowski2D(first, firstPose, second, secondPose, directionX, directionY) {
+  const points = new Float64Array(4);
+  const firstFeature = supportLeaf2D(points, 0, first, firstPose, directionX, directionY);
+  const secondFeature = supportLeaf2D(points, 2, second, secondPose, -directionX, -directionY);
+  return {
+    x: points[0] - points[2],
+    y: points[1] - points[3],
+    firstX: points[0],
+    firstY: points[1],
+    secondX: points[2],
+    secondY: points[3],
+    firstFeature,
+    secondFeature
+  };
+}
+function supportLeaf2D(output, outputOffset, leaf, pose, directionX, directionY) {
+  const cosine = Math.cos(pose.rotationRadians);
+  const sine = Math.sin(pose.rotationRadians);
+  const localDirectionX = cosine * directionX + sine * directionY;
+  const localDirectionY = -sine * directionX + cosine * directionY;
+  const local = localSupport(leaf, localDirectionX, localDirectionY);
+  transformPointInto(output, outputOffset, local.x, local.y, pose);
+  return local.feature;
+}
+function centerOfLeaf2D(output, outputOffset, leaf, pose) {
+  let x;
+  let y;
+  switch (leaf.kind) {
+    case "circle":
+    case "ellipse":
+    case "box":
+    case "rounded-box":
+      x = leaf.center[0];
+      y = leaf.center[1];
+      break;
+    case "capsule":
+    case "segment":
+      x = (leaf.start[0] + leaf.end[0]) / 2;
+      y = (leaf.start[1] + leaf.end[1]) / 2;
+      break;
+    case "polygon": {
+      x = 0;
+      y = 0;
+      const count = leaf.vertices.length / 2;
+      for (let index = 0; index < count; index += 1) {
+        x += leaf.vertices[index * 2];
+        y += leaf.vertices[index * 2 + 1];
+      }
+      x /= count;
+      y /= count;
+      break;
+    }
+  }
+  transformPointInto(output, outputOffset, x, y, pose);
+}
+function localSupport(leaf, directionX, directionY) {
+  const length = Math.hypot(directionX, directionY);
+  const unitX = length > GEOMETRY_EPSILON ? directionX / length : 1;
+  const unitY = length > GEOMETRY_EPSILON ? directionY / length : 0;
+  switch (leaf.kind) {
+    case "circle":
+      return { x: leaf.center[0] + unitX * leaf.radius, y: leaf.center[1] + unitY * leaf.radius, feature: 0 };
+    case "ellipse": {
+      const cosine = Math.cos(leaf.rotationRadians);
+      const sine = Math.sin(leaf.rotationRadians);
+      const dx = cosine * directionX + sine * directionY;
+      const dy = -sine * directionX + cosine * directionY;
+      const denominator = Math.hypot(leaf.radiusX * dx, leaf.radiusY * dy);
+      const ellipseX = denominator > GEOMETRY_EPSILON ? leaf.radiusX * leaf.radiusX * dx / denominator : leaf.radiusX;
+      const ellipseY = denominator > GEOMETRY_EPSILON ? leaf.radiusY * leaf.radiusY * dy / denominator : 0;
+      return {
+        x: leaf.center[0] + cosine * ellipseX - sine * ellipseY,
+        y: leaf.center[1] + sine * ellipseX + cosine * ellipseY,
+        feature: 0
+      };
+    }
+    case "box": {
+      const vertices = [
+        [-leaf.halfWidth, -leaf.halfHeight],
+        [leaf.halfWidth, -leaf.halfHeight],
+        [leaf.halfWidth, leaf.halfHeight],
+        [-leaf.halfWidth, leaf.halfHeight]
+      ];
+      let best = 0;
+      let bestProjection = Number.NEGATIVE_INFINITY;
+      for (let index = 0; index < vertices.length; index += 1) {
+        const vertex2 = vertices[index];
+        const projection = vertex2[0] * directionX + vertex2[1] * directionY;
+        if (projection > bestProjection) {
+          best = index;
+          bestProjection = projection;
+        }
+      }
+      const vertex = vertices[best];
+      return { x: leaf.center[0] + vertex[0], y: leaf.center[1] + vertex[1], feature: best };
+    }
+    case "rounded-box": {
+      let bestX = 0;
+      let bestY = 0;
+      let bestProjection = Number.NEGATIVE_INFINITY;
+      let bestFeature = 0;
+      for (let feature = 0; feature < 4; feature += 1) {
+        const radius = leaf.radii[feature];
+        const right = feature === 1 || feature === 2;
+        const bottom = feature >= 2;
+        const x = leaf.center[0] + (right ? leaf.halfWidth - radius : -leaf.halfWidth + radius) + unitX * radius;
+        const y = leaf.center[1] + (bottom ? leaf.halfHeight - radius : -leaf.halfHeight + radius) + unitY * radius;
+        const projection = x * directionX + y * directionY;
+        if (projection > bestProjection + GEOMETRY_EPSILON) {
+          bestX = x;
+          bestY = y;
+          bestProjection = projection;
+          bestFeature = feature;
+        }
+      }
+      return { x: bestX, y: bestY, feature: bestFeature };
+    }
+    case "capsule": {
+      const startProjection = leaf.start[0] * directionX + leaf.start[1] * directionY;
+      const endProjection = leaf.end[0] * directionX + leaf.end[1] * directionY;
+      const feature = endProjection > startProjection ? 1 : 0;
+      const endpoint = feature === 0 ? leaf.start : leaf.end;
+      return { x: endpoint[0] + unitX * leaf.radius, y: endpoint[1] + unitY * leaf.radius, feature };
+    }
+    case "segment": {
+      const startProjection = leaf.start[0] * directionX + leaf.start[1] * directionY;
+      const endProjection = leaf.end[0] * directionX + leaf.end[1] * directionY;
+      const feature = endProjection > startProjection ? 1 : 0;
+      const endpoint = feature === 0 ? leaf.start : leaf.end;
+      return { x: endpoint[0], y: endpoint[1], feature };
+    }
+    case "polygon": {
+      let best = 0;
+      let bestProjection = Number.NEGATIVE_INFINITY;
+      for (let index = 0; index < leaf.vertices.length / 2; index += 1) {
+        const x = leaf.vertices[index * 2];
+        const y = leaf.vertices[index * 2 + 1];
+        const projection = x * directionX + y * directionY;
+        if (projection > bestProjection) {
+          best = index;
+          bestProjection = projection;
+        }
+      }
+      return { x: leaf.vertices[best * 2], y: leaf.vertices[best * 2 + 1], feature: best };
+    }
+  }
+}
+export {
+  centerOfLeaf2D,
+  supportLeaf2D,
+  supportMinkowski2D
+};
+//# sourceMappingURL=support.js.map

package/dist/features/physics/lib/2d/collision/support.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/features/physics/lib/2d/collision/support.ts"],
+  "sourcesContent": ["import { transformPointInto, type InternalPose2D } from '../math.js';\nimport { GEOMETRY_EPSILON } from '../numeric-policy.js';\nimport type { ConvexLeaf2D } from '../shape-records.js';\n\nexport interface SupportPoint2D {\n  readonly x: number;\n  readonly y: number;\n  readonly feature: number;\n}\n\nexport interface MinkowskiVertex2D {\n  readonly x: number;\n  readonly y: number;\n  readonly firstX: number;\n  readonly firstY: number;\n  readonly secondX: number;\n  readonly secondY: number;\n  readonly firstFeature: number;\n  readonly secondFeature: number;\n}\n\nexport function supportMinkowski2D(\n  first: ConvexLeaf2D,\n  firstPose: InternalPose2D,\n  second: ConvexLeaf2D,\n  secondPose: InternalPose2D,\n  directionX: number,\n  directionY: number,\n): MinkowskiVertex2D {\n  const points = new Float64Array(4);\n  const firstFeature = supportLeaf2D(points, 0, first, firstPose, directionX, directionY);\n  const secondFeature = supportLeaf2D(points, 2, second, secondPose, -directionX, -directionY);\n  return {\n    x: points[0]! - points[2]!,\n    y: points[1]! - points[3]!,\n    firstX: points[0]!,\n    firstY: points[1]!,\n    secondX: points[2]!,\n    secondY: points[3]!,\n    firstFeature,\n    secondFeature,\n  };\n}\n\nexport function supportLeaf2D(\n  output: Float64Array,\n  outputOffset: number,\n  leaf: ConvexLeaf2D,\n  pose: InternalPose2D,\n  directionX: number,\n  directionY: number,\n): number {\n  const cosine = Math.cos(pose.rotationRadians);\n  const sine = Math.sin(pose.rotationRadians);\n  const localDirectionX = cosine * directionX + sine * directionY;\n  const localDirectionY = -sine * directionX + cosine * directionY;\n  const local = localSupport(leaf, localDirectionX, localDirectionY);\n  transformPointInto(output, outputOffset, local.x, local.y, pose);\n  return local.feature;\n}\n\nexport function centerOfLeaf2D(\n  output: Float64Array,\n  outputOffset: number,\n  leaf: ConvexLeaf2D,\n  pose: InternalPose2D,\n): void {\n  let x: number;\n  let y: number;\n  switch (leaf.kind) {\n    case 'circle':\n    case 'ellipse':\n    case 'box':\n    case 'rounded-box':\n      x = leaf.center[0]!;\n      y = leaf.center[1]!;\n      break;\n    case 'capsule':\n    case 'segment':\n      x = (leaf.start[0]! + leaf.end[0]!) / 2;\n      y = (leaf.start[1]! + leaf.end[1]!) / 2;\n      break;\n    case 'polygon': {\n      x = 0;\n      y = 0;\n      const count = leaf.vertices.length / 2;\n      for (let index = 0; index < count; index += 1) {\n        x += leaf.vertices[index * 2]!;\n        y += leaf.vertices[index * 2 + 1]!;\n      }\n      x /= count;\n      y /= count;\n      break;\n    }\n  }\n  transformPointInto(output, outputOffset, x, y, pose);\n}\n\nfunction localSupport(\n  leaf: ConvexLeaf2D,\n  directionX: number,\n  directionY: number,\n): SupportPoint2D {\n  const length = Math.hypot(directionX, directionY);\n  const unitX = length > GEOMETRY_EPSILON ? directionX / length : 1;\n  const unitY = length > GEOMETRY_EPSILON ? directionY / length : 0;\n  switch (leaf.kind) {\n    case 'circle':\n      return { x: leaf.center[0]! + unitX * leaf.radius, y: leaf.center[1]! + unitY * leaf.radius, feature: 0 };\n    case 'ellipse': {\n      const cosine = Math.cos(leaf.rotationRadians);\n      const sine = Math.sin(leaf.rotationRadians);\n      const dx = cosine * directionX + sine * directionY;\n      const dy = -sine * directionX + cosine * directionY;\n      const denominator = Math.hypot(leaf.radiusX * dx, leaf.radiusY * dy);\n      const ellipseX = denominator > GEOMETRY_EPSILON\n        ? leaf.radiusX * leaf.radiusX * dx / denominator\n        : leaf.radiusX;\n      const ellipseY = denominator > GEOMETRY_EPSILON\n        ? leaf.radiusY * leaf.radiusY * dy / denominator\n        : 0;\n      return {\n        x: leaf.center[0]! + cosine * ellipseX - sine * ellipseY,\n        y: leaf.center[1]! + sine * ellipseX + cosine * ellipseY,\n        feature: 0,\n      };\n    }\n    case 'box': {\n      const vertices = [\n        [-leaf.halfWidth, -leaf.halfHeight],\n        [leaf.halfWidth, -leaf.halfHeight],\n        [leaf.halfWidth, leaf.halfHeight],\n        [-leaf.halfWidth, leaf.halfHeight],\n      ] as const;\n      let best = 0;\n      let bestProjection = Number.NEGATIVE_INFINITY;\n      for (let index = 0; index < vertices.length; index += 1) {\n        const vertex = vertices[index]!;\n        const projection = vertex[0] * directionX + vertex[1] * directionY;\n        if (projection > bestProjection) {\n          best = index;\n          bestProjection = projection;\n        }\n      }\n      const vertex = vertices[best]!;\n      return { x: leaf.center[0]! + vertex[0], y: leaf.center[1]! + vertex[1], feature: best };\n    }\n    case 'rounded-box': {\n      let bestX = 0;\n      let bestY = 0;\n      let bestProjection = Number.NEGATIVE_INFINITY;\n      let bestFeature = 0;\n      for (let feature = 0; feature < 4; feature += 1) {\n        const radius = leaf.radii[feature]!;\n        const right = feature === 1 || feature === 2;\n        const bottom = feature >= 2;\n        const x = leaf.center[0]! + (right ? leaf.halfWidth - radius : -leaf.halfWidth + radius) + unitX * radius;\n        const y = leaf.center[1]! + (bottom ? leaf.halfHeight - radius : -leaf.halfHeight + radius) + unitY * radius;\n        const projection = x * directionX + y * directionY;\n        if (projection > bestProjection + GEOMETRY_EPSILON) {\n          bestX = x;\n          bestY = y;\n          bestProjection = projection;\n          bestFeature = feature;\n        }\n      }\n      return { x: bestX, y: bestY, feature: bestFeature };\n    }\n    case 'capsule': {\n      const startProjection = leaf.start[0]! * directionX + leaf.start[1]! * directionY;\n      const endProjection = leaf.end[0]! * directionX + leaf.end[1]! * directionY;\n      const feature = endProjection > startProjection ? 1 : 0;\n      const endpoint = feature === 0 ? leaf.start : leaf.end;\n      return { x: endpoint[0]! + unitX * leaf.radius, y: endpoint[1]! + unitY * leaf.radius, feature };\n    }\n    case 'segment': {\n      const startProjection = leaf.start[0]! * directionX + leaf.start[1]! * directionY;\n      const endProjection = leaf.end[0]! * directionX + leaf.end[1]! * directionY;\n      const feature = endProjection > startProjection ? 1 : 0;\n      const endpoint = feature === 0 ? leaf.start : leaf.end;\n      return { x: endpoint[0]!, y: endpoint[1]!, feature };\n    }\n    case 'polygon': {\n      let best = 0;\n      let bestProjection = Number.NEGATIVE_INFINITY;\n      for (let index = 0; index < leaf.vertices.length / 2; index += 1) {\n        const x = leaf.vertices[index * 2]!;\n        const y = leaf.vertices[index * 2 + 1]!;\n        const projection = x * directionX + y * directionY;\n        if (projection > bestProjection) {\n          best = index;\n          bestProjection = projection;\n        }\n      }\n      return { x: leaf.vertices[best * 2]!, y: leaf.vertices[best * 2 + 1]!, feature: best };\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["vertex"]
+}

package/dist/features/physics/lib/2d/inspection-types.d.ts

@@ -0,0 +1,159 @@
+import type { PibblPhysicsAabb2D, PibblPhysicsContactPoint2D, PibblPhysicsPose2D, PibblPhysicsVector2 } from "../../2d-geometry.js";
+/**
+ * Diagnostic body identity, committed and presented poses, motion, sleeping state, and mass.
+ *
+ * @see {@link PibblPhysicsPose2D}
+ * @see {@link PibblPhysicsVector2}
+ * @see {@link PibblPhysicsInspection2D}
+ */
+export interface PibblPhysicsBodyInspection2D {
+    /** Stable identifier of this resource or connection. See {@link PibblPhysicsBodyInspection2D}. */
+    readonly id: number;
+    /**
+     * Generation counter distinguishing successive bindings of a stable identity. See
+     * {@link PibblPhysicsBodyInspection2D}.
+     */
+    readonly generation: number;
+    /**
+     * Selects `"dynamic"` , `"kinematic"` , `"static"` for type. See
+     * {@link PibblPhysicsBodyInspection2D}.
+     */
+    readonly type: "dynamic" | "kinematic" | "static";
+    /**
+     * Whether this operation or resource participates in updates. See
+     * {@link PibblPhysicsBodyInspection2D}.
+     */
+    readonly enabled: boolean;
+    /** Whether the body is currently sleeping. See {@link PibblPhysicsBodyInspection2D}. */
+    readonly sleeping: boolean;
+    /** Committed physical position and rotation. See {@link PibblPhysicsPose2D}. */
+    readonly pose: PibblPhysicsPose2D;
+    /** Interpolated pose currently used for drawing. See {@link PibblPhysicsPose2D}. */
+    readonly presentationPose: PibblPhysicsPose2D;
+    /** Center of mass in the reported physics coordinate system. See {@link PibblPhysicsVector2}. */
+    readonly centerOfMass: PibblPhysicsVector2;
+    /**
+     * Linear velocity in the simulation coordinate system per second. See {@link PibblPhysicsVector2}
+     * .
+     */
+    readonly linearVelocity: PibblPhysicsVector2;
+    /** Angular velocity in degrees per second. See {@link PibblPhysicsBodyInspection2D}. */
+    readonly angularVelocityDegreesPerSecond: number;
+    /** Mass used by the spring or physics calculation. See {@link PibblPhysicsBodyInspection2D}. */
+    readonly mass: number | null;
+}
+/**
+ * Serializable collider identity, shape kinds, bounds, sensor state, and string label.
+ *
+ * @see {@link PibblPhysicsAabb2D}
+ * @see {@link PibblPhysicsInspection2D}
+ */
+export interface PibblPhysicsColliderInspection2D {
+    /**
+     * Stable identifier of this resource or connection. See {@link PibblPhysicsColliderInspection2D}.
+     */
+    readonly id: number;
+    /**
+     * Generation counter distinguishing successive bindings of a stable identity. See
+     * {@link PibblPhysicsColliderInspection2D}.
+     */
+    readonly generation: number;
+    /** Identifier of the collider's owning body. See {@link PibblPhysicsColliderInspection2D}. */
+    readonly bodyId: number;
+    /**
+     * Whether the collider reports overlaps instead of producing contact response. See
+     * {@link PibblPhysicsColliderInspection2D}.
+     */
+    readonly sensor: boolean;
+    /** String tags only. Arbitrary application objects are never serialized. */
+    readonly label: string | null;
+    /**
+     * Kinds of shape geometry represented by the collider. See
+     * {@link PibblPhysicsColliderInspection2D}.
+     */
+    readonly shapeKinds: readonly string[];
+    /** Logical region constraining the content or query. See {@link PibblPhysicsAabb2D}. */
+    readonly bounds: PibblPhysicsAabb2D;
+}
+/**
+ * Diagnostic contact geometry and impulse between two collider identities.
+ *
+ * @see {@link PibblPhysicsVector2}
+ * @see {@link PibblPhysicsContactPoint2D}
+ * @see {@link PibblPhysicsInspection2D}
+ */
+export interface PibblPhysicsContactInspection2D {
+    /**
+     * Identifier of the first collider in the contact pair. See
+     * {@link PibblPhysicsContactInspection2D}.
+     */
+    readonly firstColliderId: number;
+    /**
+     * Identifier of the second collider in the contact pair. See
+     * {@link PibblPhysicsContactInspection2D}.
+     */
+    readonly secondColliderId: number;
+    /**
+     * Whether the collider reports overlaps instead of producing contact response. See
+     * {@link PibblPhysicsContactInspection2D}.
+     */
+    readonly sensor: boolean;
+    /** Contact or surface normal returned by this query. See {@link PibblPhysicsVector2}. */
+    readonly normal: PibblPhysicsVector2;
+    /**
+     * Points defining the geometry or reported by the contact query. See
+     * {@link PibblPhysicsContactPoint2D}.
+     */
+    readonly points: readonly PibblPhysicsContactPoint2D[];
+    /** Normal contact impulse reported by the solver. See {@link PibblPhysicsContactInspection2D}. */
+    readonly normalImpulse: number;
+}
+/**
+ * Read-only observations, not an engine serialization/restore format.
+ *
+ * @see {@link PibblPhysicsBodyInspection2D}
+ * @see {@link PibblPhysicsColliderInspection2D}
+ * @see {@link PibblPhysicsContactInspection2D}
+ */
+export interface PibblPhysicsInspection2D {
+    /**
+     * The literal "rapier-2d@0.21.0" identifying this variant. See {@link PibblPhysicsInspection2D}.
+     */
+    readonly engine: "rapier-2d@0.21.0";
+    /** Selects `"root"`, `"local"` for space. See {@link PibblPhysicsInspection2D}. */
+    readonly space: "root" | "local";
+    /**
+     * Revision used to detect changes to the underlying state or geometry. See
+     * {@link PibblPhysicsInspection2D}.
+     */
+    readonly revision: number;
+    /** Simulation tick associated with this observation. See {@link PibblPhysicsInspection2D}. */
+    readonly tick: number;
+    /**
+     * Whether the inspected world is actively advancing simulation. See
+     * {@link PibblPhysicsInspection2D}.
+     */
+    readonly advancing: boolean;
+    /**
+     * Number of scheduler frames in which this world failed to advance. See
+     * {@link PibblPhysicsInspection2D}.
+     */
+    readonly failedFrames: number;
+    /**
+     * Diagnostic information about the most recent simulation failure. See
+     * {@link PibblPhysicsInspection2D}.
+     */
+    readonly lastFailure: string | null;
+    /** Committed body snapshots in the inspected world. See {@link PibblPhysicsBodyInspection2D}. */
+    readonly bodies: readonly PibblPhysicsBodyInspection2D[];
+    /**
+     * Committed collider snapshots in the inspected world. See
+     * {@link PibblPhysicsColliderInspection2D}.
+     */
+    readonly colliders: readonly PibblPhysicsColliderInspection2D[];
+    /**
+     * Committed contact snapshots in the inspected world. See {@link PibblPhysicsContactInspection2D}
+     * .
+     */
+    readonly contacts: readonly PibblPhysicsContactInspection2D[];
+}

package/dist/features/physics/lib/2d/math.d.ts

@@ -0,0 +1,27 @@
+import type { PibblPhysicsAabb2D, PibblPhysicsPose2D, PibblPhysicsVector2 } from '../../2d-geometry.js';
+export declare const CURVE_FLATTENING_TOLERANCE = 0.05;
+export declare const CURVE_FLATTENING_MAX_DEPTH = 12;
+export interface InternalPose2D {
+    readonly x: number;
+    readonly y: number;
+    readonly rotationRadians: number;
+}
+export declare const IDENTITY_POSE_2D: InternalPose2D;
+export declare function copyPose2D(pose: PibblPhysicsPose2D | undefined, path: string): InternalPose2D;
+/** Returns outer(inner(point)). */
+export declare function composePose2D(outer: InternalPose2D, inner: InternalPose2D): InternalPose2D;
+export declare function transformPointInto(output: Float64Array, outputOffset: number, x: number, y: number, pose: InternalPose2D): void;
+export declare function cross2D(ax: number, ay: number, bx: number, by: number, cx: number, cy: number): number;
+export declare function canonicalizeContour2D(source: readonly PibblPhysicsVector2[], options: Readonly<{
+    strictlyConvex: boolean;
+    path: string;
+}>): Float64Array;
+export declare function triangulateContour2D(vertices: Float64Array): readonly Float64Array[];
+export declare function polygonMassData2D(vertices: Float64Array): Readonly<{
+    area: number;
+    centroidX: number;
+    centroidY: number;
+    unitInertia: number;
+}>;
+export declare function freezeBounds2D(minX: number, minY: number, maxX: number, maxY: number): PibblPhysicsAabb2D;
+export declare function cleanZero(value: number): number;

package/dist/features/physics/lib/2d/math.js

@@ -0,0 +1,314 @@
+import { copyFiniteVector2, requireFiniteNumber } from "../shared/validation.js";
+import { DEGREES_TO_RADIANS, GEOMETRY_EPSILON } from "./numeric-policy.js";
+const CURVE_FLATTENING_TOLERANCE = 0.05;
+const CURVE_FLATTENING_MAX_DEPTH = 12;
+const IDENTITY_POSE_2D = Object.freeze({
+  x: 0,
+  y: 0,
+  rotationRadians: 0
+});
+function copyPose2D(pose, path) {
+  if (pose === void 0) {
+    return IDENTITY_POSE_2D;
+  }
+  const position = copyFiniteVector2(pose.position, `${path}.position`);
+  return Object.freeze({
+    x: position[0],
+    y: position[1],
+    rotationRadians: requireFiniteNumber(pose.rotationDegrees, `${path}.rotationDegrees`) * DEGREES_TO_RADIANS
+  });
+}
+function composePose2D(outer, inner) {
+  const cosine = Math.cos(outer.rotationRadians);
+  const sine = Math.sin(outer.rotationRadians);
+  return Object.freeze({
+    x: outer.x + cosine * inner.x - sine * inner.y,
+    y: outer.y + sine * inner.x + cosine * inner.y,
+    rotationRadians: outer.rotationRadians + inner.rotationRadians
+  });
+}
+function transformPointInto(output, outputOffset, x, y, pose) {
+  const cosine = Math.cos(pose.rotationRadians);
+  const sine = Math.sin(pose.rotationRadians);
+  output[outputOffset] = pose.x + cosine * x - sine * y;
+  output[outputOffset + 1] = pose.y + sine * x + cosine * y;
+}
+function cross2D(ax, ay, bx, by, cx, cy) {
+  return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
+}
+function canonicalizeContour2D(source, options) {
+  const copied = source.map((point, index) => {
+    const owned = copyFiniteVector2(point, `${options.path}[${index}]`);
+    return [owned[0], owned[1]];
+  });
+  if (copied.length > 1 && copied[0][0] === copied.at(-1)[0] && copied[0][1] === copied.at(-1)[1]) {
+    copied.pop();
+  }
+  if (copied.length < 3) {
+    throw new RangeError(`${options.path} must contain at least three vertices.`);
+  }
+  const cleaned = options.strictlyConvex ? copied : removeCollinearAndAdjacentDuplicates(copied);
+  for (let first = 0; first < cleaned.length; first += 1) {
+    for (let second = first + 1; second < cleaned.length; second += 1) {
+      if (cleaned[first][0] === cleaned[second][0] && cleaned[first][1] === cleaned[second][1]) {
+        throw new RangeError(`${options.path} must not contain duplicate vertices.`);
+      }
+    }
+  }
+  if (cleaned.length < 3) {
+    throw new RangeError(`${options.path} must enclose a nonzero area.`);
+  }
+  if (hasSelfIntersection(cleaned)) {
+    throw new RangeError(`${options.path} must describe a simple polygon.`);
+  }
+  let signedTwiceArea = 0;
+  for (let index = 0; index < cleaned.length; index += 1) {
+    const current = cleaned[index];
+    const next = cleaned[(index + 1) % cleaned.length];
+    signedTwiceArea += current[0] * next[1] - next[0] * current[1];
+  }
+  if (Math.abs(signedTwiceArea) <= GEOMETRY_EPSILON) {
+    throw new RangeError(`${options.path} must enclose a nonzero area.`);
+  }
+  if (signedTwiceArea < 0) {
+    cleaned.reverse();
+  }
+  if (options.strictlyConvex) {
+    for (let index = 0; index < cleaned.length; index += 1) {
+      const previous = cleaned[(index + cleaned.length - 1) % cleaned.length];
+      const current = cleaned[index];
+      const next = cleaned[(index + 1) % cleaned.length];
+      if (cross2D(
+        previous[0],
+        previous[1],
+        current[0],
+        current[1],
+        next[0],
+        next[1]
+      ) <= GEOMETRY_EPSILON) {
+        throw new RangeError(
+          `${options.path} must describe a strictly convex polygon without collinear vertices.`
+        );
+      }
+    }
+  }
+  let start = 0;
+  for (let index = 1; index < cleaned.length; index += 1) {
+    const candidate = cleaned[index];
+    const selected = cleaned[start];
+    if (candidate[0] < selected[0] || candidate[0] === selected[0] && candidate[1] < selected[1]) {
+      start = index;
+    }
+  }
+  const result = new Float64Array(cleaned.length * 2);
+  for (let index = 0; index < cleaned.length; index += 1) {
+    const point = cleaned[(start + index) % cleaned.length];
+    result[index * 2] = point[0];
+    result[index * 2 + 1] = point[1];
+  }
+  return result;
+}
+function triangulateContour2D(vertices) {
+  const count = vertices.length / 2;
+  const remaining = Array.from({ length: count }, (_, index) => index);
+  const triangles = [];
+  while (remaining.length > 3) {
+    let selectedPosition = -1;
+    let selectedCanonicalIndex = Number.POSITIVE_INFINITY;
+    for (let position = 0; position < remaining.length; position += 1) {
+      const previous2 = remaining[(position + remaining.length - 1) % remaining.length];
+      const current2 = remaining[position];
+      const next2 = remaining[(position + 1) % remaining.length];
+      const turn = cross2D(
+        vertices[previous2 * 2],
+        vertices[previous2 * 2 + 1],
+        vertices[current2 * 2],
+        vertices[current2 * 2 + 1],
+        vertices[next2 * 2],
+        vertices[next2 * 2 + 1]
+      );
+      if (turn <= GEOMETRY_EPSILON) {
+        continue;
+      }
+      let containsVertex = false;
+      for (const candidate of remaining) {
+        if (candidate === previous2 || candidate === current2 || candidate === next2) {
+          continue;
+        }
+        if (pointInTriangle(vertices, candidate, previous2, current2, next2)) {
+          containsVertex = true;
+          break;
+        }
+      }
+      if (!containsVertex && current2 < selectedCanonicalIndex) {
+        selectedPosition = position;
+        selectedCanonicalIndex = current2;
+      }
+    }
+    if (selectedPosition < 0) {
+      throw new RangeError("contour could not be triangulated deterministically.");
+    }
+    const previous = remaining[(selectedPosition + remaining.length - 1) % remaining.length];
+    const current = remaining[selectedPosition];
+    const next = remaining[(selectedPosition + 1) % remaining.length];
+    triangles.push(copyTriangle(vertices, previous, current, next));
+    remaining.splice(selectedPosition, 1);
+  }
+  triangles.push(copyTriangle(vertices, remaining[0], remaining[1], remaining[2]));
+  return Object.freeze(triangles);
+}
+function polygonMassData2D(vertices) {
+  let twiceArea = 0;
+  let centroidXTimesSixArea = 0;
+  let centroidYTimesSixArea = 0;
+  let inertiaTimesTwelve = 0;
+  for (let offset = 0; offset < vertices.length; offset += 2) {
+    const nextOffset = (offset + 2) % vertices.length;
+    const x1 = vertices[offset];
+    const y1 = vertices[offset + 1];
+    const x2 = vertices[nextOffset];
+    const y2 = vertices[nextOffset + 1];
+    const cross = x1 * y2 - x2 * y1;
+    twiceArea += cross;
+    centroidXTimesSixArea += (x1 + x2) * cross;
+    centroidYTimesSixArea += (y1 + y2) * cross;
+    inertiaTimesTwelve += cross * (x1 * x1 + x1 * x2 + x2 * x2 + y1 * y1 + y1 * y2 + y2 * y2);
+  }
+  const area = twiceArea / 2;
+  const centroidX = centroidXTimesSixArea / (3 * twiceArea);
+  const centroidY = centroidYTimesSixArea / (3 * twiceArea);
+  const inertiaAboutOrigin = inertiaTimesTwelve / 12;
+  return Object.freeze({
+    area,
+    centroidX,
+    centroidY,
+    unitInertia: inertiaAboutOrigin - area * (centroidX * centroidX + centroidY * centroidY)
+  });
+}
+function freezeBounds2D(minX, minY, maxX, maxY) {
+  return Object.freeze({
+    min: Object.freeze([cleanZero(minX), cleanZero(minY)]),
+    max: Object.freeze([cleanZero(maxX), cleanZero(maxY)])
+  });
+}
+function cleanZero(value) {
+  return Object.is(value, -0) ? 0 : value;
+}
+function removeCollinearAndAdjacentDuplicates(source) {
+  const points = source.filter((point, index) => {
+    const previous = source[(index + source.length - 1) % source.length];
+    return point[0] !== previous[0] || point[1] !== previous[1];
+  });
+  let removed = true;
+  while (removed && points.length >= 3) {
+    removed = false;
+    for (let index = 0; index < points.length; index += 1) {
+      const previous = points[(index + points.length - 1) % points.length];
+      const current = points[index];
+      const next = points[(index + 1) % points.length];
+      if (Math.abs(
+        cross2D(
+          previous[0],
+          previous[1],
+          current[0],
+          current[1],
+          next[0],
+          next[1]
+        )
+      ) <= GEOMETRY_EPSILON) {
+        points.splice(index, 1);
+        removed = true;
+        break;
+      }
+    }
+  }
+  return points;
+}
+function hasSelfIntersection(points) {
+  for (let first = 0; first < points.length; first += 1) {
+    const firstNext = (first + 1) % points.length;
+    for (let second = first + 1; second < points.length; second += 1) {
+      const secondNext = (second + 1) % points.length;
+      if (first === second || firstNext === second || secondNext === first) {
+        continue;
+      }
+      if (segmentsIntersect(
+        points[first],
+        points[firstNext],
+        points[second],
+        points[secondNext]
+      )) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function segmentsIntersect(firstStart, firstEnd, secondStart, secondEnd) {
+  const firstSide = cross2D(
+    firstStart[0],
+    firstStart[1],
+    firstEnd[0],
+    firstEnd[1],
+    secondStart[0],
+    secondStart[1]
+  );
+  const secondSide = cross2D(
+    firstStart[0],
+    firstStart[1],
+    firstEnd[0],
+    firstEnd[1],
+    secondEnd[0],
+    secondEnd[1]
+  );
+  const thirdSide = cross2D(
+    secondStart[0],
+    secondStart[1],
+    secondEnd[0],
+    secondEnd[1],
+    firstStart[0],
+    firstStart[1]
+  );
+  const fourthSide = cross2D(
+    secondStart[0],
+    secondStart[1],
+    secondEnd[0],
+    secondEnd[1],
+    firstEnd[0],
+    firstEnd[1]
+  );
+  return Math.sign(firstSide) !== Math.sign(secondSide) && Math.sign(thirdSide) !== Math.sign(fourthSide);
+}
+function pointInTriangle(vertices, point, first, second, third) {
+  const px = vertices[point * 2];
+  const py = vertices[point * 2 + 1];
+  const firstCross = cross2D(vertices[first * 2], vertices[first * 2 + 1], vertices[second * 2], vertices[second * 2 + 1], px, py);
+  const secondCross = cross2D(vertices[second * 2], vertices[second * 2 + 1], vertices[third * 2], vertices[third * 2 + 1], px, py);
+  const thirdCross = cross2D(vertices[third * 2], vertices[third * 2 + 1], vertices[first * 2], vertices[first * 2 + 1], px, py);
+  return firstCross >= -GEOMETRY_EPSILON && secondCross >= -GEOMETRY_EPSILON && thirdCross >= -GEOMETRY_EPSILON;
+}
+function copyTriangle(vertices, first, second, third) {
+  return new Float64Array([
+    vertices[first * 2],
+    vertices[first * 2 + 1],
+    vertices[second * 2],
+    vertices[second * 2 + 1],
+    vertices[third * 2],
+    vertices[third * 2 + 1]
+  ]);
+}
+export {
+  CURVE_FLATTENING_MAX_DEPTH,
+  CURVE_FLATTENING_TOLERANCE,
+  IDENTITY_POSE_2D,
+  canonicalizeContour2D,
+  cleanZero,
+  composePose2D,
+  copyPose2D,
+  cross2D,
+  freezeBounds2D,
+  polygonMassData2D,
+  transformPointInto,
+  triangulateContour2D
+};
+//# sourceMappingURL=math.js.map