gnss-js 0.1.2 → 1.0.0

package/dist/antex.d.cts

@@ -0,0 +1,77 @@
+/**
+ * ANTEX 1.4 (Antenna Exchange Format) parser.
+ * Parses receiver and satellite antenna calibration files containing
+ * Phase Center Offsets (PCO) and Phase Center Variations (PCV).
+ */
+interface FrequencyData {
+    /** Frequency code, e.g. "G01", "E05" */
+    frequency: string;
+    /** Phase Center Offset — North/X component (mm) */
+    pcoN: number;
+    /** Phase Center Offset — East/Y component (mm) */
+    pcoE: number;
+    /** Phase Center Offset — Up/Z component (mm) */
+    pcoU: number;
+    /** Non-azimuth-dependent PCV values (mm), length = numZen */
+    pcvNoazi: number[];
+    /**
+     * Azimuth-dependent PCV grid (mm).
+     * Rows = azimuths (0..360 step dazi), cols = zenith angles.
+     * Empty when dazi === 0 (no azimuth dependence).
+     */
+    pcv: number[][];
+}
+interface AntennaEntry {
+    /** Antenna type name (20 chars, e.g. "LEIAR20         LEIM") */
+    type: string;
+    /** Serial number or satellite code (e.g. "G05", or blank for type-mean) */
+    serialNo: string;
+    /** SVN code (satellites only, optional) */
+    svnCode: string;
+    /** COSPAR ID (satellites only, optional) */
+    cosparId: string;
+    /** Whether this is a satellite antenna (vs receiver) */
+    isSatellite: boolean;
+    /** Calibration method */
+    method: string;
+    /** Agency that performed calibration */
+    agency: string;
+    /** Number of individual antennas calibrated */
+    numCalibrated: number;
+    /** Calibration date string */
+    date: string;
+    /** Azimuth increment (degrees). 0 = no azimuth dependence. */
+    dazi: number;
+    /** Zenith/nadir start angle (degrees) */
+    zen1: number;
+    /** Zenith/nadir end angle (degrees) */
+    zen2: number;
+    /** Zenith/nadir increment (degrees) */
+    dzen: number;
+    /** SINEX code (optional) */
+    sinexCode: string;
+    /** Valid-from date (optional) */
+    validFrom: string;
+    /** Valid-until date (optional) */
+    validUntil: string;
+    /** Per-frequency calibration data */
+    frequencies: FrequencyData[];
+}
+interface AntexFile {
+    /** Format version (e.g. 1.4) */
+    version: number;
+    /** Satellite system flag ('G','R','E','C','J','S','M') */
+    system: string;
+    /** PCV type: 'A' (absolute) or 'R' (relative) */
+    pcvType: string;
+    /** Reference antenna type (for relative values) */
+    refAntenna: string;
+    /** Header comments */
+    comments: string[];
+    /** All antenna entries in the file */
+    antennas: AntennaEntry[];
+}
+declare function parseAntex(text: string): AntexFile;
+declare function frequencyLabel(code: string): string;
+
+export { type AntennaEntry, type AntexFile, type FrequencyData, frequencyLabel, parseAntex };

package/dist/antex.d.ts

@@ -0,0 +1,77 @@
+/**
+ * ANTEX 1.4 (Antenna Exchange Format) parser.
+ * Parses receiver and satellite antenna calibration files containing
+ * Phase Center Offsets (PCO) and Phase Center Variations (PCV).
+ */
+interface FrequencyData {
+    /** Frequency code, e.g. "G01", "E05" */
+    frequency: string;
+    /** Phase Center Offset — North/X component (mm) */
+    pcoN: number;
+    /** Phase Center Offset — East/Y component (mm) */
+    pcoE: number;
+    /** Phase Center Offset — Up/Z component (mm) */
+    pcoU: number;
+    /** Non-azimuth-dependent PCV values (mm), length = numZen */
+    pcvNoazi: number[];
+    /**
+     * Azimuth-dependent PCV grid (mm).
+     * Rows = azimuths (0..360 step dazi), cols = zenith angles.
+     * Empty when dazi === 0 (no azimuth dependence).
+     */
+    pcv: number[][];
+}
+interface AntennaEntry {
+    /** Antenna type name (20 chars, e.g. "LEIAR20         LEIM") */
+    type: string;
+    /** Serial number or satellite code (e.g. "G05", or blank for type-mean) */
+    serialNo: string;
+    /** SVN code (satellites only, optional) */
+    svnCode: string;
+    /** COSPAR ID (satellites only, optional) */
+    cosparId: string;
+    /** Whether this is a satellite antenna (vs receiver) */
+    isSatellite: boolean;
+    /** Calibration method */
+    method: string;
+    /** Agency that performed calibration */
+    agency: string;
+    /** Number of individual antennas calibrated */
+    numCalibrated: number;
+    /** Calibration date string */
+    date: string;
+    /** Azimuth increment (degrees). 0 = no azimuth dependence. */
+    dazi: number;
+    /** Zenith/nadir start angle (degrees) */
+    zen1: number;
+    /** Zenith/nadir end angle (degrees) */
+    zen2: number;
+    /** Zenith/nadir increment (degrees) */
+    dzen: number;
+    /** SINEX code (optional) */
+    sinexCode: string;
+    /** Valid-from date (optional) */
+    validFrom: string;
+    /** Valid-until date (optional) */
+    validUntil: string;
+    /** Per-frequency calibration data */
+    frequencies: FrequencyData[];
+}
+interface AntexFile {
+    /** Format version (e.g. 1.4) */
+    version: number;
+    /** Satellite system flag ('G','R','E','C','J','S','M') */
+    system: string;
+    /** PCV type: 'A' (absolute) or 'R' (relative) */
+    pcvType: string;
+    /** Reference antenna type (for relative values) */
+    refAntenna: string;
+    /** Header comments */
+    comments: string[];
+    /** All antenna entries in the file */
+    antennas: AntennaEntry[];
+}
+declare function parseAntex(text: string): AntexFile;
+declare function frequencyLabel(code: string): string;
+
+export { type AntennaEntry, type AntexFile, type FrequencyData, frequencyLabel, parseAntex };

package/dist/antex.js

@@ -0,0 +1,8 @@
+import {
+  frequencyLabel,
+  parseAntex
+} from "./chunk-5CMSYIYM.js";
+export {
+  frequencyLabel,
+  parseAntex
+};

package/dist/chunk-354IRDOG.js

@@ -0,0 +1,239 @@
+// 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-37QNKGTC.js

@@ -0,0 +1,65 @@
+import {
+  WGS84_ECCENTRICITY_SQUARED,
+  WGS84_SEMI_MAJOR_AXIS
+} from "./chunk-6FAL6P4G.js";
+
+// 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];
+}
+
+export {
+  clampUnit,
+  geodeticToEcef,
+  ecefToGeodetic,
+  getEnuDifference,
+  getAer
+};

package/dist/chunk-5CMSYIYM.js

@@ -0,0 +1,214 @@
+// src/antex/index.ts
+function label(line) {
+  return (line.length >= 80 ? line.substring(60, 80) : line.substring(60)).trimEnd();
+}
+function parseFloat10(s) {
+  return parseFloat(s) || 0;
+}
+function parseFloat6(s) {
+  return parseFloat(s) || 0;
+}
+function parseInt6(s) {
+  return parseInt(s, 10) || 0;
+}
+function parseValidityDate(line) {
+  const year = parseInt(line.substring(0, 6), 10);
+  const month = parseInt(line.substring(6, 12), 10);
+  const day = parseInt(line.substring(12, 18), 10);
+  const hour = parseInt(line.substring(18, 24), 10);
+  const min = parseInt(line.substring(24, 30), 10);
+  if (isNaN(year)) return "";
+  return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")} ${String(hour).padStart(2, "0")}:${String(min).padStart(2, "0")}`;
+}
+function parsePcvRow(line, offset, count) {
+  const vals = [];
+  for (let i = 0; i < count; i++) {
+    const start = offset + i * 8;
+    const s = line.substring(start, start + 8);
+    vals.push(parseFloat(s) || 0);
+  }
+  return vals;
+}
+function parseFrequencyBlock(lines, numZen, hasAzimuth, _numAzi) {
+  let frequency = "";
+  let pcoN = 0, pcoE = 0, pcoU = 0;
+  const pcvNoazi = [];
+  const pcv = [];
+  for (const line of lines) {
+    const lbl = label(line);
+    if (lbl === "START OF FREQUENCY") {
+      frequency = line.substring(3, 6).trim();
+    } else if (lbl === "NORTH / EAST / UP") {
+      pcoN = parseFloat10(line.substring(0, 10));
+      pcoE = parseFloat10(line.substring(10, 20));
+      pcoU = parseFloat10(line.substring(20, 30));
+    } else if (line.substring(3, 8) === "NOAZI") {
+      pcvNoazi.push(...parsePcvRow(line, 8, numZen));
+    } else if (lbl !== "END OF FREQUENCY" && lbl !== "START OF FREQUENCY") {
+      if (hasAzimuth && line.length > 8) {
+        const row = parsePcvRow(line, 8, numZen);
+        pcv.push(row);
+      }
+    }
+  }
+  return { frequency, pcoN, pcoE, pcoU, pcvNoazi, pcv };
+}
+function parseAntex(text) {
+  const allLines = text.split(/\r?\n/);
+  let version = 0;
+  let system = "";
+  let pcvType = "";
+  let refAntenna = "";
+  const comments = [];
+  const antennas = [];
+  let inHeader = true;
+  let inAntenna = false;
+  let inFreq = false;
+  let freqLines = [];
+  let type = "", serialNo = "", svnCode = "", cosparId = "";
+  let method = "", agency = "", date = "";
+  let numCalibrated = 0;
+  let dazi = 0, zen1 = 0, zen2 = 0, dzen = 0;
+  let sinexCode = "", validFrom = "", validUntil = "";
+  let frequencies = [];
+  let isSatellite = false;
+  for (const rawLine of allLines) {
+    const line = rawLine.length < 80 ? rawLine.padEnd(80) : rawLine;
+    const lbl = label(line);
+    if (inHeader) {
+      if (lbl === "ANTEX VERSION / SYST") {
+        version = parseFloat(line.substring(0, 8)) || 0;
+        system = line.substring(20, 21).trim();
+      } else if (lbl === "PCV TYPE / REFANT") {
+        pcvType = line.substring(0, 1).trim();
+        refAntenna = line.substring(20, 40).trim();
+      } else if (lbl === "COMMENT") {
+        comments.push(line.substring(0, 60).trim());
+      } else if (lbl === "END OF HEADER") {
+        inHeader = false;
+      }
+      continue;
+    }
+    if (lbl === "START OF ANTENNA") {
+      inAntenna = true;
+      type = "";
+      serialNo = "";
+      svnCode = "";
+      cosparId = "";
+      method = "";
+      agency = "";
+      date = "";
+      numCalibrated = 0;
+      dazi = 0;
+      zen1 = 0;
+      zen2 = 0;
+      dzen = 0;
+      sinexCode = "";
+      validFrom = "";
+      validUntil = "";
+      frequencies = [];
+      isSatellite = false;
+      continue;
+    }
+    if (!inAntenna) continue;
+    if (lbl === "END OF ANTENNA") {
+      antennas.push({
+        type,
+        serialNo,
+        svnCode,
+        cosparId,
+        isSatellite,
+        method,
+        agency,
+        numCalibrated,
+        date,
+        dazi,
+        zen1,
+        zen2,
+        dzen,
+        sinexCode,
+        validFrom,
+        validUntil,
+        frequencies
+      });
+      inAntenna = false;
+      continue;
+    }
+    if (lbl === "TYPE / SERIAL NO") {
+      type = line.substring(0, 20).trim();
+      serialNo = line.substring(20, 40).trim();
+      svnCode = line.substring(40, 50).trim();
+      cosparId = line.substring(50, 60).trim();
+      isSatellite = /^[GRECIJS]\d{2,3}$/.test(serialNo);
+    } else if (lbl === "METH / BY / # / DATE") {
+      method = line.substring(0, 20).trim();
+      agency = line.substring(20, 40).trim();
+      numCalibrated = parseInt6(line.substring(40, 46));
+      date = line.substring(50, 60).trim();
+    } else if (lbl === "DAZI") {
+      dazi = parseFloat6(line.substring(2, 8));
+    } else if (lbl === "ZEN1 / ZEN2 / DZEN") {
+      zen1 = parseFloat6(line.substring(2, 8));
+      zen2 = parseFloat6(line.substring(8, 14));
+      dzen = parseFloat6(line.substring(14, 20));
+    } else if (lbl === "SINEX CODE") {
+      sinexCode = line.substring(0, 10).trim();
+    } else if (lbl === "VALID FROM") {
+      validFrom = parseValidityDate(line);
+    } else if (lbl === "VALID UNTIL") {
+      validUntil = parseValidityDate(line);
+    } else if (lbl === "START OF FREQUENCY") {
+      inFreq = true;
+      freqLines = [line];
+    } else if (lbl === "END OF FREQUENCY") {
+      freqLines.push(line);
+      inFreq = false;
+      const numZen = dzen > 0 ? Math.round((zen2 - zen1) / dzen) + 1 : 0;
+      const hasAzimuth = dazi > 0;
+      const numAzi = hasAzimuth ? Math.round(360 / dazi) + 1 : 0;
+      frequencies.push(
+        parseFrequencyBlock(freqLines, numZen, hasAzimuth, numAzi)
+      );
+    } else if (lbl === "START OF FREQ RMS") {
+      inFreq = false;
+    } else if (inFreq) {
+      freqLines.push(line);
+    }
+  }
+  return { version, system, pcvType, refAntenna, comments, antennas };
+}
+var FREQ_LABELS = {
+  G01: "GPS L1",
+  G02: "GPS L2",
+  G05: "GPS L5",
+  R01: "GLO G1",
+  R02: "GLO G2",
+  R04: "GLO G1a",
+  R06: "GLO G2a",
+  E01: "GAL E1",
+  E05: "GAL E5a",
+  E06: "GAL E6",
+  E07: "GAL E5b",
+  E08: "GAL E5",
+  C01: "BDS B1",
+  C02: "BDS B1-2",
+  C05: "BDS B2a",
+  C06: "BDS B3",
+  C07: "BDS B2b",
+  C08: "BDS B2",
+  J01: "QZS L1",
+  J02: "QZS L2",
+  J05: "QZS L5",
+  J06: "QZS LEX",
+  S01: "SBS L1",
+  S05: "SBS L5",
+  I05: "NIC L5"
+};
+function frequencyLabel(code) {
+  return FREQ_LABELS[code] ?? code;
+}
+
+export {
+  parseAntex,
+  frequencyLabel
+};

package/dist/chunk-6FAL6P4G.js

@@ -0,0 +1,12 @@
+// 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;
+
+export {
+  WGS84_SEMI_MAJOR_AXIS,
+  WGS84_SEMI_MINOR_AXIS,
+  WGS84_FLATTENING,
+  WGS84_ECCENTRICITY_SQUARED
+};