@forgeax/engine-math 0.0.0-dev.8d955ade1c79

package/dist/quat.d.ts

@@ -0,0 +1,312 @@
+import type { EulerOrder, Mat3Like, Quat, QuatLike, Vec3, Vec3Like } from './types';
+export type { Quat, QuatLike };
+/** Create a Quat (default all zero; callers usually call identity() right after). */
+export declare function create(): Quat;
+/** Allocate a new Quat copy. */
+export declare function clone(a: QuatLike): Quat;
+/** out = identity quaternion [0, 0, 0, 1]. Returns out. */
+export declare function identity(out: Quat): Quat;
+/**
+ * out = quaternion representing rotation by angleRadians around axis. Returns out.
+ *
+ * axis does not have to be pre-normalized; this function normalizes it internally.
+ *
+ * @degrade axis is the zero vector (lengthSq < EPS_NORMALIZE) → out = identity
+ * (no throw, registry #8).
+ *
+ * @example
+ * ```ts
+ * quat.fromAxisAngle(out, [0, 1, 0], Math.PI / 2);
+ * // Guard: if (vec3.lengthSq(axis) < EPS_NORMALIZE) skip;
+ * ```
+ */
+export declare function fromAxisAngle(out: Quat, axis: Vec3Like, angleRadians: number): Quat;
+/**
+ * out = quaternion from intrinsic Euler angles (x, y, z, order). Returns out.
+ *
+ * Angle unit = **radians** (aligned with wgpu-matrix / Three.js; research §fact-correction 4
+ * deviates from gl-matrix's degrees).
+ * 6 orders: XYZ / YXZ / ZXY / ZYX / YZX / XZY (intrinsic rotation: literal order x → y → z).
+ * Implementation: split each axis rotation into single-axis quaternions, then Hamilton-multiply
+ * in `order`.
+ *
+ * @degrade order outside the EulerOrder union (only possible via `as any` cast) →
+ *          **silently computes as if 'XYZ'** (D-P2 + AC-06 no throw; registry #9).
+ *
+ * @example
+ * ```ts
+ * quat.fromEuler(out, 0.5, 0.3, 0.1, 'XYZ');
+ * quat.fromEuler(out, 0.5, 0.3, 0.1, 'unknown' as any); // silently computed as 'XYZ'
+ * // Guard: pass an EulerOrder union literal; the TS layer already blocks unknown strings.
+ * ```
+ */
+export declare function fromEuler(out: Quat, x: number, y: number, z: number, order: EulerOrder): Quat;
+/**
+ * out = quaternion from a 3x3 rotation matrix m (column-major, length 9). Returns out.
+ *
+ * Implementation: Shepperd's case-split (branch on trace / largest diagonal entry); numerically
+ * more stable than the direct trace method (avoids sqrt(0) when trace ≈ -1).
+ *
+ * Assumption: m is a pure rotation matrix (|det|=1, columns orthogonal). If not, the result is
+ * undefined but does not throw.
+ *
+ * @degrade m is not a pure rotation (contains shear / scale) → numerically undefined but does
+ *          not throw (AC-06 no throw; callers should normalize column vectors first or avoid
+ *          introducing non-pure-rotation matrices at the ECS-design layer).
+ *
+ * @example
+ * ```ts
+ * quat.fromRotationMatrix(out, mat3InstanceColumnMajor);
+ * ```
+ */
+export declare function fromRotationMatrix(out: Quat, m: Mat3Like): Quat;
+/**
+ * out = orientation quaternion for an object placed at `eye` and facing `target`. Returns out.
+ *
+ * This is the ergonomic camera/look-at helper: it yields the WORLD-space orientation an entity's
+ * Transform.rotation needs so that its local -z axis points from `eye` toward `target` (the camera
+ * convention, matching `mat4.lookAt`). Use it instead of hand-wiring
+ * `mat4.lookAt → mat4.invert → mat3.fromMat4 → quat.fromRotationMatrix`; that chain is easy to get
+ * wrong (notably `fromRotationMatrix` takes a mat3, but `Mat4Like`≡`Mat3Like`≡`ArrayLike<number>`,
+ * so passing a mat4 typechecks and silently reads garbage → NaN → nothing renders).
+ *
+ * Convenience composition (like `mat4.computeViewProj`), not a primitive: it builds the same
+ * right/newUp/forward basis as `mat4.lookAt` and reuses `fromRotationMatrix` for the extraction.
+ *
+ * @degrade eye ≈ target (|eye-target| < EPS_NORMALIZE) → out = identity (same convention as
+ *          `mat4.lookAt` degenerate #4; no throw, AC-06).
+ * @degrade up collinear with the view direction → alternative up auto-selected (same as
+ *          `mat4.lookAt` #5).
+ *
+ * @example
+ * ```ts
+ * // aim a camera at the origin
+ * const q = quat.fromLookAt(quat.create(), [-2.5, 4.5, 9], [0, 0, 0], [0, 1, 0]);
+ * world.set(cameraEntity, Transform, { pos: [-2.5, 4.5, 9], rot: q });
+ * ```
+ */
+export declare function fromLookAt(out: Quat, eye: Vec3Like, target: Vec3Like, up: Vec3Like): Quat;
+/**
+ * out = quaternion that rotates the unit vector v to w (shortest arc). Returns out.
+ *
+ * Assumes v and w are normalized; if not, the caller is responsible.
+ *
+ * @degrade v ≈ w (dot > 1 - EPS_QUAT_PARALLEL) → out = identity (registry #13).
+ * @degrade v ≈ -w (dot < -1 + EPS_QUAT_PARALLEL) → pick a perpendicular axis and do a 180°
+ *          rotation (prefer (0,1,0); fall back to (1,0,0) when collinear with v;
+ *          registry #12 + D-P18).
+ *
+ * @example
+ * ```ts
+ * quat.fromUnitVectors(out, [1,0,0], [0,1,0]); // 90° around Z
+ * quat.fromUnitVectors(out, [1,0,0], [-1,0,0]); // 180° opposite: pick (0,1,0) axis
+ * ```
+ */
+export declare function fromUnitVectors(out: Quat, v: Vec3Like, w: Vec3Like): Quat;
+/**
+ * out = a * b (Hamilton product). Returns out.
+ *
+ * Aliasing-safe: reads all 8 source elements into locals first.
+ */
+export declare function multiply(out: Quat, a: QuatLike, b: QuatLike): Quat;
+/**
+ * out = the orientation `q` after rotating a further `angleRadians` about world-space `axis`,
+ * re-normalized. Returns out.
+ *
+ * This is the ergonomic *incremental rotate* helper — the per-frame spin/animation move. It folds
+ * the three steps every rotating demo otherwise hand-wires: build the delta quaternion
+ * (`fromAxisAngle`), **pre**-multiply it onto the current orientation (world-space axis, matching
+ * **Bevy `Transform::rotate(r)` = `r * self.rotation`** / `rotate_y(θ)`), and — the step that is
+ * silently omitted and makes the naive loop wrong — **normalize** to shed the floating-point error
+ * that accumulates over thousands of frames into a non-unit quaternion (skew / scale artefacts).
+ *
+ * Prefer this over hand-writing `quat.multiply(q, delta, q)` in an update system: that loop drifts,
+ * so demos work around it with an absolute-angle accumulator + `fromAxisAngle` (can't compose onto an
+ * existing orientation) or raw `sin/cos` quaternion literals. `rotateAxis` composes safely.
+ *
+ * Convenience composition (like `fromLookAt`), not a primitive: same result as
+ * `normalize(out, multiply(out, fromAxisAngle(tmp, axis, angleRadians), q))`, fused + aliasing-safe.
+ *
+ * @degrade `axis` zero-length → the delta is identity (degenerate registry #8), so out = normalize(q)
+ *          (no rotation applied; no throw, consistent with the sibling helpers).
+ *
+ * @example
+ * ```ts
+ * // in an Update system: spin a cube about +Y at `speed` rad/s using the frame delta
+ * const dt = world.getResource(Time).delta;
+ * const t = world.get(entity, Transform).unwrap();
+ * quat.rotateAxis(t.quat, t.quat, [0, 1, 0], speed * dt); // in-place accumulate, no drift
+ * world.set(entity, Transform, t);
+ * ```
+ */
+export declare function rotateAxis(out: Quat, q: QuatLike, axis: Vec3Like, angleRadians: number): Quat;
+/**
+ * out = spherical linear interpolation(a, b, t). Returns out.
+ *
+ * t is not clamped (extrapolation semantics matches vec.lerp).
+ *
+ * @degrade dot(a, b) < -EPS_SLERP_DOT_LIMIT (anti-parallel) → **negate b' = -b then slerp**
+ *          (D-P6; q and -q represent the same rotation; registry #10).
+ * @degrade |dot(a, b)| > 1 - EPS_SLERP_DOT_LIMIT (endpoint coincidence or near-coincidence) →
+ *          falls back to nlerp (avoids acos blow-up; registry #11).
+ *
+ * @example
+ * ```ts
+ * quat.slerp(out, a, b, 0.5);
+ * // Anti-parallel (dot ≈ -1): caller does not need to pre-process; the negation fall-back
+ * // happens internally.
+ * ```
+ */
+export declare function slerp(out: Quat, a: QuatLike, b: QuatLike, t: number): Quat;
+/**
+ * out = normalized lerp(a, b, t). Returns out.
+ *
+ * Faster than slerp but the angular velocity is non-uniform; use it as a slerp substitute near endpoints.
+ * Like slerp, automatically handles dot < 0 by negating b to keep the shortest arc.
+ *
+ * @degrade lerp result is near zero (very rare) → out = identity.
+ *
+ * @example
+ * ```ts
+ * quat.nlerp(out, qA, qB, 0.5);
+ * // Very rare: lerp result lengthSq < EPS_NORMALIZE → out = (0, 0, 0, 1)
+ * ```
+ */
+export declare function nlerp(out: Quat, a: QuatLike, b: QuatLike, t: number): Quat;
+/**
+ * out = inverse of a (conjugate / lengthSq). Returns out.
+ *
+ * For unit quaternions, invert is equivalent to conjugate (and faster); this implementation uses
+ * the general a/|a|² form to support non-unit inputs.
+ *
+ * @degrade lengthSq(a) < EPS_NORMALIZE (zero quaternion) → out = identity (does not return NaN;
+ *          same convention as mat invert).
+ *
+ * @example
+ * ```ts
+ * quat.invert(out, q);
+ * quat.invert(out, quat.create(0, 0, 0, 0)); // → out = identity (0, 0, 0, 1), AC-06 no throw
+ * ```
+ */
+export declare function invert(out: Quat, a: QuatLike): Quat;
+/** out = conjugate quaternion [-x, -y, -z, w] (aliasing-safe). Returns out. */
+export declare function conjugate(out: Quat, a: QuatLike): Quat;
+/** dot(a, b) = ax*bx + ay*by + az*bz + aw*bw (returns scalar). */
+export declare function dot(a: QuatLike, b: QuatLike): number;
+/** sqrt(x² + y² + z² + w²). Delegates to lengthSq + Math.sqrt (canonical pattern; see clone-5-quat-audit.md). */
+export declare function length(a: QuatLike): number;
+/** x² + y² + z² + w² (no sqrt). */
+export declare function lengthSq(a: QuatLike): number;
+/**
+ * out = q · v · q⁻¹ (rotate vec3 v by the unit quaternion q). Returns out.
+ *
+ * Rodrigues optimized form (research Finding 3, 18 mul + 12 add):
+ *   t = 2 · cross(q.xyz, v)
+ *   out = v + q.w · t + cross(q.xyz, t)
+ *
+ * 3-5× faster than going through mat4 (fromQuat → transformVec3); same shape as gl-matrix
+ * `vec3.transformQuat` / Three.js `Vector3.applyQuaternion` (industry consensus).
+ *
+ * Aliasing-safe: reads v.xyz / q.xyzw into locals before writing out.
+ *
+ * @degrade q must be a unit-length quaternion. A non-unit q introduces implicit scaling
+ *          (D-4 silent convention; no throw; AI users always get unit-length q from
+ *          quat.fromAxisAngle / fromEuler / normalize / slerp, so this branch is not hit).
+ *          When q = (0,0,0,0), t = 0 → out = v (the natural result of the formula; matches
+ *          gl-matrix / Three.js; non-NaN, no throw).
+ *
+ * @example
+ * ```ts
+ * const q = quat.fromAxisAngle(quat.create(), [0, 1, 0], Math.PI / 2);
+ * const out = vec3.create();
+ * quat.transformVec3(out, q, [1, 0, 0]); // → out ≈ (0, 0, -1)
+ * // Guard: q derived from the quat surface is always unit-length; callers do not need to normalize.
+ * ```
+ */
+export declare function transformVec3(out: Vec3, q: QuatLike, v: Vec3Like): Vec3;
+/**
+ * out = a / length(a). Returns out.
+ *
+ * @degrade lengthSq(a) < EPS_NORMALIZE → out = [0, 0, 0, 0] (same convention as vec.normalize;
+ *          does not write identity, preserving the "zero quaternion" semantics; if the caller
+ *          needs identity it should use fromAxisAngle with 0-axis).
+ *
+ * @example
+ * ```ts
+ * quat.normalize(out, q);
+ * quat.normalize(out, quat.create(0, 0, 0, 0)); // → out = (0, 0, 0, 0); zero-quaternion semantics preserved
+ * ```
+ */
+export declare function normalize(out: Quat, a: QuatLike): Quat;
+/**
+ * Convenience: quaternion representing rotation `theta` radians around the
+ * Y axis. Equivalent to `quat.fromEuler(out, 0, theta, 0, 'YXZ')` but
+ * allocates its own output `Quat`.
+ *
+ * Formula: `(0, sin(theta/2), 0, cos(theta/2))`.
+ *
+ * @degrade eulerY(0) → identity, eulerY(2pi) → identity within epsilon.
+ *
+ * @example
+ * ```ts
+ * const yaw45 = quat.eulerY(Math.PI / 4);
+ * // yaw45 ≈ [0, 0.3826834, 0, 0.9238795]
+ * ```
+ *
+ * @example Equivalent to the verbose form:
+ * ```ts
+ * const q1 = quat.eulerY(theta);
+ * const q2 = quat.fromEuler(quat.create(), 0, theta, 0, 'YXZ');
+ * // q1 === q2 (within epsilon)
+ * ```
+ */
+export declare function eulerY(theta: number): Quat;
+/**
+ * Local right axis: the world-space direction the rotation's own +X axis points.
+ * `right(out, q) = quat.transformVec3(out, q, [1, 0, 0])`. Mirrors
+ * `mat4.getRight`; matches Bevy `Transform::local_x` / `Transform::right`.
+ *
+ * @degrade q must be unit-length (guaranteed by the quat surface); a unit q
+ *          yields a unit result. q = (0,0,0,0) → out = (1,0,0) (the natural
+ *          transformVec3 result; non-NaN, no throw).
+ *
+ * @example
+ * ```ts
+ * const q = quat.eulerY(Math.PI / 2); // 90° about +Y
+ * quat.right(vec3.create(), q); // → (0, 0, -1): +X yawed a quarter-turn
+ * ```
+ */
+export declare function right(out: Vec3, q: QuatLike): Vec3;
+/**
+ * Local up axis: the world-space direction the rotation's own +Y axis points.
+ * `up(out, q) = quat.transformVec3(out, q, [0, 1, 0])`. Mirrors `mat4.getUp`;
+ * matches Bevy `Transform::local_y` / `Transform::up`.
+ *
+ * @degrade q must be unit-length (guaranteed by the quat surface); a unit q
+ *          yields a unit result. q = (0,0,0,0) → out = (0,1,0).
+ *
+ * @example
+ * ```ts
+ * const q = quat.fromAxisAngle(quat.create(), [1, 0, 0], Math.PI / 2); // pitch 90°
+ * quat.up(vec3.create(), q); // → (0, 0, 1): +Y pitched onto +Z
+ * ```
+ */
+export declare function up(out: Vec3, q: QuatLike): Vec3;
+/**
+ * Local forward axis: the world-space direction the rotation's own −Z axis
+ * points (−Z look convention, RL-4). `forward(out, q) =
+ * quat.transformVec3(out, q, [0, 0, -1])`. Mirrors `mat4.getForward`; matches
+ * Bevy `Transform::forward` (Bevy also uses −Z). A quat from `fromLookAt(eye,
+ * target, up)` has `forward(q)` ≈ normalize(target − eye).
+ *
+ * @degrade q must be unit-length (guaranteed by the quat surface); a unit q
+ *          yields a unit result. q = (0,0,0,0) → out = (0,0,-1).
+ *
+ * @example
+ * ```ts
+ * const q = quat.eulerY(Math.PI / 2); // 90° about +Y
+ * quat.forward(vec3.create(), q); // → (-1, 0, 0): -Z yawed a quarter-turn
+ * ```
+ */
+export declare function forward(out: Vec3, q: QuatLike): Vec3;
+//# sourceMappingURL=quat.d.ts.map

package/dist/quat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quat.d.ts","sourceRoot":"","sources":["../src/quat.ts"],"names":[],"mappings":"AA2CA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEpF,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AAQ/B,qFAAqF;AACrF,wBAAgB,MAAM,IAAI,IAAI,CAE7B;AAED,gCAAgC;AAChC,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,GAAG,IAAI,CAEvC;AAED,2DAA2D;AAC3D,wBAAgB,QAAQ,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI,CAMxC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAgBnF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAyD7F;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,GAAG,IAAI,CA6C/D;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,GAAG,IAAI,CAmEzF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,IAAI,CA2DzE;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,IAAI,CAclE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CA6C7F;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAmC1E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAsC1E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,GAAG,IAAI,CAenD;AAED,+EAA+E;AAC/E,wBAAgB,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,GAAG,IAAI,CAMtD;AAED,kEAAkE;AAClE,wBAAgB,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAOpD;AAED,iHAAiH;AACjH,wBAAgB,MAAM,CAAC,CAAC,EAAE,QAAQ,GAAG,MAAM,CAE1C;AAED,mCAAmC;AACnC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,QAAQ,GAAG,MAAM,CAE5C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,IAAI,CAiBvE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,GAAG,IAAI,CAGtD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAG1C;AAkBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,GAAG,IAAI,CAElD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,GAAG,IAAI,CAE/C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,GAAG,IAAI,CAEpD"}

package/dist/ray.d.ts

@@ -0,0 +1,144 @@
+import type { Box3Like } from './box3';
+import type { Mat4Like, Vec2, Vec3, Vec3Like } from './types';
+/**
+ * Result of a ray-triangle intersection test (Moller-Trumbore).
+ * `t` = ray parameter, `u`/`v` = barycentric coordinates.
+ */
+export interface RayTriResult {
+    hit: boolean;
+    t: number;
+    u: number;
+    v: number;
+}
+/**
+ * Ray storage: Float32Array length 6 [ox, oy, oz, dx, dy, dz], direction normalized.
+ * Local brand (not part of the seven-piece SSOT; same rationale as Box3).
+ */
+export type Ray = Float32Array & {
+    readonly __ray: void;
+};
+/**
+ * Ray readable input: ArrayLike<number> of length 6 (ordering identical to Ray).
+ */
+export type RayLike = ArrayLike<number>;
+/**
+ * Create a Ray. Defaults to origin=(0,0,0), direction=(0,0,-1) normalized.
+ *
+ * When `out` is not provided, a new Float32Array is allocated.
+ * When `origin` / `direction` are provided, direction is normalized
+ * (zero-length direction falls back to (0,0,0) per gl-matrix style).
+ */
+export declare function create(out?: Float32Array, origin?: Vec3Like, direction?: Vec3Like): Ray;
+/**
+ * Copy the origin of `r` into `out`. Returns `out`.
+ */
+export declare function getOrigin(out: Vec3, r: RayLike): Vec3;
+/**
+ * Copy the direction of `r` into `out`. Returns `out`.
+ */
+export declare function getDirection(out: Vec3, r: RayLike): Vec3;
+/**
+ * Overwrite the origin of `r` with `o`. Returns `r`.
+ */
+export declare function setOrigin(r: Ray, o: Vec3Like): Ray;
+/**
+ * Overwrite the direction of `r` with `d` and normalize it.
+ * Zero-length direction falls back to (0,0,0) (gl-matrix style).
+ * Returns `r`.
+ */
+export declare function setDirection(r: Ray, d: Vec3Like): Ray;
+/**
+ * Result of a ray-AABB intersection test.
+ */
+export interface RayAabbResult {
+    hit: boolean;
+    /** Entry distance along the ray (clamped to 0 when origin is inside the box). */
+    tmin: number;
+}
+/**
+ * Test whether a ray intersects an axis-aligned bounding box using the
+ * slab (Kay-Kajiya) method.
+ *
+ * Six degenerate cases per research Finding 2:
+ *   1. hit from outside → `tmin > 0`
+ *   2. hit from inside → `tmin = 0`
+ *   3. miss (ray away) → `hit = false`
+ *   4. parallel-axis miss → natural via ±Inf propagation
+ *   5. edge/corner NaN-safe → guard `t1 > t2` NaN scenarios with `Number.isNaN`
+ *   6. thin box (1D/2D) → correct via interval shrink
+ *
+ * Algorithm: precompute `inv = 1/D`, use `inv[i] < 0` (not direction[i] < 0)
+ * to handle `-0` direction correctly. On each axis compute `(min - O)*inv` and
+ * `(max - O)*inv`, swap when `inv < 0`, then accumulate `t_near = max(t_near, t1)`,
+ * `t_far = min(t_far, t2)`. Hit when `t_far >= max(t_near, 0)`.
+ *
+ * Input: `r` (Ray with normalized direction) + `aabb` (Box3Like, 6 floats).
+ * Output: `{ hit: boolean, tmin: number }`.
+ */
+export declare function rayAabbIntersects(r: RayLike, aabb: Box3Like): RayAabbResult;
+/**
+ * Project a screen-space coordinate into a world-space Ray.
+ *
+ * `screenX` / `screenY` are in pixels relative to the top-left corner of the viewport
+ * (DOM convention: y-down). They are clamped to `[0, vpWidth]` / `[0, vpHeight]` and
+ * sanitized against NaN/Inf.
+ *
+ * `kind` discriminates the projection type so callers can branch on the result if needed;
+ * both paths use the same two-point unproject algorithm.
+ *
+ * @param out The Ray to write into.
+ * @param screenX Horizontal pixel coordinate (y-down origin, top-left).
+ * @param screenY Vertical pixel coordinate.
+ * @param vpWidth Viewport width in pixels.
+ * @param vpHeight Viewport height in pixels.
+ * @param view Camera view matrix (world→eye).
+ * @param proj Camera projection matrix (eye→clip).
+ * @param kind `'perspective'` or `'orthographic'`.
+ * @returns `out` (same Ray instance).
+ */
+export declare function screenToRay(out: Ray, screenX: number, screenY: number, vpWidth: number, vpHeight: number, view: Mat4Like, proj: Mat4Like, _kind: 'perspective' | 'orthographic'): Ray;
+/** Result of projecting a world-space point to screen-space pixel coordinates. */
+export interface WorldToScreenResult {
+    /** True if the NDC coordinates are within clip-space bounds. */
+    onScreen: boolean;
+    /** True if the original world-space point is behind the camera (w < 0).
+     *  When true, `out` is meaningless (requirements §7). */
+    behind: boolean;
+}
+/**
+ * Project a world-space point to screen-space pixel coordinates.
+ *
+ * Performs a full mat4 * vec4 internally to capture the pre-divide `w` component
+ * (projectPoint discards `w`, so it cannot report `behind`).
+ *
+ * Pixel mapping: top-left origin, y-down (DOM convention).
+ *   px = (ndc.x * 0.5 + 0.5) * canvasW
+ *   py = (1 - (ndc.y * 0.5 + 0.5)) * canvasH
+ *
+ * Degenerate viewport (canvasW <= 0 || canvasH <= 0): returns { onScreen: false, behind: false },
+ * leaves `out` untouched.
+ *
+ * @param out Vec2 to write pixel coordinates into (y-down, top-left origin).
+ * @param worldPos World-space point (3 floats).
+ * @param viewProj Combined view-projection matrix (proj * view, 16 floats).
+ * @param canvasW Canvas width in pixels.
+ * @param canvasH Canvas height in pixels.
+ * @returns { onScreen: boolean, behind: boolean } — pure data flags, no allocation.
+ */
+export declare function worldToScreen(out: Vec2, worldPos: Vec3Like, viewProj: Mat4Like, canvasW: number, canvasH: number): WorldToScreenResult;
+/**
+ * Test whether a ray intersects a triangle using the Moller-Trumbore algorithm.
+ *
+ * Double-sided: both front and back faces are checked (abs(det) < epsilon).
+ * Degenerate triangles (collinear / zero-area) return hit=false.
+ * Ray origin behind the triangle (t <= 0) is rejected.
+ * NaN inputs are guarded against — any NaN input returns hit=false.
+ *
+ * @param r Ray (RayLike, 6 floats: ox,oy,oz,dx,dy,dz with normalized direction).
+ * @param a Triangle vertex A (Vec3Like, 3 floats).
+ * @param b Triangle vertex B (Vec3Like, 3 floats).
+ * @param c Triangle vertex C (Vec3Like, 3 floats).
+ * @returns RayTriResult with hit flag, t (ray parameter), and u/v (barycentric coordinates).
+ */
+export declare function rayTriangleIntersects(r: RayLike, a: Vec3Like, b: Vec3Like, c: Vec3Like): RayTriResult;
+//# sourceMappingURL=ray.d.ts.map

package/dist/ray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ray.d.ts","sourceRoot":"","sources":["../src/ray.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAEvC,OAAO,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE9D;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,OAAO,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED;;;GAGG;AACH,MAAM,MAAM,GAAG,GAAG,YAAY,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;CAAE,CAAC;AAE1D;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AAExC;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,GAAG,CAAC,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,QAAQ,GAAG,GAAG,CAgCvF;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,GAAG,IAAI,CAKrD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,GAAG,IAAI,CAKxD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,QAAQ,GAAG,GAAG,CAKlD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,QAAQ,GAAG,GAAG,CAgBrD;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,OAAO,CAAC;IACb,iFAAiF;IACjF,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,GAAG,aAAa,CAgE3E;AA0BD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,aAAa,GAAG,cAAc,GACpC,GAAG,CAoEL;AAaD,kFAAkF;AAClF,MAAM,WAAW,mBAAmB;IAClC,gEAAgE;IAChE,QAAQ,EAAE,OAAO,CAAC;IAClB;6DACyD;IACzD,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,IAAI,EACT,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,mBAAmB,CAkDrB;AAmBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,CAAC,EAAE,OAAO,EACV,CAAC,EAAE,QAAQ,EACX,CAAC,EAAE,QAAQ,EACX,CAAC,EAAE,QAAQ,GACV,YAAY,CAiFd"}

package/dist/ray2.d.ts

@@ -0,0 +1,38 @@
+import type { Box2Like } from './box2';
+import type { Circle2Like } from './circle2';
+import type { Vec2, Vec2Like } from './types';
+/** 2D ray storage: [originX, originY, directionX, directionY, maxDistance]. */
+export type Ray2 = Float32Array & {
+    readonly __ray2: void;
+};
+/** Readable 2D ray input. */
+export type Ray2Like = ArrayLike<number>;
+/** Result shared by AABB, circle, and swept-volume intersection tests. */
+export interface Ray2Intersection {
+    hit: boolean;
+    /** Entry distance along the normalized ray, clamped to zero when inside. */
+    t: number;
+}
+/** Create a normalized finite 2D ray. `maxDistance` defaults to infinity. */
+export declare function create(out?: Float32Array, origin?: Vec2Like, direction?: Vec2Like, maxDistance?: number): Ray2;
+/** Copy the ray origin to out. */
+export declare function getOrigin(out: Vec2, ray: Ray2Like): Vec2;
+/** Copy the normalized ray direction to out. */
+export declare function getDirection(out: Vec2, ray: Ray2Like): Vec2;
+/** Return the ray's finite travel limit. */
+export declare function getMaxDistance(ray: Ray2Like): number;
+/** Set the ray origin. */
+export declare function setOrigin(ray: Ray2, origin: Vec2Like): Ray2;
+/** Set and normalize the ray direction. */
+export declare function setDirection(ray: Ray2, direction: Vec2Like): Ray2;
+/** Set the ray's non-negative travel limit. */
+export declare function setMaxDistance(ray: Ray2, maxDistance: number): Ray2;
+/** Intersect a finite ray with an AABB using the 2D slab method. */
+export declare function rayAabbIntersects(ray: Ray2Like, box: Box2Like): Ray2Intersection;
+/** Intersect a finite ray with a bounding circle. */
+export declare function rayCircleIntersects(ray: Ray2Like, circle: Circle2Like): Ray2Intersection;
+/** Sweep an AABB along a finite ray and intersect it with a target AABB. */
+export declare function aabbCastIntersects(ray: Ray2Like, moving: Box2Like, target: Box2Like): Ray2Intersection;
+/** Sweep a circle along a finite ray and intersect it with a target circle. */
+export declare function circleCastIntersects(ray: Ray2Like, moving: Circle2Like, target: Circle2Like): Ray2Intersection;
+//# sourceMappingURL=ray2.d.ts.map

package/dist/ray2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ray2.d.ts","sourceRoot":"","sources":["../src/ray2.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE9C,+EAA+E;AAC/E,MAAM,MAAM,IAAI,GAAG,YAAY,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC;AAE5D,6BAA6B;AAC7B,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AAEzC,0EAA0E;AAC1E,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,OAAO,CAAC;IACb,4EAA4E;IAC5E,CAAC,EAAE,MAAM,CAAC;CACX;AAED,6EAA6E;AAC7E,wBAAgB,MAAM,CACpB,GAAG,CAAC,EAAE,YAAY,EAClB,MAAM,CAAC,EAAE,QAAQ,EACjB,SAAS,CAAC,EAAE,QAAQ,EACpB,WAAW,SAA2B,GACrC,IAAI,CAiBN;AAED,kCAAkC;AAClC,wBAAgB,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,GAAG,IAAI,CAIxD;AAED,gDAAgD;AAChD,wBAAgB,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,GAAG,IAAI,CAI3D;AAED,4CAA4C;AAC5C,wBAAgB,cAAc,CAAC,GAAG,EAAE,QAAQ,GAAG,MAAM,CAEpD;AAED,0BAA0B;AAC1B,wBAAgB,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAG,IAAI,CAI3D;AAED,2CAA2C;AAC3C,wBAAgB,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,GAAG,IAAI,CAajE;AAED,+CAA+C;AAC/C,wBAAgB,cAAc,CAAC,GAAG,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAGnE;AAED,oEAAoE;AACpE,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,GAAG,gBAAgB,CAEhF;AAED,qDAAqD;AACrD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,GAAG,gBAAgB,CAExF;AAED,4EAA4E;AAC5E,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,QAAQ,GACf,gBAAgB,CAUlB;AAED,+EAA+E;AAC/E,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,WAAW,GAClB,gBAAgB,CAOlB"}

package/dist/sphere.d.ts

@@ -0,0 +1,41 @@
+import * as box3 from './box3';
+import type { Vec3Like } from './types';
+/**
+ * Sphere storage: Float32Array length 4 [cx, cy, cz, radius].
+ * Local brand (not part of the seven-piece SSOT); see box3.ts rationale.
+ */
+export type Sphere = Float32Array & {
+    readonly __sphere: void;
+};
+/**
+ * Sphere readable input: ArrayLike<number> of length 4 (ordering identical to Sphere).
+ */
+export type SphereLike = ArrayLike<number>;
+/**
+ * Create a Sphere. Defaults to a zero-radius sphere at the origin.
+ */
+export declare function create(cx?: number, cy?: number, cz?: number, radius?: number): Sphere;
+/**
+ * Grow the sphere so `point` lies inside (boundary inclusive). Returns `out`.
+ *
+ * If the sphere was empty (radius < 0) the call re-seeds the center to `point`
+ * with radius 0. Otherwise the radius is set to max(current, distance(center, point)).
+ */
+export declare function expandByPoint(out: Sphere, point: Vec3Like): Sphere;
+/**
+ * True when `point` is inside `sphere` (boundary inclusive). Empty sphere
+ * (radius < 0) contains nothing.
+ */
+export declare function containsPoint(s: SphereLike, point: Vec3Like): boolean;
+/**
+ * True when `sphere` overlaps `box` (boundary inclusive). Uses the standard
+ * closest-point-on-AABB distance test.
+ */
+export declare function intersectsBox(s: SphereLike, b: box3.Box3Like): boolean;
+/**
+ * Build an enclosing sphere from `points` via AABB-center + max-distance
+ * approximation. Empty `points` leaves the negative-radius empty sphere at
+ * the origin.
+ */
+export declare function fromPoints(out: Sphere, points: readonly Vec3Like[]): Sphere;
+//# sourceMappingURL=sphere.d.ts.map

package/dist/sphere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sphere.d.ts","sourceRoot":"","sources":["../src/sphere.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,YAAY,GAAG;IAAE,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAA;CAAE,CAAC;AAEhE;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AAE3C;;GAEG;AACH,wBAAgB,MAAM,CAAC,EAAE,SAAI,EAAE,EAAE,SAAI,EAAE,EAAE,SAAI,EAAE,MAAM,SAAI,GAAG,MAAM,CAEjE;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,MAAM,CAkBlE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAOrE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,IAAI,CAAC,QAAQ,GAAG,OAAO,CAmBtE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,QAAQ,EAAE,GAAG,MAAM,CA6B3E"}

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+/** 2D vector storage: Float32Array length 2, brand=__vec2. */
+export type Vec2 = Float32Array & {
+    readonly __vec2: void;
+};
+/** 3D vector storage: Float32Array length 3, brand=__vec3. */
+export type Vec3 = Float32Array & {
+    readonly __vec3: void;
+};
+/** 4D vector / homogeneous coordinate storage: Float32Array length 4, brand=__vec4. */
+export type Vec4 = Float32Array & {
+    readonly __vec4: void;
+};
+/** Quaternion storage: Float32Array length 4 [x,y,z,w], brand=__quat (mutually exclusive with Vec4). */
+export type Quat = Float32Array & {
+    readonly __quat: void;
+};
+/** 3x3 matrix storage: Float32Array length 9 packed layout (D-P4); column-major (toGpuLayout hook reserved). */
+export type Mat3 = Float32Array & {
+    readonly __mat3: void;
+};
+/** 4x4 matrix storage: Float32Array length 16 column-major, brand=__mat4. */
+export type Mat4 = Float32Array & {
+    readonly __mat4: void;
+};
+/** Linear-space RGBA color: Float32Array length 4 [r,g,b,a] ∈ [0,1], brand=__color (mutually exclusive with Vec4). */
+export type Color = Float32Array & {
+    readonly __color: void;
+};
+/** Euler angle: enum of six intrinsic rotation orders (D-P19). */
+export type EulerOrder = 'XYZ' | 'YXZ' | 'ZXY' | 'ZYX' | 'YZX' | 'XZY';
+/**
+ * Euler angle interface: x/y/z radians + order rotation order.
+ *
+ * Not a Float32Array because length=3 plus a string order needs plain-object storage;
+ * performance-insensitive (euler is only used at editor/IO boundary; runtime always converts to Quat).
+ */
+export interface Euler {
+    x: number;
+    y: number;
+    z: number;
+    order: EulerOrder;
+}
+/** Vec2 readable input: ArrayLike<number> of length 2. */
+export type Vec2Like = ArrayLike<number>;
+/** Vec3 readable input: ArrayLike<number> of length 3. */
+export type Vec3Like = ArrayLike<number>;
+/** Vec4 readable input: ArrayLike<number> of length 4. */
+export type Vec4Like = ArrayLike<number>;
+/** Quat readable input: ArrayLike<number> of length 4. */
+export type QuatLike = ArrayLike<number>;
+/** Mat3 readable input: ArrayLike<number> of length 9. */
+export type Mat3Like = ArrayLike<number>;
+/** Mat4 readable input: ArrayLike<number> of length 16. */
+export type Mat4Like = ArrayLike<number>;
+/** Color readable input: ArrayLike<number> of length 4. */
+export type ColorLike = ArrayLike<number>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAmBA,8DAA8D;AAC9D,MAAM,MAAM,IAAI,GAAG,YAAY,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC;AAE5D,8DAA8D;AAC9D,MAAM,MAAM,IAAI,GAAG,YAAY,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC;AAE5D,uFAAuF;AACvF,MAAM,MAAM,IAAI,GAAG,YAAY,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC;AAE5D,wGAAwG;AACxG,MAAM,MAAM,IAAI,GAAG,YAAY,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC;AAE5D,gHAAgH;AAChH,MAAM,MAAM,IAAI,GAAG,YAAY,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC;AAE5D,6EAA6E;AAC7E,MAAM,MAAM,IAAI,GAAG,YAAY,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC;AAE5D,sHAAsH;AACtH,MAAM,MAAM,KAAK,GAAG,YAAY,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAA;CAAE,CAAC;AAI9D,kEAAkE;AAClE,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AAEvE;;;;;GAKG;AACH,MAAM,WAAW,KAAK;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,UAAU,CAAC;CACnB;AAQD,0DAA0D;AAC1D,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AACzC,0DAA0D;AAC1D,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AACzC,0DAA0D;AAC1D,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AACzC,0DAA0D;AAC1D,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AACzC,0DAA0D;AAC1D,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AACzC,2DAA2D;AAC3D,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AACzC,2DAA2D;AAC3D,MAAM,MAAM,SAAS,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC"}