@ue-too/border 0.14.0 → 0.15.0

package/README.md

@@ -22,11 +22,13 @@ Geodesy and map projection library for TypeScript.
 ## Installation
 
 Using Bun:
+
 ```bash
 bun add @ue-too/border
 ```
 
 Using npm:
+
 ```bash
 npm install @ue-too/border
 ```
@@ -37,12 +39,12 @@ Here's a simple example calculating distance and bearing between two cities:
 
 ```typescript
 import {
-  greatCircleDistance,
-  initialBearingOfGreatCircle
+    greatCircleDistance,
+    initialBearingOfGreatCircle,
 } from '@ue-too/border';
 
 // New York to London
-const nyc = { latitude: 40.7128, longitude: -74.0060 };
+const nyc = { latitude: 40.7128, longitude: -74.006 };
 const london = { latitude: 51.5074, longitude: -0.1278 };
 
 // Calculate great circle distance (in meters)
@@ -86,17 +88,15 @@ Map projections transform spherical coordinates (latitude/longitude) to flat 2D
 Calculate the great circle distance between two points.
 
 ```typescript
-function greatCircleDistance(
-  from: GeoCoord,
-  to: GeoCoord
-): number; // Returns distance in meters
+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
+    { latitude: 51.5074, longitude: -0.1278 }, // London
+    { latitude: 48.8566, longitude: 2.3522 } // Paris
 );
 console.log(distance / 1000, 'km'); // ~344 km
 ```
@@ -106,17 +106,15 @@ console.log(distance / 1000, 'km'); // ~344 km
 Calculate the initial bearing (direction) for a great circle path.
 
 ```typescript
-function initialBearingOfGreatCircle(
-  from: GeoCoord,
-  to: GeoCoord
-): number; // Returns bearing in degrees (0-360)
+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
+    { latitude: 40.7128, longitude: -74.006 }, // NYC
+    { latitude: 51.5074, longitude: -0.1278 } // London
 );
 console.log(bearing, '°'); // ~51.4° (northeast)
 ```
@@ -127,13 +125,14 @@ Find the destination point given origin, bearing, and distance.
 
 ```typescript
 function destinationFromOriginOnGreatCircle(
-  origin: GeoCoord,
-  bearing: number,  // Degrees
-  distance: number  // Meters
+    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);
@@ -145,10 +144,7 @@ console.log('100km east:', destination);
 Find the midpoint along a great circle path.
 
 ```typescript
-function midpointOnGreatCircle(
-  from: GeoCoord,
-  to: GeoCoord
-): GeoCoord;
+function midpointOnGreatCircle(from: GeoCoord, to: GeoCoord): GeoCoord;
 ```
 
 #### `intermediatePointOnGreatCircle(from, to, fraction)`
@@ -157,13 +153,14 @@ 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
+    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);
@@ -176,10 +173,7 @@ const point = intermediatePointOnGreatCircle(nyc, london, 0.25);
 Calculate the rhumb line distance (constant bearing path).
 
 ```typescript
-function rhumbDistance(
-  from: GeoCoord,
-  to: GeoCoord
-): number; // Returns distance in meters
+function rhumbDistance(from: GeoCoord, to: GeoCoord): number; // Returns distance in meters
 ```
 
 #### `rhumbBearing(from, to)`
@@ -187,10 +181,7 @@ function rhumbDistance(
 Calculate the constant bearing for a rhumb line.
 
 ```typescript
-function rhumbBearing(
-  from: GeoCoord,
-  to: GeoCoord
-): number; // Returns bearing in degrees (0-360)
+function rhumbBearing(from: GeoCoord, to: GeoCoord): number; // Returns bearing in degrees (0-360)
 ```
 
 #### `destinationFromOriginOnRhumbLine(origin, bearing, distance)`
@@ -199,9 +190,9 @@ Find the destination on a rhumb line given origin, bearing, and distance.
 
 ```typescript
 function destinationFromOriginOnRhumbLine(
-  origin: GeoCoord,
-  bearing: number,  // Degrees
-  distance: number  // Meters
+    origin: GeoCoord,
+    bearing: number, // Degrees
+    distance: number // Meters
 ): GeoCoord;
 ```
 
@@ -210,10 +201,7 @@ function destinationFromOriginOnRhumbLine(
 Find the midpoint along a rhumb line.
 
 ```typescript
-function midpointOnRhumbLine(
-  from: GeoCoord,
-  to: GeoCoord
-): GeoCoord;
+function midpointOnRhumbLine(from: GeoCoord, to: GeoCoord): GeoCoord;
 ```
 
 ### Map Projection Functions
@@ -223,12 +211,11 @@ function midpointOnRhumbLine(
 Convert geographic coordinates to Mercator projection.
 
 ```typescript
-function mercatorProjection(
-  coord: GeoCoord
-): Point; // Returns {x, y} in normalized coordinates
+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);
@@ -239,9 +226,7 @@ console.log('Mercator coordinates:', point);
 Convert Mercator coordinates back to geographic.
 
 ```typescript
-function inverseMercatorProjection(
-  point: Point
-): GeoCoord; // Returns {latitude, longitude}
+function inverseMercatorProjection(point: Point): GeoCoord; // Returns {latitude, longitude}
 ```
 
 #### `orthoProjection(coord, origin)`
@@ -250,24 +235,25 @@ Convert geographic coordinates to orthographic projection (hemisphere view).
 
 ```typescript
 function orthoProjection(
-  coord: GeoCoord,
-  origin: GeoCoord  // Center of projection
+    coord: GeoCoord,
+    origin: GeoCoord // Center of projection
 ): {
-  coord: Point;     // Projected point
-  clipped: boolean; // True if coord is on the back hemisphere
+    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 }
+    { latitude: 51.5074, longitude: -0.1278 },
+    { latitude: 90, longitude: 0 }
 );
 
 if (!result.clipped) {
-  console.log('Visible at:', result.coord);
+    console.log('Visible at:', result.coord);
 }
 ```
 
@@ -275,13 +261,13 @@ if (!result.clipped) {
 
 ```typescript
 type GeoCoord = {
-  latitude: number;   // Degrees, -90 to 90
-  longitude: number;  // Degrees, -180 to 180
+    latitude: number; // Degrees, -90 to 90
+    longitude: number; // Degrees, -180 to 180
 };
 
 type Point = {
-  x: number;
-  y: number;
+    x: number;
+    y: number;
 };
 ```
 
@@ -291,13 +277,13 @@ type Point = {
 
 ```typescript
 import {
-  greatCircleDistance,
-  initialBearingOfGreatCircle,
-  intermediatePointOnGreatCircle
+    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
+const arrival = { latitude: 51.47, longitude: -0.4543 }; // LHR
 
 // Total distance
 const distance = greatCircleDistance(departure, arrival);
@@ -318,30 +304,27 @@ console.log('Midpoint:', midpoint);
 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 }
+    { name: 'New York', latitude: 40.7128, longitude: -74.006 },
+    { 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);
+    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;
+    // 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);
+    drawCity(x, y, city.name);
 });
 ```
 
 ### Navigate with Constant Bearing
 
 ```typescript
-import {
-  rhumbBearing,
-  destinationFromOriginOnRhumbLine
-} from '@ue-too/border';
+import { destinationFromOriginOnRhumbLine, rhumbBearing } from '@ue-too/border';
 
 const start = { latitude: 50.0, longitude: -5.0 };
 const target = { latitude: 58.0, longitude: 3.0 };
@@ -355,12 +338,12 @@ const nauticalMileInMeters = 1852;
 let currentPos = start;
 
 for (let i = 1; i <= 10; i++) {
-  currentPos = destinationFromOriginOnRhumbLine(
-    currentPos,
-    bearing,
-    50 * nauticalMileInMeters
-  );
-  console.log(`Waypoint ${i}:`, currentPos);
+    currentPos = destinationFromOriginOnRhumbLine(
+        currentPos,
+        bearing,
+        50 * nauticalMileInMeters
+    );
+    console.log(`Waypoint ${i}:`, currentPos);
 }
 ```
 
@@ -372,20 +355,25 @@ 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 } }
+    { name: 'London', coord: { latitude: 51.5074, longitude: -0.1278 } },
+    { name: 'Berlin', coord: { latitude: 52.52, longitude: 13.405 } },
+    { 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)
+    ...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');
+console.log(
+    'Nearest city:',
+    distances[0].name,
+    '- ',
+    (distances[0].distance / 1000).toFixed(0),
+    'km'
+);
 ```
 
 ### Globe Visualization with Orthographic Projection
@@ -397,21 +385,21 @@ import { orthoProjection } from '@ue-too/border';
 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 } }
+    { name: 'London', coord: { latitude: 51.5074, longitude: -0.1278 } },
+    { name: 'Paris', coord: { latitude: 48.8566, longitude: 2.3522 } },
+    { name: 'Berlin', coord: { latitude: 52.52, longitude: 13.405 } },
 ];
 
 cities.forEach(city => {
-  const result = orthoProjection(city.coord, viewCenter);
+    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;
+    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);
-  }
+        drawCityOnGlobe(screenX, screenY, city.name);
+    }
 });
 ```
 
@@ -453,6 +441,7 @@ This library follows these principles:
 - **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)

package/greateCircle.d.ts

@@ -1,4 +1,4 @@
-import { GeoCoord } from "./projection";
+import { GeoCoord } from './projection';
 /**
  * Calculates an intermediate point along a great circle path.
  *

package/index.d.ts

@@ -115,6 +115,6 @@
  * @see {@link greateCircle} for great circle navigation
  * @see {@link rhumbLine} for rhumb line navigation
  */
-export * from "./projection";
-export * from "./greateCircle";
-export * from "./rhumbLine";
+export * from './projection';
+export * from './greateCircle';
+export * from './rhumbLine';

package/index.js.map

@@ -6,11 +6,11 @@
     "rhumbLine.ts"
   ],
   "sourcesContent": [
-    "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"
+    "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(\n    interestPoint: GeoCoord,\n    centerLongitude: number = 0\n): Point {\n    const r = 6371000;\n    const latitude = (interestPoint.latitude * Math.PI) / 180;\n    const longitude = (interestPoint.longitude * Math.PI) / 180;\n    let x =\n        r *\n        normalizeAngleMinusPiToPi(\n            longitude - (centerLongitude * Math.PI) / 180\n        );\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(\n    point: Point,\n    centerLongitude: number = 0\n): 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 {\n        latitude: (latitude * 180) / Math.PI,\n        longitude: (longitude * 180) / Math.PI,\n    };\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(\n    interestPoint: GeoCoord,\n    origin: GeoCoord\n): { 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 =\n        r *\n        Math.cos(latitude) *\n        Math.sin(longitude - (origin.longitude * Math.PI) / 180);\n    const y =\n        r *\n        (Math.cos((origin.latitude * Math.PI) / 180) * Math.sin(latitude) -\n            Math.sin((origin.latitude * Math.PI) / 180) *\n                Math.cos(latitude) *\n                Math.cos(longitude - (origin.longitude * Math.PI) / 180));\n    const clipped =\n        Math.sin((origin.latitude * Math.PI) / 180) * Math.sin(latitude) +\n        Math.cos((origin.latitude * Math.PI) / 180) *\n            Math.cos(latitude) *\n            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(\n    interestPoint: Point,\n    origin: GeoCoord\n): GeoCoord {\n    const r = 6371000;\n    const rho = Math.sqrt(\n        interestPoint.x * interestPoint.x + interestPoint.y * interestPoint.y\n    );\n    const c = Math.asin(rho / r);\n    const latitude =\n        (Math.asin(\n            Math.cos(c) * Math.sin((origin.latitude * Math.PI) / 180) +\n                (interestPoint.y *\n                    Math.sin(c) *\n                    Math.cos((origin.latitude * Math.PI) / 180)) /\n                    rho\n        ) *\n            180) /\n        Math.PI;\n    const longitude =\n        origin.longitude +\n        (Math.atan2(\n            interestPoint.x * Math.sin(c),\n            rho * Math.cos(c) * Math.cos((origin.latitude * Math.PI) / 180) -\n                interestPoint.y *\n                    Math.sin(c) *\n                    Math.sin((origin.latitude * Math.PI) / 180)\n        ) *\n            180) /\n            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 * 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(\n    startCoord: GeoCoord,\n    endCoord: GeoCoord,\n    fraction: number\n): 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 =\n        Math.sin(Δφ / 2) * Math.sin(Δφ / 2) +\n        Math.cos(φ1) * Math.cos(φ2) * Math.sin(Δλ / 2) * Math.sin(Δλ / 2);\n    const c =\n        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(\n    startCoord: GeoCoord,\n    endCoord: GeoCoord\n): 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(\n        Math.sin(φ1) + Math.sin(φ2),\n        Math.sqrt((Math.cos(φ1) + Bx) * (Math.cos(φ1) + Bx) + By * By)\n    );\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(\n    startCoord: GeoCoord,\n    endCoord: GeoCoord\n): 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 =\n        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(\n    startCoord: GeoCoord,\n    endCoord: GeoCoord\n): 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 =\n        Math.sin(Δφ / 2) * Math.sin(Δφ / 2) +\n        Math.cos(φ1) * Math.cos(φ2) * 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(\n    startCoord: GeoCoord,\n    bearing: number,\n    distance: number\n): 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(\n        Math.sin(φ1) * Math.cos(d) + Math.cos(φ1) * Math.sin(d) * Math.cos(θ)\n    );\n    const λ2 =\n        λ1 +\n        Math.atan2(\n            Math.sin(θ) * Math.sin(d) * Math.cos(φ1),\n            Math.cos(d) - Math.sin(φ1) * Math.sin(φ2)\n        );\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(\n    startCoord: GeoCoord,\n    endCoord: GeoCoord\n): 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(\n        Math.tan(Math.PI / 4 + φ2 / 2) / Math.tan(Math.PI / 4 + φ1 / 2)\n    );\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)\n        Δλ = Δλ > 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(\n        Math.tan(Math.PI / 4 + φ2 / 2) / Math.tan(Math.PI / 4 + φ1 / 2)\n    );\n\n    // if dLon over 180° take shorter rhumb line across the anti-meridian:\n    if (Math.abs(Δλ) > Math.PI)\n        Δλ = Δλ > 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(\n    startCoord: GeoCoord,\n    bearing: number,\n    distance: number\n): 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(\n        Math.tan(φ2 / 2 + Math.PI / 4) / Math.tan(φ1 / 2 + Math.PI / 4)\n    );\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(\n    startCoord: GeoCoord,\n    endCoord: GeoCoord\n): 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 =\n        ((λ2 - λ1) * Math.log(f3) + λ1 * Math.log(f2) - λ2 * Math.log(f1)) /\n        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": "AAgDO,SAAS,CAAkB,CAAC,EAAyB,EAA0B,EAAS,CAE3F,IAAM,EAAW,EAAc,SAAW,KAAK,GAAK,IAC9C,EAAY,EAAc,UAAY,KAAK,GAAK,IAClD,EAHM,QAGE,EAA0B,EAAY,EAAkB,KAAK,GAAK,GAAG,EAC7E,EAJM,QAIE,KAAK,IAAI,KAAK,IAAI,KAAK,GAAK,EAAI,EAAW,CAAC,CAAC,EACzD,MAAO,CAAC,EAAG,EAAG,EAAG,CAAC,EAuBf,SAAS,CAAyB,CAAC,EAAc,EAA0B,EAAY,CAE1F,IAAM,EAAY,EAAM,EADd,QACsB,EAEhC,MAAO,CAAC,UADS,EAAI,KAAK,KAAK,KAAK,IAAI,EAAM,EAFpC,OAEyC,CAAC,EAAI,KAAK,GAAK,GACrC,IAAM,KAAK,GAAI,UAAW,EAAY,IAAM,KAAK,EAAE,EAkC7E,SAAS,CAAe,CAAC,EAAyB,EAAmD,CAExG,IAAM,EAAW,EAAc,SAAW,KAAK,GAAK,IAC9C,EAAY,EAAc,UAAY,KAAK,GAAK,IAChD,EAHI,QAGI,KAAK,IAAI,CAAQ,EAAI,KAAK,IAAI,EAAY,EAAO,UAAY,KAAK,GAAK,GAAG,EAClF,EAJI,SAIK,KAAK,IAAI,EAAO,SAAW,KAAK,GAAK,GAAG,EAAI,KAAK,IAAI,CAAQ,EAAI,KAAK,IAAI,EAAO,SAAW,KAAK,GAAK,GAAG,EAAI,KAAK,IAAI,CAAQ,EAAI,KAAK,IAAI,EAAY,EAAO,UAAY,KAAK,GAAK,GAAG,GAGtM,MAAO,CAAC,QAFQ,KAAK,IAAI,EAAO,SAAW,KAAK,GAAK,GAAG,EAAI,KAAK,IAAI,CAAQ,EAAI,KAAK,IAAI,EAAO,SAAW,KAAK,GAAK,GAAG,EAAI,KAAK,IAAI,CAAQ,EAAI,KAAK,IAAI,EAAY,EAAO,UAAY,KAAK,GAAK,GAAG,EAE5K,EAAG,MAAO,CAAC,EAAG,EAAG,EAAG,CAAC,CAAC,EAwB9C,SAAS,CAAsB,CAAC,EAAsB,EAA4B,CAErF,IAAM,EAAM,KAAK,KAAK,EAAc,EAAI,EAAc,EAAI,EAAc,EAAI,EAAc,CAAC,EACrF,EAAI,KAAK,KAAK,EAFV,OAEiB,EACrB,EAAW,KAAK,KAAK,KAAK,IAAI,CAAC,EAAI,KAAK,IAAI,EAAO,SAAW,KAAK,GAAK,GAAG,EAAK,EAAc,EAAI,KAAK,IAAI,CAAC,EAAI,KAAK,IAAI,EAAO,SAAW,KAAK,GAAK,GAAG,EAAK,CAAG,EAAI,IAAM,KAAK,GAC/K,EAAY,EAAO,UAAY,KAAK,MAAM,EAAc,EAAI,KAAK,IAAI,CAAC,EAAG,EAAM,KAAK,IAAI,CAAC,EAAE,KAAK,IAAI,EAAO,SAAW,KAAK,GAAK,GAAG,EAAI,EAAc,EAAI,KAAK,IAAI,CAAC,EAAI,KAAK,IAAI,EAAO,SAAW,KAAK,GAAK,GAAG,CAAC,EAAI,IAAM,KAAK,GACrO,MAAO,CAAC,SAAU,EAAU,UAAW,CAAS,EAGpD,SAAS,CAAyB,CAAC,EAAuB,CAOtD,OALA,EAAQ,GAAS,KAAK,GAAK,GAG3B,GAAS,EAAQ,EAAI,KAAK,KAAO,EAAI,KAAK,IAAM,KAAK,GAE9C,EC7HJ,SAAS,CAA8B,CAAC,EAAsB,EAAoB,EAA2B,CAChH,IAAM,GAAK,EAAS,SAAW,EAAW,UAAY,KAAK,GAAK,IAC1D,GAAK,EAAS,UAAY,EAAW,WAAa,KAAK,GAAK,IAC5D,EAAI,EAAW,SAAW,KAAK,GAAK,IACpC,EAAI,EAAW,UAAY,KAAK,GAAK,IACrC,EAAI,EAAS,SAAW,KAAK,GAAK,IAClC,EAAI,EAAS,UAAY,KAAK,GAAK,IACnC,EAAe,KAAK,IAAI,EAAI,CAAC,EAAI,KAAK,IAAI,EAAK,CAAC,EAC9C,KAAK,IAAI,CAAC,EAAI,KAAK,IAAI,CAAE,EACzB,KAAK,IAAI,EAAI,CAAC,EAAI,KAAK,IAAI,EAAK,CAAC,EACnC,EAAI,EAAI,KAAK,MAAM,KAAK,KAAK,CAAY,EAAG,KAAK,KAAK,EAAI,CAAY,CAAC,EAEvE,EAAI,KAAK,KAAK,EAAI,GAAY,CAAC,EAAI,KAAK,IAAI,CAAC,EAC7C,EAAI,KAAK,IAAI,EAAW,CAAC,EAAI,KAAK,IAAI,CAAC,EACvC,EAAI,EAAI,KAAK,IAAI,CAAC,EAAI,KAAK,IAAI,CAAE,EAAI,EAAI,KAAK,IAAI,CAAE,EAAI,KAAK,IAAI,CAAE,EACnE,EAAI,EAAI,KAAK,IAAI,CAAC,EAAI,KAAK,IAAI,CAAE,EAAI,EAAI,KAAK,IAAI,CAAE,EAAI,KAAK,IAAI,CAAE,EACnE,EAAI,EAAI,KAAK,IAAI,CAAC,EAAI,EAAI,KAAK,IAAI,CAAE,EACrC,EAAI,KAAK,MAAM,EAAG,KAAK,KAAK,EAAI,EAAI,EAAI,CAAC,CAAC,EAC1C,EAAI,KAAK,MAAM,EAAG,CAAC,EACzB,MAAO,CAAC,SAAU,EAAG,UAAW,CAAE,EAwB/B,SAAS,CAAqB,CAAC,EAAsB,EAA6B,CACrF,IAAM,EAAI,EAAW,SAAW,KAAK,GAAK,IACpC,EAAI,EAAS,SAAW,KAAK,GAAK,IAClC,EAAI,EAAW,UAAY,KAAK,GAAK,IACrC,EAAI,EAAS,UAAY,KAAK,GAAK,IACnC,EAAK,KAAK,IAAI,CAAC,EAAI,KAAK,IAAI,EAAK,CAAE,EACnC,EAAK,KAAK,IAAI,CAAC,EAAI,KAAK,IAAI,EAAK,CAAE,EACnC,EAAI,KAAK,MAAM,KAAK,IAAI,CAAE,EAAI,KAAK,IAAI,CAAE,EAC3B,KAAK,MAAO,KAAK,IAAI,CAAC,EAAI,IAAO,KAAK,IAAI,CAAE,EAAI,GAAM,EAAK,CAAG,CAAE,EAC9E,EAAI,EAAK,KAAK,MAAM,EAAI,KAAK,IAAI,CAAE,EAAI,CAAE,EAC/C,MAAO,CAAC,SAAU,EAAG,UAAW,CAAE,EAW/B,SAAS,CAA2B,CAAC,EAAsB,EAA2B,CACzF,IAAM,EAAI,EAAW,SAAW,KAAK,GAAK,IACpC,EAAI,EAAS,SAAW,KAAK,GAAK,IAClC,EAAI,EAAW,UAAY,KAAK,GAAK,IACrC,EAAI,EAAS,UAAY,KAAK,GAAK,IACnC,EAAI,KAAK,IAAI,EAAE,CAAE,EAAI,KAAK,IAAI,CAAE,EAChC,EAAI,KAAK,IAAI,CAAC,EAAI,KAAK,IAAI,CAAE,EAC3B,KAAK,IAAI,CAAC,EAAI,KAAK,IAAI,CAAE,EAAE,KAAK,IAAI,EAAK,CAAE,EAGnD,OAFS,KAAK,MAAM,EAAG,CAAC,EACP,IAAM,KAAK,GAAK,KAAO,IA8BrC,SAAS,CAAmB,CAAC,EAAsB,EAA2B,CAEjF,IAAM,EAAI,EAAW,SAAW,KAAK,GAAK,IACpC,EAAI,EAAS,SAAW,KAAK,GAAK,IAClC,GAAK,EAAS,SAAW,EAAW,UAAY,KAAK,GAAK,IAC1D,GAAK,EAAS,UAAY,EAAW,WAAa,KAAK,GAAK,IAE5D,EAAI,KAAK,IAAI,EAAI,CAAC,EAAI,KAAK,IAAI,EAAK,CAAC,EACnC,KAAK,IAAI,CAAC,EAAI,KAAK,IAAI,CAAE,EACzB,KAAK,IAAI,EAAI,CAAC,EAAI,KAAK,IAAI,EAAK,CAAC,EAIzC,MAZU,UASA,EAAI,KAAK,MAAM,KAAK,KAAK,CAAC,EAAG,KAAK,KAAK,EAAI,CAAC,CAAC,GAgCpD,SAAS,CAAkC,CAAC,EAAsB,EAAiB,EAA2B,CAEjH,IAAM,EAAI,EAAW,SAAW,KAAK,GAAK,IACpC,EAAI,EAAW,UAAY,KAAK,GAAK,IACrC,EAAG,EAAU,KAAK,GAAK,IACvB,EAAI,EAJA,QAKJ,EAAI,KAAK,KAAK,KAAK,IAAI,CAAE,EAAI,KAAK,IAAI,CAAC,EAC3B,KAAK,IAAI,CAAC,EAAI,KAAK,IAAI,CAAC,EAAI,KAAK,IAAI,CAAE,CAAC,EACpD,EAAI,EAAK,KAAK,MAAM,KAAK,IAAI,CAAE,EAAG,KAAK,IAAI,CAAC,EAAI,KAAK,IAAI,CAAE,EAC1C,KAAK,IAAI,CAAC,EAAI,KAAK,IAAI,CAAC,EAAI,KAAK,IAAI,CAAE,CAAC,EAC/D,MAAO,CAAC,SAAU,EAAG,UAAW,CAAE,ECxJ/B,SAAS,CAAa,CAAC,EAAsB,EAA2B,CAE3E,IAAM,EAAI,EAAW,SAAW,KAAK,GAAG,IAClC,EAAI,EAAS,SAAW,KAAK,GAAG,IAChC,GAAK,EAAS,SAAW,EAAW,UAAY,KAAK,GAAG,IAC1D,GAAK,EAAS,UAAY,EAAW,WAAa,KAAK,GAAG,IACxD,EAAI,KAAK,IAAI,KAAK,IAAI,KAAK,GAAK,EAAI,EAAK,CAAC,EAAE,KAAK,IAAI,KAAK,GAAK,EAAI,EAAK,CAAC,CAAC,EAC1E,EAAI,KAAK,IAAI,CAAE,EAAG,cAAS,EAAK,EAAK,KAAK,IAAI,CAAE,EAGtD,GAAI,KAAK,IAAI,CAAE,EAAG,KAAK,GAAI,EAAK,EAAK,EAAI,EAAG,EAAI,KAAK,GAAK,GAAO,EAAI,KAAK,GAAK,EAG/E,OADa,KAAK,KAAK,EAAI,EAAK,EAAI,EAAI,EAAK,CAAG,EAXtC,QAwCP,SAAS,CAAY,CAAC,EAAsB,EAA2B,CAC1E,IAAM,EAAI,EAAW,SAAW,KAAK,GAAK,IACpC,EAAI,EAAS,SAAW,KAAK,GAAK,IACpC,GAAK,EAAS,UAAY,EAAW,WAAa,KAAK,GAAK,IAC1D,EAAI,KAAK,IAAI,KAAK,IAAI,KAAK,GAAK,EAAI,EAAK,CAAC,EAAI,KAAK,IAAI,KAAK,GAAK,EAAI,EAAK,CAAC,CAAC,EAGlF,GAAI,KAAK,IAAI,CAAE,EAAG,KAAK,GAAI,EAAK,EAAK,EAAI,EAAE,EAAI,KAAK,GAAG,GAAO,EAAI,KAAK,GAAK,EAG5E,OADa,KAAK,MAAM,EAAG,CAAG,EAAG,IAAM,KAAK,GA8BzC,SAAS,CAAgC,CAAC,EAAsB,EAAiB,EAA2B,CAE/G,IAAM,EAAI,EAAW,SAAW,KAAK,GAAK,IACpC,EAAI,EAAW,UAAY,KAAK,GAAK,IACrC,EAAG,EAAU,KAAK,GAAK,IAEvB,EADI,EAJA,QAMJ,EAAI,EAAI,KAAK,IAAI,CAAE,EACrB,EAAI,EAAK,EAEP,EAAI,KAAK,IAAI,KAAK,IAAI,EAAK,EAAI,KAAK,GAAK,CAAC,EAAI,KAAK,IAAI,EAAK,EAAI,KAAK,GAAK,CAAC,CAAC,EAC5E,EAAI,KAAK,IAAI,CAAE,EAAG,cAAS,EAAK,EAAK,KAAK,IAAI,CAAE,EAEhD,EAAI,EAAI,KAAK,IAAI,CAAE,EAAG,EACtB,EAAI,EAAK,EAGf,GAAI,KAAK,IAAI,CAAC,EAAI,KAAK,GAAK,EAAG,EAAK,EAAK,EAAI,KAAK,GAAK,EAAK,CAAC,KAAK,GAAK,EACvE,MAAO,CAAC,SAAU,EAAG,UAAW,CAAE,EAwB/B,SAAS,CAAmB,CAAC,EAAsB,EAA6B,CACnF,IAAI,EAAI,EAAW,UAAY,KAAK,GAAK,IACnC,EAAI,EAAS,UAAY,KAAK,GAAK,IACnC,EAAI,EAAW,SAAW,KAAK,GAAK,IACpC,EAAI,EAAS,SAAW,KAAK,GAAK,IACxC,GAAI,KAAK,IAAI,EAAI,CAAE,EAAI,KAAK,GAAI,GAAM,EAAI,KAAK,GAE/C,IAAM,GAAK,EAAK,GAAM,EAChB,EAAK,KAAK,IAAI,KAAK,GAAK,EAAI,EAAI,CAAC,EACjC,EAAK,KAAK,IAAI,KAAK,GAAK,EAAI,EAAI,CAAC,EACjC,EAAK,KAAK,IAAI,KAAK,GAAK,EAAI,EAAI,CAAC,EACnC,IAAO,EAAK,GAAM,KAAK,IAAI,CAAE,EAAI,EAAK,KAAK,IAAI,CAAE,EAAI,EAAK,KAAK,IAAI,CAAE,GAAM,KAAK,IAAI,EAAK,CAAE,EAE/F,GAAI,CAAC,SAAS,CAAC,EAAG,GAAM,EAAK,GAAM,EACnC,MAAO,CAAC,SAAU,EAAG,UAAW,CAAE",
+  "mappings": "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",
   "debugId": "ADDDACDC1E32424A64756E2164756E21",
   "names": []
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ue-too/border",
   "type": "module",
-  "version": "0.14.0",
+  "version": "0.15.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.14.0"
+    "@ue-too/math": "^0.15.0"
   },
   "main": "./index.js",
   "types": "./index.d.ts",

package/projection.d.ts

@@ -1,4 +1,4 @@
-import { Point } from "@ue-too/math";
+import { Point } from '@ue-too/math';
 /**
  * Geographic coordinate representing a location on Earth's surface.
  *

package/rhumbLine.d.ts

@@ -1,4 +1,4 @@
-import { GeoCoord } from "./projection";
+import { GeoCoord } from './projection';
 /**
  * Calculates the distance along a rhumb line between two points.
  *