@ue-too/border 0.9.4 → 0.10.0

package/README.md

@@ -1,6 +1,486 @@
-# border
+# @ue-too/border
 
-This is a library that provides utilities for working with and geographic projections.
-Following the tutorial from [Chris Veness](https://www.movable-type.co.uk/scripts/latlong.html).
+Geodesy and map projection library for TypeScript.
 
-Detailed information would be added in the future.
+[![npm version](https://img.shields.io/npm/v/@ue-too/border.svg)](https://www.npmjs.com/package/@ue-too/border)
+[![license](https://img.shields.io/npm/l/@ue-too/border.svg)](https://github.com/ue-too/ue-too/blob/main/LICENSE.txt)
+
+## Overview
+
+`@ue-too/border` provides geodesy calculations and map projections for working with geographic coordinates on the Earth's surface. Based on algorithms from [Movable Type Scripts](https://www.movable-type.co.uk/scripts/latlong.html) by Chris Veness, this library includes utilities for great circle navigation, rhumb line navigation, and coordinate transformations.
+
+### Key Features
+
+- **Great Circle Navigation**: Shortest path calculations on a sphere
+- **Rhumb Line Navigation**: Constant bearing paths for easier navigation
+- **Map Projections**: Mercator and orthographic projections with inverse transformations
+- **Distance Calculations**: Accurate distances between geographic coordinates
+- **Bearing Calculations**: Initial and constant bearings for navigation
+- **Intermediate Points**: Find points along paths
+- **Midpoint Calculation**: Find midpoints between coordinates
+
+## Installation
+
+Using Bun:
+```bash
+bun add @ue-too/border
+```
+
+Using npm:
+```bash
+npm install @ue-too/border
+```
+
+## Quick Start
+
+Here's a simple example calculating distance and bearing between two cities:
+
+```typescript
+import {
+  greatCircleDistance,
+  initialBearingOfGreatCircle
+} from '@ue-too/border';
+
+// New York to London
+const nyc = { latitude: 40.7128, longitude: -74.0060 };
+const london = { latitude: 51.5074, longitude: -0.1278 };
+
+// Calculate great circle distance (in meters)
+const distance = greatCircleDistance(nyc, london);
+console.log('Distance:', (distance / 1000).toFixed(0), 'km'); // ~5570 km
+
+// Calculate initial bearing (in degrees)
+const bearing = initialBearingOfGreatCircle(nyc, london);
+console.log('Bearing:', bearing.toFixed(1), '°'); // ~51.4° (northeast)
+```
+
+## Core Concepts
+
+### Great Circles
+
+A great circle is the shortest path between two points on a sphere (like the Earth). Airlines typically fly great circle routes to minimize distance.
+
+- **Advantages**: Shortest distance, fuel-efficient
+- **Characteristics**: Bearing changes continuously along the path (except when traveling due north/south or along the equator)
+
+### Rhumb Lines
+
+A rhumb line (loxodrome) is a path of constant bearing. While slightly longer than great circles, they're easier to navigate.
+
+- **Advantages**: Constant bearing, simpler navigation
+- **Characteristics**: Spirals toward poles, longer distance than great circles (except along equator or meridians)
+
+### Map Projections
+
+Map projections transform spherical coordinates (latitude/longitude) to flat 2D coordinates for display.
+
+- **Mercator**: Preserves angles, distorts size at high latitudes
+- **Orthographic**: Perspective view from space, shows one hemisphere
+
+## Core APIs
+
+### Great Circle Functions
+
+#### `greatCircleDistance(from, to)`
+
+Calculate the great circle distance between two points.
+
+```typescript
+function greatCircleDistance(
+  from: GeoCoord,
+  to: GeoCoord
+): number; // Returns distance in meters
+```
+
+**Example:**
+```typescript
+const distance = greatCircleDistance(
+  { latitude: 51.5074, longitude: -0.1278 }, // London
+  { latitude: 48.8566, longitude: 2.3522 }   // Paris
+);
+console.log(distance / 1000, 'km'); // ~344 km
+```
+
+#### `initialBearingOfGreatCircle(from, to)`
+
+Calculate the initial bearing (direction) for a great circle path.
+
+```typescript
+function initialBearingOfGreatCircle(
+  from: GeoCoord,
+  to: GeoCoord
+): number; // Returns bearing in degrees (0-360)
+```
+
+**Example:**
+```typescript
+const bearing = initialBearingOfGreatCircle(
+  { latitude: 40.7128, longitude: -74.0060 }, // NYC
+  { latitude: 51.5074, longitude: -0.1278 }   // London
+);
+console.log(bearing, '°'); // ~51.4° (northeast)
+```
+
+#### `destinationFromOriginOnGreatCircle(origin, bearing, distance)`
+
+Find the destination point given origin, bearing, and distance.
+
+```typescript
+function destinationFromOriginOnGreatCircle(
+  origin: GeoCoord,
+  bearing: number,  // Degrees
+  distance: number  // Meters
+): GeoCoord;
+```
+
+**Example:**
+```typescript
+const start = { latitude: 51.5074, longitude: -0.1278 };
+const destination = destinationFromOriginOnGreatCircle(start, 90, 100000);
+console.log('100km east:', destination);
+```
+
+#### `midpointOnGreatCircle(from, to)`
+
+Find the midpoint along a great circle path.
+
+```typescript
+function midpointOnGreatCircle(
+  from: GeoCoord,
+  to: GeoCoord
+): GeoCoord;
+```
+
+#### `intermediatePointOnGreatCircle(from, to, fraction)`
+
+Find a point at a given fraction along the great circle path.
+
+```typescript
+function intermediatePointOnGreatCircle(
+  from: GeoCoord,
+  to: GeoCoord,
+  fraction: number  // 0.0 to 1.0
+): GeoCoord;
+```
+
+**Example:**
+```typescript
+// Find the point 25% of the way from NYC to London
+const point = intermediatePointOnGreatCircle(nyc, london, 0.25);
+```
+
+### Rhumb Line Functions
+
+#### `rhumbDistance(from, to)`
+
+Calculate the rhumb line distance (constant bearing path).
+
+```typescript
+function rhumbDistance(
+  from: GeoCoord,
+  to: GeoCoord
+): number; // Returns distance in meters
+```
+
+#### `rhumbBearing(from, to)`
+
+Calculate the constant bearing for a rhumb line.
+
+```typescript
+function rhumbBearing(
+  from: GeoCoord,
+  to: GeoCoord
+): number; // Returns bearing in degrees (0-360)
+```
+
+#### `destinationFromOriginOnRhumbLine(origin, bearing, distance)`
+
+Find the destination on a rhumb line given origin, bearing, and distance.
+
+```typescript
+function destinationFromOriginOnRhumbLine(
+  origin: GeoCoord,
+  bearing: number,  // Degrees
+  distance: number  // Meters
+): GeoCoord;
+```
+
+#### `midpointOnRhumbLine(from, to)`
+
+Find the midpoint along a rhumb line.
+
+```typescript
+function midpointOnRhumbLine(
+  from: GeoCoord,
+  to: GeoCoord
+): GeoCoord;
+```
+
+### Map Projection Functions
+
+#### `mercatorProjection(coord)`
+
+Convert geographic coordinates to Mercator projection.
+
+```typescript
+function mercatorProjection(
+  coord: GeoCoord
+): Point; // Returns {x, y} in normalized coordinates
+```
+
+**Example:**
+```typescript
+const point = mercatorProjection({ latitude: 51.5074, longitude: -0.1278 });
+console.log('Mercator coordinates:', point);
+```
+
+#### `inverseMercatorProjection(point)`
+
+Convert Mercator coordinates back to geographic.
+
+```typescript
+function inverseMercatorProjection(
+  point: Point
+): GeoCoord; // Returns {latitude, longitude}
+```
+
+#### `orthoProjection(coord, origin)`
+
+Convert geographic coordinates to orthographic projection (hemisphere view).
+
+```typescript
+function orthoProjection(
+  coord: GeoCoord,
+  origin: GeoCoord  // Center of projection
+): {
+  coord: Point;     // Projected point
+  clipped: boolean; // True if coord is on the back hemisphere
+};
+```
+
+**Example:**
+```typescript
+// Project London as seen from the North Pole
+const result = orthoProjection(
+  { latitude: 51.5074, longitude: -0.1278 },
+  { latitude: 90, longitude: 0 }
+);
+
+if (!result.clipped) {
+  console.log('Visible at:', result.coord);
+}
+```
+
+### Type Definitions
+
+```typescript
+type GeoCoord = {
+  latitude: number;   // Degrees, -90 to 90
+  longitude: number;  // Degrees, -180 to 180
+};
+
+type Point = {
+  x: number;
+  y: number;
+};
+```
+
+## Common Use Cases
+
+### Calculate Flight Distance and Route
+
+```typescript
+import {
+  greatCircleDistance,
+  initialBearingOfGreatCircle,
+  intermediatePointOnGreatCircle
+} from '@ue-too/border';
+
+const departure = { latitude: 40.6413, longitude: -73.7781 }; // JFK
+const arrival = { latitude: 51.4700, longitude: -0.4543 };    // LHR
+
+// Total distance
+const distance = greatCircleDistance(departure, arrival);
+console.log('Flight distance:', (distance / 1000).toFixed(0), 'km');
+
+// Initial heading
+const heading = initialBearingOfGreatCircle(departure, arrival);
+console.log('Initial heading:', heading.toFixed(1), '°');
+
+// Waypoint halfway through
+const midpoint = intermediatePointOnGreatCircle(departure, arrival, 0.5);
+console.log('Midpoint:', midpoint);
+```
+
+### Display Map with Mercator Projection
+
+```typescript
+import { mercatorProjection } from '@ue-too/border';
+
+const cities = [
+  { name: 'New York', latitude: 40.7128, longitude: -74.0060 },
+  { name: 'London', latitude: 51.5074, longitude: -0.1278 },
+  { name: 'Tokyo', latitude: 35.6762, longitude: 139.6503 }
+];
+
+// Project to screen coordinates
+cities.forEach(city => {
+  const point = mercatorProjection(city);
+
+  // Scale to canvas (assuming 1000x600 canvas)
+  const x = (point.x + 180) / 360 * 1000;
+  const y = (1 - (point.y + 90) / 180) * 600;
+
+  drawCity(x, y, city.name);
+});
+```
+
+### Navigate with Constant Bearing
+
+```typescript
+import {
+  rhumbBearing,
+  destinationFromOriginOnRhumbLine
+} from '@ue-too/border';
+
+const start = { latitude: 50.0, longitude: -5.0 };
+const target = { latitude: 58.0, longitude: 3.0 };
+
+// Get constant bearing to maintain
+const bearing = rhumbBearing(start, target);
+console.log('Sail on bearing:', bearing.toFixed(1), '°');
+
+// Calculate positions every 50 nautical miles
+const nauticalMileInMeters = 1852;
+let currentPos = start;
+
+for (let i = 1; i <= 10; i++) {
+  currentPos = destinationFromOriginOnRhumbLine(
+    currentPos,
+    bearing,
+    50 * nauticalMileInMeters
+  );
+  console.log(`Waypoint ${i}:`, currentPos);
+}
+```
+
+### Find Nearest City
+
+```typescript
+import { greatCircleDistance } from '@ue-too/border';
+
+const userLocation = { latitude: 48.8566, longitude: 2.3522 }; // Paris
+
+const cities = [
+  { name: 'London', coord: { latitude: 51.5074, longitude: -0.1278 } },
+  { name: 'Berlin', coord: { latitude: 52.5200, longitude: 13.4050 } },
+  { name: 'Madrid', coord: { latitude: 40.4168, longitude: -3.7038 } },
+  { name: 'Rome', coord: { latitude: 41.9028, longitude: 12.4964 } }
+];
+
+const distances = cities.map(city => ({
+  ...city,
+  distance: greatCircleDistance(userLocation, city.coord)
+}));
+
+distances.sort((a, b) => a.distance - b.distance);
+console.log('Nearest city:', distances[0].name,
+            '- ', (distances[0].distance / 1000).toFixed(0), 'km');
+```
+
+### Globe Visualization with Orthographic Projection
+
+```typescript
+import { orthoProjection } from '@ue-too/border';
+
+// View centered on Europe
+const viewCenter = { latitude: 50, longitude: 10 };
+
+const cities = [
+  { name: 'London', coord: { latitude: 51.5074, longitude: -0.1278 } },
+  { name: 'Paris', coord: { latitude: 48.8566, longitude: 2.3522 } },
+  { name: 'Berlin', coord: { latitude: 52.5200, longitude: 13.4050 } }
+];
+
+cities.forEach(city => {
+  const result = orthoProjection(city.coord, viewCenter);
+
+  if (!result.clipped) {
+    // City is visible on this hemisphere
+    const screenX = result.coord.x * 400 + 400; // Scale to canvas
+    const screenY = result.coord.y * 400 + 400;
+
+    drawCityOnGlobe(screenX, screenY, city.name);
+  }
+});
+```
+
+## API Reference
+
+For complete API documentation with detailed type information, see the [TypeDoc-generated documentation](../../docs/border).
+
+## TypeScript Support
+
+This package is written in TypeScript with complete type definitions:
+
+```typescript
+import { GeoCoord, Point, greatCircleDistance } from '@ue-too/border';
+
+// Coordinates are fully typed
+const coord: GeoCoord = { latitude: 51.5074, longitude: -0.1278 };
+
+// Function signatures are type-safe
+const distance: number = greatCircleDistance(coord1, coord2);
+
+// Projection results are typed
+const point: Point = mercatorProjection(coord);
+```
+
+## Design Philosophy
+
+This library follows these principles:
+
+- **Accuracy**: Uses proven geodesy algorithms from academic sources
+- **Simplicity**: Clean, focused API for common geodesy tasks
+- **Type Safety**: Full TypeScript type definitions
+- **Performance**: Efficient calculations suitable for real-time applications
+- **Practicality**: Focused on real-world mapping and navigation use cases
+
+## Performance Considerations
+
+- **Distance calculations**: O(1) - simple trigonometric calculations
+- **Projections**: O(1) - direct mathematical transformations
+- **Intermediate points**: O(1) - no iteration required
+
+**Performance Tips:**
+- Cache distance and bearing calculations if coordinates don't change
+- For many points, batch projection calculations
+- Use appropriate projection for your use case (Mercator for general mapping, orthographic for globes)
+
+## Limitations
+
+- **Earth model**: Assumes spherical Earth (not ellipsoidal) - sufficient for most applications but less accurate for high-precision surveying
+- **Coordinate range**: Latitude must be in [-90, 90], longitude in [-180, 180]
+- **Polar regions**: Some calculations may be less accurate near poles
+- **Mercator distortion**: Mercator projection heavily distorts areas near poles
+
+## Related Packages
+
+- **[@ue-too/math](../math)**: Vector operations for point calculations
+- **[@ue-too/curve](../curve)**: Bezier curves for drawing map features
+- **[@ue-too/board](../board)**: Canvas board for rendering maps
+
+## Further Reading
+
+- [Movable Type Scripts](https://www.movable-type.co.uk/scripts/latlong.html) - Comprehensive geodesy reference
+- [Map Projections](https://en.wikipedia.org/wiki/Map_projection) - Understanding different projections
+- [Great Circle Navigation](https://en.wikipedia.org/wiki/Great-circle_navigation) - Theory and applications
+- [Rhumb Line](https://en.wikipedia.org/wiki/Rhumb_line) - Constant bearing navigation
+
+## License
+
+MIT
+
+## Repository
+
+[https://github.com/ue-too/ue-too](https://github.com/ue-too/ue-too)

package/greateCircle.d.ts

@@ -1,5 +1,54 @@
 import { GeoCoord } from "./projection";
+/**
+ * Calculates an intermediate point along a great circle path.
+ *
+ * @remarks
+ * Given two points on Earth's surface, this finds a point at a specified
+ * fraction along the great circle (shortest) path between them.
+ *
+ * Uses the spherical interpolation formula for accurate results on a sphere.
+ *
+ * @param startCoord - The starting geographic coordinate
+ * @param endCoord - The ending geographic coordinate
+ * @param fraction - The fraction along the path (0 = start, 1 = end, 0.5 = midpoint)
+ * @returns The intermediate point at the specified fraction
+ *
+ * @example
+ * ```typescript
+ * const nyc = { latitude: 40.7128, longitude: -74.0060 };
+ * const london = { latitude: 51.5074, longitude: -0.1278 };
+ *
+ * // Find point 25% of the way from NYC to London
+ * const quarter = intermediatePointOnGreatCircle(nyc, london, 0.25);
+ *
+ * // Find point 75% of the way
+ * const threeQuarters = intermediatePointOnGreatCircle(nyc, london, 0.75);
+ * ```
+ *
+ * @category Great Circle
+ */
 export declare function intermediatePointOnGreatCircle(startCoord: GeoCoord, endCoord: GeoCoord, fraction: number): GeoCoord;
+/**
+ * Calculates the midpoint along a great circle path.
+ *
+ * @remarks
+ * This is a specialized, optimized version of {@link intermediatePointOnGreatCircle}
+ * for finding the exact midpoint (fraction = 0.5).
+ *
+ * @param startCoord - The starting geographic coordinate
+ * @param endCoord - The ending geographic coordinate
+ * @returns The midpoint on the great circle path
+ *
+ * @example
+ * ```typescript
+ * const start = { latitude: 50.0, longitude: -5.0 };
+ * const end = { latitude: 58.0, longitude: 3.0 };
+ * const mid = midPointOnGreatCircle(start, end);
+ * console.log('Midpoint:', mid);
+ * ```
+ *
+ * @category Great Circle
+ */
 export declare function midPointOnGreatCircle(startCoord: GeoCoord, endCoord: GeoCoord): GeoCoord;
 /**
  * Calculate the initial bearing between two points on the Earth's surface.
@@ -10,5 +59,57 @@ export declare function midPointOnGreatCircle(startCoord: GeoCoord, endCoord: Ge
  * @returns The bearing in degrees.
  */
 export declare function initialBearingOfGreatCircle(startCoord: GeoCoord, endCoord: GeoCoord): number;
+/**
+ * Calculates the great circle distance between two points on Earth.
+ *
+ * @remarks
+ * Uses the haversine formula to calculate the shortest distance over Earth's
+ * surface between two geographic coordinates. This is the "as-the-crow-flies"
+ * distance.
+ *
+ * The calculation assumes Earth's mean radius of 6,371,000 meters and treats
+ * Earth as a perfect sphere.
+ *
+ * @param startCoord - The starting geographic coordinate
+ * @param endCoord - The ending geographic coordinate
+ * @returns The distance in meters
+ *
+ * @example
+ * ```typescript
+ * const nyc = { latitude: 40.7128, longitude: -74.0060 };
+ * const london = { latitude: 51.5074, longitude: -0.1278 };
+ *
+ * const distance = greatCircleDistance(nyc, london);
+ * console.log('Distance:', distance / 1000, 'km'); // ~5570 km
+ * ```
+ *
+ * @category Great Circle
+ */
 export declare function greatCircleDistance(startCoord: GeoCoord, endCoord: GeoCoord): number;
+/**
+ * Calculates the destination point given a start point, bearing, and distance on a great circle.
+ *
+ * @remarks
+ * Starting from a given point and traveling along a great circle at a specific
+ * initial bearing for a given distance, this calculates where you'll end up.
+ *
+ * Note: The bearing will change along the path (except when traveling due north/south
+ * or along the equator) because great circles are not straight lines on most map projections.
+ *
+ * @param startCoord - The starting geographic coordinate
+ * @param bearing - The initial bearing in degrees (0 = north, 90 = east, etc.)
+ * @param distance - The distance to travel in meters
+ * @returns The destination coordinate
+ *
+ * @example
+ * ```typescript
+ * const start = { latitude: 40.7128, longitude: -74.0060 }; // NYC
+ *
+ * // Travel 1000km northeast from NYC
+ * const destination = destinationFromOriginOnGreatCircle(start, 45, 1000000);
+ * console.log('Destination:', destination);
+ * ```
+ *
+ * @category Great Circle
+ */
 export declare function destinationFromOriginOnGreatCircle(startCoord: GeoCoord, bearing: number, distance: number): GeoCoord;

package/index.d.ts

@@ -1,3 +1,120 @@
+/**
+ * @packageDocumentation
+ * Geodesy and map projection library for TypeScript.
+ *
+ * @remarks
+ * The `@ue-too/border` package provides geodesy calculations and map projections
+ * for working with geographic coordinates on the Earth's surface. It includes utilities
+ * for great circle navigation, rhumb line navigation, and coordinate transformations.
+ *
+ * ## Core Concepts
+ *
+ * - **Great Circles**: Shortest path between two points on a sphere (like flight routes)
+ * - **Rhumb Lines**: Constant bearing paths (easier for navigation, slightly longer)
+ * - **Map Projections**: Converting geographic coordinates to 2D points and vice versa
+ *
+ * ## Key Features
+ *
+ * ### Great Circle Navigation
+ * - Calculate distance between two geographic points
+ * - Find initial bearing for great circle path
+ * - Calculate intermediate points along great circle
+ * - Find destination given origin, bearing, and distance
+ * - Calculate midpoint on great circle
+ *
+ * ### Rhumb Line Navigation
+ * - Calculate rhumb line distance (constant bearing path)
+ * - Find bearing for rhumb line
+ * - Calculate destination on rhumb line
+ * - Find midpoint on rhumb line
+ *
+ * ### Map Projections
+ * - **Mercator Projection**: Cylindrical map projection preserving angles
+ * - **Orthographic Projection**: Perspective view of hemisphere from space
+ * - Inverse projections for converting back to geographic coordinates
+ *
+ * ## Main Exports
+ *
+ * - {@link GeoCoord} - Geographic coordinate type (latitude/longitude)
+ * - {@link mercatorProjection} - Convert geo coordinates to Mercator projection
+ * - {@link orthoProjection} - Convert geo coordinates to orthographic projection
+ * - {@link greatCircleDistance} - Calculate great circle distance
+ * - {@link initialBearingOfGreatCircle} - Calculate initial bearing
+ * - {@link rhumbDistance} - Calculate rhumb line distance
+ * - {@link rhumbBearing} - Calculate rhumb line bearing
+ *
+ * @example
+ * Great circle navigation
+ * ```typescript
+ * import {
+ *   greatCircleDistance,
+ *   initialBearingOfGreatCircle,
+ *   destinationFromOriginOnGreatCircle
+ * } from '@ue-too/border';
+ *
+ * // New York to London
+ * const nyc = { latitude: 40.7128, longitude: -74.0060 };
+ * const london = { latitude: 51.5074, longitude: -0.1278 };
+ *
+ * // Calculate distance in meters
+ * const distance = greatCircleDistance(nyc, london);
+ * console.log('Distance:', distance / 1000, 'km'); // ~5570 km
+ *
+ * // Calculate initial bearing
+ * const bearing = initialBearingOfGreatCircle(nyc, london);
+ * console.log('Bearing:', bearing, 'degrees'); // ~51 degrees (northeast)
+ *
+ * // Find point 1000km along the path
+ * const intermediate = destinationFromOriginOnGreatCircle(nyc, bearing, 1000000);
+ * ```
+ *
+ * @example
+ * Rhumb line navigation
+ * ```typescript
+ * import { rhumbDistance, rhumbBearing, destinationFromOriginOnRhumbLine } from '@ue-too/border';
+ *
+ * const start = { latitude: 50.0, longitude: -5.0 };
+ * const end = { latitude: 58.0, longitude: 3.0 };
+ *
+ * // Calculate rhumb line distance
+ * const dist = rhumbDistance(start, end);
+ *
+ * // Calculate constant bearing
+ * const bearing = rhumbBearing(start, end);
+ *
+ * // Navigate 100km on constant bearing
+ * const destination = destinationFromOriginOnRhumbLine(start, bearing, 100000);
+ * ```
+ *
+ * @example
+ * Map projections
+ * ```typescript
+ * import {
+ *   mercatorProjection,
+ *   inverseMercatorProjection,
+ *   orthoProjection
+ * } from '@ue-too/border';
+ *
+ * // Convert geographic to Mercator
+ * const coord = { latitude: 51.5074, longitude: -0.1278 };
+ * const point = mercatorProjection(coord);
+ * console.log('Mercator point:', point); // {x: ..., y: ...}
+ *
+ * // Convert back to geographic
+ * const geoCoord = inverseMercatorProjection(point);
+ *
+ * // Orthographic projection (hemisphere view)
+ * const origin = { latitude: 45.0, longitude: 0.0 };
+ * const result = orthoProjection(coord, origin);
+ * if (!result.clipped) {
+ *   console.log('Visible at:', result.coord);
+ * }
+ * ```
+ *
+ * @see {@link projection} for map projection functions
+ * @see {@link greateCircle} for great circle navigation
+ * @see {@link rhumbLine} for rhumb line navigation
+ */
 export * from "./projection";
 export * from "./greateCircle";
 export * from "./rhumbLine";

package/index.js

@@ -1,173 +1,3 @@
-// src/projection.ts
-function mercatorProjection(interestPoint, centerLongitude = 0) {
-  const r = 6371000;
-  const latitude = interestPoint.latitude * Math.PI / 180;
-  const longitude = interestPoint.longitude * Math.PI / 180;
-  let x = r * normalizeAngleMinusPiToPi(longitude - centerLongitude * Math.PI / 180);
-  let y = r * Math.log(Math.tan(Math.PI / 4 + latitude / 2));
-  return { x, y };
-}
-function inverseMercatorProjection(point, centerLongitude = 0) {
-  const r = 6371000;
-  const longitude = point.x / r + centerLongitude;
-  const latitude = 2 * Math.atan(Math.exp(point.y / r)) - Math.PI / 2;
-  return { latitude: latitude * 180 / Math.PI, longitude: longitude * 180 / Math.PI };
-}
-function orthoProjection(interestPoint, origin) {
-  const r = 6371000;
-  const latitude = interestPoint.latitude * Math.PI / 180;
-  const longitude = interestPoint.longitude * Math.PI / 180;
-  const x = r * Math.cos(latitude) * Math.sin(longitude - origin.longitude * Math.PI / 180);
-  const y = r * (Math.cos(origin.latitude * Math.PI / 180) * Math.sin(latitude) - Math.sin(origin.latitude * Math.PI / 180) * Math.cos(latitude) * Math.cos(longitude - origin.longitude * Math.PI / 180));
-  const clipped = Math.sin(origin.latitude * Math.PI / 180) * Math.sin(latitude) + Math.cos(origin.latitude * Math.PI / 180) * Math.cos(latitude) * Math.cos(longitude - origin.longitude * Math.PI / 180);
-  return { clipped: clipped < 0, coord: { x, y } };
-}
-function inverseOrthoProjection(interestPoint, origin) {
-  const r = 6371000;
-  const rho = Math.sqrt(interestPoint.x * interestPoint.x + interestPoint.y * interestPoint.y);
-  const c = Math.asin(rho / r);
-  const latitude = Math.asin(Math.cos(c) * Math.sin(origin.latitude * Math.PI / 180) + interestPoint.y * Math.sin(c) * Math.cos(origin.latitude * Math.PI / 180) / rho) * 180 / Math.PI;
-  const longitude = origin.longitude + Math.atan2(interestPoint.x * Math.sin(c), rho * Math.cos(c) * Math.cos(origin.latitude * Math.PI / 180) - interestPoint.y * Math.sin(c) * Math.sin(origin.latitude * Math.PI / 180)) * 180 / Math.PI;
-  return { latitude, longitude };
-}
-function normalizeAngleMinusPiToPi(angle) {
-  angle = angle % (Math.PI * 2);
-  angle = (angle + 3 * Math.PI) % (2 * Math.PI) - Math.PI;
-  return angle;
-}
-// src/greateCircle.ts
-function intermediatePointOnGreatCircle(startCoord, endCoord, fraction) {
-  const Δ_ = (endCoord.latitude - startCoord.latitude) * Math.PI / 180;
-  const Δ_2 = (endCoord.longitude - startCoord.longitude) * Math.PI / 180;
-  const φ1 = startCoord.latitude * Math.PI / 180;
-  const λ1 = startCoord.longitude * Math.PI / 180;
-  const φ2 = endCoord.latitude * Math.PI / 180;
-  const λ2 = endCoord.longitude * Math.PI / 180;
-  const angularDistA = Math.sin(Δ_ / 2) * Math.sin(Δ_ / 2) + Math.cos(φ1) * Math.cos(φ2) * Math.sin(Δ_2 / 2) * Math.sin(Δ_2 / 2);
-  const c = 2 * Math.atan2(Math.sqrt(angularDistA), Math.sqrt(1 - angularDistA));
-  const a = Math.sin((1 - fraction) * c) / Math.sin(c);
-  const b = Math.sin(fraction * c) / Math.sin(c);
-  const x = a * Math.cos(φ1) * Math.cos(λ1) + b * Math.cos(φ2) * Math.cos(λ2);
-  const y = a * Math.cos(φ1) * Math.sin(λ1) + b * Math.cos(φ2) * Math.sin(λ2);
-  const z = a * Math.sin(φ1) * b * Math.sin(φ2);
-  const φi = Math.atan2(z, Math.sqrt(x * x + y * y));
-  const λi = Math.atan2(y, x);
-  return { latitude: φi, longitude: λi };
-}
-function midPointOnGreatCircle(startCoord, endCoord) {
-  const φ1 = startCoord.latitude * Math.PI / 180;
-  const φ2 = endCoord.latitude * Math.PI / 180;
-  const λ1 = startCoord.longitude * Math.PI / 180;
-  const λ2 = endCoord.longitude * Math.PI / 180;
-  const Bx = Math.cos(φ2) * Math.cos(λ2 - λ1);
-  const By = Math.cos(φ2) * Math.sin(λ2 - λ1);
-  const φ3 = Math.atan2(Math.sin(φ1) + Math.sin(φ2), Math.sqrt((Math.cos(φ1) + Bx) * (Math.cos(φ1) + Bx) + By * By));
-  const λ3 = λ1 + Math.atan2(By, Math.cos(φ1) + Bx);
-  return { latitude: φ3, longitude: λ3 };
-}
-function initialBearingOfGreatCircle(startCoord, endCoord) {
-  const φ1 = startCoord.latitude * Math.PI / 180;
-  const φ2 = endCoord.latitude * Math.PI / 180;
-  const λ1 = startCoord.longitude * Math.PI / 180;
-  const λ2 = endCoord.longitude * Math.PI / 180;
-  const y = Math.sin(λ2 - λ1) * Math.cos(φ2);
-  const x = Math.cos(φ1) * Math.sin(φ2) - Math.sin(φ1) * Math.cos(φ2) * Math.cos(λ2 - λ1);
-  const θ = Math.atan2(y, x);
-  const brng = (θ * 180 / Math.PI + 360) % 360;
-  return brng;
-}
-function greatCircleDistance(startCoord, endCoord) {
-  const R = 6371000;
-  const φ1 = startCoord.latitude * Math.PI / 180;
-  const φ2 = endCoord.latitude * Math.PI / 180;
-  const Δ_ = (endCoord.latitude - startCoord.latitude) * Math.PI / 180;
-  const Δ_2 = (endCoord.longitude - startCoord.longitude) * Math.PI / 180;
-  const a = Math.sin(Δ_ / 2) * Math.sin(Δ_ / 2) + Math.cos(φ1) * Math.cos(φ2) * Math.sin(Δ_2 / 2) * Math.sin(Δ_2 / 2);
-  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-  const d = R * c;
-  return d;
-}
-function destinationFromOriginOnGreatCircle(startCoord, bearing, distance) {
-  const R = 6371000;
-  const φ1 = startCoord.latitude * Math.PI / 180;
-  const λ1 = startCoord.longitude * Math.PI / 180;
-  const θ = bearing * Math.PI / 180;
-  const d = distance / R;
-  const φ2 = Math.asin(Math.sin(φ1) * Math.cos(d) + Math.cos(φ1) * Math.sin(d) * Math.cos(θ));
-  const λ2 = λ1 + Math.atan2(Math.sin(θ) * Math.sin(d) * Math.cos(φ1), Math.cos(d) - Math.sin(φ1) * Math.sin(φ2));
-  return { latitude: φ2, longitude: λ2 };
-}
-// src/rhumbLine.ts
-function rhumbDistance(startCoord, endCoord) {
-  const R = 6371000;
-  const φ1 = startCoord.latitude * Math.PI / 180;
-  const φ2 = endCoord.latitude * Math.PI / 180;
-  const Δ_ = (endCoord.latitude - startCoord.latitude) * Math.PI / 180;
-  let Δ_2 = (endCoord.longitude - startCoord.longitude) * Math.PI / 180;
-  const Δ_3 = Math.log(Math.tan(Math.PI / 4 + φ2 / 2) / Math.tan(Math.PI / 4 + φ1 / 2));
-  const q = Math.abs(Δ_3) > 0.00000000001 ? Δ_ / Δ_3 : Math.cos(φ1);
-  if (Math.abs(Δ_2) > Math.PI)
-    Δ_2 = Δ_2 > 0 ? -(2 * Math.PI - Δ_2) : 2 * Math.PI + Δ_2;
-  const dist = Math.sqrt(Δ_ * Δ_ + q * q * Δ_2 * Δ_2) * R;
-  return dist;
-}
-function rhumbBearing(startCoord, endCoord) {
-  const φ1 = startCoord.latitude * Math.PI / 180;
-  const φ2 = endCoord.latitude * Math.PI / 180;
-  let Δ_ = (endCoord.longitude - startCoord.longitude) * Math.PI / 180;
-  const Δ_2 = Math.log(Math.tan(Math.PI / 4 + φ2 / 2) / Math.tan(Math.PI / 4 + φ1 / 2));
-  if (Math.abs(Δ_) > Math.PI)
-    Δ_ = Δ_ > 0 ? -(2 * Math.PI - Δ_) : 2 * Math.PI + Δ_;
-  const brng = Math.atan2(Δ_, Δ_2) * 180 / Math.PI;
-  return brng;
-}
-function destinationFromOriginOnRhumbLine(startCoord, bearing, distance) {
-  const R = 6371000;
-  const φ1 = startCoord.latitude * Math.PI / 180;
-  const λ1 = startCoord.longitude * Math.PI / 180;
-  const θ = bearing * Math.PI / 180;
-  const d = distance;
-  const δ = d / R;
-  const Δ_ = δ * Math.cos(θ);
-  let φ2 = φ1 + Δ_;
-  const Δ_2 = Math.log(Math.tan(φ2 / 2 + Math.PI / 4) / Math.tan(φ1 / 2 + Math.PI / 4));
-  const q = Math.abs(Δ_2) > 0.00000000001 ? Δ_ / Δ_2 : Math.cos(φ1);
-  const Δ_3 = δ * Math.sin(θ) / q;
-  const λ2 = λ1 + Δ_3;
-  if (Math.abs(φ2) > Math.PI / 2)
-    φ2 = φ2 > 0 ? Math.PI - φ2 : -Math.PI - φ2;
-  return { latitude: φ2, longitude: λ2 };
-}
-function midPointOnRhumbLine(startCoord, endCoord) {
-  let λ1 = startCoord.longitude * Math.PI / 180;
-  const λ2 = endCoord.longitude * Math.PI / 180;
-  const φ1 = startCoord.latitude * Math.PI / 180;
-  const φ2 = endCoord.latitude * Math.PI / 180;
-  if (Math.abs(λ2 - λ1) > Math.PI)
-    λ1 += 2 * Math.PI;
-  const φ3 = (φ1 + φ2) / 2;
-  const f1 = Math.tan(Math.PI / 4 + φ1 / 2);
-  const f2 = Math.tan(Math.PI / 4 + φ2 / 2);
-  const f3 = Math.tan(Math.PI / 4 + φ3 / 2);
-  let λ3 = ((λ2 - λ1) * Math.log(f3) + λ1 * Math.log(f2) - λ2 * Math.log(f1)) / Math.log(f2 / f1);
-  if (!isFinite(λ3))
-    λ3 = (λ1 + λ2) / 2;
-  return { latitude: φ3, longitude: λ3 };
-}
-export {
-  rhumbDistance,
-  rhumbBearing,
-  orthoProjection,
-  midPointOnRhumbLine,
-  midPointOnGreatCircle,
-  mercatorProjection,
-  inverseOrthoProjection,
-  inverseMercatorProjection,
-  intermediatePointOnGreatCircle,
-  initialBearingOfGreatCircle,
-  greatCircleDistance,
-  destinationFromOriginOnRhumbLine,
-  destinationFromOriginOnGreatCircle
-};
+function w(c,e=0){let p=c.latitude*Math.PI/180,l=c.longitude*Math.PI/180,m=6371000*D(l-e*Math.PI/180),i=6371000*Math.log(Math.tan(Math.PI/4+p/2));return{x:m,y:i}}function R(c,e=0){let p=c.x/6371000+e;return{latitude:(2*Math.atan(Math.exp(c.y/6371000))-Math.PI/2)*180/Math.PI,longitude:p*180/Math.PI}}function g(c,e){let p=c.latitude*Math.PI/180,l=c.longitude*Math.PI/180,m=6371000*Math.cos(p)*Math.sin(l-e.longitude*Math.PI/180),i=6371000*(Math.cos(e.latitude*Math.PI/180)*Math.sin(p)-Math.sin(e.latitude*Math.PI/180)*Math.cos(p)*Math.cos(l-e.longitude*Math.PI/180));return{clipped:Math.sin(e.latitude*Math.PI/180)*Math.sin(p)+Math.cos(e.latitude*Math.PI/180)*Math.cos(p)*Math.cos(l-e.longitude*Math.PI/180)<0,coord:{x:m,y:i}}}function E(c,e){let p=Math.sqrt(c.x*c.x+c.y*c.y),l=Math.asin(p/6371000),m=Math.asin(Math.cos(l)*Math.sin(e.latitude*Math.PI/180)+c.y*Math.sin(l)*Math.cos(e.latitude*Math.PI/180)/p)*180/Math.PI,i=e.longitude+Math.atan2(c.x*Math.sin(l),p*Math.cos(l)*Math.cos(e.latitude*Math.PI/180)-c.y*Math.sin(l)*Math.sin(e.latitude*Math.PI/180))*180/Math.PI;return{latitude:m,longitude:i}}function D(c){return c=c%(Math.PI*2),c=(c+3*Math.PI)%(2*Math.PI)-Math.PI,c}function B(c,e,b){let p=(e.latitude-c.latitude)*Math.PI/180,l=(e.longitude-c.longitude)*Math.PI/180,m=c.latitude*Math.PI/180,i=c.longitude*Math.PI/180,v=e.latitude*Math.PI/180,j=e.longitude*Math.PI/180,u=Math.sin(p/2)*Math.sin(p/2)+Math.cos(m)*Math.cos(v)*Math.sin(l/2)*Math.sin(l/2),k=2*Math.atan2(Math.sqrt(u),Math.sqrt(1-u)),h=Math.sin((1-b)*k)/Math.sin(k),f=Math.sin(b*k)/Math.sin(k),a=h*Math.cos(m)*Math.cos(i)+f*Math.cos(v)*Math.cos(j),O=h*Math.cos(m)*Math.sin(i)+f*Math.cos(v)*Math.sin(j),G=h*Math.sin(m)*f*Math.sin(v),M=Math.atan2(G,Math.sqrt(a*a+O*O)),F=Math.atan2(O,a);return{latitude:M,longitude:F}}function K(c,e){let b=c.latitude*Math.PI/180,p=e.latitude*Math.PI/180,l=c.longitude*Math.PI/180,m=e.longitude*Math.PI/180,i=Math.cos(p)*Math.cos(m-l),v=Math.cos(p)*Math.sin(m-l),j=Math.atan2(Math.sin(b)+Math.sin(p),Math.sqrt((Math.cos(b)+i)*(Math.cos(b)+i)+v*v)),u=l+Math.atan2(v,Math.cos(b)+i);return{latitude:j,longitude:u}}function N(c,e){let b=c.latitude*Math.PI/180,p=e.latitude*Math.PI/180,l=c.longitude*Math.PI/180,m=e.longitude*Math.PI/180,i=Math.sin(m-l)*Math.cos(p),v=Math.cos(b)*Math.sin(p)-Math.sin(b)*Math.cos(p)*Math.cos(m-l);return(Math.atan2(i,v)*180/Math.PI+360)%360}function S(c,e){let p=c.latitude*Math.PI/180,l=e.latitude*Math.PI/180,m=(e.latitude-c.latitude)*Math.PI/180,i=(e.longitude-c.longitude)*Math.PI/180,v=Math.sin(m/2)*Math.sin(m/2)+Math.cos(p)*Math.cos(l)*Math.sin(i/2)*Math.sin(i/2);return 6371000*(2*Math.atan2(Math.sqrt(v),Math.sqrt(1-v)))}function V(c,e,b){let l=c.latitude*Math.PI/180,m=c.longitude*Math.PI/180,i=e*Math.PI/180,v=b/6371000,j=Math.asin(Math.sin(l)*Math.cos(v)+Math.cos(l)*Math.sin(v)*Math.cos(i)),u=m+Math.atan2(Math.sin(i)*Math.sin(v)*Math.cos(l),Math.cos(v)-Math.sin(l)*Math.sin(j));return{latitude:j,longitude:u}}function H(c,e){let p=c.latitude*Math.PI/180,l=e.latitude*Math.PI/180,m=(e.latitude-c.latitude)*Math.PI/180,i=(e.longitude-c.longitude)*Math.PI/180,v=Math.log(Math.tan(Math.PI/4+l/2)/Math.tan(Math.PI/4+p/2)),j=Math.abs(v)>0.00000000001?m/v:Math.cos(p);if(Math.abs(i)>Math.PI)i=i>0?-(2*Math.PI-i):2*Math.PI+i;return Math.sqrt(m*m+j*j*i*i)*6371000}function J(c,e){let b=c.latitude*Math.PI/180,p=e.latitude*Math.PI/180,l=(e.longitude-c.longitude)*Math.PI/180,m=Math.log(Math.tan(Math.PI/4+p/2)/Math.tan(Math.PI/4+b/2));if(Math.abs(l)>Math.PI)l=l>0?-(2*Math.PI-l):2*Math.PI+l;return Math.atan2(l,m)*180/Math.PI}function L(c,e,b){let l=c.latitude*Math.PI/180,m=c.longitude*Math.PI/180,i=e*Math.PI/180,j=b/6371000,u=j*Math.cos(i),k=l+u,h=Math.log(Math.tan(k/2+Math.PI/4)/Math.tan(l/2+Math.PI/4)),f=Math.abs(h)>0.00000000001?u/h:Math.cos(l),a=j*Math.sin(i)/f,O=m+a;if(Math.abs(k)>Math.PI/2)k=k>0?Math.PI-k:-Math.PI-k;return{latitude:k,longitude:O}}function Q(c,e){let b=c.longitude*Math.PI/180,p=e.longitude*Math.PI/180,l=c.latitude*Math.PI/180,m=e.latitude*Math.PI/180;if(Math.abs(p-b)>Math.PI)b+=2*Math.PI;let i=(l+m)/2,v=Math.tan(Math.PI/4+l/2),j=Math.tan(Math.PI/4+m/2),u=Math.tan(Math.PI/4+i/2),k=((p-b)*Math.log(u)+b*Math.log(j)-p*Math.log(v))/Math.log(j/v);if(!isFinite(k))k=(b+p)/2;return{latitude:i,longitude:k}}export{H as rhumbDistance,J as rhumbBearing,g as orthoProjection,Q as midPointOnRhumbLine,K as midPointOnGreatCircle,w as mercatorProjection,E as inverseOrthoProjection,R as inverseMercatorProjection,B as intermediatePointOnGreatCircle,N as initialBearingOfGreatCircle,S as greatCircleDistance,L as destinationFromOriginOnRhumbLine,V as destinationFromOriginOnGreatCircle};
 
-//# debugId=7FC1B3305866843664756E2164756E21
+//# debugId=ADDDACDC1E32424A64756E2164756E21

package/index.js.map

@@ -2,11 +2,11 @@
   "version": 3,
   "sources": ["../src/projection.ts", "../src/greateCircle.ts", "../src/rhumbLine.ts"],
   "sourcesContent": [
-    "import { Point } from \"@ue-too/math\";\n\nexport type GeoCoord = {\n    longitude: number;\n    latitude: number;\n}\n\nexport function mercatorProjection(interestPoint: GeoCoord, centerLongitude: number = 0): Point{\n    const r = 6371000;\n    const latitude = interestPoint.latitude * Math.PI / 180;\n    const longitude = interestPoint.longitude * Math.PI / 180;\n    let x = r * normalizeAngleMinusPiToPi(longitude - centerLongitude * Math.PI / 180);\n    let y = r * Math.log(Math.tan(Math.PI / 4 + latitude / 2));\n    return {x: x, y: y};\n}\n\nexport function inverseMercatorProjection(point: Point, centerLongitude: number = 0): GeoCoord{\n    const r = 6371000;\n    const longitude = point.x / r + centerLongitude;\n    const latitude = 2 * Math.atan(Math.exp(point.y / r)) - Math.PI / 2;\n    return {latitude: latitude * 180 / Math.PI, longitude: longitude * 180 / Math.PI};\n}\n\nexport function orthoProjection(interestPoint: GeoCoord, origin: GeoCoord): {clipped: boolean, coord: Point}{\n    const r = 6371000;\n    const latitude = interestPoint.latitude * Math.PI / 180;\n    const longitude = interestPoint.longitude * Math.PI / 180;\n    const x = r * Math.cos(latitude) * Math.sin(longitude - origin.longitude * Math.PI / 180);\n    const y = r * (Math.cos(origin.latitude * Math.PI / 180) * Math.sin(latitude) - Math.sin(origin.latitude * Math.PI / 180) * Math.cos(latitude) * Math.cos(longitude - origin.longitude * Math.PI / 180));\n    const clipped = Math.sin(origin.latitude * Math.PI / 180) * Math.sin(latitude) + Math.cos(origin.latitude * Math.PI / 180) * Math.cos(latitude) * Math.cos(longitude - origin.longitude * Math.PI / 180);\n\n    return {clipped: clipped < 0, coord: {x: x, y: y}};\n}\n\nexport function inverseOrthoProjection(interestPoint: Point, origin: GeoCoord): GeoCoord {\n    const r = 6371000;\n    const rho = Math.sqrt(interestPoint.x * interestPoint.x + interestPoint.y * interestPoint.y);\n    const c = Math.asin(rho / r);\n    const latitude = Math.asin(Math.cos(c) * Math.sin(origin.latitude * Math.PI / 180) + (interestPoint.y * Math.sin(c) * Math.cos(origin.latitude * Math.PI / 180)) / rho) * 180 / Math.PI;\n    const longitude = origin.longitude + Math.atan2(interestPoint.x * Math.sin(c), rho * Math.cos(c)*Math.cos(origin.latitude * Math.PI / 180) - interestPoint.y * Math.sin(c) * Math.sin(origin.latitude * Math.PI / 180)) * 180 / Math.PI;\n    return {latitude: latitude, longitude: longitude};\n}\n\nfunction normalizeAngleMinusPiToPi(angle: number): number {\n    // Reduce the angle\n    angle = angle % (Math.PI * 2);\n\n    // Force it to be in the range -π to π\n    angle = (angle + 3 * Math.PI) % (2 * Math.PI) - Math.PI;\n\n    return angle;\n}\n",
-    "import { GeoCoord } from \"./projection\";\n\n/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */\n/* Geodesy representation conversion functions                        (c) Chris Veness 2002-2022  */\n/*                                                                                   MIT Licence  */\n/* www.movable-type.co.uk/scripts/latlong.html                                                    */\n/* www.movable-type.co.uk/scripts/js/geodesy/geodesy-library.html#dms                             */\n/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */\n\n\nexport function intermediatePointOnGreatCircle(startCoord: GeoCoord, endCoord: GeoCoord, fraction: number): GeoCoord{\n    const Δφ = (endCoord.latitude - startCoord.latitude) * Math.PI / 180;\n    const Δλ = (endCoord.longitude - startCoord.longitude) * Math.PI / 180;\n    const φ1 = startCoord.latitude * Math.PI / 180;\n    const λ1 = startCoord.longitude * Math.PI / 180;\n    const φ2 = endCoord.latitude * Math.PI / 180;\n    const λ2 = endCoord.longitude * Math.PI / 180;\n    const angularDistA = Math.sin(Δφ / 2) * Math.sin(Δφ / 2) +\n            Math.cos(φ1) * Math.cos(φ2) *\n            Math.sin(Δλ / 2) * Math.sin(Δλ / 2);\n    const c = 2 * Math.atan2(Math.sqrt(angularDistA), Math.sqrt(1 - angularDistA));\n \n    const a = Math.sin((1 - fraction) * c) / Math.sin(c);\n    const b = Math.sin(fraction * c) / Math.sin(c);\n    const x = a * Math.cos(φ1) * Math.cos(λ1) + b * Math.cos(φ2) * Math.cos(λ2);\n    const y = a * Math.cos(φ1) * Math.sin(λ1) + b * Math.cos(φ2) * Math.sin(λ2);\n    const z = a * Math.sin(φ1) * b * Math.sin(φ2);\n    const φi = Math.atan2(z, Math.sqrt(x * x + y * y));\n    const λi = Math.atan2(y, x);\n    return {latitude: φi, longitude: λi};\n}\n\nexport function midPointOnGreatCircle(startCoord: GeoCoord, endCoord: GeoCoord): GeoCoord{\n    const φ1 = startCoord.latitude * Math.PI / 180;\n    const φ2 = endCoord.latitude * Math.PI / 180;\n    const λ1 = startCoord.longitude * Math.PI / 180;\n    const λ2 = endCoord.longitude * Math.PI / 180;\n    const Bx = Math.cos(φ2) * Math.cos(λ2 - λ1);\n    const By = Math.cos(φ2) * Math.sin(λ2 - λ1);\n    const φ3 = Math.atan2(Math.sin(φ1) + Math.sin(φ2),\n                        Math.sqrt( (Math.cos(φ1) + Bx) * (Math.cos(φ1) + Bx) + By * By ) );\n    const λ3 = λ1 + Math.atan2(By, Math.cos(φ1) + Bx);\n    return {latitude: φ3, longitude: λ3};\n}\n\n/**\n * Calculate the initial bearing between two points on the Earth's surface. \n * (traveling along the great circle would result in different bearing from the start point to the end point)\n * \n * @param startCoord - The starting point in GeoCoord format.\n * @param endCoord - The ending point in GeoCoord format.\n * @returns The bearing in degrees.\n */\nexport function initialBearingOfGreatCircle(startCoord: GeoCoord, endCoord: GeoCoord): number{\n    const φ1 = startCoord.latitude * Math.PI / 180;\n    const φ2 = endCoord.latitude * Math.PI / 180;\n    const λ1 = startCoord.longitude * Math.PI / 180;\n    const λ2 = endCoord.longitude * Math.PI / 180;\n    const y = Math.sin(λ2-λ1) * Math.cos(φ2);\n    const x = Math.cos(φ1) * Math.sin(φ2) -\n            Math.sin(φ1) * Math.cos(φ2)*Math.cos(λ2 - λ1);\n    const θ = Math.atan2(y, x);\n    const brng = (θ * 180 / Math.PI + 360) % 360; // in degrees\n    return brng;\n}\n\nexport function greatCircleDistance(startCoord: GeoCoord, endCoord: GeoCoord): number{\n    const R = 6371e3; // metres\n    const φ1 = startCoord.latitude * Math.PI / 180; // φ, λ in radians\n    const φ2 = endCoord.latitude * Math.PI / 180;\n    const Δφ = (endCoord.latitude - startCoord.latitude) * Math.PI / 180;\n    const Δλ = (endCoord.longitude - startCoord.longitude) * Math.PI / 180;\n\n    const a = Math.sin(Δφ / 2) * Math.sin(Δφ / 2) +\n            Math.cos(φ1) * Math.cos(φ2) *\n            Math.sin(Δλ / 2) * Math.sin(Δλ / 2);\n    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));\n\n    const d = R * c; // in metres\n    return d;\n} \n\nexport function destinationFromOriginOnGreatCircle(startCoord: GeoCoord, bearing: number, distance: number): GeoCoord{\n    const R = 6371e3; // metres\n    const φ1 = startCoord.latitude * Math.PI / 180; // φ, λ in radians\n    const λ1 = startCoord.longitude * Math.PI / 180;\n    const θ = bearing * Math.PI / 180;\n    const d = distance / R; // angular distance in radians\n    const φ2 = Math.asin(Math.sin(φ1) * Math.cos(d) +\n                      Math.cos(φ1) * Math.sin(d) * Math.cos(θ) );\n    const λ2 = λ1 + Math.atan2(Math.sin(θ) * Math.sin(d) * Math.cos(φ1),\n                           Math.cos(d) - Math.sin(φ1) * Math.sin(φ2));\n    return {latitude: φ2, longitude: λ2};\n}\n",
-    "import { GeoCoord } from \"./projection\";\n\n/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */\n/* Geodesy representation conversion functions                        (c) Chris Veness 2002-2022  */\n/*                                                                                   MIT Licence  */\n/* www.movable-type.co.uk/scripts/latlong.html                                                    */\n/* www.movable-type.co.uk/scripts/js/geodesy/geodesy-library.html#dms                             */\n/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */\n\nexport function rhumbDistance(startCoord: GeoCoord, endCoord: GeoCoord): number{\n    const R = 6371e3; // metres\n    const φ1 = startCoord.latitude * Math.PI/180; // φ, λ in radians\n    const φ2 = endCoord.latitude * Math.PI/180;\n    const Δφ = (endCoord.latitude - startCoord.latitude) * Math.PI/180;\n    let Δλ = (endCoord.longitude - startCoord.longitude) * Math.PI/180;\n    const Δψ = Math.log(Math.tan(Math.PI / 4 + φ2 / 2)/Math.tan(Math.PI / 4 + φ1 / 2));\n    const q = Math.abs(Δψ) > 10e-12 ? Δφ / Δψ : Math.cos(φ1); // E-W course becomes ill-conditioned with 0/0\n\n    // if dLon over 180° take shorter rhumb line across the anti-meridian:\n    if (Math.abs(Δλ) > Math.PI) Δλ = Δλ > 0 ? - (2 * Math.PI - Δλ) : (2 * Math.PI + Δλ);\n\n    const dist = Math.sqrt(Δφ * Δφ + q * q * Δλ * Δλ) * R;\n    return dist;\n}\n\nexport function rhumbBearing(startCoord: GeoCoord, endCoord: GeoCoord): number{\n    const φ1 = startCoord.latitude * Math.PI / 180; // φ, λ in radians\n    const φ2 = endCoord.latitude * Math.PI / 180;\n    let Δλ = (endCoord.longitude - startCoord.longitude) * Math.PI / 180;\n    const Δψ = Math.log(Math.tan(Math.PI / 4 + φ2 / 2) / Math.tan(Math.PI / 4 + φ1 / 2));\n\n    // if dLon over 180° take shorter rhumb line across the anti-meridian:\n    if (Math.abs(Δλ) > Math.PI) Δλ = Δλ > 0 ? -(2 * Math.PI-Δλ) : (2 * Math.PI + Δλ);\n\n    const brng = Math.atan2(Δλ, Δψ) * 180 / Math.PI;\n    return brng;\n}\n\nexport function destinationFromOriginOnRhumbLine(startCoord: GeoCoord, bearing: number, distance: number): GeoCoord{\n    const R = 6371e3; // metres\n    const φ1 = startCoord.latitude * Math.PI / 180; // φ, λ in radians\n    const λ1 = startCoord.longitude * Math.PI / 180;\n    const θ = bearing * Math.PI / 180;\n    const d = distance;\n    const δ = d / R;\n    const Δφ = δ * Math.cos(θ);\n    let φ2 = φ1 + Δφ;\n\n    const Δψ = Math.log(Math.tan(φ2 / 2 + Math.PI / 4) / Math.tan(φ1 / 2 + Math.PI / 4));\n    const q = Math.abs(Δψ) > 10e-12 ? Δφ / Δψ : Math.cos(φ1); // E-W course becomes ill-conditioned with 0/0\n\n    const Δλ = δ * Math.sin(θ) / q;\n    const λ2 = λ1 + Δλ;\n\n    // check for some daft bugger going past the pole, normalise latitude if so\n    if (Math.abs(φ2) > Math.PI / 2) φ2 = φ2 > 0 ? Math.PI - φ2 : -Math.PI - φ2;\n    return {latitude: φ2, longitude: λ2};\n}\n\nexport function midPointOnRhumbLine(startCoord: GeoCoord, endCoord: GeoCoord): GeoCoord{\n    let λ1 = startCoord.longitude * Math.PI / 180;  \n    const λ2 = endCoord.longitude * Math.PI / 180;\n    const φ1 = startCoord.latitude * Math.PI / 180;\n    const φ2 = endCoord.latitude * Math.PI / 180; \n    if (Math.abs(λ2 - λ1) > Math.PI) λ1 += 2 * Math.PI; // crossing anti-meridian\n\n    const φ3 = (φ1 + φ2) / 2;\n    const f1 = Math.tan(Math.PI / 4 + φ1 / 2);\n    const f2 = Math.tan(Math.PI / 4 + φ2 / 2);\n    const f3 = Math.tan(Math.PI / 4 + φ3 / 2);\n    let λ3 = ( (λ2 - λ1) * Math.log(f3) + λ1 * Math.log(f2) - λ2 * Math.log(f1) ) / Math.log(f2 / f1);\n\n    if (!isFinite(λ3)) λ3 = (λ1 + λ2) / 2; // parallel of latitude\n    return {latitude: φ3, longitude: λ3};\n}\n"
+    "import { Point } from \"@ue-too/math\";\n\n/**\n * Geographic coordinate representing a location on Earth's surface.\n *\n * @remarks\n * Coordinates use the WGS84 standard:\n * - Latitude: -90 to 90 degrees (negative = south, positive = north)\n * - Longitude: -180 to 180 degrees (negative = west, positive = east)\n *\n * @category Types\n */\nexport type GeoCoord = {\n    /** Longitude in degrees (-180 to 180) */\n    longitude: number;\n    /** Latitude in degrees (-90 to 90) */\n    latitude: number;\n}\n\n/**\n * Projects a geographic coordinate to Mercator projection.\n *\n * @remarks\n * The Mercator projection is a cylindrical map projection that preserves angles\n * and shapes locally. It's widely used for navigation because straight lines on\n * the map represent constant bearings (rhumb lines).\n *\n * The projection uses Earth's mean radius of 6,371,000 meters.\n *\n * Note: The Mercator projection becomes increasingly distorted near the poles.\n *\n * @param interestPoint - The geographic coordinate to project\n * @param centerLongitude - The central meridian in degrees (default: 0)\n * @returns The projected point in meters from the central meridian\n *\n * @example\n * ```typescript\n * const coord = { latitude: 51.5074, longitude: -0.1278 }; // London\n * const point = mercatorProjection(coord);\n * console.log(point); // { x: -14232.4, y: 6711665.7 }\n *\n * // With custom center longitude\n * const pointCentered = mercatorProjection(coord, -0.1278);\n * console.log(pointCentered.x); // Close to 0\n * ```\n *\n * @category Projections\n */\nexport function mercatorProjection(interestPoint: GeoCoord, centerLongitude: number = 0): Point{\n    const r = 6371000;\n    const latitude = interestPoint.latitude * Math.PI / 180;\n    const longitude = interestPoint.longitude * Math.PI / 180;\n    let x = r * normalizeAngleMinusPiToPi(longitude - centerLongitude * Math.PI / 180);\n    let y = r * Math.log(Math.tan(Math.PI / 4 + latitude / 2));\n    return {x: x, y: y};\n}\n\n/**\n * Converts a Mercator projection point back to geographic coordinates.\n *\n * @remarks\n * This is the inverse of {@link mercatorProjection}. Given a point in Mercator\n * projection space (in meters), it returns the corresponding latitude/longitude.\n *\n * @param point - The point in Mercator projection (in meters)\n * @param centerLongitude - The central meridian in degrees (must match the forward projection)\n * @returns The geographic coordinate\n *\n * @example\n * ```typescript\n * const point = { x: -14232.4, y: 6711665.7 };\n * const coord = inverseMercatorProjection(point);\n * console.log(coord); // { latitude: ~51.5, longitude: ~-0.13 }\n * ```\n *\n * @category Projections\n */\nexport function inverseMercatorProjection(point: Point, centerLongitude: number = 0): GeoCoord{\n    const r = 6371000;\n    const longitude = point.x / r + centerLongitude;\n    const latitude = 2 * Math.atan(Math.exp(point.y / r)) - Math.PI / 2;\n    return {latitude: latitude * 180 / Math.PI, longitude: longitude * 180 / Math.PI};\n}\n\n/**\n * Projects a geographic coordinate to orthographic projection.\n *\n * @remarks\n * The orthographic projection shows Earth as it would appear from space,\n * displaying one hemisphere at a time. It's useful for globe-like visualizations.\n *\n * Points on the back hemisphere (not visible from the origin viewpoint) are\n * marked as clipped.\n *\n * The projection uses Earth's mean radius of 6,371,000 meters.\n *\n * @param interestPoint - The geographic coordinate to project\n * @param origin - The center point of the hemisphere to view\n * @returns Object with clipped flag and projected coordinate\n *\n * @example\n * ```typescript\n * const origin = { latitude: 45.0, longitude: 0.0 }; // View centered on France\n * const coord = { latitude: 51.5, longitude: -0.1 }; // London\n *\n * const result = orthoProjection(coord, origin);\n * if (!result.clipped) {\n *   console.log('London is visible at:', result.coord);\n * } else {\n *   console.log('London is on the back of the globe');\n * }\n * ```\n *\n * @category Projections\n */\nexport function orthoProjection(interestPoint: GeoCoord, origin: GeoCoord): {clipped: boolean, coord: Point}{\n    const r = 6371000;\n    const latitude = interestPoint.latitude * Math.PI / 180;\n    const longitude = interestPoint.longitude * Math.PI / 180;\n    const x = r * Math.cos(latitude) * Math.sin(longitude - origin.longitude * Math.PI / 180);\n    const y = r * (Math.cos(origin.latitude * Math.PI / 180) * Math.sin(latitude) - Math.sin(origin.latitude * Math.PI / 180) * Math.cos(latitude) * Math.cos(longitude - origin.longitude * Math.PI / 180));\n    const clipped = Math.sin(origin.latitude * Math.PI / 180) * Math.sin(latitude) + Math.cos(origin.latitude * Math.PI / 180) * Math.cos(latitude) * Math.cos(longitude - origin.longitude * Math.PI / 180);\n\n    return {clipped: clipped < 0, coord: {x: x, y: y}};\n}\n\n/**\n * Converts an orthographic projection point back to geographic coordinates.\n *\n * @remarks\n * This is the inverse of {@link orthoProjection}. Given a point in orthographic\n * projection space (in meters), it returns the corresponding latitude/longitude.\n *\n * @param interestPoint - The point in orthographic projection (in meters)\n * @param origin - The center point of the hemisphere (must match the forward projection)\n * @returns The geographic coordinate\n *\n * @example\n * ```typescript\n * const origin = { latitude: 45.0, longitude: 0.0 };\n * const point = { x: 100000, y: 200000 }; // Some point in projection space\n * const coord = inverseOrthoProjection(point, origin);\n * console.log(coord); // { latitude: ..., longitude: ... }\n * ```\n *\n * @category Projections\n */\nexport function inverseOrthoProjection(interestPoint: Point, origin: GeoCoord): GeoCoord {\n    const r = 6371000;\n    const rho = Math.sqrt(interestPoint.x * interestPoint.x + interestPoint.y * interestPoint.y);\n    const c = Math.asin(rho / r);\n    const latitude = Math.asin(Math.cos(c) * Math.sin(origin.latitude * Math.PI / 180) + (interestPoint.y * Math.sin(c) * Math.cos(origin.latitude * Math.PI / 180)) / rho) * 180 / Math.PI;\n    const longitude = origin.longitude + Math.atan2(interestPoint.x * Math.sin(c), rho * Math.cos(c)*Math.cos(origin.latitude * Math.PI / 180) - interestPoint.y * Math.sin(c) * Math.sin(origin.latitude * Math.PI / 180)) * 180 / Math.PI;\n    return {latitude: latitude, longitude: longitude};\n}\n\nfunction normalizeAngleMinusPiToPi(angle: number): number {\n    // Reduce the angle\n    angle = angle % (Math.PI * 2);\n\n    // Force it to be in the range -π to π\n    angle = (angle + 3 * Math.PI) % (2 * Math.PI) - Math.PI;\n\n    return angle;\n}\n",
+    "import { GeoCoord } from \"./projection\";\n\n/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */\n/* Geodesy representation conversion functions                        (c) Chris Veness 2002-2022  */\n/*                                                                                   MIT Licence  */\n/* www.movable-type.co.uk/scripts/latlong.html                                                    */\n/* www.movable-type.co.uk/scripts/js/geodesy/geodesy-library.html#dms                             */\n/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */\n\n\n/**\n * Calculates an intermediate point along a great circle path.\n *\n * @remarks\n * Given two points on Earth's surface, this finds a point at a specified\n * fraction along the great circle (shortest) path between them.\n *\n * Uses the spherical interpolation formula for accurate results on a sphere.\n *\n * @param startCoord - The starting geographic coordinate\n * @param endCoord - The ending geographic coordinate\n * @param fraction - The fraction along the path (0 = start, 1 = end, 0.5 = midpoint)\n * @returns The intermediate point at the specified fraction\n *\n * @example\n * ```typescript\n * const nyc = { latitude: 40.7128, longitude: -74.0060 };\n * const london = { latitude: 51.5074, longitude: -0.1278 };\n *\n * // Find point 25% of the way from NYC to London\n * const quarter = intermediatePointOnGreatCircle(nyc, london, 0.25);\n *\n * // Find point 75% of the way\n * const threeQuarters = intermediatePointOnGreatCircle(nyc, london, 0.75);\n * ```\n *\n * @category Great Circle\n */\nexport function intermediatePointOnGreatCircle(startCoord: GeoCoord, endCoord: GeoCoord, fraction: number): GeoCoord{\n    const Δφ = (endCoord.latitude - startCoord.latitude) * Math.PI / 180;\n    const Δλ = (endCoord.longitude - startCoord.longitude) * Math.PI / 180;\n    const φ1 = startCoord.latitude * Math.PI / 180;\n    const λ1 = startCoord.longitude * Math.PI / 180;\n    const φ2 = endCoord.latitude * Math.PI / 180;\n    const λ2 = endCoord.longitude * Math.PI / 180;\n    const angularDistA = Math.sin(Δφ / 2) * Math.sin(Δφ / 2) +\n            Math.cos(φ1) * Math.cos(φ2) *\n            Math.sin(Δλ / 2) * Math.sin(Δλ / 2);\n    const c = 2 * Math.atan2(Math.sqrt(angularDistA), Math.sqrt(1 - angularDistA));\n \n    const a = Math.sin((1 - fraction) * c) / Math.sin(c);\n    const b = Math.sin(fraction * c) / Math.sin(c);\n    const x = a * Math.cos(φ1) * Math.cos(λ1) + b * Math.cos(φ2) * Math.cos(λ2);\n    const y = a * Math.cos(φ1) * Math.sin(λ1) + b * Math.cos(φ2) * Math.sin(λ2);\n    const z = a * Math.sin(φ1) * b * Math.sin(φ2);\n    const φi = Math.atan2(z, Math.sqrt(x * x + y * y));\n    const λi = Math.atan2(y, x);\n    return {latitude: φi, longitude: λi};\n}\n\n/**\n * Calculates the midpoint along a great circle path.\n *\n * @remarks\n * This is a specialized, optimized version of {@link intermediatePointOnGreatCircle}\n * for finding the exact midpoint (fraction = 0.5).\n *\n * @param startCoord - The starting geographic coordinate\n * @param endCoord - The ending geographic coordinate\n * @returns The midpoint on the great circle path\n *\n * @example\n * ```typescript\n * const start = { latitude: 50.0, longitude: -5.0 };\n * const end = { latitude: 58.0, longitude: 3.0 };\n * const mid = midPointOnGreatCircle(start, end);\n * console.log('Midpoint:', mid);\n * ```\n *\n * @category Great Circle\n */\nexport function midPointOnGreatCircle(startCoord: GeoCoord, endCoord: GeoCoord): GeoCoord{\n    const φ1 = startCoord.latitude * Math.PI / 180;\n    const φ2 = endCoord.latitude * Math.PI / 180;\n    const λ1 = startCoord.longitude * Math.PI / 180;\n    const λ2 = endCoord.longitude * Math.PI / 180;\n    const Bx = Math.cos(φ2) * Math.cos(λ2 - λ1);\n    const By = Math.cos(φ2) * Math.sin(λ2 - λ1);\n    const φ3 = Math.atan2(Math.sin(φ1) + Math.sin(φ2),\n                        Math.sqrt( (Math.cos(φ1) + Bx) * (Math.cos(φ1) + Bx) + By * By ) );\n    const λ3 = λ1 + Math.atan2(By, Math.cos(φ1) + Bx);\n    return {latitude: φ3, longitude: λ3};\n}\n\n/**\n * Calculate the initial bearing between two points on the Earth's surface. \n * (traveling along the great circle would result in different bearing from the start point to the end point)\n * \n * @param startCoord - The starting point in GeoCoord format.\n * @param endCoord - The ending point in GeoCoord format.\n * @returns The bearing in degrees.\n */\nexport function initialBearingOfGreatCircle(startCoord: GeoCoord, endCoord: GeoCoord): number{\n    const φ1 = startCoord.latitude * Math.PI / 180;\n    const φ2 = endCoord.latitude * Math.PI / 180;\n    const λ1 = startCoord.longitude * Math.PI / 180;\n    const λ2 = endCoord.longitude * Math.PI / 180;\n    const y = Math.sin(λ2-λ1) * Math.cos(φ2);\n    const x = Math.cos(φ1) * Math.sin(φ2) -\n            Math.sin(φ1) * Math.cos(φ2)*Math.cos(λ2 - λ1);\n    const θ = Math.atan2(y, x);\n    const brng = (θ * 180 / Math.PI + 360) % 360; // in degrees\n    return brng;\n}\n\n/**\n * Calculates the great circle distance between two points on Earth.\n *\n * @remarks\n * Uses the haversine formula to calculate the shortest distance over Earth's\n * surface between two geographic coordinates. This is the \"as-the-crow-flies\"\n * distance.\n *\n * The calculation assumes Earth's mean radius of 6,371,000 meters and treats\n * Earth as a perfect sphere.\n *\n * @param startCoord - The starting geographic coordinate\n * @param endCoord - The ending geographic coordinate\n * @returns The distance in meters\n *\n * @example\n * ```typescript\n * const nyc = { latitude: 40.7128, longitude: -74.0060 };\n * const london = { latitude: 51.5074, longitude: -0.1278 };\n *\n * const distance = greatCircleDistance(nyc, london);\n * console.log('Distance:', distance / 1000, 'km'); // ~5570 km\n * ```\n *\n * @category Great Circle\n */\nexport function greatCircleDistance(startCoord: GeoCoord, endCoord: GeoCoord): number{\n    const R = 6371e3; // metres\n    const φ1 = startCoord.latitude * Math.PI / 180; // φ, λ in radians\n    const φ2 = endCoord.latitude * Math.PI / 180;\n    const Δφ = (endCoord.latitude - startCoord.latitude) * Math.PI / 180;\n    const Δλ = (endCoord.longitude - startCoord.longitude) * Math.PI / 180;\n\n    const a = Math.sin(Δφ / 2) * Math.sin(Δφ / 2) +\n            Math.cos(φ1) * Math.cos(φ2) *\n            Math.sin(Δλ / 2) * Math.sin(Δλ / 2);\n    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));\n\n    const d = R * c; // in metres\n    return d;\n} \n\n/**\n * Calculates the destination point given a start point, bearing, and distance on a great circle.\n *\n * @remarks\n * Starting from a given point and traveling along a great circle at a specific\n * initial bearing for a given distance, this calculates where you'll end up.\n *\n * Note: The bearing will change along the path (except when traveling due north/south\n * or along the equator) because great circles are not straight lines on most map projections.\n *\n * @param startCoord - The starting geographic coordinate\n * @param bearing - The initial bearing in degrees (0 = north, 90 = east, etc.)\n * @param distance - The distance to travel in meters\n * @returns The destination coordinate\n *\n * @example\n * ```typescript\n * const start = { latitude: 40.7128, longitude: -74.0060 }; // NYC\n *\n * // Travel 1000km northeast from NYC\n * const destination = destinationFromOriginOnGreatCircle(start, 45, 1000000);\n * console.log('Destination:', destination);\n * ```\n *\n * @category Great Circle\n */\nexport function destinationFromOriginOnGreatCircle(startCoord: GeoCoord, bearing: number, distance: number): GeoCoord{\n    const R = 6371e3; // metres\n    const φ1 = startCoord.latitude * Math.PI / 180; // φ, λ in radians\n    const λ1 = startCoord.longitude * Math.PI / 180;\n    const θ = bearing * Math.PI / 180;\n    const d = distance / R; // angular distance in radians\n    const φ2 = Math.asin(Math.sin(φ1) * Math.cos(d) +\n                      Math.cos(φ1) * Math.sin(d) * Math.cos(θ) );\n    const λ2 = λ1 + Math.atan2(Math.sin(θ) * Math.sin(d) * Math.cos(φ1),\n                           Math.cos(d) - Math.sin(φ1) * Math.sin(φ2));\n    return {latitude: φ2, longitude: λ2};\n}\n",
+    "import { GeoCoord } from \"./projection\";\n\n/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */\n/* Geodesy representation conversion functions                        (c) Chris Veness 2002-2022  */\n/*                                                                                   MIT Licence  */\n/* www.movable-type.co.uk/scripts/latlong.html                                                    */\n/* www.movable-type.co.uk/scripts/js/geodesy/geodesy-library.html#dms                             */\n/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */\n\n/**\n * Calculates the distance along a rhumb line between two points.\n *\n * @remarks\n * A rhumb line (also called loxodrome) is a path of constant bearing. Unlike great\n * circles, rhumb lines appear as straight lines on Mercator projections, making them\n * easier for navigation.\n *\n * Rhumb lines are generally slightly longer than great circle routes, except when\n * traveling due east/west along the equator or due north/south.\n *\n * Uses Earth's mean radius of 6,371,000 meters.\n *\n * @param startCoord - The starting geographic coordinate\n * @param endCoord - The ending geographic coordinate\n * @returns The distance in meters along the rhumb line\n *\n * @example\n * ```typescript\n * const start = { latitude: 50.0, longitude: -5.0 };\n * const end = { latitude: 58.0, longitude: 3.0 };\n *\n * const distance = rhumbDistance(start, end);\n * console.log('Rhumb distance:', distance / 1000, 'km');\n *\n * // Compare with great circle distance\n * const gcDistance = greatCircleDistance(start, end);\n * console.log('Great circle is', (distance - gcDistance) / 1000, 'km shorter');\n * ```\n *\n * @category Rhumb Line\n */\nexport function rhumbDistance(startCoord: GeoCoord, endCoord: GeoCoord): number{\n    const R = 6371e3; // metres\n    const φ1 = startCoord.latitude * Math.PI/180; // φ, λ in radians\n    const φ2 = endCoord.latitude * Math.PI/180;\n    const Δφ = (endCoord.latitude - startCoord.latitude) * Math.PI/180;\n    let Δλ = (endCoord.longitude - startCoord.longitude) * Math.PI/180;\n    const Δψ = Math.log(Math.tan(Math.PI / 4 + φ2 / 2)/Math.tan(Math.PI / 4 + φ1 / 2));\n    const q = Math.abs(Δψ) > 10e-12 ? Δφ / Δψ : Math.cos(φ1); // E-W course becomes ill-conditioned with 0/0\n\n    // if dLon over 180° take shorter rhumb line across the anti-meridian:\n    if (Math.abs(Δλ) > Math.PI) Δλ = Δλ > 0 ? - (2 * Math.PI - Δλ) : (2 * Math.PI + Δλ);\n\n    const dist = Math.sqrt(Δφ * Δφ + q * q * Δλ * Δλ) * R;\n    return dist;\n}\n\n/**\n * Calculates the constant bearing along a rhumb line.\n *\n * @remarks\n * Unlike great circles where the bearing changes along the path, rhumb lines\n * maintain a constant bearing. This makes them simpler for navigation - you can\n * follow a single compass direction.\n *\n * @param startCoord - The starting geographic coordinate\n * @param endCoord - The ending geographic coordinate\n * @returns The constant bearing in degrees (0-360)\n *\n * @example\n * ```typescript\n * const start = { latitude: 50.0, longitude: -5.0 };\n * const end = { latitude: 58.0, longitude: 3.0 };\n *\n * const bearing = rhumbBearing(start, end);\n * console.log('Constant bearing:', bearing, 'degrees');\n *\n * // This bearing stays constant along the entire path\n * ```\n *\n * @category Rhumb Line\n */\nexport function rhumbBearing(startCoord: GeoCoord, endCoord: GeoCoord): number{\n    const φ1 = startCoord.latitude * Math.PI / 180; // φ, λ in radians\n    const φ2 = endCoord.latitude * Math.PI / 180;\n    let Δλ = (endCoord.longitude - startCoord.longitude) * Math.PI / 180;\n    const Δψ = Math.log(Math.tan(Math.PI / 4 + φ2 / 2) / Math.tan(Math.PI / 4 + φ1 / 2));\n\n    // if dLon over 180° take shorter rhumb line across the anti-meridian:\n    if (Math.abs(Δλ) > Math.PI) Δλ = Δλ > 0 ? -(2 * Math.PI-Δλ) : (2 * Math.PI + Δλ);\n\n    const brng = Math.atan2(Δλ, Δψ) * 180 / Math.PI;\n    return brng;\n}\n\n/**\n * Calculates the destination point given a start point, constant bearing, and distance on a rhumb line.\n *\n * @remarks\n * Starting from a given point and traveling at a constant bearing for a given\n * distance, this calculates where you'll end up. The bearing remains constant\n * throughout the journey.\n *\n * This is the rhumb line equivalent of {@link destinationFromOriginOnGreatCircle}.\n *\n * @param startCoord - The starting geographic coordinate\n * @param bearing - The constant bearing in degrees (0 = north, 90 = east, etc.)\n * @param distance - The distance to travel in meters\n * @returns The destination coordinate\n *\n * @example\n * ```typescript\n * const start = { latitude: 40.0, longitude: -74.0 };\n *\n * // Travel 500km on constant bearing of 45 degrees (northeast)\n * const destination = destinationFromOriginOnRhumbLine(start, 45, 500000);\n * console.log('Destination:', destination);\n * ```\n *\n * @category Rhumb Line\n */\nexport function destinationFromOriginOnRhumbLine(startCoord: GeoCoord, bearing: number, distance: number): GeoCoord{\n    const R = 6371e3; // metres\n    const φ1 = startCoord.latitude * Math.PI / 180; // φ, λ in radians\n    const λ1 = startCoord.longitude * Math.PI / 180;\n    const θ = bearing * Math.PI / 180;\n    const d = distance;\n    const δ = d / R;\n    const Δφ = δ * Math.cos(θ);\n    let φ2 = φ1 + Δφ;\n\n    const Δψ = Math.log(Math.tan(φ2 / 2 + Math.PI / 4) / Math.tan(φ1 / 2 + Math.PI / 4));\n    const q = Math.abs(Δψ) > 10e-12 ? Δφ / Δψ : Math.cos(φ1); // E-W course becomes ill-conditioned with 0/0\n\n    const Δλ = δ * Math.sin(θ) / q;\n    const λ2 = λ1 + Δλ;\n\n    // check for some daft bugger going past the pole, normalise latitude if so\n    if (Math.abs(φ2) > Math.PI / 2) φ2 = φ2 > 0 ? Math.PI - φ2 : -Math.PI - φ2;\n    return {latitude: φ2, longitude: λ2};\n}\n\n/**\n * Calculates the midpoint along a rhumb line.\n *\n * @remarks\n * Finds the point exactly halfway along a rhumb line path between two points.\n *\n * @param startCoord - The starting geographic coordinate\n * @param endCoord - The ending geographic coordinate\n * @returns The midpoint on the rhumb line path\n *\n * @example\n * ```typescript\n * const start = { latitude: 50.0, longitude: -5.0 };\n * const end = { latitude: 58.0, longitude: 3.0 };\n *\n * const mid = midPointOnRhumbLine(start, end);\n * console.log('Midpoint:', mid);\n * ```\n *\n * @category Rhumb Line\n */\nexport function midPointOnRhumbLine(startCoord: GeoCoord, endCoord: GeoCoord): GeoCoord{\n    let λ1 = startCoord.longitude * Math.PI / 180;  \n    const λ2 = endCoord.longitude * Math.PI / 180;\n    const φ1 = startCoord.latitude * Math.PI / 180;\n    const φ2 = endCoord.latitude * Math.PI / 180; \n    if (Math.abs(λ2 - λ1) > Math.PI) λ1 += 2 * Math.PI; // crossing anti-meridian\n\n    const φ3 = (φ1 + φ2) / 2;\n    const f1 = Math.tan(Math.PI / 4 + φ1 / 2);\n    const f2 = Math.tan(Math.PI / 4 + φ2 / 2);\n    const f3 = Math.tan(Math.PI / 4 + φ3 / 2);\n    let λ3 = ( (λ2 - λ1) * Math.log(f3) + λ1 * Math.log(f2) - λ2 * Math.log(f1) ) / Math.log(f2 / f1);\n\n    if (!isFinite(λ3)) λ3 = (λ1 + λ2) / 2; // parallel of latitude\n    return {latitude: φ3, longitude: λ3};\n}\n"
   ],
-  "mappings": "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",
-  "debugId": "7FC1B3305866843664756E2164756E21",
+  "mappings": "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",
+  "debugId": "ADDDACDC1E32424A64756E2164756E21",
   "names": []
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ue-too/border",
   "type": "module",
-  "version": "0.9.4",
+  "version": "0.10.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/ue-too/ue-too.git"
@@ -20,7 +20,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@ue-too/math": "^0.9.4"
+    "@ue-too/math": "^0.10.0"
   },
   "main": "./index.js",
   "types": "./index.d.ts",

package/projection.d.ts

@@ -1,12 +1,125 @@
 import { Point } from "@ue-too/math";
+/**
+ * Geographic coordinate representing a location on Earth's surface.
+ *
+ * @remarks
+ * Coordinates use the WGS84 standard:
+ * - Latitude: -90 to 90 degrees (negative = south, positive = north)
+ * - Longitude: -180 to 180 degrees (negative = west, positive = east)
+ *
+ * @category Types
+ */
 export type GeoCoord = {
+    /** Longitude in degrees (-180 to 180) */
     longitude: number;
+    /** Latitude in degrees (-90 to 90) */
     latitude: number;
 };
+/**
+ * Projects a geographic coordinate to Mercator projection.
+ *
+ * @remarks
+ * The Mercator projection is a cylindrical map projection that preserves angles
+ * and shapes locally. It's widely used for navigation because straight lines on
+ * the map represent constant bearings (rhumb lines).
+ *
+ * The projection uses Earth's mean radius of 6,371,000 meters.
+ *
+ * Note: The Mercator projection becomes increasingly distorted near the poles.
+ *
+ * @param interestPoint - The geographic coordinate to project
+ * @param centerLongitude - The central meridian in degrees (default: 0)
+ * @returns The projected point in meters from the central meridian
+ *
+ * @example
+ * ```typescript
+ * const coord = { latitude: 51.5074, longitude: -0.1278 }; // London
+ * const point = mercatorProjection(coord);
+ * console.log(point); // { x: -14232.4, y: 6711665.7 }
+ *
+ * // With custom center longitude
+ * const pointCentered = mercatorProjection(coord, -0.1278);
+ * console.log(pointCentered.x); // Close to 0
+ * ```
+ *
+ * @category Projections
+ */
 export declare function mercatorProjection(interestPoint: GeoCoord, centerLongitude?: number): Point;
+/**
+ * Converts a Mercator projection point back to geographic coordinates.
+ *
+ * @remarks
+ * This is the inverse of {@link mercatorProjection}. Given a point in Mercator
+ * projection space (in meters), it returns the corresponding latitude/longitude.
+ *
+ * @param point - The point in Mercator projection (in meters)
+ * @param centerLongitude - The central meridian in degrees (must match the forward projection)
+ * @returns The geographic coordinate
+ *
+ * @example
+ * ```typescript
+ * const point = { x: -14232.4, y: 6711665.7 };
+ * const coord = inverseMercatorProjection(point);
+ * console.log(coord); // { latitude: ~51.5, longitude: ~-0.13 }
+ * ```
+ *
+ * @category Projections
+ */
 export declare function inverseMercatorProjection(point: Point, centerLongitude?: number): GeoCoord;
+/**
+ * Projects a geographic coordinate to orthographic projection.
+ *
+ * @remarks
+ * The orthographic projection shows Earth as it would appear from space,
+ * displaying one hemisphere at a time. It's useful for globe-like visualizations.
+ *
+ * Points on the back hemisphere (not visible from the origin viewpoint) are
+ * marked as clipped.
+ *
+ * The projection uses Earth's mean radius of 6,371,000 meters.
+ *
+ * @param interestPoint - The geographic coordinate to project
+ * @param origin - The center point of the hemisphere to view
+ * @returns Object with clipped flag and projected coordinate
+ *
+ * @example
+ * ```typescript
+ * const origin = { latitude: 45.0, longitude: 0.0 }; // View centered on France
+ * const coord = { latitude: 51.5, longitude: -0.1 }; // London
+ *
+ * const result = orthoProjection(coord, origin);
+ * if (!result.clipped) {
+ *   console.log('London is visible at:', result.coord);
+ * } else {
+ *   console.log('London is on the back of the globe');
+ * }
+ * ```
+ *
+ * @category Projections
+ */
 export declare function orthoProjection(interestPoint: GeoCoord, origin: GeoCoord): {
     clipped: boolean;
     coord: Point;
 };
+/**
+ * Converts an orthographic projection point back to geographic coordinates.
+ *
+ * @remarks
+ * This is the inverse of {@link orthoProjection}. Given a point in orthographic
+ * projection space (in meters), it returns the corresponding latitude/longitude.
+ *
+ * @param interestPoint - The point in orthographic projection (in meters)
+ * @param origin - The center point of the hemisphere (must match the forward projection)
+ * @returns The geographic coordinate
+ *
+ * @example
+ * ```typescript
+ * const origin = { latitude: 45.0, longitude: 0.0 };
+ * const point = { x: 100000, y: 200000 }; // Some point in projection space
+ * const coord = inverseOrthoProjection(point, origin);
+ * console.log(coord); // { latitude: ..., longitude: ... }
+ * ```
+ *
+ * @category Projections
+ */
 export declare function inverseOrthoProjection(interestPoint: Point, origin: GeoCoord): GeoCoord;

package/rhumbLine.d.ts

@@ -1,5 +1,109 @@
 import { GeoCoord } from "./projection";
+/**
+ * Calculates the distance along a rhumb line between two points.
+ *
+ * @remarks
+ * A rhumb line (also called loxodrome) is a path of constant bearing. Unlike great
+ * circles, rhumb lines appear as straight lines on Mercator projections, making them
+ * easier for navigation.
+ *
+ * Rhumb lines are generally slightly longer than great circle routes, except when
+ * traveling due east/west along the equator or due north/south.
+ *
+ * Uses Earth's mean radius of 6,371,000 meters.
+ *
+ * @param startCoord - The starting geographic coordinate
+ * @param endCoord - The ending geographic coordinate
+ * @returns The distance in meters along the rhumb line
+ *
+ * @example
+ * ```typescript
+ * const start = { latitude: 50.0, longitude: -5.0 };
+ * const end = { latitude: 58.0, longitude: 3.0 };
+ *
+ * const distance = rhumbDistance(start, end);
+ * console.log('Rhumb distance:', distance / 1000, 'km');
+ *
+ * // Compare with great circle distance
+ * const gcDistance = greatCircleDistance(start, end);
+ * console.log('Great circle is', (distance - gcDistance) / 1000, 'km shorter');
+ * ```
+ *
+ * @category Rhumb Line
+ */
 export declare function rhumbDistance(startCoord: GeoCoord, endCoord: GeoCoord): number;
+/**
+ * Calculates the constant bearing along a rhumb line.
+ *
+ * @remarks
+ * Unlike great circles where the bearing changes along the path, rhumb lines
+ * maintain a constant bearing. This makes them simpler for navigation - you can
+ * follow a single compass direction.
+ *
+ * @param startCoord - The starting geographic coordinate
+ * @param endCoord - The ending geographic coordinate
+ * @returns The constant bearing in degrees (0-360)
+ *
+ * @example
+ * ```typescript
+ * const start = { latitude: 50.0, longitude: -5.0 };
+ * const end = { latitude: 58.0, longitude: 3.0 };
+ *
+ * const bearing = rhumbBearing(start, end);
+ * console.log('Constant bearing:', bearing, 'degrees');
+ *
+ * // This bearing stays constant along the entire path
+ * ```
+ *
+ * @category Rhumb Line
+ */
 export declare function rhumbBearing(startCoord: GeoCoord, endCoord: GeoCoord): number;
+/**
+ * Calculates the destination point given a start point, constant bearing, and distance on a rhumb line.
+ *
+ * @remarks
+ * Starting from a given point and traveling at a constant bearing for a given
+ * distance, this calculates where you'll end up. The bearing remains constant
+ * throughout the journey.
+ *
+ * This is the rhumb line equivalent of {@link destinationFromOriginOnGreatCircle}.
+ *
+ * @param startCoord - The starting geographic coordinate
+ * @param bearing - The constant bearing in degrees (0 = north, 90 = east, etc.)
+ * @param distance - The distance to travel in meters
+ * @returns The destination coordinate
+ *
+ * @example
+ * ```typescript
+ * const start = { latitude: 40.0, longitude: -74.0 };
+ *
+ * // Travel 500km on constant bearing of 45 degrees (northeast)
+ * const destination = destinationFromOriginOnRhumbLine(start, 45, 500000);
+ * console.log('Destination:', destination);
+ * ```
+ *
+ * @category Rhumb Line
+ */
 export declare function destinationFromOriginOnRhumbLine(startCoord: GeoCoord, bearing: number, distance: number): GeoCoord;
+/**
+ * Calculates the midpoint along a rhumb line.
+ *
+ * @remarks
+ * Finds the point exactly halfway along a rhumb line path between two points.
+ *
+ * @param startCoord - The starting geographic coordinate
+ * @param endCoord - The ending geographic coordinate
+ * @returns The midpoint on the rhumb line path
+ *
+ * @example
+ * ```typescript
+ * const start = { latitude: 50.0, longitude: -5.0 };
+ * const end = { latitude: 58.0, longitude: 3.0 };
+ *
+ * const mid = midPointOnRhumbLine(start, end);
+ * console.log('Midpoint:', mid);
+ * ```
+ *
+ * @category Rhumb Line
+ */
 export declare function midPointOnRhumbLine(startCoord: GeoCoord, endCoord: GeoCoord): GeoCoord;