gnss-js 1.26.0 → 1.28.0

package/dist/chunk-4KMWWCUR.js

@@ -0,0 +1,120 @@
+// src/rinex/sp3.ts
+var BAD_CLOCK = 999999.999999;
+function parseSp3(text) {
+  const lines = text.split("\n");
+  const epochs = [];
+  const satellites = {};
+  let version = "";
+  let intervalSec = 0;
+  let timeSystem = "GPS";
+  let timeSystemSet = false;
+  let epochIdx = -1;
+  for (const line of lines) {
+    if (!version && line.startsWith("#") && line.charAt(1) !== "#") {
+      version = line.charAt(1);
+    }
+    if (line.startsWith("##")) {
+      const f = line.slice(2).trim().split(/\s+/);
+      intervalSec = Number(f[2]) || 0;
+    } else if (line.startsWith("%c") && !timeSystemSet) {
+      const sys = line.slice(9, 12).trim();
+      if (sys && !/^c+$/.test(sys)) {
+        timeSystem = sys;
+        timeSystemSet = true;
+      }
+    } else if (line.startsWith("*")) {
+      const f = line.slice(1).trim().split(/\s+/).map(Number);
+      if (f.length >= 6 && f.every(Number.isFinite)) {
+        const sec = f[5];
+        epochs.push(
+          Date.UTC(
+            f[0],
+            f[1] - 1,
+            f[2],
+            f[3],
+            f[4],
+            Math.floor(sec),
+            Math.round(sec % 1 * 1e3)
+          )
+        );
+        epochIdx++;
+      }
+    } else if (line.startsWith("P") && epochIdx >= 0) {
+      const prn = line.slice(1, 4).replace(/\s/g, "0");
+      const f = line.slice(4).trim().split(/\s+/).map(Number);
+      if (f.length < 3) continue;
+      const [xKm, yKm, zKm] = f;
+      let arr = satellites[prn];
+      if (!arr) satellites[prn] = arr = [];
+      while (arr.length < epochIdx) arr.push(null);
+      if (xKm === 0 && yKm === 0 && zKm === 0) {
+        arr.push(null);
+        continue;
+      }
+      const clkUs = f[3];
+      arr.push({
+        x: xKm * 1e3,
+        y: yKm * 1e3,
+        z: zKm * 1e3,
+        clk: clkUs !== void 0 && Math.abs(clkUs) < BAD_CLOCK ? clkUs * 1e-6 : null
+      });
+    }
+  }
+  for (const arr of Object.values(satellites)) {
+    while (arr.length < epochs.length) arr.push(null);
+  }
+  return { version, epochs, intervalSec, timeSystem, satellites };
+}
+function sp3Position(sp3, prn, tMs, order = 9) {
+  const samples = sp3.satellites[prn];
+  const { epochs } = sp3;
+  const n = epochs.length;
+  if (!samples || n < order) return null;
+  if (tMs < epochs[0] || tMs > epochs[n - 1]) return null;
+  let lo = 0;
+  let hi = n - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (epochs[mid] <= tMs) lo = mid;
+    else hi = mid - 1;
+  }
+  let start = lo - (order >> 1) + (order % 2 === 0 ? 1 : 0);
+  start = Math.max(0, Math.min(n - order, start));
+  for (let i = start; i < start + order; i++) {
+    if (!samples[i]) return null;
+  }
+  const t0 = epochs[start];
+  const t = (tMs - t0) / 1e3;
+  let x = 0;
+  let y = 0;
+  let z = 0;
+  for (let i = 0; i < order; i++) {
+    const ti = (epochs[start + i] - t0) / 1e3;
+    let w = 1;
+    for (let j = 0; j < order; j++) {
+      if (j === i) continue;
+      const tj = (epochs[start + j] - t0) / 1e3;
+      w *= (t - tj) / (ti - tj);
+    }
+    const s = samples[start + i];
+    x += w * s.x;
+    y += w * s.y;
+    z += w * s.z;
+  }
+  let clk = null;
+  const a = samples[lo];
+  const b = samples[Math.min(lo + 1, n - 1)];
+  if (a?.clk != null && b?.clk != null) {
+    const span = epochs[Math.min(lo + 1, n - 1)] - epochs[lo];
+    const f = span > 0 ? (tMs - epochs[lo]) / span : 0;
+    clk = a.clk * (1 - f) + b.clk * f;
+  } else if (a?.clk != null) {
+    clk = a.clk;
+  }
+  return { x, y, z, clk };
+}
+
+export {
+  parseSp3,
+  sp3Position
+};

package/dist/{chunk-WDUN4BWL.js → chunk-6GTS5MVI.js}

@@ -6,6 +6,442 @@ import {
   GPS_PI
 } from "./chunk-IQ5OIMQD.js";
 
+// src/rinex/crx-writer.ts
+var ARC_ORDER = 3;
+function emptyData() {
+  return { u: [0, 0, 0, 0], l: [0, 0, 0, 0], order: -1 };
+}
+function cAtol(s) {
+  let i = 0;
+  while (i < s.length && (s[i] === " " || s[i] === "	")) i++;
+  let sign = 1;
+  if (s[i] === "+" || s[i] === "-") {
+    if (s[i] === "-") sign = -1;
+    i++;
+  }
+  let n = 0;
+  let any = false;
+  while (i < s.length && s[i] >= "0" && s[i] <= "9") {
+    n = n * 10 + (s.charCodeAt(i) - 48);
+    i++;
+    any = true;
+  }
+  return any ? sign * n : 0;
+}
+function strdiff(s1, s2) {
+  let ds = "";
+  const n = Math.min(s1.length, s2.length);
+  let i = 0;
+  for (; i < n; i++) {
+    if (s2[i] === s1[i]) ds += " ";
+    else if (s2[i] === " ") ds += "&";
+    else ds += s2[i];
+  }
+  if (s1.length > s2.length) {
+    for (let k = i; k < s1.length; k++) ds += s1[k] === " " ? " " : "&";
+  } else if (s2.length > s1.length) {
+    ds += s2.slice(i);
+  }
+  let end = ds.length;
+  while (end > 0 && ds[end - 1] === " ") end--;
+  return ds.slice(0, end);
+}
+function readValue(field14) {
+  const c = field14.padEnd(14, " ").split("");
+  const p7 = c[7];
+  c[10] = c[9];
+  c[9] = c[8];
+  let l = cAtol(c.slice(9, 14).join(""));
+  let u;
+  if (p7 === " ") {
+    u = 0;
+  } else if (p7 === "-") {
+    u = 0;
+    l = -l;
+  } else {
+    c[8] = ".";
+    u = cAtol(c.slice(0, 14).join(""));
+    if (u < 0) l = -l;
+  }
+  return { u, l };
+}
+function putdiff(dddu, dddl) {
+  dddu += Math.trunc(dddl / 1e5);
+  dddl %= 1e5;
+  if (dddu < 0 && dddl > 0) {
+    dddu++;
+    dddl -= 1e5;
+  } else if (dddu > 0 && dddl < 0) {
+    dddu--;
+    dddl += 1e5;
+  }
+  if (dddu === 0) return String(dddl);
+  return `${dddu}${String(Math.abs(dddl)).padStart(5, "0")}`;
+}
+function putClock(du, dl, cOrder) {
+  du += Math.trunc(dl / 1e8);
+  dl %= 1e8;
+  if (du < 0 && dl > 0) {
+    du++;
+    dl -= 1e8;
+  } else if (du > 0 && dl < 0) {
+    du--;
+    dl += 1e8;
+  }
+  let out = "";
+  if (cOrder === 0) out += `${ARC_ORDER}&`;
+  if (du === 0) out += String(dl);
+  else out += `${du}${String(Math.abs(dl)).padStart(8, "0")}`;
+  return out;
+}
+function chop(line) {
+  let end = line.length;
+  if (end > 0 && line[end - 1] === "\r") end--;
+  while (end > 0 && line[end - 1] === " ") end--;
+  return line.slice(0, end);
+}
+function readSat(lines, cursor, rinexVersion, ntype, ntypeGnss) {
+  let line = chop(lines[cursor.li++] ?? "");
+  let maxField;
+  let ntypeRec;
+  let firstRec;
+  let satId = "";
+  if (rinexVersion === 2) {
+    maxField = 5;
+    ntypeRec = ntype;
+    firstRec = 0;
+  } else {
+    satId = line.slice(0, 3);
+    const sys = line[0];
+    maxField = ntypeRec = ntypeGnss[sys] ?? -1;
+    if (maxField < 0) return null;
+    firstRec = 3;
+  }
+  const data = [];
+  let flag = "";
+  for (let i = 0; i < ntypeRec; i += maxField) {
+    const nfield = Math.min(ntypeRec - i, maxField);
+    const need = firstRec + 16 * nfield;
+    let body = line;
+    if (body.length < need) body = body.padEnd(need, " ");
+    for (let j = 0; j < nfield; j++) {
+      const p = firstRec + j * 16;
+      const rec = body.slice(p, p + 16);
+      const d = emptyData();
+      if (rec[10] === ".") {
+        flag += rec[14] ?? " ";
+        flag += rec[15] ?? " ";
+        const v = readValue(rec.slice(0, 14));
+        d.u[0] = v.u;
+        d.l[0] = v.l;
+        d.order = 0;
+      } else if (rec.slice(0, 14).trim() === "") {
+        flag += rec[14] ?? " ";
+        flag += rec[15] ?? " ";
+        d.order = -1;
+      } else {
+        return null;
+      }
+      data.push(d);
+    }
+    if (i + maxField < ntypeRec) {
+      line = chop(lines[cursor.li++] ?? "");
+    }
+  }
+  return { sat: { data, flag, ntypeRec }, satId };
+}
+var MONTHS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+function crinexDate() {
+  const d = /* @__PURE__ */ new Date();
+  const dd = String(d.getUTCDate()).padStart(2, "0");
+  const mon = MONTHS[d.getUTCMonth()];
+  const yy = String(d.getUTCFullYear() % 100).padStart(2, "0");
+  const hh = String(d.getUTCHours()).padStart(2, "0");
+  const mm = String(d.getUTCMinutes()).padStart(2, "0");
+  return `${dd}-${mon}-${yy} ${hh}:${mm}`;
+}
+function writeCrx(rinexText, opts = {}) {
+  const rawLines = rinexText.split("\n");
+  const cursor = { li: 0 };
+  const out = [];
+  const firstLine = chop(rawLines[cursor.li++] ?? "");
+  if (firstLine.slice(60, 80) !== "RINEX VERSION / TYPE" || firstLine[20] !== "O") {
+    throw new Error("writeCrx: not a RINEX observation file");
+  }
+  const rinexVersion = parseInt(firstLine, 10);
+  const rinexVersionFull = readVersionFull(firstLine);
+  if (rinexVersionFull < 0) throw new Error("writeCrx: invalid RINEX version");
+  const crxVersion = rinexVersionFull >= 402 ? "3.1" : rinexVersion === 2 ? "1.0" : "3.0";
+  out.push(
+    `${crxVersion.padEnd(20)}${"COMPACT RINEX FORMAT".padEnd(40)}${"CRINEX VERS   / TYPE".padEnd(20)}`
+  );
+  const prog = (opts.prog ?? "gnss-js writeCrx").slice(0, 40);
+  const date = opts.date ?? crinexDate();
+  out.push(`${prog.padEnd(40)}${date.padEnd(20)}CRINEX PROG / DATE`);
+  out.push(firstLine);
+  let ntype = 0;
+  const ntypeGnss = {};
+  let line;
+  do {
+    line = chop(rawLines[cursor.li++] ?? "");
+    out.push(line);
+    const label = line.slice(60).trimStart();
+    if (label.startsWith("# / TYPES OF OBSERV") && line[5] !== " ") {
+      ntype = parseInt(line, 10);
+    } else if (label.startsWith("SYS / # / OBS TYPES") && line[0] !== " ") {
+      ntypeGnss[line[0]] = parseInt(line.slice(3), 10);
+    }
+    if (cursor.li >= rawLines.length) break;
+  } while (!line.slice(60).trimStart().startsWith("END OF HEADER"));
+  const v2 = rinexVersion === 2;
+  const off = v2 ? { event: 28, nsat: 29, satlst: 32, clock: 68, satOld: 32, shiftClk: 1 } : {
+    event: 31,
+    nsat: 32,
+    satlst: 41,
+    clock: 41,
+    satOld: 41,
+    shiftClk: 4,
+    psec: 57
+  };
+  let oldline = "&";
+  let nsatOld = 0;
+  let clk0 = { u: [0, 0, 0, 0], l: [0, 0, 0, 0] };
+  let dy0 = [];
+  let flag0 = [];
+  let oldpsec = "";
+  let clkOrderPrev = -1;
+  const resetArcs = () => {
+    oldline = "&";
+    nsatOld = 0;
+    clkOrderPrev = -1;
+  };
+  for (; ; ) {
+    if (cursor.li >= rawLines.length) break;
+    let epoch = rawLines[cursor.li];
+    if (epoch === void 0) break;
+    if (epoch === "" && cursor.li === rawLines.length - 1) break;
+    cursor.li++;
+    epoch = chop(epoch);
+    if (epoch === "") continue;
+    let newline;
+    if (v2) {
+      newline = epoch;
+    } else {
+      newline = epoch.length < 41 ? epoch.padEnd(41, " ") : epoch;
+    }
+    const eventFlag = parseInt(newline[off.event] ?? "0", 10) || 0;
+    if (eventFlag > 1) {
+      putEventData(rawLines, cursor, v2, newline, out, ntypeGnss, (n) => {
+        ntype = n;
+      });
+      resetArcs();
+      clk0 = { u: [0, 0, 0, 0], l: [0, 0, 0, 0] };
+      dy0 = [];
+      flag0 = [];
+      continue;
+    }
+    let newpsec = "";
+    if (rinexVersionFull >= 402 && newline.length === 62) {
+      const psec = newline.slice(off.psec, off.psec + 5);
+      if (/^\d{5}$/.test(psec)) newpsec = psec;
+      newline = newline.slice(0, off.psec).replace(/\s+$/, "");
+    }
+    let clkOrder = -1;
+    const clk1 = { u: [0, 0, 0, 0], l: [0, 0, 0, 0] };
+    if (newline.length > off.clock) {
+      clkOrder = readClock(
+        newline.slice(off.clock),
+        off.shiftClk,
+        clk1,
+        clkOrderPrev
+      );
+      if (clkOrder > -1) {
+        newline = newline.slice(0, off.clock).replace(/\s+$/, "");
+        if (!v2 && newline.length < 41) newline = newline.padEnd(41, " ");
+      }
+    }
+    clkOrderPrev = clkOrder;
+    const nsat = parseInt((newline.slice(off.nsat) || "0").trim(), 10) || 0;
+    if (v2 && nsat > 12) {
+      newline = readMoreSat(rawLines, cursor, nsat, newline);
+    }
+    const sats = [];
+    const satIds = [];
+    let bad = false;
+    let satlist = v2 ? newline.slice(off.satlst, off.satlst + nsat * 3) : "";
+    for (let i = 0; i < nsat; i++) {
+      const r = readSat(rawLines, cursor, rinexVersion, ntype, ntypeGnss);
+      if (!r) {
+        bad = true;
+        break;
+      }
+      sats.push(r.sat);
+      satIds.push(v2 ? satlist.slice(i * 3, i * 3 + 3) : r.satId);
+    }
+    if (bad) continue;
+    if (!v2) satlist = satIds.join("");
+    const fullNew = v2 ? newline : newline.slice(0, 41) + satlist;
+    const oldSatList = v2 ? oldline.slice(off.satOld, off.satOld + nsatOld * 3) : oldline.slice(off.satOld);
+    const sattbl = [];
+    const dup = /* @__PURE__ */ new Set();
+    for (let i = 0; i < nsat; i++) {
+      const id = satIds[i];
+      if (dup.has(id)) {
+        bad = true;
+        break;
+      }
+      dup.add(id);
+      let found = -1;
+      for (let j = 0; j < nsatOld; j++) {
+        if (oldSatList.slice(j * 3, j * 3 + 3) === id) {
+          found = j;
+          break;
+        }
+      }
+      sattbl.push(found);
+    }
+    if (bad) continue;
+    out.push(strdiff(oldline, fullNew));
+    let clockLine = "";
+    if (clkOrder > -1) {
+      if (clkOrder > 0) processClock(clk1, clk0, clkOrder);
+      clockLine += putClock(clk1.u[clkOrder], clk1.l[clkOrder], clkOrder);
+    }
+    if (newpsec.length === 5) {
+      clockLine += " " + strdiff(oldpsec, newpsec);
+    }
+    out.push(clockLine);
+    const dataLines = buildData(sats, sattbl, dy0, flag0, rinexVersion);
+    for (const dl of dataLines) out.push(dl);
+    oldline = fullNew;
+    nsatOld = nsat;
+    clk0 = clk1;
+    oldpsec = newpsec;
+    dy0 = sats.map((s) => s.data);
+    flag0 = sats.map((s) => s.flag);
+  }
+  return out.join("\n") + "\n";
+}
+function readClock(field, shiftClk, clk1, prevOrder) {
+  const c = field.split("");
+  if (c[2] !== ".") return -1;
+  for (let k = 0; k < shiftClk; k++) c[2 + k] = c[3 + k];
+  c[2 + shiftClk] = ".";
+  const s = c.join("");
+  const m = /(-?\d+)\.(\d+)/.exec(s);
+  if (!m) return -1;
+  clk1.u[0] = parseInt(m[1], 10);
+  clk1.l[0] = parseInt(m[2], 10);
+  if (c[0] === "-" || c[1] === "-") clk1.l[0] = -clk1.l[0];
+  return Math.min(prevOrder + 1, ARC_ORDER);
+}
+function processClock(clk1, clk0, clkOrder) {
+  for (let i = 0; i < clkOrder; i++) {
+    clk1.u[i + 1] = clk1.u[i] - clk0.u[i];
+    clk1.l[i + 1] = clk1.l[i] - clk0.l[i];
+  }
+}
+function takeDiff(py1, py0) {
+  py1.order = py0.order;
+  if (py1.order < ARC_ORDER) py1.order++;
+  for (let k = 0; k < py1.order; k++) {
+    py1.u[k + 1] = py1.u[k] - py0.u[k];
+    py1.l[k + 1] = py1.l[k] - py0.l[k];
+  }
+}
+function buildData(sats, sattbl, dy0, flag0, rinexVersion) {
+  const lines = [];
+  for (let i = 0; i < sats.length; i++) {
+    const sat = sats[i];
+    const i0 = sattbl[i];
+    const prevFlag = (i0 >= 0 ? flag0[i0] ?? "" : "").split("");
+    let line = "";
+    for (let j = 0; j < sat.ntypeRec; j++) {
+      const py1 = sat.data[j];
+      if (py1.order >= 0) {
+        if (i0 < 0 || dy0[i0]?.[j]?.order === -1) {
+          py1.order = 0;
+          line += `${ARC_ORDER}&`;
+        } else {
+          takeDiff(py1, dy0[i0][j]);
+          if (Math.abs(py1.u[py1.order]) > 1e5) {
+            py1.order = 0;
+            line += `${ARC_ORDER}&`;
+          }
+        }
+        line += putdiff(py1.u[py1.order], py1.l[py1.order]);
+      } else if (i0 >= 0 && rinexVersion === 2) {
+        prevFlag[j * 2] = " ";
+        prevFlag[j * 2 + 1] = " ";
+      }
+      line += " ";
+    }
+    if (i0 < 0 && rinexVersion !== 2) {
+      for (const ch of sat.flag) line += ch === " " ? "&" : ch;
+    } else {
+      line += i0 < 0 ? strdiff("", sat.flag) : strdiff(prevFlag.join(""), sat.flag);
+      line = line.replace(/ +$/, "");
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+function putEventData(lines, cursor, v2, epochLine, out, ntypeGnss, setNtype) {
+  if (v2) {
+    out.push("&" + epochLine.slice(1));
+    if (epochLine.length > 29) {
+      const n = parseInt(epochLine.slice(29), 10) || 0;
+      for (let i = 0; i < n; i++) {
+        const l = chop(lines[cursor.li++] ?? "");
+        out.push(l);
+        if (l.slice(60).trimStart().startsWith("# / TYPES OF OBSERV") && l[5] !== " ") {
+          setNtype(parseInt(l, 10));
+        }
+      }
+    }
+  } else {
+    out.push(epochLine.replace(/\s+$/, ""));
+    const n = parseInt(epochLine.slice(32), 10) || 0;
+    for (let i = 0; i < n; i++) {
+      const l = chop(lines[cursor.li++] ?? "");
+      out.push(l);
+      if (l.slice(60).trimStart().startsWith("SYS / # / OBS TYPES") && l[0] !== " ") {
+        ntypeGnss[l[0]] = parseInt(l.slice(3), 10);
+      }
+    }
+  }
+}
+function readMoreSat(lines, cursor, n, epochLine) {
+  let result = epochLine;
+  let remaining = n;
+  while (remaining > 12) {
+    const l = lines[cursor.li++] ?? "";
+    const chopped = chop(l);
+    result += chopped[2] === " " ? chopped.slice(32) : chopped;
+    remaining -= 12;
+  }
+  return result;
+}
+function readVersionFull(line) {
+  if (line[5] === "2" && line[6] === " ") return 200;
+  const d = (c) => c !== void 0 && c >= "0" && c <= "9";
+  if (!d(line[5]) || line[6] !== "." || !d(line[7]) || !d(line[8])) return -1;
+  return (line.charCodeAt(5) - 48) * 100 + (line.charCodeAt(7) - 48) * 10 + (line.charCodeAt(8) - 48);
+}
+
 // src/rinex/format.ts
 function padL(s, w) {
   return s.length >= w ? s.slice(0, w) : s + " ".repeat(w - s.length);
@@ -981,122 +1417,6 @@ function parseIonex(text) {
   return { epochs, lats, lons, maps };
 }
 
-// src/rinex/sp3.ts
-var BAD_CLOCK = 999999.999999;
-function parseSp3(text) {
-  const lines = text.split("\n");
-  const epochs = [];
-  const satellites = {};
-  let version = "";
-  let intervalSec = 0;
-  let timeSystem = "GPS";
-  let timeSystemSet = false;
-  let epochIdx = -1;
-  for (const line of lines) {
-    if (!version && line.startsWith("#") && line.charAt(1) !== "#") {
-      version = line.charAt(1);
-    }
-    if (line.startsWith("##")) {
-      const f = line.slice(2).trim().split(/\s+/);
-      intervalSec = Number(f[2]) || 0;
-    } else if (line.startsWith("%c") && !timeSystemSet) {
-      const sys = line.slice(9, 12).trim();
-      if (sys && !/^c+$/.test(sys)) {
-        timeSystem = sys;
-        timeSystemSet = true;
-      }
-    } else if (line.startsWith("*")) {
-      const f = line.slice(1).trim().split(/\s+/).map(Number);
-      if (f.length >= 6 && f.every(Number.isFinite)) {
-        const sec = f[5];
-        epochs.push(
-          Date.UTC(
-            f[0],
-            f[1] - 1,
-            f[2],
-            f[3],
-            f[4],
-            Math.floor(sec),
-            Math.round(sec % 1 * 1e3)
-          )
-        );
-        epochIdx++;
-      }
-    } else if (line.startsWith("P") && epochIdx >= 0) {
-      const prn = line.slice(1, 4).replace(/\s/g, "0");
-      const f = line.slice(4).trim().split(/\s+/).map(Number);
-      if (f.length < 3) continue;
-      const [xKm, yKm, zKm] = f;
-      let arr = satellites[prn];
-      if (!arr) satellites[prn] = arr = [];
-      while (arr.length < epochIdx) arr.push(null);
-      if (xKm === 0 && yKm === 0 && zKm === 0) {
-        arr.push(null);
-        continue;
-      }
-      const clkUs = f[3];
-      arr.push({
-        x: xKm * 1e3,
-        y: yKm * 1e3,
-        z: zKm * 1e3,
-        clk: clkUs !== void 0 && Math.abs(clkUs) < BAD_CLOCK ? clkUs * 1e-6 : null
-      });
-    }
-  }
-  for (const arr of Object.values(satellites)) {
-    while (arr.length < epochs.length) arr.push(null);
-  }
-  return { version, epochs, intervalSec, timeSystem, satellites };
-}
-function sp3Position(sp3, prn, tMs, order = 9) {
-  const samples = sp3.satellites[prn];
-  const { epochs } = sp3;
-  const n = epochs.length;
-  if (!samples || n < order) return null;
-  if (tMs < epochs[0] || tMs > epochs[n - 1]) return null;
-  let lo = 0;
-  let hi = n - 1;
-  while (lo < hi) {
-    const mid = lo + hi + 1 >> 1;
-    if (epochs[mid] <= tMs) lo = mid;
-    else hi = mid - 1;
-  }
-  let start = lo - (order >> 1) + (order % 2 === 0 ? 1 : 0);
-  start = Math.max(0, Math.min(n - order, start));
-  for (let i = start; i < start + order; i++) {
-    if (!samples[i]) return null;
-  }
-  const t0 = epochs[start];
-  const t = (tMs - t0) / 1e3;
-  let x = 0;
-  let y = 0;
-  let z = 0;
-  for (let i = 0; i < order; i++) {
-    const ti = (epochs[start + i] - t0) / 1e3;
-    let w = 1;
-    for (let j = 0; j < order; j++) {
-      if (j === i) continue;
-      const tj = (epochs[start + j] - t0) / 1e3;
-      w *= (t - tj) / (ti - tj);
-    }
-    const s = samples[start + i];
-    x += w * s.x;
-    y += w * s.y;
-    z += w * s.z;
-  }
-  let clk = null;
-  const a = samples[lo];
-  const b = samples[Math.min(lo + 1, n - 1)];
-  if (a?.clk != null && b?.clk != null) {
-    const span = epochs[Math.min(lo + 1, n - 1)] - epochs[lo];
-    const f = span > 0 ? (tMs - epochs[lo]) / span : 0;
-    clk = a.clk * (1 - f) + b.clk * f;
-  } else if (a?.clk != null) {
-    clk = a.clk;
-  }
-  return { x, y, z, clk };
-}
-
 // src/rinex/obs-writer-common.ts
 function createGzipLineSink() {
   const encoder = new TextEncoder();
@@ -1472,6 +1792,7 @@ function writeRinex4ObsBlob(header, epochs, obsTypes) {
 }
 
 export {
+  writeCrx,
   padL,
   padR,
   fmtF,
@@ -1483,8 +1804,6 @@ export {
   writeRinexNav,
   writeRinexNav4,
   parseIonex,
-  parseSp3,
-  sp3Position,
   createGzipLineSink,
   stationHeaderLines,
   writeRinexObsBlob,