gnss-js 0.1.2 → 1.0.1

package/dist/chunk-LEEU5OIO.js

@@ -0,0 +1,75 @@
+// src/constants/time.ts
+var SECONDS_IN_WEEK = 604800;
+var SECONDS_IN_DAY = 86400;
+var SECONDS_IN_HOUR = 3600;
+var SECONDS_IN_MINUTE = 60;
+var MILLISECONDS_IN_WEEK = 6048e5;
+var MILLISECONDS_IN_DAY = 864e5;
+var MILLISECONDS_IN_HOUR = 36e5;
+var MILLISECONDS_IN_MINUTE = 6e4;
+var MILLISECONDS_IN_SECOND = 1e3;
+var MILLISECONDS_TT_TAI = 32184;
+var MILLISECONDS_GPS_TAI = 19e3;
+var START_GPS_TIME = /* @__PURE__ */ new Date("1980-01-06T00:00:00Z");
+var START_GAL_TIME = /* @__PURE__ */ new Date("1999-08-22T00:00:00Z");
+var START_BDS_TIME = /* @__PURE__ */ new Date("2006-01-01T00:00:14Z");
+var START_UNIX_TIME = /* @__PURE__ */ new Date("1969-12-31T23:59:49Z");
+var START_NTP_TIME = /* @__PURE__ */ new Date("1900-01-01T00:00:00Z");
+var START_GLO_LEAP = /* @__PURE__ */ new Date("1996-01-01T00:00:00Z");
+var START_TAI_TIME = /* @__PURE__ */ new Date("1957-12-31T23:59:41Z");
+var RINEX_CODES = [
+  "a",
+  "b",
+  "c",
+  "d",
+  "e",
+  "f",
+  "g",
+  "h",
+  "i",
+  "j",
+  "k",
+  "l",
+  "m",
+  "n",
+  "o",
+  "p",
+  "q",
+  "r",
+  "s",
+  "t",
+  "u",
+  "v",
+  "w",
+  "x"
+];
+var START_JULIAN_TAI = 24362045e-1;
+var DAYS_MJD_JULIAN = 24000005e-1;
+var DAYS_MJD2000_MJD = 51544.5;
+var START_MJD_UNIX_SECONDS = 40587;
+
+export {
+  SECONDS_IN_WEEK,
+  SECONDS_IN_DAY,
+  SECONDS_IN_HOUR,
+  SECONDS_IN_MINUTE,
+  MILLISECONDS_IN_WEEK,
+  MILLISECONDS_IN_DAY,
+  MILLISECONDS_IN_HOUR,
+  MILLISECONDS_IN_MINUTE,
+  MILLISECONDS_IN_SECOND,
+  MILLISECONDS_TT_TAI,
+  MILLISECONDS_GPS_TAI,
+  START_GPS_TIME,
+  START_GAL_TIME,
+  START_BDS_TIME,
+  START_UNIX_TIME,
+  START_NTP_TIME,
+  START_GLO_LEAP,
+  START_TAI_TIME,
+  RINEX_CODES,
+  START_JULIAN_TAI,
+  DAYS_MJD_JULIAN,
+  DAYS_MJD2000_MJD,
+  START_MJD_UNIX_SECONDS
+};

package/dist/chunk-LWNTWBHB.js

@@ -0,0 +1,268 @@
+// src/constants/gnss.ts
+var SYSTEM_NAMES = {
+  G: "GPS",
+  R: "GLONASS",
+  E: "Galileo",
+  C: "BeiDou",
+  J: "QZSS",
+  I: "NavIC",
+  S: "SBAS"
+};
+var SYS_SHORT = {
+  G: "GPS",
+  R: "GLO",
+  E: "GAL",
+  C: "BDS",
+  J: "QZS",
+  I: "NIC",
+  S: "SBS"
+};
+var C_LIGHT = 299792458;
+var FREQ = {
+  G: { "1": 157542e4, "2": 12276e5, "5": 117645e4 },
+  R: { "3": 1202025e3 },
+  E: {
+    "1": 157542e4,
+    "5": 117645e4,
+    "6": 127875e4,
+    "7": 120714e4,
+    "8": 1191795e3
+  },
+  C: {
+    "1": 157542e4,
+    "2": 1561098e3,
+    "5": 117645e4,
+    "6": 126852e4,
+    "7": 120714e4
+  },
+  J: { "1": 157542e4, "2": 12276e5, "5": 117645e4, "6": 127875e4 },
+  I: { "5": 117645e4, "9": 2492028e3 },
+  S: { "1": 157542e4, "5": 117645e4 }
+};
+var BAND_LABELS = {
+  G: { "1": "L1", "2": "L2", "5": "L5" },
+  R: { "1": "G1", "2": "G2", "3": "G3" },
+  E: { "1": "E1", "5": "E5a", "6": "E6", "7": "E5b", "8": "E5" },
+  C: { "1": "B1C", "2": "B1I", "5": "B2a", "6": "B3I", "7": "B2I" },
+  J: { "1": "L1", "2": "L2", "5": "L5", "6": "L6" },
+  I: { "5": "L5", "9": "S" },
+  S: { "1": "L1", "5": "L5" }
+};
+var DUAL_FREQ_PAIRS = {
+  G: [
+    ["1", "2"],
+    ["1", "5"]
+  ],
+  R: [
+    ["1", "2"],
+    ["1", "3"]
+  ],
+  E: [
+    ["1", "5"],
+    ["1", "7"],
+    ["1", "6"]
+  ],
+  C: [
+    ["2", "7"],
+    ["2", "6"],
+    ["1", "5"]
+  ],
+  J: [
+    ["1", "2"],
+    ["1", "5"]
+  ],
+  I: [["5", "9"]],
+  S: [["1", "5"]]
+};
+var GLO_F1_BASE = 1602e6;
+var GLO_F1_STEP = 562500;
+var GLO_F2_BASE = 1246e6;
+var GLO_F2_STEP = 437500;
+var GLO_F3 = 1202025e3;
+var GLO_CHANNEL_FALLBACK = {
+  R01: 1,
+  R02: -4,
+  R03: 5,
+  R04: 6,
+  R05: 1,
+  R06: -4,
+  R07: 5,
+  R08: 6,
+  R09: -2,
+  R10: -7,
+  R11: 0,
+  R12: -1,
+  R13: -2,
+  R14: -7,
+  R15: 0,
+  R16: -1,
+  R17: 4,
+  R18: -3,
+  R19: 3,
+  R20: 2,
+  R21: 4,
+  R22: -3,
+  R23: 3,
+  R24: 2
+};
+function buildGloChannelMap(slots) {
+  if (Object.keys(slots).length === 0) return { ...GLO_CHANNEL_FALLBACK };
+  const map = {};
+  for (const [slot, k] of Object.entries(slots)) {
+    map[`R${String(slot).padStart(2, "0")}`] = k;
+  }
+  return map;
+}
+function gloFreq(gloChannels, prn, band) {
+  const k = gloChannels[prn];
+  if (k === void 0) return void 0;
+  if (band === "1") return GLO_F1_BASE + k * GLO_F1_STEP;
+  if (band === "2") return GLO_F2_BASE + k * GLO_F2_STEP;
+  if (band === "3") return GLO_F3;
+  return void 0;
+}
+function getFreq(gloChannels, prn, band) {
+  const sys = prn[0];
+  if (sys === "R") return gloFreq(gloChannels, prn, band);
+  return FREQ[sys]?.[band];
+}
+var BDS_SATELLITES = [
+  { prn: "C01", phase: "BDS-2", orbit: "GEO" },
+  { prn: "C02", phase: "BDS-2", orbit: "GEO" },
+  { prn: "C03", phase: "BDS-2", orbit: "GEO" },
+  { prn: "C04", phase: "BDS-2", orbit: "GEO" },
+  { prn: "C05", phase: "BDS-2", orbit: "GEO" },
+  { prn: "C06", phase: "BDS-2", orbit: "IGSO" },
+  { prn: "C07", phase: "BDS-2", orbit: "IGSO" },
+  { prn: "C08", phase: "BDS-2", orbit: "IGSO" },
+  { prn: "C09", phase: "BDS-2", orbit: "IGSO" },
+  { prn: "C10", phase: "BDS-2", orbit: "IGSO" },
+  { prn: "C13", phase: "BDS-2", orbit: "IGSO" },
+  { prn: "C16", phase: "BDS-2", orbit: "IGSO" },
+  { prn: "C11", phase: "BDS-2", orbit: "MEO" },
+  { prn: "C12", phase: "BDS-2", orbit: "MEO" },
+  { prn: "C14", phase: "BDS-2", orbit: "MEO" },
+  { prn: "C19", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C20", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C21", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C22", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C23", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C24", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C25", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C26", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C27", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C28", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C29", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C30", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C32", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C33", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C34", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C35", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C36", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C37", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C41", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C42", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C43", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C44", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C45", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C46", phase: "BDS-3", orbit: "MEO" },
+  { prn: "C38", phase: "BDS-3", orbit: "IGSO" },
+  { prn: "C39", phase: "BDS-3", orbit: "IGSO" },
+  { prn: "C40", phase: "BDS-3", orbit: "IGSO" },
+  { prn: "C59", phase: "BDS-3", orbit: "GEO" },
+  { prn: "C60", phase: "BDS-3", orbit: "GEO" },
+  { prn: "C61", phase: "BDS-3", orbit: "GEO" }
+];
+var ATTR_PRIORITY = {
+  X: 8,
+  C: 7,
+  S: 6,
+  L: 6,
+  Q: 6,
+  I: 5,
+  B: 5,
+  D: 4,
+  Z: 3,
+  P: 2,
+  W: 1
+};
+function attrRank(code) {
+  return ATTR_PRIORITY[code[2] ?? ""] ?? 3;
+}
+function buildObsIndices(header) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [sys, codes] of Object.entries(header.obsTypes)) {
+    if (sys === "_v2") continue;
+    const lIdx = /* @__PURE__ */ new Map();
+    const lRank = /* @__PURE__ */ new Map();
+    const cIdx = /* @__PURE__ */ new Map();
+    const cRank = /* @__PURE__ */ new Map();
+    for (let i = 0; i < codes.length; i++) {
+      const code = codes[i];
+      const type = code[0];
+      const band = code[1];
+      if (!band) continue;
+      const rank = attrRank(code);
+      if (type === "L" && rank > (lRank.get(band) ?? -1)) {
+        lIdx.set(band, i);
+        lRank.set(band, rank);
+      }
+      if ((type === "C" || type === "P") && rank > (cRank.get(band) ?? -1)) {
+        cIdx.set(band, i);
+        cRank.set(band, rank);
+      }
+    }
+    const bandMap = /* @__PURE__ */ new Map();
+    for (const [band, li] of lIdx) {
+      bandMap.set(band, { L: li, C: cIdx.get(band) ?? null });
+    }
+    if (bandMap.size > 0) result.set(sys, bandMap);
+  }
+  const v2codes = header.obsTypes["_v2"];
+  if (v2codes) {
+    const lIdx = /* @__PURE__ */ new Map();
+    const cIdx = /* @__PURE__ */ new Map();
+    for (let i = 0; i < v2codes.length; i++) {
+      const code = v2codes[i];
+      const type = code[0];
+      const band = code[1];
+      if (!band) continue;
+      if (type === "L" && !lIdx.has(band)) lIdx.set(band, i);
+      if ((type === "C" || type === "P") && !cIdx.has(band)) cIdx.set(band, i);
+    }
+    const bandMap = /* @__PURE__ */ new Map();
+    for (const [band, li] of lIdx) {
+      bandMap.set(band, { L: li, C: cIdx.get(band) ?? null });
+    }
+    if (bandMap.size > 0) result.set("_v2", bandMap);
+  }
+  return result;
+}
+var ARC_GAP_FACTOR = 5;
+var DEFAULT_ELEV_MASK_DEG = 5;
+function formatUTCTime(d) {
+  return `${String(d.getUTCHours()).padStart(2, "0")}:${String(d.getUTCMinutes()).padStart(2, "0")}:${String(d.getUTCSeconds()).padStart(2, "0")}`;
+}
+
+export {
+  SYSTEM_NAMES,
+  SYS_SHORT,
+  C_LIGHT,
+  FREQ,
+  BAND_LABELS,
+  DUAL_FREQ_PAIRS,
+  GLO_F1_BASE,
+  GLO_F1_STEP,
+  GLO_F2_BASE,
+  GLO_F2_STEP,
+  GLO_F3,
+  GLO_CHANNEL_FALLBACK,
+  buildGloChannelMap,
+  gloFreq,
+  getFreq,
+  BDS_SATELLITES,
+  buildObsIndices,
+  ARC_GAP_FACTOR,
+  DEFAULT_ELEV_MASK_DEG,
+  formatUTCTime
+};

package/dist/chunk-MIIM4LDY.js

@@ -0,0 +1,239 @@
+import {
+  WGS84_ECCENTRICITY_SQUARED,
+  WGS84_FLATTENING,
+  WGS84_SEMI_MAJOR_AXIS,
+  WGS84_SEMI_MINOR_AXIS
+} from "./chunk-6FAL6P4G.js";
+
+// 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/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;
+}
+
+export {
+  rad2deg,
+  deg2rad,
+  deg2dms,
+  vincenty,
+  rhumbLine,
+  euclidean3D,
+  greatCircleMidpoint,
+  horizonDistance,
+  geodeticToUtm,
+  geodeticToMaidenhead,
+  geodeticToGeohash
+};