gnss-js 0.1.1 → 1.0.0

package/dist/chunk-K7WZQFBV.js

@@ -0,0 +1,236 @@
+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
+};

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
+};