gnss-js 0.1.2 → 1.0.0

package/dist/coordinates.cjs

@@ -0,0 +1,334 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/coordinates/index.ts
+var coordinates_exports = {};
+__export(coordinates_exports, {
+  clampUnit: () => clampUnit,
+  deg2dms: () => deg2dms,
+  deg2rad: () => deg2rad,
+  ecefToGeodetic: () => ecefToGeodetic,
+  euclidean3D: () => euclidean3D,
+  geodeticToEcef: () => geodeticToEcef,
+  geodeticToGeohash: () => geodeticToGeohash,
+  geodeticToMaidenhead: () => geodeticToMaidenhead,
+  geodeticToUtm: () => geodeticToUtm,
+  getAer: () => getAer,
+  getEnuDifference: () => getEnuDifference,
+  greatCircleMidpoint: () => greatCircleMidpoint,
+  horizonDistance: () => horizonDistance,
+  rad2deg: () => rad2deg,
+  rhumbLine: () => rhumbLine,
+  vincenty: () => vincenty
+});
+module.exports = __toCommonJS(coordinates_exports);
+
+// src/coordinates/units.ts
+function rad2deg(radians) {
+  return radians * 180 / Math.PI;
+}
+function deg2rad(degrees) {
+  return degrees * Math.PI / 180;
+}
+function deg2dms(deg) {
+  deg = Math.abs(deg);
+  let d = Math.floor(deg);
+  let m = Math.floor(deg * 60) % 60;
+  let s = deg * 3600 % 60;
+  if (s >= 59.9995) {
+    m += 1;
+    s = 0;
+  }
+  if (m === 60) {
+    d += 1;
+    m = 0;
+  }
+  return [d, m, s];
+}
+
+// src/constants/wgs84.ts
+var WGS84_SEMI_MAJOR_AXIS = 6378137;
+var WGS84_SEMI_MINOR_AXIS = 6356752314245e-6;
+var WGS84_FLATTENING = 1 / 298.257223563;
+var WGS84_ECCENTRICITY_SQUARED = 0.006694379990197;
+
+// src/coordinates/ecef.ts
+function clampUnit(x) {
+  return x < -1 ? -1 : x > 1 ? 1 : x;
+}
+function geodeticToEcef(lat, lon, h) {
+  const N = WGS84_SEMI_MAJOR_AXIS / Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED * Math.sin(lat) ** 2);
+  const x = (N + h) * Math.cos(lat) * Math.cos(lon);
+  const y = (N + h) * Math.cos(lat) * Math.sin(lon);
+  const z = ((1 - WGS84_ECCENTRICITY_SQUARED) * N + h) * Math.sin(lat);
+  return [x, y, z];
+}
+function ecefToGeodetic(x, y, z) {
+  const lon = Math.atan2(y, x);
+  const p = Math.sqrt(x * x + y * y);
+  if (p < 1e-10) {
+    const b = WGS84_SEMI_MAJOR_AXIS * Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED);
+    const lat2 = z >= 0 ? Math.PI / 2 : -Math.PI / 2;
+    const alt2 = Math.abs(z) - b;
+    return [lat2, lon, alt2];
+  }
+  let lat = Math.atan2(z, p * (1 - WGS84_ECCENTRICITY_SQUARED));
+  let N;
+  for (let i = 0; i < 10; i++) {
+    const sinLat2 = Math.sin(lat);
+    N = WGS84_SEMI_MAJOR_AXIS / Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED * sinLat2 * sinLat2);
+    const prevLat = lat;
+    lat = Math.atan2(z + WGS84_ECCENTRICITY_SQUARED * N * sinLat2, p);
+    if (Math.abs(lat - prevLat) < 1e-15) break;
+  }
+  const sinLat = Math.sin(lat);
+  N = WGS84_SEMI_MAJOR_AXIS / Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED * sinLat * sinLat);
+  const alt = p / Math.cos(lat) - N;
+  return [lat, lon, alt];
+}
+function getEnuDifference(x, y, z, xRef, yRef, zRef) {
+  const [latRef, lonRef] = ecefToGeodetic(xRef, yRef, zRef);
+  const deltaX = x - xRef;
+  const deltaY = y - yRef;
+  const deltaZ = z - zRef;
+  const deltaE = -Math.sin(lonRef) * deltaX + Math.cos(lonRef) * deltaY;
+  const deltaN = -Math.cos(lonRef) * Math.sin(latRef) * deltaX - Math.sin(lonRef) * Math.sin(latRef) * deltaY + Math.cos(latRef) * deltaZ;
+  const deltaU = Math.cos(lonRef) * Math.cos(latRef) * deltaX + Math.sin(lonRef) * Math.cos(latRef) * deltaY + Math.sin(latRef) * deltaZ;
+  return [deltaE, deltaN, deltaU];
+}
+function getAer(x, y, z, xRef, yRef, zRef) {
+  const slant = Math.sqrt((x - xRef) ** 2 + (y - yRef) ** 2 + (z - zRef) ** 2);
+  if (!slant) return [0, 0, 0];
+  const [deltaE, deltaN, deltaU] = getEnuDifference(x, y, z, xRef, yRef, zRef);
+  const elevation = Math.asin(clampUnit(deltaU / slant));
+  const azimuth = Math.atan2(deltaE, deltaN);
+  return [elevation, azimuth, slant];
+}
+
+// src/coordinates/geodesy.ts
+function vincenty(lat1, lon1, lat2, lon2) {
+  const U1 = Math.atan((1 - WGS84_FLATTENING) * Math.tan(lat1));
+  const U2 = Math.atan((1 - WGS84_FLATTENING) * Math.tan(lat2));
+  const sinU1 = Math.sin(U1), cosU1 = Math.cos(U1);
+  const sinU2 = Math.sin(U2), cosU2 = Math.cos(U2);
+  let lambda = lon2 - lon1;
+  let lambdaPrev;
+  let sinSigma, cosSigma, sigma;
+  let sinAlpha, cos2Alpha, cos2SigmaM;
+  let C;
+  let iter = 0;
+  do {
+    const sinLambda2 = Math.sin(lambda);
+    const cosLambda2 = Math.cos(lambda);
+    sinSigma = Math.sqrt(
+      (cosU2 * sinLambda2) ** 2 + (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda2) ** 2
+    );
+    if (sinSigma === 0) {
+      return { distance: 0, initialBearing: 0, finalBearing: 0 };
+    }
+    cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda2;
+    sigma = Math.atan2(sinSigma, cosSigma);
+    sinAlpha = cosU1 * cosU2 * sinLambda2 / sinSigma;
+    cos2Alpha = 1 - sinAlpha ** 2;
+    cos2SigmaM = cos2Alpha !== 0 ? cosSigma - 2 * sinU1 * sinU2 / cos2Alpha : 0;
+    C = WGS84_FLATTENING / 16 * cos2Alpha * (4 + WGS84_FLATTENING * (4 - 3 * cos2Alpha));
+    lambdaPrev = lambda;
+    lambda = lon2 - lon1 + (1 - C) * WGS84_FLATTENING * sinAlpha * (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM ** 2)));
+  } while (Math.abs(lambda - lambdaPrev) > 1e-12 && ++iter < 200);
+  if (iter >= 200) {
+    const cosLat1 = Math.cos(lat1), sinLat1 = Math.sin(lat1);
+    const cosLat2 = Math.cos(lat2), sinLat2 = Math.sin(lat2);
+    const dLon = lon2 - lon1;
+    sigma = Math.acos(
+      Math.min(1, Math.max(-1, sinLat1 * sinLat2 + cosLat1 * cosLat2 * Math.cos(dLon)))
+    );
+    const distance2 = WGS84_SEMI_MAJOR_AXIS * sigma;
+    const ib = Math.atan2(
+      cosLat2 * Math.sin(dLon),
+      cosLat1 * sinLat2 - sinLat1 * cosLat2 * Math.cos(dLon)
+    );
+    const fb = Math.atan2(
+      cosLat1 * Math.sin(-dLon),
+      -sinLat1 * cosLat2 + cosLat1 * sinLat2 * Math.cos(-dLon)
+    );
+    return { distance: distance2, initialBearing: ib, finalBearing: fb };
+  }
+  const uSq = cos2Alpha * (WGS84_SEMI_MAJOR_AXIS ** 2 - WGS84_SEMI_MINOR_AXIS ** 2) / WGS84_SEMI_MINOR_AXIS ** 2;
+  const A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
+  const B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+  const deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 * (cosSigma * (-1 + 2 * cos2SigmaM ** 2) - B / 6 * cos2SigmaM * (-3 + 4 * sinSigma ** 2) * (-3 + 4 * cos2SigmaM ** 2)));
+  const distance = WGS84_SEMI_MINOR_AXIS * A * (sigma - deltaSigma);
+  const sinLambda = Math.sin(lambda);
+  const cosLambda = Math.cos(lambda);
+  const initialBearing = Math.atan2(
+    cosU2 * sinLambda,
+    cosU1 * sinU2 - sinU1 * cosU2 * cosLambda
+  );
+  const finalBearing = Math.atan2(
+    cosU1 * sinLambda,
+    -sinU1 * cosU2 + cosU1 * sinU2 * cosLambda
+  );
+  return { distance, initialBearing, finalBearing };
+}
+function rhumbLine(lat1, lon1, lat2, lon2) {
+  const dLat = lat2 - lat1;
+  let dLon = lon2 - lon1;
+  const MAX_LAT = Math.PI / 2 - 1e-10;
+  const isometricLat = (lat) => {
+    const clampedLat = Math.max(-MAX_LAT, Math.min(MAX_LAT, lat));
+    const sinLat = Math.sin(clampedLat);
+    const e = Math.sqrt(WGS84_ECCENTRICITY_SQUARED);
+    return Math.log(
+      Math.tan(Math.PI / 4 + clampedLat / 2) * ((1 - e * sinLat) / (1 + e * sinLat)) ** (e / 2)
+    );
+  };
+  const psi1 = isometricLat(lat1);
+  const psi2 = isometricLat(lat2);
+  const dPsi = psi2 - psi1;
+  const q = Math.abs(dPsi) > 1e-12 ? dLat / dPsi : Math.cos(lat1);
+  if (Math.abs(dLon) > Math.PI) {
+    dLon = dLon > 0 ? -(2 * Math.PI - dLon) : 2 * Math.PI + dLon;
+  }
+  const bearing = Math.atan2(dLon, dPsi);
+  const e22 = WGS84_ECCENTRICITY_SQUARED;
+  const e4 = e22 * e22;
+  const e6 = e4 * e22;
+  const meridionalRadius = WGS84_SEMI_MAJOR_AXIS * (1 - e22) * (1 + 3 / 4 * e22 + 45 / 64 * e4 + 175 / 256 * e6);
+  const distance = Math.sqrt(dLat ** 2 + q ** 2 * dLon ** 2) * meridionalRadius;
+  return { distance, bearing };
+}
+function euclidean3D(x1, y1, z1, x2, y2, z2) {
+  return Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2 + (z2 - z1) ** 2);
+}
+function greatCircleMidpoint(lat1, lon1, lat2, lon2) {
+  const dLon = lon2 - lon1;
+  const Bx = Math.cos(lat2) * Math.cos(dLon);
+  const By = Math.cos(lat2) * Math.sin(dLon);
+  const sumX = Math.cos(lat1) + Bx;
+  const denom = Math.sqrt(sumX ** 2 + By ** 2);
+  if (denom < 1e-15) {
+    return [(lat1 + lat2) / 2, lon1];
+  }
+  const latMid = Math.atan2(Math.sin(lat1) + Math.sin(lat2), denom);
+  const lonMid = lon1 + Math.atan2(By, sumX);
+  return [latMid, lonMid];
+}
+function horizonDistance(heightMeters) {
+  if (heightMeters <= 0) return 0;
+  const k = 0.13;
+  const R = WGS84_SEMI_MAJOR_AXIS;
+  const Re = R / (1 - k);
+  return Math.sqrt(2 * Re * heightMeters + heightMeters ** 2);
+}
+
+// src/coordinates/projections.ts
+var e2 = WGS84_ECCENTRICITY_SQUARED;
+var k0 = 0.9996;
+function geodeticToUtm(lat, lon) {
+  const MAX_UTM_LAT = 84 * (Math.PI / 180);
+  lat = Math.max(-MAX_UTM_LAT, Math.min(MAX_UTM_LAT, lat));
+  const latDeg = lat * 180 / Math.PI;
+  const lonDeg = lon * 180 / Math.PI;
+  const zone = Math.floor((lonDeg + 180) / 6) + 1;
+  const lon0 = ((zone - 1) * 6 - 180 + 3) * (Math.PI / 180);
+  const ep2 = e2 / (1 - e2);
+  const N = WGS84_SEMI_MAJOR_AXIS / Math.sqrt(1 - e2 * Math.sin(lat) ** 2);
+  const T = Math.tan(lat) ** 2;
+  const C = ep2 * Math.cos(lat) ** 2;
+  const A = Math.cos(lat) * (lon - lon0);
+  const M = WGS84_SEMI_MAJOR_AXIS * ((1 - e2 / 4 - 3 * e2 ** 2 / 64 - 5 * e2 ** 3 / 256) * lat - (3 * e2 / 8 + 3 * e2 ** 2 / 32 + 45 * e2 ** 3 / 1024) * Math.sin(2 * lat) + (15 * e2 ** 2 / 256 + 45 * e2 ** 3 / 1024) * Math.sin(4 * lat) - 35 * e2 ** 3 / 3072 * Math.sin(6 * lat));
+  const easting = k0 * N * (A + (1 - T + C) * A ** 3 / 6 + (5 - 18 * T + T ** 2 + 72 * C - 58 * ep2) * A ** 5 / 120) + 5e5;
+  let northing = k0 * (M + N * Math.tan(lat) * (A ** 2 / 2 + (5 - T + 9 * C + 4 * C ** 2) * A ** 4 / 24 + (61 - 58 * T + T ** 2 + 600 * C - 330 * ep2) * A ** 6 / 720));
+  const hemisphere = latDeg >= 0 ? "N" : "S";
+  if (hemisphere === "S") {
+    northing += 1e7;
+  }
+  return { easting, northing, zone, hemisphere };
+}
+function geodeticToMaidenhead(lat, lon) {
+  const latDeg = Math.max(0, Math.min(179.999999, lat * 180 / Math.PI + 90));
+  const lonDeg = Math.max(0, Math.min(359.999999, lon * 180 / Math.PI + 180));
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWX";
+  const idx = (i) => Math.max(0, Math.min(23, i));
+  const a1 = chars[idx(Math.floor(lonDeg / 20))];
+  const a2 = chars[idx(Math.floor(latDeg / 10))];
+  const a3 = Math.floor(lonDeg % 20 / 2);
+  const a4 = Math.floor(latDeg % 10);
+  const a5 = chars[idx(Math.floor(lonDeg % 2 * 12))];
+  const a6 = chars[idx(Math.floor(latDeg % 1 * 24))];
+  return `${a1}${a2}${a3}${a4}${a5.toLowerCase()}${a6.toLowerCase()}`;
+}
+function geodeticToGeohash(lat, lon, precision = 8) {
+  const latDeg = lat * 180 / Math.PI;
+  const lonDeg = lon * 180 / Math.PI;
+  const base32 = "0123456789bcdefghjkmnpqrstuvwxyz";
+  let minLat = -90, maxLat = 90;
+  let minLon = -180, maxLon = 180;
+  let hash = "";
+  let bit = 0;
+  let ch = 0;
+  let isLon = true;
+  while (hash.length < precision) {
+    if (isLon) {
+      const mid = (minLon + maxLon) / 2;
+      if (lonDeg >= mid) {
+        ch = ch | 1 << 4 - bit;
+        minLon = mid;
+      } else {
+        maxLon = mid;
+      }
+    } else {
+      const mid = (minLat + maxLat) / 2;
+      if (latDeg >= mid) {
+        ch = ch | 1 << 4 - bit;
+        minLat = mid;
+      } else {
+        maxLat = mid;
+      }
+    }
+    isLon = !isLon;
+    if (bit < 4) {
+      bit++;
+    } else {
+      hash += base32[ch];
+      bit = 0;
+      ch = 0;
+    }
+  }
+  return hash;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clampUnit,
+  deg2dms,
+  deg2rad,
+  ecefToGeodetic,
+  euclidean3D,
+  geodeticToEcef,
+  geodeticToGeohash,
+  geodeticToMaidenhead,
+  geodeticToUtm,
+  getAer,
+  getEnuDifference,
+  greatCircleMidpoint,
+  horizonDistance,
+  rad2deg,
+  rhumbLine,
+  vincenty
+});

package/dist/coordinates.d.cts

@@ -0,0 +1,81 @@
+export { c as clampUnit, e as ecefToGeodetic, g as geodeticToEcef, a as getAer, b as getEnuDifference } from './ecef-CF0uAysr.cjs';
+
+/** Convert radians to degrees. */
+declare function rad2deg(radians: number): number;
+/** Convert degrees to radians. */
+declare function deg2rad(degrees: number): number;
+/**
+ * Convert decimal degrees to [degrees, minutes, seconds].
+ * Always returns positive values (use the sign of the input separately).
+ */
+declare function deg2dms(deg: number): [number, number, number];
+
+/**
+ * Vincenty's inverse formula — orthodromic (great-circle) distance,
+ * initial bearing, and final bearing on the WGS84 ellipsoid.
+ * All angles in radians.
+ * @returns { distance (m), initialBearing (rad), finalBearing (rad) }
+ */
+declare function vincenty(lat1: number, lon1: number, lat2: number, lon2: number): {
+    distance: number;
+    initialBearing: number;
+    finalBearing: number;
+};
+/**
+ * Loxodromic (rhumb line) distance and constant bearing on the WGS84 ellipsoid.
+ * Uses the ellipsoidal rhumb-line formula with isometric latitudes.
+ * All angles in radians.
+ * @param lat1 Start latitude (rad)
+ * @param lon1 Start longitude (rad)
+ * @param lat2 End latitude (rad)
+ * @param lon2 End longitude (rad)
+ * @returns {distance: meters, bearing: radians}
+ */
+declare function rhumbLine(lat1: number, lon1: number, lat2: number, lon2: number): {
+    distance: number;
+    bearing: number;
+};
+/**
+ * 3D Euclidean (straight-line, through-the-earth) distance between two ECEF positions.
+ * @returns Distance in meters
+ */
+declare function euclidean3D(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): number;
+/**
+ * Geodetic midpoint along the great-circle arc.
+ * @returns [lat, lon] in radians
+ */
+declare function greatCircleMidpoint(lat1: number, lon1: number, lat2: number, lon2: number): [number, number];
+/**
+ * Geometric horizon distance from a given height above the ellipsoid.
+ * Uses the simple geometric formula with refraction coefficient k = 0.13 (standard atmosphere).
+ * @param heightMeters Height above ellipsoid in meters
+ * @returns Distance in meters
+ */
+declare function horizonDistance(heightMeters: number): number;
+
+/**
+ * Convert geodetic coordinates to UTM.
+ * @param lat Latitude in radians
+ * @param lon Longitude in radians
+ */
+declare function geodeticToUtm(lat: number, lon: number): {
+    easting: number;
+    northing: number;
+    zone: number;
+    hemisphere: 'N' | 'S';
+};
+/**
+ * Maidenhead grid locator (6 characters) from geodetic coordinates.
+ * @param lat Latitude in radians
+ * @param lon Longitude in radians
+ */
+declare function geodeticToMaidenhead(lat: number, lon: number): string;
+/**
+ * Geohash encoding from geodetic coordinates.
+ * @param lat Latitude in radians
+ * @param lon Longitude in radians
+ * @param precision Number of characters (default 8)
+ */
+declare function geodeticToGeohash(lat: number, lon: number, precision?: number): string;
+
+export { deg2dms, deg2rad, euclidean3D, geodeticToGeohash, geodeticToMaidenhead, geodeticToUtm, greatCircleMidpoint, horizonDistance, rad2deg, rhumbLine, vincenty };

package/dist/coordinates.d.ts

@@ -0,0 +1,81 @@
+export { c as clampUnit, e as ecefToGeodetic, g as geodeticToEcef, a as getAer, b as getEnuDifference } from './ecef-CF0uAysr.js';
+
+/** Convert radians to degrees. */
+declare function rad2deg(radians: number): number;
+/** Convert degrees to radians. */
+declare function deg2rad(degrees: number): number;
+/**
+ * Convert decimal degrees to [degrees, minutes, seconds].
+ * Always returns positive values (use the sign of the input separately).
+ */
+declare function deg2dms(deg: number): [number, number, number];
+
+/**
+ * Vincenty's inverse formula — orthodromic (great-circle) distance,
+ * initial bearing, and final bearing on the WGS84 ellipsoid.
+ * All angles in radians.
+ * @returns { distance (m), initialBearing (rad), finalBearing (rad) }
+ */
+declare function vincenty(lat1: number, lon1: number, lat2: number, lon2: number): {
+    distance: number;
+    initialBearing: number;
+    finalBearing: number;
+};
+/**
+ * Loxodromic (rhumb line) distance and constant bearing on the WGS84 ellipsoid.
+ * Uses the ellipsoidal rhumb-line formula with isometric latitudes.
+ * All angles in radians.
+ * @param lat1 Start latitude (rad)
+ * @param lon1 Start longitude (rad)
+ * @param lat2 End latitude (rad)
+ * @param lon2 End longitude (rad)
+ * @returns {distance: meters, bearing: radians}
+ */
+declare function rhumbLine(lat1: number, lon1: number, lat2: number, lon2: number): {
+    distance: number;
+    bearing: number;
+};
+/**
+ * 3D Euclidean (straight-line, through-the-earth) distance between two ECEF positions.
+ * @returns Distance in meters
+ */
+declare function euclidean3D(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): number;
+/**
+ * Geodetic midpoint along the great-circle arc.
+ * @returns [lat, lon] in radians
+ */
+declare function greatCircleMidpoint(lat1: number, lon1: number, lat2: number, lon2: number): [number, number];
+/**
+ * Geometric horizon distance from a given height above the ellipsoid.
+ * Uses the simple geometric formula with refraction coefficient k = 0.13 (standard atmosphere).
+ * @param heightMeters Height above ellipsoid in meters
+ * @returns Distance in meters
+ */
+declare function horizonDistance(heightMeters: number): number;
+
+/**
+ * Convert geodetic coordinates to UTM.
+ * @param lat Latitude in radians
+ * @param lon Longitude in radians
+ */
+declare function geodeticToUtm(lat: number, lon: number): {
+    easting: number;
+    northing: number;
+    zone: number;
+    hemisphere: 'N' | 'S';
+};
+/**
+ * Maidenhead grid locator (6 characters) from geodetic coordinates.
+ * @param lat Latitude in radians
+ * @param lon Longitude in radians
+ */
+declare function geodeticToMaidenhead(lat: number, lon: number): string;
+/**
+ * Geohash encoding from geodetic coordinates.
+ * @param lat Latitude in radians
+ * @param lon Longitude in radians
+ * @param precision Number of characters (default 8)
+ */
+declare function geodeticToGeohash(lat: number, lon: number, precision?: number): string;
+
+export { deg2dms, deg2rad, euclidean3D, geodeticToGeohash, geodeticToMaidenhead, geodeticToUtm, greatCircleMidpoint, horizonDistance, rad2deg, rhumbLine, vincenty };

package/dist/coordinates.js

@@ -0,0 +1,39 @@
+import {
+  deg2dms,
+  deg2rad,
+  euclidean3D,
+  geodeticToGeohash,
+  geodeticToMaidenhead,
+  geodeticToUtm,
+  greatCircleMidpoint,
+  horizonDistance,
+  rad2deg,
+  rhumbLine,
+  vincenty
+} from "./chunk-K7WZQFBV.js";
+import {
+  clampUnit,
+  ecefToGeodetic,
+  geodeticToEcef,
+  getAer,
+  getEnuDifference
+} from "./chunk-37QNKGTC.js";
+import "./chunk-6FAL6P4G.js";
+export {
+  clampUnit,
+  deg2dms,
+  deg2rad,
+  ecefToGeodetic,
+  euclidean3D,
+  geodeticToEcef,
+  geodeticToGeohash,
+  geodeticToMaidenhead,
+  geodeticToUtm,
+  getAer,
+  getEnuDifference,
+  greatCircleMidpoint,
+  horizonDistance,
+  rad2deg,
+  rhumbLine,
+  vincenty
+};

package/dist/ecef-CF0uAysr.d.cts

@@ -0,0 +1,40 @@
+/**
+ * Clamp value to [-1, 1] to prevent NaN from asin/acos rounding errors.
+ * @param x Value to clamp
+ * @returns Clamped value in [-1, 1]
+ */
+declare function clampUnit(x: number): number;
+/**
+ * Convert geodetic coordinates to ECEF (Earth-Centered, Earth-Fixed).
+ * @param lat Latitude in radians
+ * @param lon Longitude in radians
+ * @param h Ellipsoidal height in meters
+ * @returns [X, Y, Z] in meters
+ */
+declare function geodeticToEcef(lat: number, lon: number, h: number): [number, number, number];
+/**
+ * Convert ECEF coordinates to geodetic (iterative Bowring method).
+ * @param x X in meters
+ * @param y Y in meters
+ * @param z Z in meters
+ * @returns [lat (rad), lon (rad), height (m)]
+ */
+declare function ecefToGeodetic(x: number, y: number, z: number): [number, number, number];
+/**
+ * Compute ENU (East, North, Up) difference between a point and a reference in ECEF.
+ * @param x Target X in meters (ECEF)
+ * @param y Target Y in meters (ECEF)
+ * @param z Target Z in meters (ECEF)
+ * @param xRef Reference X in meters (ECEF)
+ * @param yRef Reference Y in meters (ECEF)
+ * @param zRef Reference Z in meters (ECEF)
+ * @returns [deltaE, deltaN, deltaU] in meters
+ */
+declare function getEnuDifference(x: number, y: number, z: number, xRef: number, yRef: number, zRef: number): [number, number, number];
+/**
+ * Compute Azimuth, Elevation, and Range from a reference point to a target in ECEF.
+ * @returns [elevation (rad), azimuth (rad), slant range (m)]
+ */
+declare function getAer(x: number, y: number, z: number, xRef: number, yRef: number, zRef: number): [number, number, number];
+
+export { getAer as a, getEnuDifference as b, clampUnit as c, ecefToGeodetic as e, geodeticToEcef as g };

package/dist/ecef-CF0uAysr.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Clamp value to [-1, 1] to prevent NaN from asin/acos rounding errors.
+ * @param x Value to clamp
+ * @returns Clamped value in [-1, 1]
+ */
+declare function clampUnit(x: number): number;
+/**
+ * Convert geodetic coordinates to ECEF (Earth-Centered, Earth-Fixed).
+ * @param lat Latitude in radians
+ * @param lon Longitude in radians
+ * @param h Ellipsoidal height in meters
+ * @returns [X, Y, Z] in meters
+ */
+declare function geodeticToEcef(lat: number, lon: number, h: number): [number, number, number];
+/**
+ * Convert ECEF coordinates to geodetic (iterative Bowring method).
+ * @param x X in meters
+ * @param y Y in meters
+ * @param z Z in meters
+ * @returns [lat (rad), lon (rad), height (m)]
+ */
+declare function ecefToGeodetic(x: number, y: number, z: number): [number, number, number];
+/**
+ * Compute ENU (East, North, Up) difference between a point and a reference in ECEF.
+ * @param x Target X in meters (ECEF)
+ * @param y Target Y in meters (ECEF)
+ * @param z Target Z in meters (ECEF)
+ * @param xRef Reference X in meters (ECEF)
+ * @param yRef Reference Y in meters (ECEF)
+ * @param zRef Reference Z in meters (ECEF)
+ * @returns [deltaE, deltaN, deltaU] in meters
+ */
+declare function getEnuDifference(x: number, y: number, z: number, xRef: number, yRef: number, zRef: number): [number, number, number];
+/**
+ * Compute Azimuth, Elevation, and Range from a reference point to a target in ECEF.
+ * @returns [elevation (rad), azimuth (rad), slant range (m)]
+ */
+declare function getAer(x: number, y: number, z: number, xRef: number, yRef: number, zRef: number): [number, number, number];
+
+export { getAer as a, getEnuDifference as b, clampUnit as c, ecefToGeodetic as e, geodeticToEcef as g };