@ue-too/math 0.9.4 → 0.10.0

package/README.md

@@ -1,4 +1,258 @@
-# math
-This is a library that provides basic mathematical utilities for uē-tôo.
+<h1 align="center">
+    @ue-too/math
+</h1>
+<p align="center">
+    Mathematical utilities for 2D and 3D point operations and transformations
+</p>
 
-Detailed information would be added in the future.
+<div align="center">
+
+[![npm version](https://img.shields.io/npm/v/@ue-too/math.svg?style=for-the-badge)](https://www.npmjs.com/package/@ue-too/math)
+[![License](https://img.shields.io/github/license/ue-too/ue-too?style=for-the-badge)](https://github.com/ue-too/ue-too/blob/main/LICENSE.txt)
+
+</div>
+
+## Overview
+
+`@ue-too/math` provides essential mathematical operations for canvas-based applications, including vector arithmetic, geometric transformations, angle calculations, and point comparisons. It seamlessly handles both 2D and 3D coordinates.
+
+### Key Features
+
+- **Vector Operations**: Addition, subtraction, scaling, dot product, cross product
+- **Geometric Transformations**: Rotation, axis transformation, coordinate conversion
+- **Angle Utilities**: Normalization, angular difference calculation
+- **Point Utilities**: Distance, interpolation, intersection detection
+- **Comparison Functions**: Approximate equality with configurable precision
+- **2D/3D Support**: All operations work with optional z-coordinates
+
+## Installation
+
+```bash
+npm install @ue-too/math
+```
+
+## Quick Start
+
+```typescript
+import { PointCal, Point } from '@ue-too/math';
+
+// Vector addition
+const a: Point = { x: 1, y: 2 };
+const b: Point = { x: 3, y: 4 };
+const sum = PointCal.addVector(a, b); // { x: 4, y: 6 }
+
+// Calculate magnitude
+const magnitude = PointCal.magnitude(a); // 2.236...
+
+// Rotate a point
+const point: Point = { x: 10, y: 0 };
+const rotated = PointCal.rotatePoint(point, Math.PI / 2); // 90 degrees
+// Result: { x: ~0, y: 10 }
+
+// Get distance between points
+const distance = PointCal.distanceBetweenPoints(a, b); // 2.828...
+```
+
+## Core APIs
+
+### PointCal Class
+
+The `PointCal` class provides static methods for all point and vector operations.
+
+#### Vector Arithmetic
+
+```typescript
+// Add two vectors
+PointCal.addVector(a, b);
+
+// Subtract vectors
+PointCal.subVector(a, b);
+
+// Scale by scalar
+PointCal.multiplyVectorByScalar(v, 2.5);
+
+// Divide by scalar
+PointCal.divideVectorByScalar(v, 2);
+```
+
+#### Vector Operations
+
+```typescript
+// Magnitude (length) of vector
+PointCal.magnitude(v);
+
+// Unit vector (normalized to length 1)
+PointCal.unitVector(v);
+
+// Dot product
+PointCal.dotProduct(a, b);
+
+// Cross product
+PointCal.crossProduct(a, b);
+
+// Unit vector from point a to point b
+PointCal.unitVectorFromA2B(a, b);
+```
+
+#### Transformations
+
+```typescript
+// Rotate point around origin
+PointCal.rotatePoint(point, angleInRadians);
+
+// Rotate point around custom anchor
+PointCal.transformPointWRTAnchor(point, anchor, angleInRadians);
+
+// Transform to new axis system
+PointCal.transform2NewAxis(point, angleInRadians);
+
+// Flip y-axis (useful for coordinate system conversion)
+PointCal.flipYAxis(point);
+```
+
+#### Geometric Calculations
+
+```typescript
+// Distance between points
+PointCal.distanceBetweenPoints(a, b);
+
+// Linear interpolation (lerp)
+PointCal.linearInterpolation(a, b, 0.5); // Midpoint
+
+// Angle from vector a to vector b
+PointCal.angleFromA2B(a, b);
+
+// Line segment intersection
+PointCal.getLineIntersection(line1Start, line1End, line2Start, line2End);
+```
+
+### Angle Utilities
+
+```typescript
+import { normalizeAngleZero2TwoPI, angleSpan } from '@ue-too/math';
+
+// Normalize angle to [0, 2π)
+const normalized = normalizeAngleZero2TwoPI(Math.PI * 3); // π
+
+// Calculate smallest angle difference
+const diff = angleSpan(fromAngle, toAngle); // Range: (-π, π]
+```
+
+### Comparison Functions
+
+```typescript
+import { samePoint, sameDirection, approximatelyTheSame } from '@ue-too/math';
+
+// Check if points are approximately equal
+samePoint(a, b); // Uses default precision (0.000001)
+samePoint(a, b, 0.01); // Custom precision
+
+// Check if vectors have same direction
+sameDirection(v1, v2);
+
+// Approximate number equality
+approximatelyTheSame(1.0, 1.0000001); // true
+```
+
+## Common Use Cases
+
+### Canvas Transformations
+
+```typescript
+import { PointCal, Point } from '@ue-too/math';
+
+// Transform mouse coordinates to rotated canvas space
+const mousePos: Point = { x: 150, y: 200 };
+const canvasCenter: Point = { x: 100, y: 100 };
+const canvasRotation = Math.PI / 4; // 45 degrees
+
+const transformedPos = PointCal.transformPointWRTAnchor(
+  mousePos,
+  canvasCenter,
+  -canvasRotation // Inverse rotation
+);
+```
+
+### Path Following
+
+```typescript
+import { PointCal, Point } from '@ue-too/math';
+
+// Calculate direction from current position to target
+const current: Point = { x: 10, y: 20 };
+const target: Point = { x: 50, y: 80 };
+
+const direction = PointCal.unitVectorFromA2B(current, target);
+const speed = 5;
+
+// Move toward target
+const newPosition = PointCal.addVector(
+  current,
+  PointCal.multiplyVectorByScalar(direction, speed)
+);
+```
+
+### Smooth Interpolation
+
+```typescript
+import { PointCal, Point } from '@ue-too/math';
+
+// Animate between two positions
+const start: Point = { x: 0, y: 0 };
+const end: Point = { x: 100, y: 100 };
+const progress = 0.3; // 30% through animation
+
+const currentPos = PointCal.linearInterpolation(start, end, progress);
+```
+
+## API Reference
+
+For complete API documentation with detailed examples, see:
+- [Full TypeDoc Documentation](../../docs/math) (generated from source)
+- [Source Code](./src/index.ts) with inline JSDoc comments
+
+## TypeScript Support
+
+This package is written in TypeScript and includes full type definitions:
+
+```typescript
+import { Point, PointCal } from '@ue-too/math';
+
+const point: Point = { x: 10, y: 20 }; // z is optional
+const point3d: Point = { x: 10, y: 20, z: 30 };
+```
+
+## Performance Considerations
+
+- All operations are pure functions with no side effects
+- Static methods minimize object allocation overhead
+- Suitable for tight animation loops (60fps)
+- For performance-critical code, consider using the operations directly rather than chaining
+
+### Performance Tips
+
+```typescript
+// ✅ Good: Single operation
+const mag = PointCal.magnitude(vector);
+
+// ⚠️ Less optimal: Multiple magnitude calls
+const unit = PointCal.unitVector(vector); // Calls magnitude twice internally
+
+// ✅ Better: Calculate magnitude once if needed separately
+const mag = PointCal.magnitude(vector);
+const unit = PointCal.divideVectorByScalar(vector, mag);
+```
+
+## Related Packages
+
+- [`@ue-too/board`](../board) - Canvas viewport management with pan, zoom, rotate
+- [`@ue-too/animate`](../animate) - Animation system using these math utilities
+- [`@ue-too/dynamics`](../dynamics) - Physics engine built on these operations
+
+## License
+
+MIT License - see [LICENSE.txt](../../LICENSE.txt) for details.
+
+## Contributing
+
+> Currently not accepting contributions. If you have feature requests or bug reports, please [create an issue](https://github.com/ue-too/ue-too/issues).

package/index.d.ts

@@ -1,34 +1,533 @@
+/**
+ * @packageDocumentation
+ * Mathematical utilities for 2D and 3D point operations, vector calculations, and transformations.
+ *
+ * @remarks
+ * This package provides essential mathematical operations for canvas applications including:
+ * - Vector arithmetic (add, subtract, multiply, divide)
+ * - Vector operations (dot product, cross product, magnitude, unit vectors)
+ * - Geometric transformations (rotation, axis transformation)
+ * - Angle calculations and normalization
+ * - Point comparisons and interpolation
+ * - Line intersection detection
+ *
+ * All operations support both 2D and 3D coordinates, with the z-axis being optional.
+ *
+ * @example
+ * Basic vector operations
+ * ```typescript
+ * import { PointCal, Point } from '@ue-too/math';
+ *
+ * const a: Point = { x: 1, y: 2 };
+ * const b: Point = { x: 3, y: 4 };
+ *
+ * // Add vectors
+ * const sum = PointCal.addVector(a, b); // { x: 4, y: 6 }
+ *
+ * // Calculate magnitude
+ * const mag = PointCal.magnitude(a); // 2.236...
+ *
+ * // Get unit vector
+ * const unit = PointCal.unitVector(a); // { x: 0.447..., y: 0.894... }
+ * ```
+ *
+ * @example
+ * Rotation and transformation
+ * ```typescript
+ * import { PointCal, Point } from '@ue-too/math';
+ *
+ * const point: Point = { x: 10, y: 0 };
+ * const angle = Math.PI / 2; // 90 degrees
+ *
+ * // Rotate point around origin
+ * const rotated = PointCal.rotatePoint(point, angle); // { x: 0, y: 10 }
+ *
+ * // Rotate around a custom anchor
+ * const anchor: Point = { x: 5, y: 5 };
+ * const rotatedAroundAnchor = PointCal.transformPointWRTAnchor(point, anchor, angle);
+ * ```
+ */
+/**
+ * Represents a 2D or 3D point with optional z-coordinate.
+ *
+ * @remarks
+ * This is a lowercase variant maintained for backward compatibility.
+ * Use {@link Point} for new code.
+ *
+ * @deprecated Use {@link Point} instead for better TypeScript conventions.
+ */
 export type point = {
+    /** X-coordinate */
     x: number;
+    /** Y-coordinate */
     y: number;
+    /** Optional Z-coordinate for 3D operations */
     z?: number;
 };
+/**
+ * Represents a 2D or 3D point with optional z-coordinate.
+ *
+ * @remarks
+ * When z is undefined, operations treat the point as 2D (z = 0).
+ * This type is used throughout the library for all point and vector operations.
+ *
+ * @example
+ * ```typescript
+ * // 2D point
+ * const p2d: Point = { x: 10, y: 20 };
+ *
+ * // 3D point
+ * const p3d: Point = { x: 10, y: 20, z: 30 };
+ * ```
+ */
 export type Point = {
+    /** X-coordinate */
     x: number;
+    /** Y-coordinate */
     y: number;
+    /** Optional Z-coordinate for 3D operations */
     z?: number;
 };
+/**
+ * Utility class for point and vector calculations.
+ *
+ * @remarks
+ * PointCal provides static methods for common 2D and 3D mathematical operations
+ * used in canvas applications. All methods handle both 2D and 3D coordinates seamlessly.
+ *
+ * @example
+ * ```typescript
+ * import { PointCal, Point } from '@ue-too/math';
+ *
+ * const v1: Point = { x: 1, y: 2 };
+ * const v2: Point = { x: 3, y: 4 };
+ *
+ * const sum = PointCal.addVector(v1, v2);
+ * const dot = PointCal.dotProduct(v1, v2);
+ * ```
+ */
 export declare class PointCal {
+    /**
+     * Adds two vectors together.
+     *
+     * @param a - First vector
+     * @param b - Second vector
+     * @returns The sum of vectors a and b
+     *
+     * @remarks
+     * If either vector lacks a z-coordinate, it's treated as 0.
+     * The result will include a z-coordinate if either input has one.
+     *
+     * @example
+     * ```typescript
+     * const a = { x: 1, y: 2 };
+     * const b = { x: 3, y: 4 };
+     * const sum = PointCal.addVector(a, b); // { x: 4, y: 6 }
+     *
+     * // With 3D coordinates
+     * const a3d = { x: 1, y: 2, z: 3 };
+     * const b3d = { x: 4, y: 5, z: 6 };
+     * const sum3d = PointCal.addVector(a3d, b3d); // { x: 5, y: 7, z: 9 }
+     * ```
+     *
+     * @group Vector Arithmetic
+     */
     static addVector(a: point, b: point): Point;
+    /**
+     * Subtracts vector b from vector a.
+     *
+     * @param a - Vector to subtract from
+     * @param b - Vector to subtract
+     * @returns The difference (a - b)
+     *
+     * @remarks
+     * If either vector lacks a z-coordinate, it's treated as 0.
+     *
+     * @example
+     * ```typescript
+     * const a = { x: 5, y: 7 };
+     * const b = { x: 2, y: 3 };
+     * const diff = PointCal.subVector(a, b); // { x: 3, y: 4 }
+     * ```
+     *
+     * @group Vector Arithmetic
+     */
     static subVector(a: point, b: point): Point;
+    /**
+     * Multiplies a vector by a scalar value.
+     *
+     * @param a - Vector to multiply
+     * @param b - Scalar multiplier
+     * @returns The scaled vector
+     *
+     * @example
+     * ```typescript
+     * const v = { x: 2, y: 3 };
+     * const scaled = PointCal.multiplyVectorByScalar(v, 2.5); // { x: 5, y: 7.5 }
+     * ```
+     *
+     * @group Vector Arithmetic
+     */
     static multiplyVectorByScalar(a: point, b: number): Point;
+    /**
+     * Divides a vector by a scalar value.
+     *
+     * @param a - Vector to divide
+     * @param b - Scalar divisor
+     * @returns The divided vector, or the original vector if b is 0
+     *
+     * @remarks
+     * Division by zero returns the original vector unchanged to prevent NaN values.
+     *
+     * @example
+     * ```typescript
+     * const v = { x: 10, y: 20 };
+     * const divided = PointCal.divideVectorByScalar(v, 2); // { x: 5, y: 10 }
+     * ```
+     *
+     * @group Vector Arithmetic
+     */
     static divideVectorByScalar(a: point, b: number): Point;
+    /**
+     * Calculates the magnitude (length) of a vector.
+     *
+     * @param a - Vector to measure
+     * @returns The magnitude of the vector
+     *
+     * @remarks
+     * Uses the Euclidean distance formula: √(x² + y² + z²)
+     *
+     * @example
+     * ```typescript
+     * const v = { x: 3, y: 4 };
+     * const mag = PointCal.magnitude(v); // 5
+     *
+     * const v3d = { x: 1, y: 2, z: 2 };
+     * const mag3d = PointCal.magnitude(v3d); // 3
+     * ```
+     *
+     * @group Vector Operations
+     */
     static magnitude(a: point): number;
+    /**
+     * Converts a vector to its unit vector (normalized to length 1).
+     *
+     * @param a - Vector to normalize
+     * @returns Unit vector in the same direction, or zero vector if magnitude is 0
+     *
+     * @remarks
+     * A unit vector has magnitude 1 and preserves the original direction.
+     * Returns {x: 0, y: 0, z: 0} if the input vector has zero magnitude.
+     *
+     * **Performance note**: This method calls `magnitude()` twice. For better performance
+     * when you need both magnitude and unit vector, calculate magnitude once and divide manually.
+     *
+     * @example
+     * ```typescript
+     * const v = { x: 3, y: 4 };
+     * const unit = PointCal.unitVector(v); // { x: 0.6, y: 0.8 }
+     * ```
+     *
+     * @group Vector Operations
+     */
     static unitVector(a: point): Point;
+    /**
+     * Calculates the dot product of two vectors.
+     *
+     * @param a - First vector
+     * @param b - Second vector
+     * @returns The dot product (scalar value)
+     *
+     * @remarks
+     * The dot product is: a.x * b.x + a.y * b.y + a.z * b.z
+     *
+     * **Use cases:**
+     * - Determine if vectors are perpendicular (dot = 0)
+     * - Calculate angle between vectors: θ = acos(dot / (|a| * |b|))
+     * - Project one vector onto another
+     *
+     * @example
+     * ```typescript
+     * const a = { x: 1, y: 0 };
+     * const b = { x: 0, y: 1 };
+     * const dot = PointCal.dotProduct(a, b); // 0 (perpendicular vectors)
+     *
+     * const c = { x: 2, y: 3 };
+     * const d = { x: 4, y: 5 };
+     * const dot2 = PointCal.dotProduct(c, d); // 23
+     * ```
+     *
+     * @group Vector Operations
+     */
     static dotProduct(a: point, b: point): number;
+    /**
+     * Calculates the cross product of two vectors.
+     *
+     * @param a - First vector
+     * @param b - Second vector
+     * @returns The cross product vector perpendicular to both inputs
+     *
+     * @remarks
+     * The cross product is perpendicular to both input vectors, following the right-hand rule.
+     * For 2D vectors (z undefined), z is treated as 0.
+     *
+     * **Properties:**
+     * - Result is perpendicular to both input vectors
+     * - Magnitude equals area of parallelogram formed by vectors
+     * - Direction follows right-hand rule
+     *
+     * @example
+     * ```typescript
+     * const a = { x: 1, y: 0, z: 0 };
+     * const b = { x: 0, y: 1, z: 0 };
+     * const cross = PointCal.crossProduct(a, b); // { x: 0, y: 0, z: 1 }
+     * ```
+     *
+     * @group Vector Operations
+     */
     static crossProduct(a: point, b: point): Point;
+    /**
+     * Calculates the unit vector pointing from point a to point b.
+     *
+     * @param a - Starting point
+     * @param b - Ending point
+     * @returns Unit vector in the direction from a to b
+     *
+     * @remarks
+     * Equivalent to calling unitVector(subVector(b, a))
+     *
+     * @example
+     * ```typescript
+     * const a = { x: 0, y: 0 };
+     * const b = { x: 3, y: 4 };
+     * const direction = PointCal.unitVectorFromA2B(a, b); // { x: 0.6, y: 0.8 }
+     * ```
+     *
+     * @group Geometric Calculations
+     */
     static unitVectorFromA2B(a: point, b: point): Point;
+    /**
+     * Rotates a point around the origin.
+     *
+     * @param point - Point to rotate
+     * @param angle - Rotation angle in radians (counter-clockwise)
+     * @returns Rotated point
+     *
+     * @remarks
+     * Rotation is performed around the origin (0, 0).
+     * Positive angles rotate counter-clockwise, negative angles rotate clockwise.
+     * For rotation around a custom anchor, use {@link transformPointWRTAnchor}.
+     *
+     * **Performance**: Uses trigonometric functions (sin/cos). For many rotations with
+     * the same angle, pre-calculate sin/cos values and apply the transformation manually.
+     *
+     * @example
+     * ```typescript
+     * const point = { x: 1, y: 0 };
+     * const rotated = PointCal.rotatePoint(point, Math.PI / 2); // { x: 0, y: 1 }
+     * ```
+     *
+     * @group Transformations
+     */
     static rotatePoint(point: point, angle: number): Point;
+    /**
+     * Transforms a point's coordinates to a new rotated axis system.
+     *
+     * @param point - Point in original coordinate system
+     * @param angleFromOriginalAxis2DestAxis - Rotation angle from original to destination axis (radians, CCW positive)
+     * @returns Point coordinates in the new axis system
+     *
+     * @remarks
+     * This performs an axis rotation transformation, converting coordinates from one
+     * reference frame to another rotated by the specified angle.
+     *
+     * @example
+     * ```typescript
+     * const point = { x: 10, y: 0 };
+     * const angle = Math.PI / 4; // 45 degrees
+     * const transformed = PointCal.transform2NewAxis(point, angle);
+     * ```
+     *
+     * @group Transformations
+     */
     static transform2NewAxis(point: point, angleFromOriginalAxis2DestAxis: number): Point;
     /**
-     * @description Gets the angle from vector a to vector b. (returned angle is always between -π to π)
+     * Calculates the signed angle from vector a to vector b.
+     *
+     * @param a - First vector (starting direction)
+     * @param b - Second vector (ending direction)
+     * @returns The signed angle in radians, range: (-π, π]
+     *
+     * @remarks
+     * - Positive angles indicate counter-clockwise rotation from a to b
+     * - Negative angles indicate clockwise rotation from a to b
+     * - Uses atan2 for proper quadrant handling
+     *
+     * @example
+     * ```typescript
+     * const right = { x: 1, y: 0 };
+     * const up = { x: 0, y: 1 };
+     * const angle = PointCal.angleFromA2B(right, up); // π/2 (90 degrees CCW)
+     *
+     * const down = { x: 0, y: -1 };
+     * const angleDown = PointCal.angleFromA2B(right, down); // -π/2 (90 degrees CW)
+     * ```
+     *
+     * @group Angle Utilities
      */
     static angleFromA2B(a: point, b: point): number;
+    /**
+     * Rotates a point around a custom anchor point.
+     *
+     * @param point - Point to rotate
+     * @param anchor - Anchor point to rotate around
+     * @param angle - Rotation angle in radians (counter-clockwise)
+     * @returns Rotated point
+     *
+     * @remarks
+     * This is equivalent to:
+     * 1. Translate point by -anchor
+     * 2. Rotate around origin
+     * 3. Translate back by +anchor
+     *
+     * @example
+     * ```typescript
+     * const point = { x: 10, y: 5 };
+     * const anchor = { x: 5, y: 5 };
+     * const angle = Math.PI / 2; // 90 degrees
+     * const rotated = PointCal.transformPointWRTAnchor(point, anchor, angle);
+     * // Rotates point around anchor (5, 5)
+     * ```
+     *
+     * @group Transformations
+     */
     static transformPointWRTAnchor(point: point, anchor: point, angle: number): Point;
+    /**
+     * Calculates the Euclidean distance between two points.
+     *
+     * @param a - First point
+     * @param b - Second point
+     * @returns The distance between the two points
+     *
+     * @remarks
+     * Equivalent to calculating the magnitude of the vector from a to b.
+     *
+     * @example
+     * ```typescript
+     * const a = { x: 0, y: 0 };
+     * const b = { x: 3, y: 4 };
+     * const distance = PointCal.distanceBetweenPoints(a, b); // 5
+     * ```
+     *
+     * @group Geometric Calculations
+     */
     static distanceBetweenPoints(a: point, b: point): number;
+    /**
+     * Flips a point's y-coordinate (mirrors across the x-axis).
+     *
+     * @param point - Point to flip
+     * @returns Point with negated y-coordinate
+     *
+     * @remarks
+     * Useful for converting between coordinate systems where the y-axis direction differs.
+     * Common when converting between screen coordinates (y-down) and mathematical coordinates (y-up).
+     *
+     * @example
+     * ```typescript
+     * const point = { x: 10, y: 20 };
+     * const flipped = PointCal.flipYAxis(point); // { x: 10, y: -20 }
+     * ```
+     *
+     * @group Transformations
+     */
     static flipYAxis(point: point): Point;
+    /**
+     * Performs linear interpolation between two points.
+     *
+     * @param a - Starting point (t = 0)
+     * @param b - Ending point (t = 1)
+     * @param t - Interpolation parameter (0 to 1)
+     * @returns Interpolated point
+     *
+     * @remarks
+     * - t = 0 returns point a
+     * - t = 1 returns point b
+     * - t = 0.5 returns the midpoint
+     * - Values outside [0, 1] perform extrapolation
+     *
+     * **Performance**: Suitable for animation loops and real-time interpolation.
+     *
+     * @example
+     * ```typescript
+     * const a = { x: 0, y: 0 };
+     * const b = { x: 10, y: 20 };
+     * const mid = PointCal.linearInterpolation(a, b, 0.5); // { x: 5, y: 10 }
+     * const quarter = PointCal.linearInterpolation(a, b, 0.25); // { x: 2.5, y: 5 }
+     * ```
+     *
+     * @group Geometric Calculations
+     */
     static linearInterpolation(a: point, b: point, t: number): point;
+    /**
+     * Checks if two points are exactly equal.
+     *
+     * @param a - First point
+     * @param b - Second point
+     * @returns True if all coordinates are exactly equal
+     *
+     * @remarks
+     * Uses strict equality (===) for comparison.
+     * For approximate equality with tolerance, use {@link samePoint} instead.
+     * Missing z-coordinates are treated as 0.
+     *
+     * @example
+     * ```typescript
+     * const a = { x: 1, y: 2 };
+     * const b = { x: 1, y: 2 };
+     * PointCal.isEqual(a, b); // true
+     *
+     * const c = { x: 1.0000001, y: 2 };
+     * PointCal.isEqual(a, c); // false (use samePoint for tolerance)
+     * ```
+     *
+     * @group Geometric Calculations
+     */
     static isEqual(a: point, b: point): boolean;
+    /**
+     * Calculates the intersection point of two line segments.
+     *
+     * @param startPoint - Start of first line segment
+     * @param endPoint - End of first line segment
+     * @param startPoint2 - Start of second line segment
+     * @param endPoint2 - End of second line segment
+     * @returns Object containing intersection status and details
+     *
+     * @remarks
+     * Returns an object with:
+     * - `intersects`: Boolean indicating if segments intersect
+     * - `intersection`: The intersection point (only if intersects is true)
+     * - `offset`: Parameter t where intersection occurs on first segment (0 to 1)
+     *
+     * The segments must actually cross within their bounds (not just their infinite extensions).
+     *
+     * **Use cases:**
+     * - Collision detection between line segments
+     * - Ray casting and visibility checks
+     * - Path intersection detection
+     *
+     * @example
+     * ```typescript
+     * const line1Start = { x: 0, y: 0 };
+     * const line1End = { x: 10, y: 10 };
+     * const line2Start = { x: 0, y: 10 };
+     * const line2End = { x: 10, y: 0 };
+     *
+     * const result = PointCal.getLineIntersection(line1Start, line1End, line2Start, line2End);
+     * // { intersects: true, intersection: { x: 5, y: 5 }, offset: 0.5 }
+     * ```
+     *
+     * @group Geometric Calculations
+     */
     static getLineIntersection(startPoint: Point, endPoint: Point, startPoint2: Point, endPoint2: Point): {
         intersects: boolean;
         intersection?: Point;
@@ -36,18 +535,143 @@ export declare class PointCal {
     };
 }
 /**
- * @description Normalizes the angle to be between 0 and 2π.
+ * Normalizes an angle to the range [0, 2π).
+ *
+ * @param angle - Angle in radians (can be any value)
+ * @returns Normalized angle between 0 and 2π
+ *
+ * @remarks
+ * This function wraps any angle to the range [0, 2π) by taking the modulo
+ * and ensuring the result is positive.
  *
- * @category Camera
+ * @example
+ * ```typescript
+ * normalizeAngleZero2TwoPI(Math.PI * 3); // π (180 degrees)
+ * normalizeAngleZero2TwoPI(-Math.PI / 2); // 3π/2 (270 degrees)
+ * normalizeAngleZero2TwoPI(0); // 0
+ * ```
+ *
+ * @category Angle
  */
 export declare function normalizeAngleZero2TwoPI(angle: number): number;
 /**
- * @description Gets the smaller angle span between two angles. (in radians)
+ * Calculates the smallest angular difference between two angles.
+ *
+ * @param from - Starting angle in radians
+ * @param to - Ending angle in radians
+ * @returns The smallest angle span from 'from' to 'to', in range (-π, π]
+ *
+ * @remarks
+ * This function accounts for wrapping around 2π and always returns the shorter path.
+ * Positive result means counter-clockwise rotation, negative means clockwise.
  *
- * @category Camera
+ * @example
+ * ```typescript
+ * // From 0° to 90°
+ * angleSpan(0, Math.PI / 2); // π/2 (90 degrees CCW)
+ *
+ * // From 350° to 10° (shorter to go CCW through 0°)
+ * angleSpan(350 * Math.PI / 180, 10 * Math.PI / 180); // ≈ 20 degrees
+ *
+ * // From 10° to 350° (shorter to go CW through 0°)
+ * angleSpan(10 * Math.PI / 180, 350 * Math.PI / 180); // ≈ -20 degrees
+ * ```
+ *
+ * @category Angle
  */
 export declare function angleSpan(from: number, to: number): number;
+/**
+ * Checks if two numbers are approximately equal within a tolerance.
+ *
+ * @param a - First number
+ * @param b - Second number
+ * @param precision - Optional tolerance (defaults to 0.000001)
+ * @returns True if the absolute difference is within the precision threshold
+ *
+ * @remarks
+ * Useful for floating-point comparisons where exact equality is unreliable.
+ *
+ * @example
+ * ```typescript
+ * approximatelyTheSame(1.0, 1.0000001); // true (within default epsilon)
+ * approximatelyTheSame(1.0, 1.1); // false
+ * approximatelyTheSame(1.0, 1.01, 0.02); // true (within custom precision)
+ * ```
+ *
+ * @category Comparison
+ */
 export declare function approximatelyTheSame(a: number, b: number, precision?: number): boolean;
+/**
+ * Checks if two vectors point in the same direction.
+ *
+ * @param a - First vector
+ * @param b - Second vector
+ * @param precision - Tolerance for comparison (defaults to 0.001)
+ * @returns True if vectors have the same direction (after normalization)
+ *
+ * @remarks
+ * Normalizes both vectors to unit vectors and compares them.
+ * Magnitude does not matter, only direction.
+ *
+ * @example
+ * ```typescript
+ * const a = { x: 1, y: 0 };
+ * const b = { x: 10, y: 0 }; // Same direction, different magnitude
+ * sameDirection(a, b); // true
+ *
+ * const c = { x: 1, y: 1 };
+ * sameDirection(a, c); // false (different direction)
+ * ```
+ *
+ * @category Comparison
+ */
 export declare function sameDirection(a: Point, b: Point, precision?: number): boolean;
+/**
+ * Checks if a direction vector is aligned with a tangent vector.
+ *
+ * @param direction - Direction vector to check
+ * @param tangent - Tangent vector reference
+ * @returns True if direction aligns with tangent (within 90 degrees)
+ *
+ * @remarks
+ * Returns true if the direction is within 90 degrees of either the tangent
+ * or its reverse. Useful for determining if movement is along a path.
+ *
+ * @example
+ * ```typescript
+ * const direction = { x: 1, y: 0 };
+ * const tangent = { x: 1, y: 0.1 }; // Slightly rotated
+ * directionAlignedToTangent(direction, tangent); // true
+ *
+ * const perpendicular = { x: 0, y: 1 };
+ * directionAlignedToTangent(perpendicular, tangent); // false
+ * ```
+ *
+ * @category Comparison
+ */
 export declare function directionAlignedToTangent(direction: Point, tangent: Point): boolean;
+/**
+ * Checks if two points are approximately at the same location.
+ *
+ * @param a - First point
+ * @param b - Second point
+ * @param precision - Optional tolerance for coordinate comparison
+ * @returns True if both x and y coordinates are within precision
+ *
+ * @remarks
+ * Uses {@link approximatelyTheSame} for coordinate comparison.
+ * For exact equality, use {@link PointCal.isEqual} instead.
+ *
+ * @example
+ * ```typescript
+ * const a = { x: 1.0, y: 2.0 };
+ * const b = { x: 1.0000001, y: 2.0000001 };
+ * samePoint(a, b); // true (within default precision)
+ *
+ * const c = { x: 1.1, y: 2.0 };
+ * samePoint(a, c); // false
+ * ```
+ *
+ * @category Comparison
+ */
 export declare function samePoint(a: Point, b: Point, precision?: number): boolean;

package/index.js

@@ -1,175 +1,3 @@
-// src/index.ts
-class PointCal {
-  static addVector(a, b) {
-    if (a.z == null && b.z == null)
-      return { x: a.x + b.x, y: a.y + b.y };
-    if (a.z == null || b.z == null) {
-      if (a.z == null)
-        a.z = 0;
-      if (b.z == null)
-        b.z = 0;
-    }
-    return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
-  }
-  static subVector(a, b) {
-    if (a.z == null && b.z == null)
-      return { x: a.x - b.x, y: a.y - b.y };
-    if (a.z == null || b.z == null) {
-      if (a.z == null)
-        a.z = 0;
-      if (b.z == null)
-        b.z = 0;
-    }
-    return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
-  }
-  static multiplyVectorByScalar(a, b) {
-    if (a.z == null)
-      return { x: a.x * b, y: a.y * b };
-    return { x: a.x * b, y: a.y * b, z: a.z * b };
-  }
-  static divideVectorByScalar(a, b) {
-    if (b == 0)
-      return { x: a.x, y: a.y };
-    if (a.z == null)
-      return { x: a.x / b, y: a.y / b };
-    return { x: a.x / b, y: a.y / b, z: a.z / b };
-  }
-  static magnitude(a) {
-    if (a.z == null)
-      a.z = 0;
-    return Math.sqrt(a.x * a.x + a.y * a.y + a.z * a.z);
-  }
-  static unitVector(a) {
-    if (a.z == null)
-      a.z = 0;
-    return this.magnitude(a) != 0 ? { x: a.x / this.magnitude(a), y: a.y / this.magnitude(a), z: a.z / this.magnitude(a) } : { x: 0, y: 0, z: 0 };
-  }
-  static dotProduct(a, b) {
-    if (a.z == null && b.z == null)
-      return a.x * b.x + a.y * b.y;
-    if (a.z == null || b.z == null) {
-      if (a.z == null)
-        a.z = 0;
-      if (b.z == null)
-        b.z = 0;
-    }
-    return a.x * b.x + a.y * b.y + a.z * b.z;
-  }
-  static crossProduct(a, b) {
-    if (a.z == null || b.z == null) {
-      if (a.z == null)
-        a.z = 0;
-      if (b.z == null)
-        b.z = 0;
-    }
-    return { x: a.y * b.z - a.z * b.y, y: a.z * b.x - a.x * b.z, z: a.x * b.y - a.y * b.x };
-  }
-  static unitVectorFromA2B(a, b) {
-    return this.unitVector(this.subVector(b, a));
-  }
-  static rotatePoint(point, angle) {
-    return { x: point.x * Math.cos(angle) - point.y * Math.sin(angle), y: point.x * Math.sin(angle) + point.y * Math.cos(angle) };
-  }
-  static transform2NewAxis(point, angleFromOriginalAxis2DestAxis) {
-    return { x: point.x * Math.cos(angleFromOriginalAxis2DestAxis) + point.y * Math.sin(angleFromOriginalAxis2DestAxis), y: -point.x * Math.sin(angleFromOriginalAxis2DestAxis) + point.y * Math.cos(angleFromOriginalAxis2DestAxis) };
-  }
-  static angleFromA2B(a, b) {
-    return Math.atan2(a.x * b.y - a.y * b.x, a.x * b.x + a.y * b.y);
-  }
-  static transformPointWRTAnchor(point, anchor, angle) {
-    let newPoint = this.rotatePoint(this.subVector(point, anchor), angle);
-    return this.addVector(newPoint, anchor);
-  }
-  static distanceBetweenPoints(a, b) {
-    return this.magnitude(this.subVector(a, b));
-  }
-  static flipYAxis(point) {
-    return { x: point.x, y: -point.y, z: point.z };
-  }
-  static linearInterpolation(a, b, t) {
-    if (a.z == null || b.z == null) {
-      return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
-    } else {
-      return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t, z: a.z + (b.z - a.z) * t };
-    }
-  }
-  static isEqual(a, b) {
-    if (a.z == null) {
-      a.z = 0;
-    }
-    if (b.z == null) {
-      b.z = 0;
-    }
-    return a.x == b.x && a.y == b.y && a.z == b.z;
-  }
-  static getLineIntersection(startPoint, endPoint, startPoint2, endPoint2) {
-    const numerator = (endPoint2.x - startPoint2.x) * (startPoint.y - startPoint2.y) - (endPoint2.y - startPoint2.y) * (startPoint.x - startPoint2.x);
-    const denominator = (endPoint2.y - startPoint2.y) * (endPoint.x - startPoint.x) - (endPoint2.x - startPoint2.x) * (endPoint.y - startPoint.y);
-    if (denominator === 0) {
-      return { intersects: false };
-    }
-    const t = numerator / denominator;
-    if (t >= 0 && t <= 1) {
-      return {
-        intersects: true,
-        intersection: PointCal.linearInterpolation(startPoint, endPoint, t),
-        offset: t
-      };
-    } else {
-      return {
-        intersects: false
-      };
-    }
-  }
-}
-function normalizeAngleZero2TwoPI(angle) {
-  angle = angle % (Math.PI * 2);
-  angle = (angle + Math.PI * 2) % (Math.PI * 2);
-  return angle;
-}
-function angleSpan(from, to) {
-  from = normalizeAngleZero2TwoPI(from);
-  to = normalizeAngleZero2TwoPI(to);
-  let angleDiff = to - from;
-  if (angleDiff > Math.PI) {
-    angleDiff = -(Math.PI * 2 - angleDiff);
-  }
-  if (angleDiff < -Math.PI) {
-    angleDiff += Math.PI * 2;
-  }
-  return angleDiff;
-}
-function approximatelyTheSame(a, b, precision) {
-  const epsilon = 0.000001;
-  return Math.abs(a - b) <= (precision || epsilon);
-}
-function sameDirection(a, b, precision = 0.001) {
-  const aNormalized = PointCal.unitVector(a);
-  const bNormalized = PointCal.unitVector(b);
-  return samePoint(aNormalized, bNormalized, precision);
-}
-function directionAlignedToTangent(direction, tangent) {
-  const directionNormalized = PointCal.unitVector(direction);
-  const tangentNormalized = PointCal.unitVector(tangent);
-  const reversedTangent = { x: -tangent.x, y: -tangent.y, z: tangent.z };
-  const angle = PointCal.angleFromA2B(directionNormalized, tangentNormalized);
-  const angle2 = PointCal.angleFromA2B(directionNormalized, reversedTangent);
-  return angle < Math.PI / 2 && angle > -Math.PI / 2 && (angle2 > Math.PI / 2 || angle2 < -Math.PI / 2);
-}
-function samePoint(a, b, precision) {
-  if (approximatelyTheSame(a.x, b.x, precision) && approximatelyTheSame(a.y, b.y, precision)) {
-    return true;
-  }
-  return false;
-}
-export {
-  samePoint,
-  sameDirection,
-  normalizeAngleZero2TwoPI,
-  directionAlignedToTangent,
-  approximatelyTheSame,
-  angleSpan,
-  PointCal
-};
+class J{static addVector(j,B){if(j.z==null&&B.z==null)return{x:j.x+B.x,y:j.y+B.y};if(j.z==null||B.z==null){if(j.z==null)j.z=0;if(B.z==null)B.z=0}return{x:j.x+B.x,y:j.y+B.y,z:j.z+B.z}}static subVector(j,B){if(j.z==null&&B.z==null)return{x:j.x-B.x,y:j.y-B.y};if(j.z==null||B.z==null){if(j.z==null)j.z=0;if(B.z==null)B.z=0}return{x:j.x-B.x,y:j.y-B.y,z:j.z-B.z}}static multiplyVectorByScalar(j,B){if(j.z==null)return{x:j.x*B,y:j.y*B};return{x:j.x*B,y:j.y*B,z:j.z*B}}static divideVectorByScalar(j,B){if(B==0)return{x:j.x,y:j.y};if(j.z==null)return{x:j.x/B,y:j.y/B};return{x:j.x/B,y:j.y/B,z:j.z/B}}static magnitude(j){if(j.z==null)j.z=0;return Math.sqrt(j.x*j.x+j.y*j.y+j.z*j.z)}static unitVector(j){if(j.z==null)j.z=0;return this.magnitude(j)!=0?{x:j.x/this.magnitude(j),y:j.y/this.magnitude(j),z:j.z/this.magnitude(j)}:{x:0,y:0,z:0}}static dotProduct(j,B){if(j.z==null&&B.z==null)return j.x*B.x+j.y*B.y;if(j.z==null||B.z==null){if(j.z==null)j.z=0;if(B.z==null)B.z=0}return j.x*B.x+j.y*B.y+j.z*B.z}static crossProduct(j,B){if(j.z==null||B.z==null){if(j.z==null)j.z=0;if(B.z==null)B.z=0}return{x:j.y*B.z-j.z*B.y,y:j.z*B.x-j.x*B.z,z:j.x*B.y-j.y*B.x}}static unitVectorFromA2B(j,B){return this.unitVector(this.subVector(B,j))}static rotatePoint(j,B){return{x:j.x*Math.cos(B)-j.y*Math.sin(B),y:j.x*Math.sin(B)+j.y*Math.cos(B)}}static transform2NewAxis(j,B){return{x:j.x*Math.cos(B)+j.y*Math.sin(B),y:-j.x*Math.sin(B)+j.y*Math.cos(B)}}static angleFromA2B(j,B){return Math.atan2(j.x*B.y-j.y*B.x,j.x*B.x+j.y*B.y)}static transformPointWRTAnchor(j,B,G){let H=this.rotatePoint(this.subVector(j,B),G);return this.addVector(H,B)}static distanceBetweenPoints(j,B){return this.magnitude(this.subVector(j,B))}static flipYAxis(j){return{x:j.x,y:-j.y,z:j.z}}static linearInterpolation(j,B,G){if(j.z==null||B.z==null)return{x:j.x+(B.x-j.x)*G,y:j.y+(B.y-j.y)*G};else return{x:j.x+(B.x-j.x)*G,y:j.y+(B.y-j.y)*G,z:j.z+(B.z-j.z)*G}}static isEqual(j,B){if(j.z==null)j.z=0;if(B.z==null)B.z=0;return j.x==B.x&&j.y==B.y&&j.z==B.z}static getLineIntersection(j,B,G,H){let L=(H.x-G.x)*(j.y-G.y)-(H.y-G.y)*(j.x-G.x),M=(H.y-G.y)*(B.x-j.x)-(H.x-G.x)*(B.y-j.y);if(M===0)return{intersects:!1};let K=L/M;if(K>=0&&K<=1)return{intersects:!0,intersection:J.linearInterpolation(j,B,K),offset:K};else return{intersects:!1}}}function Q(j){return j=j%(Math.PI*2),j=(j+Math.PI*2)%(Math.PI*2),j}function W(j,B){j=Q(j),B=Q(B);let G=B-j;if(G>Math.PI)G=-(Math.PI*2-G);if(G<-Math.PI)G+=Math.PI*2;return G}function R(j,B,G){return Math.abs(j-B)<=(G||0.000001)}function X(j,B,G=0.001){let H=J.unitVector(j),L=J.unitVector(B);return V(H,L,G)}function Y(j,B){let G=J.unitVector(j),H=J.unitVector(B),L={x:-B.x,y:-B.y,z:B.z},M=J.angleFromA2B(G,H),K=J.angleFromA2B(G,L);return M<Math.PI/2&&M>-Math.PI/2&&(K>Math.PI/2||K<-Math.PI/2)}function V(j,B,G){if(R(j.x,B.x,G)&&R(j.y,B.y,G))return!0;return!1}export{V as samePoint,X as sameDirection,Q as normalizeAngleZero2TwoPI,Y as directionAlignedToTangent,R as approximatelyTheSame,W as angleSpan,J as PointCal};
 
-//# debugId=B0C116870CD7AAF064756E2164756E21
+//# debugId=E7FBAB931781982464756E2164756E21

package/index.js.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../src/index.ts"],
   "sourcesContent": [
-    "export type point = {\n    x: number;\n    y: number;\n    z?: number;\n}\n\nexport type Point = {\n    x: number;\n    y: number;\n    z?: number;\n}\n\n\nexport class PointCal {\n\n    static addVector(a: point, b: point): Point {\n        if (a.z == null && b.z == null) return {x: a.x + b.x, y: a.y + b.y};\n        if (a.z == null || b.z == null) {\n            if (a.z == null) a.z = 0;\n            if (b.z == null) b.z = 0;\n        }\n        return {x: a.x + b.x, y: a.y + b.y, z: a.z + b.z}; \n    }\n\n    static subVector(a: point, b: point): Point {\n        if (a.z == null && b.z == null) return {x: a.x - b.x, y: a.y - b.y};\n        if (a.z == null || b.z == null) {\n            if (a.z == null) a.z = 0;\n            if (b.z == null) b.z = 0;\n        }\n        return {x: a.x - b.x, y: a.y - b.y, z: a.z - b.z};\n    }\n\n    static multiplyVectorByScalar(a: point, b: number): Point {\n        if (a.z == null) return {x: a.x * b, y: a.y * b};\n        return {x: a.x * b, y: a.y * b, z: a.z * b};\n    }\n\n    static divideVectorByScalar(a: point, b: number): Point {\n        if (b == 0) return {x: a.x, y: a.y};\n        if (a.z == null) return {x: a.x / b, y: a.y / b};\n        return {x: a.x / b, y: a.y / b, z: a.z / b};\n    }\n\n    static magnitude(a: point): number {\n        if (a.z == null) a.z = 0;\n        return Math.sqrt(a.x * a.x + a.y * a.y + a.z * a.z);\n    }\n\n    static unitVector(a: point): Point {\n        if (a.z == null) a.z = 0;\n        return this.magnitude(a) != 0 ? {x: a.x / this.magnitude(a), y: a.y / this.magnitude(a), z: a.z / this.magnitude(a)} : {x: 0, y: 0, z: 0};\n    }\n\n    static dotProduct(a: point, b: point): number {\n        if (a.z == null && b.z == null) return a.x * b.x + a.y * b.y;\n        if (a.z == null || b.z == null) {\n            if (a.z == null) a.z = 0;\n            if (b.z == null) b.z = 0;\n        }\n        return a.x * b.x + a.y * b.y + a.z * b.z;\n    }\n\n    static crossProduct(a: point, b: point): Point {\n        if (a.z == null || b.z == null) {\n            if (a.z == null) a.z = 0;\n            if (b.z == null) b.z = 0;\n        }\n        return {x: a.y * b.z - a.z * b.y, y: a.z * b.x - a.x * b.z, z: a.x * b.y - a.y * b.x};\n    }\n\n    static unitVectorFromA2B(a: point, b: point): Point {\n        return this.unitVector(this.subVector(b, a));\n    }\n\n    static rotatePoint(point: point, angle: number): Point {\n        return {x: point.x * Math.cos(angle) - point.y * Math.sin(angle), y: point.x * Math.sin(angle) + point.y * Math.cos(angle)};\n    }\n\n    static transform2NewAxis(point: point, angleFromOriginalAxis2DestAxis: number): Point {\n        // angle is the angle from the original axis to the destination axis ccw is positive as always\n        return {x: point.x * Math.cos(angleFromOriginalAxis2DestAxis) + point.y * Math.sin(angleFromOriginalAxis2DestAxis), y: -point.x * Math.sin(angleFromOriginalAxis2DestAxis) + point.y * Math.cos(angleFromOriginalAxis2DestAxis)};\n    }\n\n    /**\n     * @description Gets the angle from vector a to vector b. (returned angle is always between -π to π)\n     */\n    static angleFromA2B(a: point, b: point): number {\n        return Math.atan2(a.x * b.y - a.y * b.x, a.x * b.x + a.y * b.y);\n    }\n\n    static transformPointWRTAnchor(point: point, anchor: point, angle: number): Point {\n        // angle is in radians\n        let newPoint = this.rotatePoint(this.subVector(point, anchor), angle);\n        return this.addVector(newPoint, anchor);\n    }\n\n    static distanceBetweenPoints(a: point, b: point): number {\n        return this.magnitude(this.subVector(a, b));\n    }\n\n    static flipYAxis(point: point): Point{\n        return {x: point.x, y: -point.y, z: point.z};\n    }\n\n    static linearInterpolation(a: point, b: point, t: number): point{\n        if (a.z == null || b.z == null) {\n            return {x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t};\n        } else {\n            return {x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t, z: a.z + (b.z - a.z) * t};\n        }\n    }\n\n    static isEqual(a: point, b: point): boolean{\n        if (a.z == null){\n            a.z = 0;\n        }\n        if (b.z == null){\n            b.z = 0;\n        }\n        return a.x == b.x && a.y == b.y && a.z == b.z;\n    }\n\n    static getLineIntersection(startPoint: Point, endPoint: Point, startPoint2: Point, endPoint2: Point):{\n        intersects: boolean,\n        intersection?: Point,\n        offset?: number\n    }{\n        const numerator = (endPoint2.x - startPoint2.x) * (startPoint.y - startPoint2.y) - (endPoint2.y - startPoint2.y) * (startPoint.x - startPoint2.x);\n        const denominator = (endPoint2.y - startPoint2.y) * (endPoint.x - startPoint.x) - (endPoint2.x - startPoint2.x) * (endPoint.y - startPoint.y);\n        \n        if (denominator === 0){\n            return {intersects: false};\n        }\n        const t = numerator / denominator;\n        if (t >= 0 && t <= 1){\n            return {\n                intersects: true, \n                intersection: PointCal.linearInterpolation(startPoint, endPoint, t),\n                offset: t\n            }\n        } else {\n            return {\n                intersects: false,\n            }\n        }\n    \n    }\n    \n}\n\n/**\n * @description Normalizes the angle to be between 0 and 2π.\n * \n * @category Camera\n */\nexport function normalizeAngleZero2TwoPI(angle: number){\n    // reduce the angle  \n    angle = angle % (Math.PI * 2);\n\n    // force it to be the positive remainder, so that 0 <= angle < 2 * Math.PI \n    angle = (angle + Math.PI * 2) % (Math.PI * 2); \n    return angle;\n}\n\n/**\n * @description Gets the smaller angle span between two angles. (in radians)\n * \n * @category Camera\n */\nexport function angleSpan(from: number, to: number): number{\n    // in radians\n    from = normalizeAngleZero2TwoPI(from);\n    to = normalizeAngleZero2TwoPI(to);\n    let angleDiff = to - from;\n    \n    if(angleDiff > Math.PI){\n        angleDiff = - (Math.PI * 2 - angleDiff);\n    }\n\n    if(angleDiff < -Math.PI){\n        angleDiff += (Math.PI * 2);\n    }\n    return angleDiff;\n}\n\nexport function approximatelyTheSame(a: number, b: number, precision?: number): boolean {\n    const epsilon = 0.000001\n    return Math.abs(a - b) <= (precision || epsilon);\n}\n\nexport function sameDirection(a: Point, b: Point, precision: number = 0.001): boolean{\n   const aNormalized = PointCal.unitVector(a);\n   const bNormalized = PointCal.unitVector(b);\n   return samePoint(aNormalized, bNormalized, precision);\n}\n\nexport function directionAlignedToTangent(direction: Point, tangent: Point): boolean {\n   const directionNormalized = PointCal.unitVector(direction);\n   const tangentNormalized = PointCal.unitVector(tangent);\n   const reversedTangent = {x: -tangent.x, y: -tangent.y, z: tangent.z};\n   const angle = PointCal.angleFromA2B(directionNormalized, tangentNormalized);\n   const angle2 = PointCal.angleFromA2B(directionNormalized, reversedTangent);\n   return (angle < Math.PI / 2 && angle > -Math.PI / 2) && (angle2 > Math.PI / 2 || angle2 < -Math.PI / 2);\n}\n\nexport function samePoint(a: Point, b: Point, precision?: number): boolean {\n    if(approximatelyTheSame(a.x, b.x, precision) && approximatelyTheSame(a.y, b.y, precision)){\n        return true;\n    }\n    return false;\n}\n"
+    "/**\n * @packageDocumentation\n * Mathematical utilities for 2D and 3D point operations, vector calculations, and transformations.\n *\n * @remarks\n * This package provides essential mathematical operations for canvas applications including:\n * - Vector arithmetic (add, subtract, multiply, divide)\n * - Vector operations (dot product, cross product, magnitude, unit vectors)\n * - Geometric transformations (rotation, axis transformation)\n * - Angle calculations and normalization\n * - Point comparisons and interpolation\n * - Line intersection detection\n *\n * All operations support both 2D and 3D coordinates, with the z-axis being optional.\n *\n * @example\n * Basic vector operations\n * ```typescript\n * import { PointCal, Point } from '@ue-too/math';\n *\n * const a: Point = { x: 1, y: 2 };\n * const b: Point = { x: 3, y: 4 };\n *\n * // Add vectors\n * const sum = PointCal.addVector(a, b); // { x: 4, y: 6 }\n *\n * // Calculate magnitude\n * const mag = PointCal.magnitude(a); // 2.236...\n *\n * // Get unit vector\n * const unit = PointCal.unitVector(a); // { x: 0.447..., y: 0.894... }\n * ```\n *\n * @example\n * Rotation and transformation\n * ```typescript\n * import { PointCal, Point } from '@ue-too/math';\n *\n * const point: Point = { x: 10, y: 0 };\n * const angle = Math.PI / 2; // 90 degrees\n *\n * // Rotate point around origin\n * const rotated = PointCal.rotatePoint(point, angle); // { x: 0, y: 10 }\n *\n * // Rotate around a custom anchor\n * const anchor: Point = { x: 5, y: 5 };\n * const rotatedAroundAnchor = PointCal.transformPointWRTAnchor(point, anchor, angle);\n * ```\n */\n\n/**\n * Represents a 2D or 3D point with optional z-coordinate.\n *\n * @remarks\n * This is a lowercase variant maintained for backward compatibility.\n * Use {@link Point} for new code.\n *\n * @deprecated Use {@link Point} instead for better TypeScript conventions.\n */\nexport type point = {\n    /** X-coordinate */\n    x: number;\n    /** Y-coordinate */\n    y: number;\n    /** Optional Z-coordinate for 3D operations */\n    z?: number;\n}\n\n/**\n * Represents a 2D or 3D point with optional z-coordinate.\n *\n * @remarks\n * When z is undefined, operations treat the point as 2D (z = 0).\n * This type is used throughout the library for all point and vector operations.\n *\n * @example\n * ```typescript\n * // 2D point\n * const p2d: Point = { x: 10, y: 20 };\n *\n * // 3D point\n * const p3d: Point = { x: 10, y: 20, z: 30 };\n * ```\n */\nexport type Point = {\n    /** X-coordinate */\n    x: number;\n    /** Y-coordinate */\n    y: number;\n    /** Optional Z-coordinate for 3D operations */\n    z?: number;\n}\n\n\n/**\n * Utility class for point and vector calculations.\n *\n * @remarks\n * PointCal provides static methods for common 2D and 3D mathematical operations\n * used in canvas applications. All methods handle both 2D and 3D coordinates seamlessly.\n *\n * @example\n * ```typescript\n * import { PointCal, Point } from '@ue-too/math';\n *\n * const v1: Point = { x: 1, y: 2 };\n * const v2: Point = { x: 3, y: 4 };\n *\n * const sum = PointCal.addVector(v1, v2);\n * const dot = PointCal.dotProduct(v1, v2);\n * ```\n */\nexport class PointCal {\n\n    /**\n     * Adds two vectors together.\n     *\n     * @param a - First vector\n     * @param b - Second vector\n     * @returns The sum of vectors a and b\n     *\n     * @remarks\n     * If either vector lacks a z-coordinate, it's treated as 0.\n     * The result will include a z-coordinate if either input has one.\n     *\n     * @example\n     * ```typescript\n     * const a = { x: 1, y: 2 };\n     * const b = { x: 3, y: 4 };\n     * const sum = PointCal.addVector(a, b); // { x: 4, y: 6 }\n     *\n     * // With 3D coordinates\n     * const a3d = { x: 1, y: 2, z: 3 };\n     * const b3d = { x: 4, y: 5, z: 6 };\n     * const sum3d = PointCal.addVector(a3d, b3d); // { x: 5, y: 7, z: 9 }\n     * ```\n     *\n     * @group Vector Arithmetic\n     */\n    static addVector(a: point, b: point): Point {\n        if (a.z == null && b.z == null) return {x: a.x + b.x, y: a.y + b.y};\n        if (a.z == null || b.z == null) {\n            if (a.z == null) a.z = 0;\n            if (b.z == null) b.z = 0;\n        }\n        return {x: a.x + b.x, y: a.y + b.y, z: a.z + b.z}; \n    }\n\n    /**\n     * Subtracts vector b from vector a.\n     *\n     * @param a - Vector to subtract from\n     * @param b - Vector to subtract\n     * @returns The difference (a - b)\n     *\n     * @remarks\n     * If either vector lacks a z-coordinate, it's treated as 0.\n     *\n     * @example\n     * ```typescript\n     * const a = { x: 5, y: 7 };\n     * const b = { x: 2, y: 3 };\n     * const diff = PointCal.subVector(a, b); // { x: 3, y: 4 }\n     * ```\n     *\n     * @group Vector Arithmetic\n     */\n    static subVector(a: point, b: point): Point {\n        if (a.z == null && b.z == null) return {x: a.x - b.x, y: a.y - b.y};\n        if (a.z == null || b.z == null) {\n            if (a.z == null) a.z = 0;\n            if (b.z == null) b.z = 0;\n        }\n        return {x: a.x - b.x, y: a.y - b.y, z: a.z - b.z};\n    }\n\n    /**\n     * Multiplies a vector by a scalar value.\n     *\n     * @param a - Vector to multiply\n     * @param b - Scalar multiplier\n     * @returns The scaled vector\n     *\n     * @example\n     * ```typescript\n     * const v = { x: 2, y: 3 };\n     * const scaled = PointCal.multiplyVectorByScalar(v, 2.5); // { x: 5, y: 7.5 }\n     * ```\n     *\n     * @group Vector Arithmetic\n     */\n    static multiplyVectorByScalar(a: point, b: number): Point {\n        if (a.z == null) return {x: a.x * b, y: a.y * b};\n        return {x: a.x * b, y: a.y * b, z: a.z * b};\n    }\n\n    /**\n     * Divides a vector by a scalar value.\n     *\n     * @param a - Vector to divide\n     * @param b - Scalar divisor\n     * @returns The divided vector, or the original vector if b is 0\n     *\n     * @remarks\n     * Division by zero returns the original vector unchanged to prevent NaN values.\n     *\n     * @example\n     * ```typescript\n     * const v = { x: 10, y: 20 };\n     * const divided = PointCal.divideVectorByScalar(v, 2); // { x: 5, y: 10 }\n     * ```\n     *\n     * @group Vector Arithmetic\n     */\n    static divideVectorByScalar(a: point, b: number): Point {\n        if (b == 0) return {x: a.x, y: a.y};\n        if (a.z == null) return {x: a.x / b, y: a.y / b};\n        return {x: a.x / b, y: a.y / b, z: a.z / b};\n    }\n\n    /**\n     * Calculates the magnitude (length) of a vector.\n     *\n     * @param a - Vector to measure\n     * @returns The magnitude of the vector\n     *\n     * @remarks\n     * Uses the Euclidean distance formula: √(x² + y² + z²)\n     *\n     * @example\n     * ```typescript\n     * const v = { x: 3, y: 4 };\n     * const mag = PointCal.magnitude(v); // 5\n     *\n     * const v3d = { x: 1, y: 2, z: 2 };\n     * const mag3d = PointCal.magnitude(v3d); // 3\n     * ```\n     *\n     * @group Vector Operations\n     */\n    static magnitude(a: point): number {\n        if (a.z == null) a.z = 0;\n        return Math.sqrt(a.x * a.x + a.y * a.y + a.z * a.z);\n    }\n\n    /**\n     * Converts a vector to its unit vector (normalized to length 1).\n     *\n     * @param a - Vector to normalize\n     * @returns Unit vector in the same direction, or zero vector if magnitude is 0\n     *\n     * @remarks\n     * A unit vector has magnitude 1 and preserves the original direction.\n     * Returns {x: 0, y: 0, z: 0} if the input vector has zero magnitude.\n     *\n     * **Performance note**: This method calls `magnitude()` twice. For better performance\n     * when you need both magnitude and unit vector, calculate magnitude once and divide manually.\n     *\n     * @example\n     * ```typescript\n     * const v = { x: 3, y: 4 };\n     * const unit = PointCal.unitVector(v); // { x: 0.6, y: 0.8 }\n     * ```\n     *\n     * @group Vector Operations\n     */\n    static unitVector(a: point): Point {\n        if (a.z == null) a.z = 0;\n        return this.magnitude(a) != 0 ? {x: a.x / this.magnitude(a), y: a.y / this.magnitude(a), z: a.z / this.magnitude(a)} : {x: 0, y: 0, z: 0};\n    }\n\n    /**\n     * Calculates the dot product of two vectors.\n     *\n     * @param a - First vector\n     * @param b - Second vector\n     * @returns The dot product (scalar value)\n     *\n     * @remarks\n     * The dot product is: a.x * b.x + a.y * b.y + a.z * b.z\n     *\n     * **Use cases:**\n     * - Determine if vectors are perpendicular (dot = 0)\n     * - Calculate angle between vectors: θ = acos(dot / (|a| * |b|))\n     * - Project one vector onto another\n     *\n     * @example\n     * ```typescript\n     * const a = { x: 1, y: 0 };\n     * const b = { x: 0, y: 1 };\n     * const dot = PointCal.dotProduct(a, b); // 0 (perpendicular vectors)\n     *\n     * const c = { x: 2, y: 3 };\n     * const d = { x: 4, y: 5 };\n     * const dot2 = PointCal.dotProduct(c, d); // 23\n     * ```\n     *\n     * @group Vector Operations\n     */\n    static dotProduct(a: point, b: point): number {\n        if (a.z == null && b.z == null) return a.x * b.x + a.y * b.y;\n        if (a.z == null || b.z == null) {\n            if (a.z == null) a.z = 0;\n            if (b.z == null) b.z = 0;\n        }\n        return a.x * b.x + a.y * b.y + a.z * b.z;\n    }\n\n    /**\n     * Calculates the cross product of two vectors.\n     *\n     * @param a - First vector\n     * @param b - Second vector\n     * @returns The cross product vector perpendicular to both inputs\n     *\n     * @remarks\n     * The cross product is perpendicular to both input vectors, following the right-hand rule.\n     * For 2D vectors (z undefined), z is treated as 0.\n     *\n     * **Properties:**\n     * - Result is perpendicular to both input vectors\n     * - Magnitude equals area of parallelogram formed by vectors\n     * - Direction follows right-hand rule\n     *\n     * @example\n     * ```typescript\n     * const a = { x: 1, y: 0, z: 0 };\n     * const b = { x: 0, y: 1, z: 0 };\n     * const cross = PointCal.crossProduct(a, b); // { x: 0, y: 0, z: 1 }\n     * ```\n     *\n     * @group Vector Operations\n     */\n    static crossProduct(a: point, b: point): Point {\n        if (a.z == null || b.z == null) {\n            if (a.z == null) a.z = 0;\n            if (b.z == null) b.z = 0;\n        }\n        return {x: a.y * b.z - a.z * b.y, y: a.z * b.x - a.x * b.z, z: a.x * b.y - a.y * b.x};\n    }\n\n    /**\n     * Calculates the unit vector pointing from point a to point b.\n     *\n     * @param a - Starting point\n     * @param b - Ending point\n     * @returns Unit vector in the direction from a to b\n     *\n     * @remarks\n     * Equivalent to calling unitVector(subVector(b, a))\n     *\n     * @example\n     * ```typescript\n     * const a = { x: 0, y: 0 };\n     * const b = { x: 3, y: 4 };\n     * const direction = PointCal.unitVectorFromA2B(a, b); // { x: 0.6, y: 0.8 }\n     * ```\n     *\n     * @group Geometric Calculations\n     */\n    static unitVectorFromA2B(a: point, b: point): Point {\n        return this.unitVector(this.subVector(b, a));\n    }\n\n    /**\n     * Rotates a point around the origin.\n     *\n     * @param point - Point to rotate\n     * @param angle - Rotation angle in radians (counter-clockwise)\n     * @returns Rotated point\n     *\n     * @remarks\n     * Rotation is performed around the origin (0, 0).\n     * Positive angles rotate counter-clockwise, negative angles rotate clockwise.\n     * For rotation around a custom anchor, use {@link transformPointWRTAnchor}.\n     *\n     * **Performance**: Uses trigonometric functions (sin/cos). For many rotations with\n     * the same angle, pre-calculate sin/cos values and apply the transformation manually.\n     *\n     * @example\n     * ```typescript\n     * const point = { x: 1, y: 0 };\n     * const rotated = PointCal.rotatePoint(point, Math.PI / 2); // { x: 0, y: 1 }\n     * ```\n     *\n     * @group Transformations\n     */\n    static rotatePoint(point: point, angle: number): Point {\n        return {x: point.x * Math.cos(angle) - point.y * Math.sin(angle), y: point.x * Math.sin(angle) + point.y * Math.cos(angle)};\n    }\n\n    /**\n     * Transforms a point's coordinates to a new rotated axis system.\n     *\n     * @param point - Point in original coordinate system\n     * @param angleFromOriginalAxis2DestAxis - Rotation angle from original to destination axis (radians, CCW positive)\n     * @returns Point coordinates in the new axis system\n     *\n     * @remarks\n     * This performs an axis rotation transformation, converting coordinates from one\n     * reference frame to another rotated by the specified angle.\n     *\n     * @example\n     * ```typescript\n     * const point = { x: 10, y: 0 };\n     * const angle = Math.PI / 4; // 45 degrees\n     * const transformed = PointCal.transform2NewAxis(point, angle);\n     * ```\n     *\n     * @group Transformations\n     */\n    static transform2NewAxis(point: point, angleFromOriginalAxis2DestAxis: number): Point {\n        // angle is the angle from the original axis to the destination axis ccw is positive as always\n        return {x: point.x * Math.cos(angleFromOriginalAxis2DestAxis) + point.y * Math.sin(angleFromOriginalAxis2DestAxis), y: -point.x * Math.sin(angleFromOriginalAxis2DestAxis) + point.y * Math.cos(angleFromOriginalAxis2DestAxis)};\n    }\n\n    /**\n     * Calculates the signed angle from vector a to vector b.\n     *\n     * @param a - First vector (starting direction)\n     * @param b - Second vector (ending direction)\n     * @returns The signed angle in radians, range: (-π, π]\n     *\n     * @remarks\n     * - Positive angles indicate counter-clockwise rotation from a to b\n     * - Negative angles indicate clockwise rotation from a to b\n     * - Uses atan2 for proper quadrant handling\n     *\n     * @example\n     * ```typescript\n     * const right = { x: 1, y: 0 };\n     * const up = { x: 0, y: 1 };\n     * const angle = PointCal.angleFromA2B(right, up); // π/2 (90 degrees CCW)\n     *\n     * const down = { x: 0, y: -1 };\n     * const angleDown = PointCal.angleFromA2B(right, down); // -π/2 (90 degrees CW)\n     * ```\n     *\n     * @group Angle Utilities\n     */\n    static angleFromA2B(a: point, b: point): number {\n        return Math.atan2(a.x * b.y - a.y * b.x, a.x * b.x + a.y * b.y);\n    }\n\n    /**\n     * Rotates a point around a custom anchor point.\n     *\n     * @param point - Point to rotate\n     * @param anchor - Anchor point to rotate around\n     * @param angle - Rotation angle in radians (counter-clockwise)\n     * @returns Rotated point\n     *\n     * @remarks\n     * This is equivalent to:\n     * 1. Translate point by -anchor\n     * 2. Rotate around origin\n     * 3. Translate back by +anchor\n     *\n     * @example\n     * ```typescript\n     * const point = { x: 10, y: 5 };\n     * const anchor = { x: 5, y: 5 };\n     * const angle = Math.PI / 2; // 90 degrees\n     * const rotated = PointCal.transformPointWRTAnchor(point, anchor, angle);\n     * // Rotates point around anchor (5, 5)\n     * ```\n     *\n     * @group Transformations\n     */\n    static transformPointWRTAnchor(point: point, anchor: point, angle: number): Point {\n        // angle is in radians\n        let newPoint = this.rotatePoint(this.subVector(point, anchor), angle);\n        return this.addVector(newPoint, anchor);\n    }\n\n    /**\n     * Calculates the Euclidean distance between two points.\n     *\n     * @param a - First point\n     * @param b - Second point\n     * @returns The distance between the two points\n     *\n     * @remarks\n     * Equivalent to calculating the magnitude of the vector from a to b.\n     *\n     * @example\n     * ```typescript\n     * const a = { x: 0, y: 0 };\n     * const b = { x: 3, y: 4 };\n     * const distance = PointCal.distanceBetweenPoints(a, b); // 5\n     * ```\n     *\n     * @group Geometric Calculations\n     */\n    static distanceBetweenPoints(a: point, b: point): number {\n        return this.magnitude(this.subVector(a, b));\n    }\n\n    /**\n     * Flips a point's y-coordinate (mirrors across the x-axis).\n     *\n     * @param point - Point to flip\n     * @returns Point with negated y-coordinate\n     *\n     * @remarks\n     * Useful for converting between coordinate systems where the y-axis direction differs.\n     * Common when converting between screen coordinates (y-down) and mathematical coordinates (y-up).\n     *\n     * @example\n     * ```typescript\n     * const point = { x: 10, y: 20 };\n     * const flipped = PointCal.flipYAxis(point); // { x: 10, y: -20 }\n     * ```\n     *\n     * @group Transformations\n     */\n    static flipYAxis(point: point): Point{\n        return {x: point.x, y: -point.y, z: point.z};\n    }\n\n    /**\n     * Performs linear interpolation between two points.\n     *\n     * @param a - Starting point (t = 0)\n     * @param b - Ending point (t = 1)\n     * @param t - Interpolation parameter (0 to 1)\n     * @returns Interpolated point\n     *\n     * @remarks\n     * - t = 0 returns point a\n     * - t = 1 returns point b\n     * - t = 0.5 returns the midpoint\n     * - Values outside [0, 1] perform extrapolation\n     *\n     * **Performance**: Suitable for animation loops and real-time interpolation.\n     *\n     * @example\n     * ```typescript\n     * const a = { x: 0, y: 0 };\n     * const b = { x: 10, y: 20 };\n     * const mid = PointCal.linearInterpolation(a, b, 0.5); // { x: 5, y: 10 }\n     * const quarter = PointCal.linearInterpolation(a, b, 0.25); // { x: 2.5, y: 5 }\n     * ```\n     *\n     * @group Geometric Calculations\n     */\n    static linearInterpolation(a: point, b: point, t: number): point{\n        if (a.z == null || b.z == null) {\n            return {x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t};\n        } else {\n            return {x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t, z: a.z + (b.z - a.z) * t};\n        }\n    }\n\n    /**\n     * Checks if two points are exactly equal.\n     *\n     * @param a - First point\n     * @param b - Second point\n     * @returns True if all coordinates are exactly equal\n     *\n     * @remarks\n     * Uses strict equality (===) for comparison.\n     * For approximate equality with tolerance, use {@link samePoint} instead.\n     * Missing z-coordinates are treated as 0.\n     *\n     * @example\n     * ```typescript\n     * const a = { x: 1, y: 2 };\n     * const b = { x: 1, y: 2 };\n     * PointCal.isEqual(a, b); // true\n     *\n     * const c = { x: 1.0000001, y: 2 };\n     * PointCal.isEqual(a, c); // false (use samePoint for tolerance)\n     * ```\n     *\n     * @group Geometric Calculations\n     */\n    static isEqual(a: point, b: point): boolean{\n        if (a.z == null){\n            a.z = 0;\n        }\n        if (b.z == null){\n            b.z = 0;\n        }\n        return a.x == b.x && a.y == b.y && a.z == b.z;\n    }\n\n    /**\n     * Calculates the intersection point of two line segments.\n     *\n     * @param startPoint - Start of first line segment\n     * @param endPoint - End of first line segment\n     * @param startPoint2 - Start of second line segment\n     * @param endPoint2 - End of second line segment\n     * @returns Object containing intersection status and details\n     *\n     * @remarks\n     * Returns an object with:\n     * - `intersects`: Boolean indicating if segments intersect\n     * - `intersection`: The intersection point (only if intersects is true)\n     * - `offset`: Parameter t where intersection occurs on first segment (0 to 1)\n     *\n     * The segments must actually cross within their bounds (not just their infinite extensions).\n     *\n     * **Use cases:**\n     * - Collision detection between line segments\n     * - Ray casting and visibility checks\n     * - Path intersection detection\n     *\n     * @example\n     * ```typescript\n     * const line1Start = { x: 0, y: 0 };\n     * const line1End = { x: 10, y: 10 };\n     * const line2Start = { x: 0, y: 10 };\n     * const line2End = { x: 10, y: 0 };\n     *\n     * const result = PointCal.getLineIntersection(line1Start, line1End, line2Start, line2End);\n     * // { intersects: true, intersection: { x: 5, y: 5 }, offset: 0.5 }\n     * ```\n     *\n     * @group Geometric Calculations\n     */\n    static getLineIntersection(startPoint: Point, endPoint: Point, startPoint2: Point, endPoint2: Point):{\n        intersects: boolean,\n        intersection?: Point,\n        offset?: number\n    }{\n        const numerator = (endPoint2.x - startPoint2.x) * (startPoint.y - startPoint2.y) - (endPoint2.y - startPoint2.y) * (startPoint.x - startPoint2.x);\n        const denominator = (endPoint2.y - startPoint2.y) * (endPoint.x - startPoint.x) - (endPoint2.x - startPoint2.x) * (endPoint.y - startPoint.y);\n        \n        if (denominator === 0){\n            return {intersects: false};\n        }\n        const t = numerator / denominator;\n        if (t >= 0 && t <= 1){\n            return {\n                intersects: true, \n                intersection: PointCal.linearInterpolation(startPoint, endPoint, t),\n                offset: t\n            }\n        } else {\n            return {\n                intersects: false,\n            }\n        }\n    \n    }\n    \n}\n\n/**\n * Normalizes an angle to the range [0, 2π).\n *\n * @param angle - Angle in radians (can be any value)\n * @returns Normalized angle between 0 and 2π\n *\n * @remarks\n * This function wraps any angle to the range [0, 2π) by taking the modulo\n * and ensuring the result is positive.\n *\n * @example\n * ```typescript\n * normalizeAngleZero2TwoPI(Math.PI * 3); // π (180 degrees)\n * normalizeAngleZero2TwoPI(-Math.PI / 2); // 3π/2 (270 degrees)\n * normalizeAngleZero2TwoPI(0); // 0\n * ```\n *\n * @category Angle\n */\nexport function normalizeAngleZero2TwoPI(angle: number){\n    // reduce the angle  \n    angle = angle % (Math.PI * 2);\n\n    // force it to be the positive remainder, so that 0 <= angle < 2 * Math.PI \n    angle = (angle + Math.PI * 2) % (Math.PI * 2); \n    return angle;\n}\n\n/**\n * Calculates the smallest angular difference between two angles.\n *\n * @param from - Starting angle in radians\n * @param to - Ending angle in radians\n * @returns The smallest angle span from 'from' to 'to', in range (-π, π]\n *\n * @remarks\n * This function accounts for wrapping around 2π and always returns the shorter path.\n * Positive result means counter-clockwise rotation, negative means clockwise.\n *\n * @example\n * ```typescript\n * // From 0° to 90°\n * angleSpan(0, Math.PI / 2); // π/2 (90 degrees CCW)\n *\n * // From 350° to 10° (shorter to go CCW through 0°)\n * angleSpan(350 * Math.PI / 180, 10 * Math.PI / 180); // ≈ 20 degrees\n *\n * // From 10° to 350° (shorter to go CW through 0°)\n * angleSpan(10 * Math.PI / 180, 350 * Math.PI / 180); // ≈ -20 degrees\n * ```\n *\n * @category Angle\n */\nexport function angleSpan(from: number, to: number): number{\n    // in radians\n    from = normalizeAngleZero2TwoPI(from);\n    to = normalizeAngleZero2TwoPI(to);\n    let angleDiff = to - from;\n    \n    if(angleDiff > Math.PI){\n        angleDiff = - (Math.PI * 2 - angleDiff);\n    }\n\n    if(angleDiff < -Math.PI){\n        angleDiff += (Math.PI * 2);\n    }\n    return angleDiff;\n}\n\n/**\n * Checks if two numbers are approximately equal within a tolerance.\n *\n * @param a - First number\n * @param b - Second number\n * @param precision - Optional tolerance (defaults to 0.000001)\n * @returns True if the absolute difference is within the precision threshold\n *\n * @remarks\n * Useful for floating-point comparisons where exact equality is unreliable.\n *\n * @example\n * ```typescript\n * approximatelyTheSame(1.0, 1.0000001); // true (within default epsilon)\n * approximatelyTheSame(1.0, 1.1); // false\n * approximatelyTheSame(1.0, 1.01, 0.02); // true (within custom precision)\n * ```\n *\n * @category Comparison\n */\nexport function approximatelyTheSame(a: number, b: number, precision?: number): boolean {\n    const epsilon = 0.000001\n    return Math.abs(a - b) <= (precision || epsilon);\n}\n\n/**\n * Checks if two vectors point in the same direction.\n *\n * @param a - First vector\n * @param b - Second vector\n * @param precision - Tolerance for comparison (defaults to 0.001)\n * @returns True if vectors have the same direction (after normalization)\n *\n * @remarks\n * Normalizes both vectors to unit vectors and compares them.\n * Magnitude does not matter, only direction.\n *\n * @example\n * ```typescript\n * const a = { x: 1, y: 0 };\n * const b = { x: 10, y: 0 }; // Same direction, different magnitude\n * sameDirection(a, b); // true\n *\n * const c = { x: 1, y: 1 };\n * sameDirection(a, c); // false (different direction)\n * ```\n *\n * @category Comparison\n */\nexport function sameDirection(a: Point, b: Point, precision: number = 0.001): boolean{\n   const aNormalized = PointCal.unitVector(a);\n   const bNormalized = PointCal.unitVector(b);\n   return samePoint(aNormalized, bNormalized, precision);\n}\n\n/**\n * Checks if a direction vector is aligned with a tangent vector.\n *\n * @param direction - Direction vector to check\n * @param tangent - Tangent vector reference\n * @returns True if direction aligns with tangent (within 90 degrees)\n *\n * @remarks\n * Returns true if the direction is within 90 degrees of either the tangent\n * or its reverse. Useful for determining if movement is along a path.\n *\n * @example\n * ```typescript\n * const direction = { x: 1, y: 0 };\n * const tangent = { x: 1, y: 0.1 }; // Slightly rotated\n * directionAlignedToTangent(direction, tangent); // true\n *\n * const perpendicular = { x: 0, y: 1 };\n * directionAlignedToTangent(perpendicular, tangent); // false\n * ```\n *\n * @category Comparison\n */\nexport function directionAlignedToTangent(direction: Point, tangent: Point): boolean {\n   const directionNormalized = PointCal.unitVector(direction);\n   const tangentNormalized = PointCal.unitVector(tangent);\n   const reversedTangent = {x: -tangent.x, y: -tangent.y, z: tangent.z};\n   const angle = PointCal.angleFromA2B(directionNormalized, tangentNormalized);\n   const angle2 = PointCal.angleFromA2B(directionNormalized, reversedTangent);\n   return (angle < Math.PI / 2 && angle > -Math.PI / 2) && (angle2 > Math.PI / 2 || angle2 < -Math.PI / 2);\n}\n\n/**\n * Checks if two points are approximately at the same location.\n *\n * @param a - First point\n * @param b - Second point\n * @param precision - Optional tolerance for coordinate comparison\n * @returns True if both x and y coordinates are within precision\n *\n * @remarks\n * Uses {@link approximatelyTheSame} for coordinate comparison.\n * For exact equality, use {@link PointCal.isEqual} instead.\n *\n * @example\n * ```typescript\n * const a = { x: 1.0, y: 2.0 };\n * const b = { x: 1.0000001, y: 2.0000001 };\n * samePoint(a, b); // true (within default precision)\n *\n * const c = { x: 1.1, y: 2.0 };\n * samePoint(a, c); // false\n * ```\n *\n * @category Comparison\n */\nexport function samePoint(a: Point, b: Point, precision?: number): boolean {\n    if(approximatelyTheSame(a.x, b.x, precision) && approximatelyTheSame(a.y, b.y, precision)){\n        return true;\n    }\n    return false;\n}\n"
   ],
-  "mappings": ";AAaO,MAAM,SAAS;AAAA,SAEX,SAAS,CAAC,GAAU,GAAiB;AAAA,IACxC,IAAI,EAAE,KAAK,QAAQ,EAAE,KAAK;AAAA,MAAM,OAAO,EAAC,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,EAAE,IAAI,EAAE,EAAC;AAAA,IAClE,IAAI,EAAE,KAAK,QAAQ,EAAE,KAAK,MAAM;AAAA,MAC5B,IAAI,EAAE,KAAK;AAAA,QAAM,EAAE,IAAI;AAAA,MACvB,IAAI,EAAE,KAAK;AAAA,QAAM,EAAE,IAAI;AAAA,IAC3B;AAAA,IACA,OAAO,EAAC,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,EAAE,IAAI,EAAE,EAAC;AAAA;AAAA,SAG7C,SAAS,CAAC,GAAU,GAAiB;AAAA,IACxC,IAAI,EAAE,KAAK,QAAQ,EAAE,KAAK;AAAA,MAAM,OAAO,EAAC,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,EAAE,IAAI,EAAE,EAAC;AAAA,IAClE,IAAI,EAAE,KAAK,QAAQ,EAAE,KAAK,MAAM;AAAA,MAC5B,IAAI,EAAE,KAAK;AAAA,QAAM,EAAE,IAAI;AAAA,MACvB,IAAI,EAAE,KAAK;AAAA,QAAM,EAAE,IAAI;AAAA,IAC3B;AAAA,IACA,OAAO,EAAC,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,EAAE,IAAI,EAAE,EAAC;AAAA;AAAA,SAG7C,sBAAsB,CAAC,GAAU,GAAkB;AAAA,IACtD,IAAI,EAAE,KAAK;AAAA,MAAM,OAAO,EAAC,GAAG,EAAE,IAAI,GAAG,GAAG,EAAE,IAAI,EAAC;AAAA,IAC/C,OAAO,EAAC,GAAG,EAAE,IAAI,GAAG,GAAG,EAAE,IAAI,GAAG,GAAG,EAAE,IAAI,EAAC;AAAA;AAAA,SAGvC,oBAAoB,CAAC,GAAU,GAAkB;AAAA,IACpD,IAAI,KAAK;AAAA,MAAG,OAAO,EAAC,GAAG,EAAE,GAAG,GAAG,EAAE,EAAC;AAAA,IAClC,IAAI,EAAE,KAAK;AAAA,MAAM,OAAO,EAAC,GAAG,EAAE,IAAI,GAAG,GAAG,EAAE,IAAI,EAAC;AAAA,IAC/C,OAAO,EAAC,GAAG,EAAE,IAAI,GAAG,GAAG,EAAE,IAAI,GAAG,GAAG,EAAE,IAAI,EAAC;AAAA;AAAA,SAGvC,SAAS,CAAC,GAAkB;AAAA,IAC/B,IAAI,EAAE,KAAK;AAAA,MAAM,EAAE,IAAI;AAAA,IACvB,OAAO,KAAK,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;AAAA;AAAA,SAG/C,UAAU,CAAC,GAAiB;AAAA,IAC/B,IAAI,EAAE,KAAK;AAAA,MAAM,EAAE,IAAI;AAAA,IACvB,OAAO,KAAK,UAAU,CAAC,KAAK,IAAI,EAAC,GAAG,EAAE,IAAI,KAAK,UAAU,CAAC,GAAG,GAAG,EAAE,IAAI,KAAK,UAAU,CAAC,GAAG,GAAG,EAAE,IAAI,KAAK,UAAU,CAAC,EAAC,IAAI,EAAC,GAAG,GAAG,GAAG,GAAG,GAAG,EAAC;AAAA;AAAA,SAGrI,UAAU,CAAC,GAAU,GAAkB;AAAA,IAC1C,IAAI,EAAE,KAAK,QAAQ,EAAE,KAAK;AAAA,MAAM,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE;AAAA,IAC3D,IAAI,EAAE,KAAK,QAAQ,EAAE,KAAK,MAAM;AAAA,MAC5B,IAAI,EAAE,KAAK;AAAA,QAAM,EAAE,IAAI;AAAA,MACvB,IAAI,EAAE,KAAK;AAAA,QAAM,EAAE,IAAI;AAAA,IAC3B;AAAA,IACA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE;AAAA;AAAA,SAGpC,YAAY,CAAC,GAAU,GAAiB;AAAA,IAC3C,IAAI,EAAE,KAAK,QAAQ,EAAE,KAAK,MAAM;AAAA,MAC5B,IAAI,EAAE,KAAK;AAAA,QAAM,EAAE,IAAI;AAAA,MACvB,IAAI,EAAE,KAAK;AAAA,QAAM,EAAE,IAAI;AAAA,IAC3B;AAAA,IACA,OAAO,EAAC,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,EAAC;AAAA;AAAA,SAGjF,iBAAiB,CAAC,GAAU,GAAiB;AAAA,IAChD,OAAO,KAAK,WAAW,KAAK,UAAU,GAAG,CAAC,CAAC;AAAA;AAAA,SAGxC,WAAW,CAAC,OAAc,OAAsB;AAAA,IACnD,OAAO,EAAC,GAAG,MAAM,IAAI,KAAK,IAAI,KAAK,IAAI,MAAM,IAAI,KAAK,IAAI,KAAK,GAAG,GAAG,MAAM,IAAI,KAAK,IAAI,KAAK,IAAI,MAAM,IAAI,KAAK,IAAI,KAAK,EAAC;AAAA;AAAA,SAGvH,iBAAiB,CAAC,OAAc,gCAA+C;AAAA,IAElF,OAAO,EAAC,GAAG,MAAM,IAAI,KAAK,IAAI,8BAA8B,IAAI,MAAM,IAAI,KAAK,IAAI,8BAA8B,GAAG,GAAG,CAAC,MAAM,IAAI,KAAK,IAAI,8BAA8B,IAAI,MAAM,IAAI,KAAK,IAAI,8BAA8B,EAAC;AAAA;AAAA,SAM5N,YAAY,CAAC,GAAU,GAAkB;AAAA,IAC5C,OAAO,KAAK,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;AAAA;AAAA,SAG3D,uBAAuB,CAAC,OAAc,QAAe,OAAsB;AAAA,IAE9E,IAAI,WAAW,KAAK,YAAY,KAAK,UAAU,OAAO,MAAM,GAAG,KAAK;AAAA,IACpE,OAAO,KAAK,UAAU,UAAU,MAAM;AAAA;AAAA,SAGnC,qBAAqB,CAAC,GAAU,GAAkB;AAAA,IACrD,OAAO,KAAK,UAAU,KAAK,UAAU,GAAG,CAAC,CAAC;AAAA;AAAA,SAGvC,SAAS,CAAC,OAAoB;AAAA,IACjC,OAAO,EAAC,GAAG,MAAM,GAAG,GAAG,CAAC,MAAM,GAAG,GAAG,MAAM,EAAC;AAAA;AAAA,SAGxC,mBAAmB,CAAC,GAAU,GAAU,GAAiB;AAAA,IAC5D,IAAI,EAAE,KAAK,QAAQ,EAAE,KAAK,MAAM;AAAA,MAC5B,OAAO,EAAC,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAC;AAAA,IAC9D,EAAO;AAAA,MACH,OAAO,EAAC,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAC;AAAA;AAAA;AAAA,SAIrF,OAAO,CAAC,GAAU,GAAkB;AAAA,IACvC,IAAI,EAAE,KAAK,MAAK;AAAA,MACZ,EAAE,IAAI;AAAA,IACV;AAAA,IACA,IAAI,EAAE,KAAK,MAAK;AAAA,MACZ,EAAE,IAAI;AAAA,IACV;AAAA,IACA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE;AAAA;AAAA,SAGzC,mBAAmB,CAAC,YAAmB,UAAiB,aAAoB,WAIlF;AAAA,IACG,MAAM,aAAa,UAAU,IAAI,YAAY,MAAM,WAAW,IAAI,YAAY,MAAM,UAAU,IAAI,YAAY,MAAM,WAAW,IAAI,YAAY;AAAA,IAC/I,MAAM,eAAe,UAAU,IAAI,YAAY,MAAM,SAAS,IAAI,WAAW,MAAM,UAAU,IAAI,YAAY,MAAM,SAAS,IAAI,WAAW;AAAA,IAE3I,IAAI,gBAAgB,GAAE;AAAA,MAClB,OAAO,EAAC,YAAY,MAAK;AAAA,IAC7B;AAAA,IACA,MAAM,IAAI,YAAY;AAAA,IACtB,IAAI,KAAK,KAAK,KAAK,GAAE;AAAA,MACjB,OAAO;AAAA,QACH,YAAY;AAAA,QACZ,cAAc,SAAS,oBAAoB,YAAY,UAAU,CAAC;AAAA,QAClE,QAAQ;AAAA,MACZ;AAAA,IACJ,EAAO;AAAA,MACH,OAAO;AAAA,QACH,YAAY;AAAA,MAChB;AAAA;AAAA;AAKZ;AAOO,SAAS,wBAAwB,CAAC,OAAc;AAAA,EAEnD,QAAQ,SAAS,KAAK,KAAK;AAAA,EAG3B,SAAS,QAAQ,KAAK,KAAK,MAAM,KAAK,KAAK;AAAA,EAC3C,OAAO;AAAA;AAQJ,SAAS,SAAS,CAAC,MAAc,IAAmB;AAAA,EAEvD,OAAO,yBAAyB,IAAI;AAAA,EACpC,KAAK,yBAAyB,EAAE;AAAA,EAChC,IAAI,YAAY,KAAK;AAAA,EAErB,IAAG,YAAY,KAAK,IAAG;AAAA,IACnB,YAAY,EAAG,KAAK,KAAK,IAAI;AAAA,EACjC;AAAA,EAEA,IAAG,YAAY,CAAC,KAAK,IAAG;AAAA,IACpB,aAAc,KAAK,KAAK;AAAA,EAC5B;AAAA,EACA,OAAO;AAAA;AAGJ,SAAS,oBAAoB,CAAC,GAAW,GAAW,WAA6B;AAAA,EACpF,MAAM,UAAU;AAAA,EAChB,OAAO,KAAK,IAAI,IAAI,CAAC,MAAM,aAAa;AAAA;AAGrC,SAAS,aAAa,CAAC,GAAU,GAAU,YAAoB,OAAe;AAAA,EAClF,MAAM,cAAc,SAAS,WAAW,CAAC;AAAA,EACzC,MAAM,cAAc,SAAS,WAAW,CAAC;AAAA,EACzC,OAAO,UAAU,aAAa,aAAa,SAAS;AAAA;AAGhD,SAAS,yBAAyB,CAAC,WAAkB,SAAyB;AAAA,EAClF,MAAM,sBAAsB,SAAS,WAAW,SAAS;AAAA,EACzD,MAAM,oBAAoB,SAAS,WAAW,OAAO;AAAA,EACrD,MAAM,kBAAkB,EAAC,GAAG,CAAC,QAAQ,GAAG,GAAG,CAAC,QAAQ,GAAG,GAAG,QAAQ,EAAC;AAAA,EACnE,MAAM,QAAQ,SAAS,aAAa,qBAAqB,iBAAiB;AAAA,EAC1E,MAAM,SAAS,SAAS,aAAa,qBAAqB,eAAe;AAAA,EACzE,OAAQ,QAAQ,KAAK,KAAK,KAAK,QAAQ,CAAC,KAAK,KAAK,MAAO,SAAS,KAAK,KAAK,KAAK,SAAS,CAAC,KAAK,KAAK;AAAA;AAGjG,SAAS,SAAS,CAAC,GAAU,GAAU,WAA6B;AAAA,EACvE,IAAG,qBAAqB,EAAE,GAAG,EAAE,GAAG,SAAS,KAAK,qBAAqB,EAAE,GAAG,EAAE,GAAG,SAAS,GAAE;AAAA,IACtF,OAAO;AAAA,EACX;AAAA,EACA,OAAO;AAAA;",
-  "debugId": "B0C116870CD7AAF064756E2164756E21",
+  "mappings": "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",
+  "debugId": "E7FBAB931781982464756E2164756E21",
   "names": []
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@ue-too/math",
   "author": "niuee",
   "type": "module",
-  "version": "0.9.4",
+  "version": "0.10.0",
   "description": "Math utilities for uē-tôo",
   "license": "MIT",
   "repository": {