gnss-js 0.1.1 → 1.0.0

package/dist/analysis.d.cts

@@ -0,0 +1,211 @@
+import { R as RinexHeader } from './parser-JPjjFgeP.cjs';
+import { O as OnSlipDetected } from './gnss-BT6ulR17.cjs';
+
+/**
+ * Multipath analysis from RINEX dual-frequency observations.
+ *
+ * Computes code-multipath (MP) combinations:
+ *   MP_i = C_i - (1 + 2/(α-1))·L_i·λ_i + (2/(α-1))·L_j·λ_j
+ * where α = (f_i/f_j)², C = pseudorange (m), L = carrier phase (cycles), λ = wavelength.
+ *
+ * Arc-mean debiasing removes carrier-phase ambiguity per continuous arc.
+ */
+
+interface MultipathPoint {
+    /** Epoch time in milliseconds. */
+    time: number;
+    /** Code multipath combination value in meters. */
+    mp: number;
+}
+interface MultipathSeries {
+    /** Satellite PRN, e.g. "G01". */
+    prn: string;
+    /** System letter, e.g. "G". */
+    system: string;
+    /** Primary band digit, e.g. "1". */
+    band: string;
+    /** Reference band digit used in dual-frequency combination, e.g. "2". */
+    refBand: string;
+    /** Human-readable label, e.g. "MP1 L1-L2". */
+    label: string;
+    /** Time series of multipath values. */
+    points: MultipathPoint[];
+    /** RMS of the multipath series in meters. */
+    rms: number;
+}
+interface MultipathSignalStat {
+    /** Human-readable label, e.g. "MP1 L1-L2 (GPS)". */
+    label: string;
+    /** System letter, e.g. "G". */
+    system: string;
+    /** Primary band digit. */
+    band: string;
+    /** Reference band digit. */
+    refBand: string;
+    /** RMS multipath in meters (aggregated across satellites). */
+    rms: number;
+    /** Total number of multipath observations. */
+    count: number;
+    /** Number of distinct satellites contributing. */
+    satellites: number;
+}
+interface MultipathResult {
+    /** Per-satellite multipath time series. */
+    series: MultipathSeries[];
+    /** Aggregated per-signal statistics. */
+    signalStats: MultipathSignalStat[];
+}
+declare class MultipathAccumulator {
+    private state;
+    private results;
+    private interval;
+    private obsIndices;
+    private gloChannels;
+    constructor(header: RinexHeader);
+    /** Observation callback — wire this into parseRinexStream. */
+    onObservation: (time: number, prn: string, _codes: string[], values: (number | null)[]) => void;
+    private pushMp;
+    /** External cycle-slip notification — close affected arcs for this PRN. */
+    notifySlip(_time: number, prn: string, bands: Set<string>): void;
+    private closeArc;
+    /** Finalize: close remaining arcs and compute statistics. */
+    finalize(): MultipathResult;
+}
+
+/**
+ * Cycle slip detection from RINEX carrier phase observations.
+ *
+ * Detection hierarchy (per frequency pair):
+ *  1. Melbourne-Wübbena (MW): uses both code (C) and phase (L) on two bands.
+ *     MW = φ_WL − P_NL / λ_WL  (wide-lane ambiguity, cycles)
+ *     Smoothed with running mean — a deviation > threshold flags a slip.
+ *     Skipped for GLONASS (FDMA: per-satellite frequencies unknown).
+ *  2. Geometry-Free (GF): L1·λ1 − L2·λ2 (requires only phase on two bands).
+ *     Removes geometry but retains ionospheric signature.
+ *  3. Single-frequency phase-code (SF): |Δφ_m − ΔP| between consecutive epochs.
+ *     Removes satellite motion via code; only works when code is available.
+ */
+
+interface CycleSlipEvent {
+    /** Epoch time in milliseconds. */
+    time: number;
+    /** Satellite PRN, e.g. "G01". */
+    prn: string;
+    /** Detection method and bands, e.g. "MW L1-L2", "GF L1-L2", or "L1" (single-freq). */
+    signal: string;
+    /**
+     * Slip magnitude. Units depend on detection method:
+     * - MW (Melbourne-Wübbena): wide-lane cycles
+     * - GF (geometry-free): meters
+     * - SF (single-frequency): meters
+     */
+    magnitude: number;
+}
+interface CycleSlipSignalStats {
+    /** Human label, e.g. "MW L1-L2 (GPS)". */
+    label: string;
+    /** System letter, e.g. "G". */
+    system: string;
+    /** Total cycle slips detected for this signal combination. */
+    totalSlips: number;
+    /** Number of distinct satellites with data. */
+    satellites: number;
+    /** Total observation epochs for this combination. */
+    totalEpochs: number;
+    /** Slip rate: slips per 1000 epochs. */
+    slipRate: number;
+}
+interface CycleSlipResult {
+    events: CycleSlipEvent[];
+    signalStats: CycleSlipSignalStats[];
+    /** Per-satellite slip counts. Key = PRN, value = total slips. */
+    satSlipCounts: Record<string, number>;
+}
+declare class CycleSlipAccumulator {
+    private obsIndices;
+    private prev;
+    private events;
+    private interval;
+    /** GLONASS PRN → channel k for FDMA frequency computation. */
+    private gloChannels;
+    private onSlip?;
+    private signalEpochs;
+    private signalSlips;
+    private signalSats;
+    constructor(header: RinexHeader, onSlip?: OnSlipDetected);
+    private recordSlip;
+    private countEpoch;
+    /** Resolve frequency for a given PRN + band. Handles GLONASS FDMA. */
+    private getFreqForPrn;
+    onObservation: (time: number, prn: string, _codes: string[], values: (number | null)[]) => void;
+    finalize(): CycleSlipResult;
+}
+
+/**
+ * Data completeness analysis from RINEX observations.
+ *
+ * Tracks which observation codes are present (non-null) vs expected for each
+ * satellite in each epoch, computing per-satellite per-signal completeness.
+ */
+
+interface CompleteSatSignal {
+    /** Satellite PRN, e.g. "G01". */
+    prn: string;
+    /** System letter, e.g. "G". */
+    system: string;
+    /** RINEX observation code, e.g. "C1C", "L1C", "S1C". */
+    code: string;
+    /** Band digit, e.g. "1". */
+    band: string;
+    /** Epochs where satellite was present and expected to transmit this signal. */
+    expected: number;
+    /** Epochs where this observation code had a non-null value. */
+    present: number;
+    /** Completeness percentage (0-100). */
+    percent: number;
+}
+interface CompleteSignalStats {
+    /** RINEX observation code, e.g. "C1C". */
+    code: string;
+    /** System letter, e.g. "G". */
+    system: string;
+    /** Human-readable label, e.g. "C1C (GPS L1)". */
+    label: string;
+    /** Total expected observations across all satellites. */
+    expected: number;
+    /** Total present (non-null) observations. */
+    present: number;
+    /** Completeness percentage (0-100). */
+    percent: number;
+    /** Number of distinct satellites contributing. */
+    satellites: number;
+}
+interface CompletenessResult {
+    /** Per-satellite per-signal completeness breakdown. */
+    cells: CompleteSatSignal[];
+    /** Aggregated per-signal statistics. */
+    signalStats: CompleteSignalStats[];
+    /** System letters present in the data. */
+    systems: string[];
+}
+declare class CompletenessAccumulator {
+    private data;
+    private header;
+    constructor(header: RinexHeader);
+    onObservation: (_time: number, prn: string, codes: string[], values: (number | null)[]) => void;
+    finalize(): CompletenessResult;
+}
+
+/**
+ * Combined quality analysis — runs cycle slip detection, data completeness,
+ * and multipath analysis in a single file re-parse pass.
+ */
+
+interface QualityResult {
+    cycleSlips: CycleSlipResult;
+    completeness: CompletenessResult;
+    multipath: MultipathResult;
+}
+declare function analyzeQuality(file: File, header: RinexHeader, onProgress?: (percent: number) => void, signal?: AbortSignal): Promise<QualityResult>;
+
+export { type CompleteSatSignal, type CompleteSignalStats, CompletenessAccumulator, type CompletenessResult, CycleSlipAccumulator, type CycleSlipEvent, type CycleSlipResult, type CycleSlipSignalStats, MultipathAccumulator, type MultipathPoint, type MultipathResult, type MultipathSeries, type MultipathSignalStat, type QualityResult, analyzeQuality };

package/dist/analysis.d.ts

@@ -0,0 +1,211 @@
+import { R as RinexHeader } from './parser-JPjjFgeP.js';
+import { O as OnSlipDetected } from './gnss-C-tgoYNa.js';
+
+/**
+ * Multipath analysis from RINEX dual-frequency observations.
+ *
+ * Computes code-multipath (MP) combinations:
+ *   MP_i = C_i - (1 + 2/(α-1))·L_i·λ_i + (2/(α-1))·L_j·λ_j
+ * where α = (f_i/f_j)², C = pseudorange (m), L = carrier phase (cycles), λ = wavelength.
+ *
+ * Arc-mean debiasing removes carrier-phase ambiguity per continuous arc.
+ */
+
+interface MultipathPoint {
+    /** Epoch time in milliseconds. */
+    time: number;
+    /** Code multipath combination value in meters. */
+    mp: number;
+}
+interface MultipathSeries {
+    /** Satellite PRN, e.g. "G01". */
+    prn: string;
+    /** System letter, e.g. "G". */
+    system: string;
+    /** Primary band digit, e.g. "1". */
+    band: string;
+    /** Reference band digit used in dual-frequency combination, e.g. "2". */
+    refBand: string;
+    /** Human-readable label, e.g. "MP1 L1-L2". */
+    label: string;
+    /** Time series of multipath values. */
+    points: MultipathPoint[];
+    /** RMS of the multipath series in meters. */
+    rms: number;
+}
+interface MultipathSignalStat {
+    /** Human-readable label, e.g. "MP1 L1-L2 (GPS)". */
+    label: string;
+    /** System letter, e.g. "G". */
+    system: string;
+    /** Primary band digit. */
+    band: string;
+    /** Reference band digit. */
+    refBand: string;
+    /** RMS multipath in meters (aggregated across satellites). */
+    rms: number;
+    /** Total number of multipath observations. */
+    count: number;
+    /** Number of distinct satellites contributing. */
+    satellites: number;
+}
+interface MultipathResult {
+    /** Per-satellite multipath time series. */
+    series: MultipathSeries[];
+    /** Aggregated per-signal statistics. */
+    signalStats: MultipathSignalStat[];
+}
+declare class MultipathAccumulator {
+    private state;
+    private results;
+    private interval;
+    private obsIndices;
+    private gloChannels;
+    constructor(header: RinexHeader);
+    /** Observation callback — wire this into parseRinexStream. */
+    onObservation: (time: number, prn: string, _codes: string[], values: (number | null)[]) => void;
+    private pushMp;
+    /** External cycle-slip notification — close affected arcs for this PRN. */
+    notifySlip(_time: number, prn: string, bands: Set<string>): void;
+    private closeArc;
+    /** Finalize: close remaining arcs and compute statistics. */
+    finalize(): MultipathResult;
+}
+
+/**
+ * Cycle slip detection from RINEX carrier phase observations.
+ *
+ * Detection hierarchy (per frequency pair):
+ *  1. Melbourne-Wübbena (MW): uses both code (C) and phase (L) on two bands.
+ *     MW = φ_WL − P_NL / λ_WL  (wide-lane ambiguity, cycles)
+ *     Smoothed with running mean — a deviation > threshold flags a slip.
+ *     Skipped for GLONASS (FDMA: per-satellite frequencies unknown).
+ *  2. Geometry-Free (GF): L1·λ1 − L2·λ2 (requires only phase on two bands).
+ *     Removes geometry but retains ionospheric signature.
+ *  3. Single-frequency phase-code (SF): |Δφ_m − ΔP| between consecutive epochs.
+ *     Removes satellite motion via code; only works when code is available.
+ */
+
+interface CycleSlipEvent {
+    /** Epoch time in milliseconds. */
+    time: number;
+    /** Satellite PRN, e.g. "G01". */
+    prn: string;
+    /** Detection method and bands, e.g. "MW L1-L2", "GF L1-L2", or "L1" (single-freq). */
+    signal: string;
+    /**
+     * Slip magnitude. Units depend on detection method:
+     * - MW (Melbourne-Wübbena): wide-lane cycles
+     * - GF (geometry-free): meters
+     * - SF (single-frequency): meters
+     */
+    magnitude: number;
+}
+interface CycleSlipSignalStats {
+    /** Human label, e.g. "MW L1-L2 (GPS)". */
+    label: string;
+    /** System letter, e.g. "G". */
+    system: string;
+    /** Total cycle slips detected for this signal combination. */
+    totalSlips: number;
+    /** Number of distinct satellites with data. */
+    satellites: number;
+    /** Total observation epochs for this combination. */
+    totalEpochs: number;
+    /** Slip rate: slips per 1000 epochs. */
+    slipRate: number;
+}
+interface CycleSlipResult {
+    events: CycleSlipEvent[];
+    signalStats: CycleSlipSignalStats[];
+    /** Per-satellite slip counts. Key = PRN, value = total slips. */
+    satSlipCounts: Record<string, number>;
+}
+declare class CycleSlipAccumulator {
+    private obsIndices;
+    private prev;
+    private events;
+    private interval;
+    /** GLONASS PRN → channel k for FDMA frequency computation. */
+    private gloChannels;
+    private onSlip?;
+    private signalEpochs;
+    private signalSlips;
+    private signalSats;
+    constructor(header: RinexHeader, onSlip?: OnSlipDetected);
+    private recordSlip;
+    private countEpoch;
+    /** Resolve frequency for a given PRN + band. Handles GLONASS FDMA. */
+    private getFreqForPrn;
+    onObservation: (time: number, prn: string, _codes: string[], values: (number | null)[]) => void;
+    finalize(): CycleSlipResult;
+}
+
+/**
+ * Data completeness analysis from RINEX observations.
+ *
+ * Tracks which observation codes are present (non-null) vs expected for each
+ * satellite in each epoch, computing per-satellite per-signal completeness.
+ */
+
+interface CompleteSatSignal {
+    /** Satellite PRN, e.g. "G01". */
+    prn: string;
+    /** System letter, e.g. "G". */
+    system: string;
+    /** RINEX observation code, e.g. "C1C", "L1C", "S1C". */
+    code: string;
+    /** Band digit, e.g. "1". */
+    band: string;
+    /** Epochs where satellite was present and expected to transmit this signal. */
+    expected: number;
+    /** Epochs where this observation code had a non-null value. */
+    present: number;
+    /** Completeness percentage (0-100). */
+    percent: number;
+}
+interface CompleteSignalStats {
+    /** RINEX observation code, e.g. "C1C". */
+    code: string;
+    /** System letter, e.g. "G". */
+    system: string;
+    /** Human-readable label, e.g. "C1C (GPS L1)". */
+    label: string;
+    /** Total expected observations across all satellites. */
+    expected: number;
+    /** Total present (non-null) observations. */
+    present: number;
+    /** Completeness percentage (0-100). */
+    percent: number;
+    /** Number of distinct satellites contributing. */
+    satellites: number;
+}
+interface CompletenessResult {
+    /** Per-satellite per-signal completeness breakdown. */
+    cells: CompleteSatSignal[];
+    /** Aggregated per-signal statistics. */
+    signalStats: CompleteSignalStats[];
+    /** System letters present in the data. */
+    systems: string[];
+}
+declare class CompletenessAccumulator {
+    private data;
+    private header;
+    constructor(header: RinexHeader);
+    onObservation: (_time: number, prn: string, codes: string[], values: (number | null)[]) => void;
+    finalize(): CompletenessResult;
+}
+
+/**
+ * Combined quality analysis — runs cycle slip detection, data completeness,
+ * and multipath analysis in a single file re-parse pass.
+ */
+
+interface QualityResult {
+    cycleSlips: CycleSlipResult;
+    completeness: CompletenessResult;
+    multipath: MultipathResult;
+}
+declare function analyzeQuality(file: File, header: RinexHeader, onProgress?: (percent: number) => void, signal?: AbortSignal): Promise<QualityResult>;
+
+export { type CompleteSatSignal, type CompleteSignalStats, CompletenessAccumulator, type CompletenessResult, CycleSlipAccumulator, type CycleSlipEvent, type CycleSlipResult, type CycleSlipSignalStats, MultipathAccumulator, type MultipathPoint, type MultipathResult, type MultipathSeries, type MultipathSignalStat, type QualityResult, analyzeQuality };

package/dist/analysis.js

@@ -0,0 +1,14 @@
+import {
+  CompletenessAccumulator,
+  CycleSlipAccumulator,
+  MultipathAccumulator,
+  analyzeQuality
+} from "./chunk-Y3R57B5P.js";
+import "./chunk-CB6EOOLA.js";
+import "./chunk-354IRDOG.js";
+export {
+  CompletenessAccumulator,
+  CycleSlipAccumulator,
+  MultipathAccumulator,
+  analyzeQuality
+};

package/dist/antex.cjs

@@ -0,0 +1,239 @@
+"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/antex/index.ts
+var antex_exports = {};
+__export(antex_exports, {
+  frequencyLabel: () => frequencyLabel,
+  parseAntex: () => parseAntex
+});
+module.exports = __toCommonJS(antex_exports);
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  frequencyLabel,
+  parseAntex
+});