@math.gl/geospatial 5.0.0-alpha.17 → 5.0.0-alpha.19

package/dist/projection/pipeline.cjs

@@ -0,0 +1,1961 @@
+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);
+
+// dist/projection/pipeline.js
+var pipeline_exports = {};
+__export(pipeline_exports, {
+  ProjectionPipeline: () => ProjectionPipeline
+});
+module.exports = __toCommonJS(pipeline_exports);
+
+// dist/crs/spatial-reference.js
+function inferCRSRepresentation(definition2) {
+  if (typeof definition2 === "object") {
+    return "projjson";
+  }
+  const text = definition2.trim();
+  if (/^[A-Z][A-Z0-9_]*\s*[\[(]/i.test(text)) {
+    return "wkt";
+  }
+  if (/(?:^|\s)\+?proj=/i.test(text)) {
+    return "proj-string";
+  }
+  if (/^[A-Z][A-Z0-9._-]*(?::[A-Z0-9._-]+)+$/i.test(text) || /^urn:ogc:def:crs:/i.test(text) || /^https?:\/\//i.test(text) || /^[A-Z][A-Z0-9._-]*$/i.test(text)) {
+    return "identifier";
+  }
+  return "opaque";
+}
+
+// dist/crs/proj-string.js
+var PROJStringSyntaxError = class extends SyntaxError {
+  /** Create a PROJ string syntax error at a source location. */
+  constructor(message, source, offset) {
+    const location = getSourceLocation(source, offset);
+    super(`${message} at ${location.line}:${location.column}`);
+    this.name = "PROJStringSyntaxError";
+    this.offset = offset;
+    this.line = location.line;
+    this.column = location.column;
+  }
+};
+function parsePROJString(text) {
+  const tokens = tokenizePROJString(text);
+  if (tokens.length === 0) {
+    throw new PROJStringSyntaxError("PROJ string is empty", text, 0);
+  }
+  const parameters = tokens.map((token) => parseParameter(token.raw, token.offset, text));
+  return { type: "proj-string", parameters };
+}
+var DMS_VALUE = /^[+-]?\d+(?:\.\d*)?d(?:\d+(?:\.\d*)?'(?:\d+(?:\.\d*)?")?)?[NSEW]?$/i;
+function parseParameter(rawToken, offset, source) {
+  const token = rawToken.startsWith("+") ? rawToken.slice(1) : rawToken;
+  if (!token) {
+    throw new PROJStringSyntaxError("Expected a parameter after '+'", source, offset);
+  }
+  const equalsIndex = token.indexOf("=");
+  const name = equalsIndex < 0 ? token : token.slice(0, equalsIndex);
+  if (!name || /[\s+=]/.test(name)) {
+    throw new PROJStringSyntaxError(`Invalid PROJ parameter name '${name}'`, source, offset);
+  }
+  if (equalsIndex < 0) {
+    return { type: "parameter", name };
+  }
+  const rawValue = token.slice(equalsIndex + 1);
+  const value = decodeParameterValue(rawValue, source, offset + equalsIndex + 1);
+  return { type: "parameter", name, value, rawValue };
+}
+function tokenizePROJString(source) {
+  const tokens = [];
+  let offset = 0;
+  while (offset < source.length) {
+    while (offset < source.length && /\s/.test(source[offset])) {
+      offset++;
+    }
+    if (offset >= source.length) {
+      break;
+    }
+    const start = offset;
+    let quote = null;
+    let escaped = false;
+    while (offset < source.length) {
+      const character = source[offset];
+      if (escaped) {
+        escaped = false;
+        offset++;
+        continue;
+      }
+      if (character === "\\" && quote) {
+        escaped = true;
+        offset++;
+        continue;
+      }
+      if (quote) {
+        if (character === quote) {
+          quote = null;
+        }
+        offset++;
+        continue;
+      }
+      if ((character === '"' || character === "'") && source[offset - 1] === "=") {
+        quote = character;
+        offset++;
+        continue;
+      }
+      if (/\s/.test(character)) {
+        break;
+      }
+      offset++;
+    }
+    if (quote) {
+      throw new PROJStringSyntaxError("Unterminated quoted PROJ value", source, start);
+    }
+    tokens.push({ raw: source.slice(start, offset), offset: start });
+  }
+  return tokens;
+}
+function decodeParameterValue(rawValue, source, offset) {
+  if (!rawValue) {
+    return "";
+  }
+  const first = rawValue[0];
+  if (first !== '"' && first !== "'") {
+    if ((rawValue.includes('"') || rawValue.includes("'")) && !DMS_VALUE.test(rawValue)) {
+      throw new PROJStringSyntaxError("Quote must begin a PROJ parameter value", source, offset);
+    }
+    return rawValue;
+  }
+  if (rawValue[rawValue.length - 1] !== first) {
+    throw new PROJStringSyntaxError("Unterminated quoted PROJ value", source, offset);
+  }
+  let value = "";
+  for (let index = 1; index < rawValue.length - 1; index++) {
+    const character = rawValue[index];
+    if (character === "\\" && index + 1 < rawValue.length - 1) {
+      value += rawValue[++index];
+    } else {
+      value += character;
+    }
+  }
+  return value;
+}
+function getSourceLocation(source, offset) {
+  let line = 1;
+  let column = 1;
+  for (let index = 0; index < offset && index < source.length; index++) {
+    if (source[index] === "\n") {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+  return { line, column };
+}
+
+// dist/projection/experimental/crs/types.js
+var _a;
+var CRS_ERROR = /* @__PURE__ */ Symbol.for("@math.gl/projection/TypeScriptCRSError");
+var TypeScriptCRSError = class _TypeScriptCRSError extends Error {
+  static [(_a = CRS_ERROR, Symbol.hasInstance)](value) {
+    if (this !== _TypeScriptCRSError)
+      return Function.prototype[Symbol.hasInstance].call(this, value);
+    return value instanceof Error && value[CRS_ERROR] === true;
+  }
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+    this[_a] = true;
+    this.name = "TypeScriptCRSError";
+  }
+};
+function unsupportedStage(message) {
+  throw new TypeScriptCRSError("missing-transform-stage", message);
+}
+
+// dist/projection/experimental/crs/spatial-reference.js
+function resolveCRSInput(input, options) {
+  if (typeof input === "string" || "type" in input)
+    return { definition: input, lossy: false };
+  const metadata = input;
+  const spatialReference = "crs" in metadata ? metadata : void 0;
+  const reference = "crs" in metadata ? metadata.crs : metadata;
+  if (reference.state !== "explicit" && reference.state !== "default")
+    throw new TypeScriptCRSError("unknown-syntax", "Cannot transform an " + reference.state + " CRS reference");
+  let lossy = false;
+  if ((spatialReference == null ? void 0 : spatialReference.coordinateEpoch) !== void 0)
+    unsupportedStage("Coordinate epochs require a time-dependent transformation");
+  if ((spatialReference == null ? void 0 : spatialReference.vertical) && spatialReference.vertical.state !== "absent") {
+    if (options.mode !== "horizontal")
+      unsupportedStage("A separately declared vertical CRS requires explicit horizontal extraction");
+    lossy = true;
+  }
+  return { definition: reference.definition, spatialReference, lossy };
+}
+function applySpatialReference(crs, reference) {
+  var _a2;
+  if (!reference)
+    return crs;
+  if (reference.coordinateFrame !== "unknown" && reference.coordinateFrame !== crs.kind)
+    throw new Error("SpatialReference coordinate frame disagrees with its CRS");
+  const order = reference.coordinateOrder;
+  const names = crs.kind === "geocentric" ? { x: "e", y: "n", z: "u" } : {
+    longitude: "e",
+    lon: "e",
+    latitude: "n",
+    lat: "n",
+    easting: "e",
+    northing: "n",
+    height: "u",
+    altitude: "u",
+    x: "e",
+    y: "n",
+    z: "u"
+  };
+  let storedAxis;
+  if (order.length) {
+    storedAxis = order.slice(0, 3).map((name) => names[name.toLowerCase()] || "?").join("");
+    if (storedAxis.length === 2)
+      storedAxis += "u";
+    if (storedAxis.length !== 3 || !storedAxis.includes("e") || !storedAxis.includes("n") || !storedAxis.includes("u"))
+      unsupportedStage("Unsupported SpatialReference coordinate order");
+    if (order.length > 4 || order.length > 3 && !["m", "measure"].includes(order[3]))
+      unsupportedStage("Unsupported fourth coordinate component");
+  }
+  if ((_a2 = reference.units) == null ? void 0 : _a2.length) {
+    const units = {
+      m: 1,
+      meter: 1,
+      metre: 1,
+      meters: 1,
+      metres: 1,
+      km: 1e3,
+      ft: 0.3048,
+      "us-ft": 1200 / 3937,
+      degree: Math.PI / 180,
+      degrees: Math.PI / 180,
+      radian: 1,
+      radians: 1,
+      grad: Math.PI / 200
+    };
+    for (let i = 0; i < Math.min(reference.units.length, 3); i++) {
+      const vertical = (storedAxis || "enu")[i] === "u";
+      const expected = crs.kind === "geocentric" ? crs.toMeter : vertical ? crs.verticalUnit : crs.kind === "geographic" ? crs.angularUnit : crs.toMeter;
+      if (Math.abs((units[reference.units[i]] ?? NaN) - expected) > 1e-12 || units[reference.units[i]] === void 0)
+        unsupportedStage("SpatialReference units disagree with its CRS");
+    }
+  }
+  return Object.freeze({ ...crs, storedAxis });
+}
+
+// dist/projection/experimental/parameters.js
+var DEGREES_TO_RADIANS = Math.PI / 180;
+function numberParameter(parameters, name, fallback) {
+  if (!Object.prototype.hasOwnProperty.call(parameters, name))
+    return fallback;
+  const value = parameters[name];
+  if (typeof value !== "string" || !/^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i.test(value)) {
+    throw new Error(`Invalid numeric PROJ parameter: +${name}`);
+  }
+  const number = Number(value);
+  if (!Number.isFinite(number))
+    throw new Error(`Invalid numeric PROJ parameter: +${name}`);
+  return number;
+}
+
+// dist/projection/experimental/crs/datum-catalog.js
+var wgs84 = { towgs84: "0,0,0", ellipse: "WGS84" };
+var nad83 = { towgs84: "0,0,0", ellipse: "GRS80" };
+var builtins = {
+  wgs84,
+  WGS84: wgs84,
+  nad83,
+  North_American_Datum_1983: nad83
+};
+var resolved = /* @__PURE__ */ new WeakMap();
+var datumNameKey = (name) => name.toLowerCase().replace(/[\s_-]/g, "");
+function getDatumDefinitions(options) {
+  var _a2;
+  if (!((_a2 = options.datumCatalogs) == null ? void 0 : _a2.length))
+    return builtins;
+  const cached = resolved.get(options);
+  if ((cached == null ? void 0 : cached.catalogs) === options.datumCatalogs)
+    return cached.definitions;
+  const definitions = Object.assign(/* @__PURE__ */ Object.create(null), builtins);
+  const names = new Map(Object.entries(builtins).map(([name, definition2]) => [
+    datumNameKey(name),
+    { definition: definition2, owner: -1 }
+  ]));
+  options.datumCatalogs.forEach((catalog, owner) => {
+    if (!catalog.name || !catalog.datums)
+      throw new Error("Invalid datum catalogue plugin");
+    for (const [name, definition2] of Object.entries(catalog.datums)) {
+      const key = datumNameKey(name);
+      if (!key || key === "none" || !definition2 || ["ellipse", "towgs84", "nadgrids"].some((field) => definition2[field] !== void 0 && typeof definition2[field] !== "string"))
+        throw new Error("Invalid datum definition: " + name);
+      const previous = names.get(key);
+      if (previous && (previous.owner !== owner || previous.definition.ellipse !== definition2.ellipse || previous.definition.towgs84 !== definition2.towgs84 || previous.definition.nadgrids !== definition2.nadgrids))
+        throw new Error("Conflicting datum registration: " + name);
+      names.set(key, { definition: definition2, owner });
+      definitions[name] = definition2;
+    }
+  });
+  resolved.set(options, { catalogs: options.datumCatalogs, definitions });
+  return definitions;
+}
+
+// dist/projection/experimental/crs/ellipsoid-table.js
+var ellipsoids = {
+  MERIT: {
+    a: 6378137,
+    rf: 298.257,
+    ellipseName: "MERIT 1983"
+  },
+  SGS85: {
+    a: 6378136,
+    rf: 298.257,
+    ellipseName: "Soviet Geodetic System 85"
+  },
+  GRS80: {
+    a: 6378137,
+    rf: 298.257222101,
+    ellipseName: "GRS 1980(IUGG, 1980)"
+  },
+  IAU76: {
+    a: 6378140,
+    rf: 298.257,
+    ellipseName: "IAU 1976"
+  },
+  airy: {
+    a: 6377563396e-3,
+    b: 635625691e-2,
+    ellipseName: "Airy 1830"
+  },
+  APL4: {
+    a: 6378137,
+    rf: 298.25,
+    ellipseName: "Appl. Physics. 1965"
+  },
+  NWL9D: {
+    a: 6378145,
+    rf: 298.25,
+    ellipseName: "Naval Weapons Lab., 1965"
+  },
+  mod_airy: {
+    a: 6377340189e-3,
+    b: 6356034446e-3,
+    ellipseName: "Modified Airy"
+  },
+  andrae: {
+    a: 637710443e-2,
+    rf: 300,
+    ellipseName: "Andrae 1876 (Den., Iclnd.)"
+  },
+  aust_SA: {
+    a: 6378160,
+    rf: 298.25,
+    ellipseName: "Australian Natl & S. Amer. 1969"
+  },
+  GRS67: {
+    a: 6378160,
+    rf: 298.247167427,
+    ellipseName: "GRS 67(IUGG 1967)"
+  },
+  bessel: {
+    a: 6377397155e-3,
+    rf: 299.1528128,
+    ellipseName: "Bessel 1841"
+  },
+  bess_nam: {
+    a: 6377483865e-3,
+    rf: 299.1528128,
+    ellipseName: "Bessel 1841 (Namibia)"
+  },
+  clrk66: {
+    a: 63782064e-1,
+    b: 63565838e-1,
+    ellipseName: "Clarke 1866"
+  },
+  clrk80: {
+    a: 6378249145e-3,
+    rf: 293.4663,
+    ellipseName: "Clarke 1880 mod."
+  },
+  clrk80ign: {
+    a: 63782492e-1,
+    b: 6356515,
+    rf: 293.4660213,
+    ellipseName: "Clarke 1880 (IGN)"
+  },
+  clrk58: {
+    a: 6378293645208759e-9,
+    rf: 294.2606763692654,
+    ellipseName: "Clarke 1858"
+  },
+  CPM: {
+    a: 63757387e-1,
+    rf: 334.29,
+    ellipseName: "Comm. des Poids et Mesures 1799"
+  },
+  delmbr: {
+    a: 6376428,
+    rf: 311.5,
+    ellipseName: "Delambre 1810 (Belgium)"
+  },
+  engelis: {
+    a: 637813605e-2,
+    rf: 298.2566,
+    ellipseName: "Engelis 1985"
+  },
+  evrst30: {
+    a: 6377276345e-3,
+    rf: 300.8017,
+    ellipseName: "Everest 1830"
+  },
+  evrst48: {
+    a: 6377304063e-3,
+    rf: 300.8017,
+    ellipseName: "Everest 1948"
+  },
+  evrst56: {
+    a: 6377301243e-3,
+    rf: 300.8017,
+    ellipseName: "Everest 1956"
+  },
+  evrst69: {
+    a: 6377295664e-3,
+    rf: 300.8017,
+    ellipseName: "Everest 1969"
+  },
+  evrstSS: {
+    a: 6377298556e-3,
+    rf: 300.8017,
+    ellipseName: "Everest (Sabah & Sarawak)"
+  },
+  fschr60: {
+    a: 6378166,
+    rf: 298.3,
+    ellipseName: "Fischer (Mercury Datum) 1960"
+  },
+  fschr60m: {
+    a: 6378155,
+    rf: 298.3,
+    ellipseName: "Fischer 1960"
+  },
+  fschr68: {
+    a: 6378150,
+    rf: 298.3,
+    ellipseName: "Fischer 1968"
+  },
+  helmert: {
+    a: 6378200,
+    rf: 298.3,
+    ellipseName: "Helmert 1906"
+  },
+  hough: {
+    a: 6378270,
+    rf: 297,
+    ellipseName: "Hough"
+  },
+  intl: {
+    a: 6378388,
+    rf: 297,
+    ellipseName: "International 1909 (Hayford)"
+  },
+  kaula: {
+    a: 6378163,
+    rf: 298.24,
+    ellipseName: "Kaula 1961"
+  },
+  lerch: {
+    a: 6378139,
+    rf: 298.257,
+    ellipseName: "Lerch 1979"
+  },
+  mprts: {
+    a: 6397300,
+    rf: 191,
+    ellipseName: "Maupertius 1738"
+  },
+  new_intl: {
+    a: 63781575e-1,
+    b: 63567722e-1,
+    ellipseName: "New International 1967"
+  },
+  plessis: {
+    a: 6376523,
+    b: 6355863,
+    ellipseName: "Plessis 1817 (France)"
+  },
+  krass: {
+    a: 6378245,
+    rf: 298.3,
+    ellipseName: "Krassovsky, 1942"
+  },
+  SEasia: {
+    a: 6378155,
+    b: 63567733205e-4,
+    ellipseName: "Southeast Asia"
+  },
+  walbeck: {
+    a: 6376896,
+    b: 63558348467e-4,
+    ellipseName: "Walbeck"
+  },
+  WGS60: {
+    a: 6378165,
+    rf: 298.3,
+    ellipseName: "WGS 60"
+  },
+  WGS66: {
+    a: 6378145,
+    rf: 298.25,
+    ellipseName: "WGS 66"
+  },
+  WGS72: {
+    a: 6378135,
+    rf: 298.26,
+    ellipseName: "WGS 72"
+  },
+  WGS84: {
+    a: 6378137,
+    rf: 298.257223563,
+    ellipseName: "WGS 84"
+  },
+  sphere: {
+    a: 6370997,
+    b: 6370997,
+    ellipseName: "Normal Sphere (r=6370997)"
+  }
+};
+var ellipsoid_table_default = ellipsoids;
+
+// dist/projection/experimental/crs/primemeridian-table.js
+var primeMeridian = {};
+primeMeridian["greenwich"] = 0;
+primeMeridian["lisbon"] = -9.131906111111;
+primeMeridian["paris"] = 2.337229166667;
+primeMeridian["bogota"] = -74.080916666667;
+primeMeridian["madrid"] = -3.687938888889;
+primeMeridian["rome"] = 12.452333333333;
+primeMeridian["bern"] = 7.439583333333;
+primeMeridian["jakarta"] = 106.807719444444;
+primeMeridian["ferro"] = -17.666666666667;
+primeMeridian["brussels"] = 4.367975;
+primeMeridian["stockholm"] = 18.058277777778;
+primeMeridian["athens"] = 23.7163375;
+primeMeridian["oslo"] = 10.722916666667;
+var primemeridian_table_default = primeMeridian;
+
+// dist/crs/units-table.js
+var linearUnits = {
+  m: { name: "meters", metersPerUnit: 1 },
+  mm: { name: "millimeters", metersPerUnit: 1e-3 },
+  cm: { name: "centimeters", metersPerUnit: 0.01 },
+  ft: { name: "feet", metersPerUnit: 0.3048 },
+  "us-ft": { name: "us-survey-feet", metersPerUnit: 1200 / 3937 },
+  fath: { name: "fathoms", metersPerUnit: 1.8288 },
+  kmi: { name: "nautical-miles", metersPerUnit: 1852 },
+  "us-ch": { name: "us-survey-chains", metersPerUnit: 20.1168402336805 },
+  "us-mi": { name: "us-survey-miles", metersPerUnit: 1609.34721869444 },
+  km: { name: "kilometers", metersPerUnit: 1e3 },
+  "ind-ft": { name: "indian-feet", metersPerUnit: 0.30479841 },
+  "ind-yd": { name: "indian-yards", metersPerUnit: 0.91439523 },
+  mi: { name: "miles", metersPerUnit: 1609.344 },
+  yd: { name: "yards", metersPerUnit: 0.9144 },
+  ch: { name: "chains", metersPerUnit: 20.1168 },
+  link: { name: "links", metersPerUnit: 0.201168 },
+  dm: { name: "decimeters", metersPerUnit: 0.1 },
+  in: { name: "inches", metersPerUnit: 0.0254 },
+  "ind-ch": { name: "indian-chains", metersPerUnit: 20.11669506 },
+  "us-in": { name: "us-survey-inches", metersPerUnit: 0.025400050800101 },
+  "us-yd": { name: "us-survey-yards", metersPerUnit: 0.914401828803658 }
+};
+
+// dist/projection/experimental/crs/normalize.js
+var ALIASES = {
+  WGS84: "+proj=longlat +datum=WGS84",
+  "EPSG:4326": "+proj=longlat +datum=WGS84",
+  "EPSG:4269": "+proj=longlat +datum=NAD83",
+  "EPSG:4978": "+proj=geocent +datum=WGS84",
+  "EPSG:4979": "+proj=longlat +datum=WGS84",
+  "EPSG:3857": "+proj=merc +a=6378137 +b=6378137 +nadgrids=@null +units=m",
+  "EPSG:3785": "EPSG:3857",
+  GOOGLE: "EPSG:3857",
+  "EPSG:900913": "EPSG:3857",
+  "EPSG:102113": "EPSG:3857"
+};
+var CORE_PARAMETERS = [
+  "proj",
+  "datum",
+  "ellps",
+  "a",
+  "b",
+  "rf",
+  "f",
+  "R",
+  "units",
+  "to_meter",
+  "vunits",
+  "vto_meter",
+  "no_defs",
+  "type",
+  "title",
+  "towgs84",
+  "nadgrids",
+  "geoidgrids",
+  "axis",
+  "pm",
+  "over",
+  "lon_wrap"
+];
+var own = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
+var keyOf = (value) => value.toLowerCase().replace(/[\s_-]/g, "");
+function lookup(table, name) {
+  const key = Object.keys(table).find((key2) => keyOf(key2) === keyOf(name));
+  return key === void 0 ? void 0 : table[key];
+}
+function parseAngle(text) {
+  if (/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(text)) {
+    const value = Number(text);
+    if (Number.isFinite(value))
+      return value;
+  }
+  if (/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?r$/i.test(text)) {
+    const value = Number(text.slice(0, -1)) / DEGREES_TO_RADIANS;
+    if (Number.isFinite(value))
+      return value;
+  }
+  const dms = /^([+-]?)(\d+(?:\.\d*)?)(?:d(?:(\d+(?:\.\d*)?)'(?:(\d+(?:\.\d*)?)")?)?)?([NSEW])?$/i.exec(text);
+  if (dms && (/d/i.test(text) || dms[5])) {
+    const minutes = Number(dms[3] || 0), seconds = Number(dms[4] || 0);
+    if (minutes < 60 && seconds < 60) {
+      const sign = dms[1] === "-" ? -1 : 1;
+      const direction = /[SW]/i.test(dms[5] || "") ? -1 : 1;
+      const value = sign * direction * (Number(dms[2]) + minutes / 60 + seconds / 3600);
+      if (Number.isFinite(value))
+        return value;
+    }
+  }
+  throw new Error("Invalid angular parameter: " + text);
+}
+function normalizeCRS(input, options = {}) {
+  var _a2;
+  const datums = getDatumDefinitions(options);
+  const resolved2 = resolveCRSInput(input, options);
+  let definition2 = resolved2.definition;
+  const aliases = options.aliases || {};
+  const visited = /* @__PURE__ */ new Set();
+  while (typeof definition2 === "string" && (own(aliases, definition2) || own(ALIASES, definition2))) {
+    if (visited.has(definition2))
+      throw new Error("Circular CRS alias: " + definition2);
+    visited.add(definition2);
+    definition2 = own(aliases, definition2) ? aliases[definition2] : ALIASES[definition2];
+  }
+  if (typeof definition2 === "string") {
+    const utm = /^EPSG:(326|327)(\d{2})$/.exec(definition2);
+    if (utm && Number(utm[2]) >= 1 && Number(utm[2]) <= 60) {
+      definition2 = "+proj=utm +datum=WGS84 +zone=" + Number(utm[2]) + (utm[1] === "327" ? " +south" : "");
+    }
+    if (definition2 === "EPSG:5041" || definition2 === "EPSG:5042") {
+      definition2 = "+proj=stere +datum=WGS84 +lat_0=" + (definition2 === "EPSG:5041" ? 90 : -90) + " +k_0=0.994 +x_0=2000000 +y_0=2000000";
+    }
+  }
+  let parsed;
+  if (inferCRSRepresentation(definition2) === "proj-string" && typeof definition2 === "string") {
+    const parameters2 = /* @__PURE__ */ Object.create(null);
+    for (const parameter of parsePROJString(definition2).parameters) {
+      if (own(parameters2, parameter.name))
+        throw new Error("Duplicate PROJ parameter: +" + parameter.name);
+      parameters2[parameter.name] = parameter.value;
+    }
+    parsed = { parameters: parameters2 };
+  } else {
+    const parser = (_a2 = options.parsers) == null ? void 0 : _a2.find((candidate) => candidate.canParse(definition2));
+    if (!parser) {
+      const serialized = ["wkt", "projjson"].includes(inferCRSRepresentation(definition2));
+      throw new TypeScriptCRSError(serialized ? "missing-parser" : "unknown-syntax", "Unsupported CRS definition; register a WKT or PROJJSON parser for structured definitions");
+    }
+    parsed = parser.parse(definition2, options);
+  }
+  const parameters = { ...parsed.parameters };
+  for (const name2 of [
+    "lon_0",
+    "lat_0",
+    "lat_1",
+    "lat_2",
+    "lat_ts",
+    "lon_wrap",
+    "lon_1",
+    "lon_2",
+    "lonc",
+    "alpha",
+    "gamma",
+    "tilt",
+    "azi",
+    "o_alpha",
+    "o_lon_c",
+    "o_lat_c",
+    "o_lon_p",
+    "o_lat_p",
+    "o_lon_1",
+    "o_lat_1",
+    "o_lon_2",
+    "o_lat_2"
+  ]) {
+    if (parameters[name2] !== void 0)
+      parameters[name2] = String(parseAngle(parameters[name2]));
+  }
+  const suppliedName = parameters["proj"];
+  const lowerName = suppliedName == null ? void 0 : suppliedName.toLowerCase();
+  const name = lowerName === "geocentric" ? "geocent" : ["longlat", "latlong", "latlon", "lonlat", "identity", "geocent"].includes(lowerName) ? lowerName : suppliedName;
+  if (!name)
+    throw new Error("CRS requires +proj");
+  const kind = ["longlat", "latlong", "latlon", "lonlat"].includes(name) ? "geographic" : name === "geocent" ? "geocentric" : name === "identity" ? "identity" : "projected";
+  const datumName = parameters["datum"];
+  const datum = datumName && datumName !== "none" ? lookup(datums, datumName) : void 0;
+  if (datumName && datumName !== "none" && !datum)
+    unsupportedStage("Unknown datum: " + datumName + "; register a datumCatalogs plugin");
+  const ellipsoid = getEllipsoid(parameters, datum == null ? void 0 : datum.ellipse);
+  const grids = parameters["nadgrids"] ?? (datum == null ? void 0 : datum.nadgrids);
+  const gridReferences = grids === void 0 ? void 0 : grids.split(",").map((entry) => {
+    const optional = entry.startsWith("@");
+    const name2 = optional ? entry.slice(1) : entry;
+    if (!name2 || /\s/.test(name2))
+      throw new Error("Invalid datum grid name");
+    return Object.freeze({ name: name2, optional });
+  });
+  const rawShift = parameters["towgs84"] ?? (datum == null ? void 0 : datum.towgs84);
+  let shift;
+  if (rawShift !== void 0) {
+    shift = rawShift.split(",").map((value) => numberParameter({ value }, "value", NaN));
+    if (![3, 7].includes(shift.length) || shift.some((value) => !Number.isFinite(value)) || shift.length === 7 && shift[6] <= -1e6) {
+      throw new Error("+towgs84 requires three or seven finite values and positive scale");
+    }
+  }
+  if (datumName === "none")
+    shift = void 0;
+  if (gridReferences && datumName !== "none")
+    shift = [0, 0, 0];
+  const datumEllipsoid = grids === "@null" || grids === "null" ? getEllipsoid({ ellps: "WGS84" }) : ellipsoid;
+  const axis = parameters["axis"] || "enu";
+  if (axis.length !== 3 || !/[ew]/.test(axis) || !/[ns]/.test(axis) || !/[ud]/.test(axis))
+    throw new Error("Invalid axis: " + axis);
+  const angularUnit = parsed.angularUnit ?? DEGREES_TO_RADIANS;
+  if (kind === "geographic" && (parameters["units"] && parameters["units"] !== "degrees" || own(parameters, "to_meter")))
+    throw new Error("Geographic coordinates must use angular units");
+  if (kind !== "geographic" && parameters["units"] === "degrees")
+    throw new Error("Linear coordinates require linear units");
+  const toMeter = unitFactor(parameters, "units", "to_meter");
+  const verticalUnit = parsed.verticalUnit ?? unitFactor(parameters, "vunits", "vto_meter");
+  if (!(verticalUnit > 0) || !Number.isFinite(verticalUnit))
+    throw new Error("Invalid vertical unit");
+  if (!(angularUnit > 0) || !Number.isFinite(angularUnit))
+    throw new Error("Invalid angular unit");
+  const pm = parameters["pm"];
+  const primeMeridian2 = pm === void 0 ? 0 : (lookup(primemeridian_table_default, pm) ?? parseAngle(pm)) * DEGREES_TO_RADIANS;
+  return applySpatialReference(Object.freeze({
+    kind,
+    projection: name,
+    parameters: Object.freeze(parameters),
+    ellipsoid,
+    datum: Object.freeze({
+      ellipsoid: datumEllipsoid,
+      towgs84: shift && Object.freeze(shift),
+      grids: datumName === "none" || grids === "@null" || grids === "null" ? void 0 : gridReferences && Object.freeze(gridReferences)
+    }),
+    areaOfUse: parsed.areaOfUse,
+    angularUnit,
+    toMeter,
+    verticalUnit,
+    primeMeridian: primeMeridian2,
+    axis,
+    longitudeWrap: parameters["lon_wrap"] === void 0 ? void 0 : Number(parameters["lon_wrap"]) * DEGREES_TO_RADIANS,
+    lossy: Boolean(parsed.lossy || resolved2.lossy)
+  }), resolved2.spatialReference);
+}
+function unitFactor(parameters, unitKey, factorKey) {
+  const unit = parameters[unitKey];
+  const table = linearUnits;
+  if (unitKey === "vunits" && unit === "degrees")
+    throw new Error("Height requires linear units");
+  if (unit && !["m", "degrees"].includes(unit) && !own(table, unit))
+    throw new Error("Unsupported units: " + unit);
+  const factor = numberParameter(parameters, factorKey, unit && table[unit] ? table[unit].metersPerUnit : 1);
+  if (!(factor > 0))
+    throw new Error("+" + factorKey + " must be positive");
+  return factor;
+}
+function getEllipsoid(parameters, datumEllipsoid) {
+  const name = datumEllipsoid || parameters["ellps"] || "WGS84";
+  const definition2 = lookup(ellipsoid_table_default, name);
+  if (!definition2)
+    throw new Error("Unsupported ellipsoid: " + name);
+  const a = numberParameter(parameters, "a", definition2.a);
+  const f = numberParameter(parameters, "f", NaN);
+  const rf = numberParameter(parameters, "rf", Number.isNaN(f) ? definition2.rf || 0 : f === 0 ? 0 : 1 / f);
+  const b = numberParameter(parameters, "b", rf ? a * (1 - 1 / rf) : own(parameters, "f") || own(parameters, "rf") || own(parameters, "a") ? a : definition2.b || a);
+  const radius = numberParameter(parameters, "R", 0);
+  if (a <= 0 || b <= 0 || b > a || rf < 0 || rf > 0 && rf <= 1 || own(parameters, "R") && radius <= 0 || !Number.isNaN(f) && (f < 0 || f >= 1))
+    throw new Error("Invalid ellipsoid dimensions");
+  return Object.freeze({
+    semiMajorAxis: radius || a,
+    semiMinorAxis: radius || b,
+    eccentricitySquared: radius ? 0 : 1 - (b / a) ** 2
+  });
+}
+
+// dist/projection/experimental/datum.js
+var import_spheroid = require("@math.gl/core/spheroid");
+var ARC_SECOND = Math.PI / (180 * 3600);
+function geodeticToGeocentricInPlace(point, ellipsoid) {
+  if (Math.abs(point.y) > Math.PI / 2)
+    throw new Error("Latitude outside geocentric domain");
+  if (!(0, import_spheroid.spheroidToCartesian)(point, ellipsoid))
+    throw new Error("Geocentric coordinate must be finite");
+}
+function geocentricToGeodeticInPlace(point, ellipsoid) {
+  const x = point.x, y = point.y, z = point.z;
+  const { semiMajorAxis: a, semiMinorAxis: b, eccentricitySquared: es } = ellipsoid;
+  if (x === 0 && y === 0 && z === 0)
+    throw new Error("Geodetic coordinates are undefined at the Earth center");
+  if (es !== 0 && Math.abs(x) < 1e-12 * a && Math.abs(y) < 1e-12 * a && Math.hypot(x, y) < 1e-12 * a) {
+    if (!Number.isFinite(Math.hypot(x, y, z)))
+      throw new Error("Geocentric radius must be finite");
+    point.x = 0;
+    point.y = Math.sign(z) * Math.PI / 2;
+    point.z = Math.abs(z) - b;
+    return;
+  }
+  if (!(0, import_spheroid.cartesianToSpheroid)(point, ellipsoid)) {
+    if (!Number.isFinite(Math.hypot(x, y, z)))
+      throw new Error("Geocentric radius must be finite");
+    throw new Error("Geocentric inverse did not converge");
+  }
+}
+function createHelmert(values, inverse) {
+  const dx = values[0], dy = values[1], dz = values[2];
+  const rx = (values[3] || 0) * ARC_SECOND, ry = (values[4] || 0) * ARC_SECOND, rz = (values[5] || 0) * ARC_SECOND;
+  const scale = 1 + (values[6] || 0) / 1e6;
+  return inverse ? (point) => {
+    const x = (point.x - dx) / scale, y = (point.y - dy) / scale, z = (point.z - dz) / scale;
+    point.x = x + rz * y - ry * z;
+    point.y = -rz * x + y + rx * z;
+    point.z = ry * x - rx * y + z;
+  } : (point) => {
+    const x = point.x, y = point.y, z = point.z;
+    point.x = scale * (x - rz * y + ry * z) + dx;
+    point.y = scale * (rz * x + y - rx * z) + dy;
+    point.z = scale * (-ry * x + rx * y + z) + dz;
+  };
+}
+function applyDatumGrids(point, datum, inverse) {
+  for (const reference of datum.grids) {
+    if (reference.name === "null")
+      return;
+    if (!reference.grid) {
+      if (reference.optional)
+        continue;
+      throw new Error("Required datum grid is not registered: " + reference.name);
+    }
+    let found = false;
+    if (reference.grid.shiftInPlace)
+      found = reference.grid.shiftInPlace(point, inverse);
+    else {
+      const output = reference.grid.shift(point.x, point.y, inverse);
+      if (output) {
+        point.x = output[0];
+        point.y = output[1];
+        found = true;
+      }
+    }
+    if (found) {
+      if (!Number.isFinite(point.x) || !Number.isFinite(point.y) || Math.abs(point.y) > Math.PI / 2)
+        throw new Error("Datum grid produced a coordinate outside the geographic domain");
+      return;
+    }
+  }
+  throw new Error("No datum grid covers coordinate: " + datum.grids.map((grid) => grid.name).join(","));
+}
+
+// dist/projection/experimental/projection-scratch.js
+function createPoint() {
+  return { x: 0, y: 0, z: 0 };
+}
+var ProjectionScratch = class {
+  constructor() {
+    this.point = createPoint();
+    this.points = [this.point];
+    this.active = 0;
+  }
+  get depth() {
+    return this.active;
+  }
+  acquire() {
+    var _a2;
+    const index = this.active++;
+    (_a2 = this.points)[index] || (_a2[index] = createPoint());
+    return this.points[index];
+  }
+  release(point) {
+    if (this.active > 0 && this.points[this.active - 1] === point)
+      this.active--;
+  }
+};
+
+// dist/projection/experimental/mutable-projection.js
+function projectionOperation(implementation, inverse, geocentric = false) {
+  const mutable = inverse ? implementation.inverseInPlace : implementation.forwardInPlace;
+  if (mutable)
+    return mutable.bind(implementation);
+  if (geocentric) {
+    const operation2 = inverse ? implementation.inverse3D : implementation.forward3D;
+    return (point) => {
+      const output = operation2.call(implementation, [point.x, point.y, point.z]);
+      point.x = output[0];
+      point.y = output[1];
+      point.z = output[2];
+    };
+  }
+  const operation = inverse ? implementation.inverse : implementation.forward;
+  return (point) => {
+    const output = operation.call(implementation, point.x, point.y);
+    point.x = output[0];
+    point.y = output[1];
+  };
+}
+
+// dist/projection/experimental/numeric-flat.js
+function createNumericFlat(steps) {
+  const program = new Float64Array(steps.length * 7);
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i], offset = i * 7;
+    program.set(step, offset);
+    if (step[0] === 2) {
+      for (let axis = 1; axis <= 3; axis++) {
+        program[offset + axis] = Math.abs(step[axis]);
+        program[offset + axis + 3] = Math.sign(step[axis]);
+      }
+    }
+  }
+  return (coordinates, dimension, epochs) => {
+    const float32 = coordinates instanceof Float32Array;
+    const epochBuffer = typeof epochs === "number" ? void 0 : epochs;
+    for (let offset = 0, record = 0; offset < coordinates.length; offset += dimension, record++) {
+      let x = coordinates[offset], y = coordinates[offset + 1], z = dimension >= 3 ? coordinates[offset + 2] : 0;
+      if (epochBuffer && !Number.isFinite(epochBuffer[record]))
+        throw new Error("Coordinate epoch must be a finite decimal year");
+      if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+        throw new Error("Pipeline coordinate must be finite");
+      for (let step = 0; step < program.length; step += 7) {
+        const kind = program[step], a = program[step + 1], b = program[step + 2], c = program[step + 3];
+        if (kind === 0) {
+          x *= a;
+          y *= b;
+          z *= c;
+        } else if (kind === 1) {
+          x /= a;
+          y /= b;
+          z /= c;
+        } else {
+          const oldX = x, oldY = y, oldZ = z;
+          x = program[step + 4] * (a === 1 ? oldX : a === 2 ? oldY : oldZ);
+          y = program[step + 5] * (b === 1 ? oldX : b === 2 ? oldY : oldZ);
+          z = program[step + 6] * (c === 1 ? oldX : c === 2 ? oldY : oldZ);
+        }
+        if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+          throw new Error("Pipeline coordinate must be finite");
+      }
+      if (float32 && Math.max(Math.abs(x), Math.abs(y), Math.abs(z)) > 34028234663852886e22)
+        throw new Error("Pipeline output exceeds Float32 range");
+      coordinates[offset] = x;
+      coordinates[offset + 1] = y;
+      if (dimension >= 3)
+        coordinates[offset + 2] = z;
+    }
+  };
+}
+
+// dist/projection/experimental/scalar-output.js
+var FLOAT32_MAX = 34028234663852886e22;
+function validateScalarOutput(coordinate, output, length) {
+  if (!(Array.isArray(coordinate) || coordinate instanceof Float32Array || coordinate instanceof Float64Array))
+    throw new Error("Scalar input requires a number array, Float32Array or Float64Array");
+  if (!(Array.isArray(output) || output instanceof Float32Array || output instanceof Float64Array) || output.length < length)
+    throw new Error("Scalar output requires a preallocated number array, Float32Array or Float64Array with sufficient capacity");
+  if (coordinate === output || Array.isArray(coordinate) || Array.isArray(output))
+    return;
+  const input = coordinate;
+  const result = output;
+  const shared = typeof SharedArrayBuffer !== "undefined" && input.buffer instanceof SharedArrayBuffer && result.buffer instanceof SharedArrayBuffer;
+  if ((input.buffer === result.buffer || shared) && input.byteOffset < result.byteOffset + length * result.BYTES_PER_ELEMENT && result.byteOffset < input.byteOffset + input.byteLength)
+    throw new Error("Scalar input/output views overlap; use the same view for in-place projection");
+}
+function writeScalarOutput(coordinate, output, point, length) {
+  if (output instanceof Float32Array) {
+    if (Math.abs(point.x) > FLOAT32_MAX || Math.abs(point.y) > FLOAT32_MAX || length >= 3 && Math.abs(point.z) > FLOAT32_MAX)
+      throw new Error("Projected coordinate exceeds Float32 range");
+    for (let i = 3; i < coordinate.length; i++) {
+      const value = coordinate[i];
+      if (Number.isFinite(value) && Math.abs(value) > FLOAT32_MAX)
+        throw new Error("Trailing ordinate exceeds Float32 range");
+    }
+  }
+  for (let i = 3; i < coordinate.length; i++)
+    output[i] = coordinate[i];
+  output[0] = point.x;
+  output[1] = point.y;
+  if (length >= 3)
+    output[2] = point.z;
+  return output;
+}
+
+// dist/projection/experimental/helmert-flat.js
+function createHelmertFlat(coefficients, inverse, exact) {
+  const dx = coefficients[9], dy = coefficients[10], dz = coefficients[11], scale = coefficients[12];
+  const a = coefficients[0], b = coefficients[1], c = coefficients[2], d = coefficients[3], e = coefficients[4], f = coefficients[5], g = coefficients[6], h = coefficients[7], j = coefficients[8];
+  return (coordinates, dimension, epochs) => {
+    const float32 = coordinates instanceof Float32Array;
+    const epochBuffer = typeof epochs === "number" ? void 0 : epochs;
+    for (let offset = 0, record = 0; offset < coordinates.length; offset += dimension, record++) {
+      let x = coordinates[offset], y = coordinates[offset + 1], z = coordinates[offset + 2];
+      if (epochBuffer && !Number.isFinite(epochBuffer[record]))
+        throw new Error("Coordinate epoch must be a finite decimal year");
+      if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+        throw new Error("Pipeline coordinate must be finite");
+      if (inverse) {
+        x = (x - dx) / scale;
+        y = (y - dy) / scale;
+        z = (z - dz) / scale;
+      }
+      let outX, outY, outZ;
+      if (exact) {
+        if (inverse) {
+          outX = a * x + d * y + g * z;
+          outY = b * x + e * y + h * z;
+          outZ = c * x + f * y + j * z;
+        } else {
+          outX = scale * (a * x + b * y + c * z) + dx;
+          outY = scale * (d * x + e * y + f * z) + dy;
+          outZ = scale * (g * x + h * y + j * z) + dz;
+        }
+      } else if (inverse) {
+        outX = x + c * y - b * z;
+        outY = -c * x + y + a * z;
+        outZ = b * x - a * y + z;
+      } else {
+        outX = scale * (x - c * y + b * z) + dx;
+        outY = scale * (c * x + y - a * z) + dy;
+        outZ = scale * (-b * x + a * y + z) + dz;
+      }
+      if (!Number.isFinite(outX) || !Number.isFinite(outY) || !Number.isFinite(outZ))
+        throw new Error("Pipeline coordinate must be finite");
+      if (float32 && Math.max(Math.abs(outX), Math.abs(outY), Math.abs(outZ)) > 34028234663852886e22)
+        throw new Error("Pipeline output exceeds Float32 range");
+      coordinates[offset] = outX;
+      coordinates[offset + 1] = outY;
+      coordinates[offset + 2] = outZ;
+    }
+  };
+}
+
+// dist/projection/experimental/exact-helmert.js
+function createExactHelmert(translation, rotation, scalePPM, coordinateFrame) {
+  const radians = Math.PI / (180 * 3600);
+  const [rx, ry, rz] = rotation.map((angle) => angle * radians);
+  const cx = Math.cos(rx), sx = Math.sin(rx), cy = Math.cos(ry), sy = Math.sin(ry), cz = Math.cos(rz), sz = Math.sin(rz);
+  let r01 = cx * sz + sx * sy * cz, r02 = sx * sz - cx * sy * cz, r10 = -cy * sz, r12 = sx * cz + cx * sy * sz, r20 = sy, r21 = -sx * cy;
+  const r00 = cy * cz, r11 = cx * cz - sx * sy * sz, r22 = cx * cy;
+  if (!coordinateFrame) {
+    [r01, r10] = [r10, r01];
+    [r02, r20] = [r20, r02];
+    [r12, r21] = [r21, r12];
+  }
+  const scale = 1 + scalePPM / 1e6;
+  const [dx, dy, dz] = translation;
+  return {
+    coefficients: [r00, r01, r02, r10, r11, r12, r20, r21, r22, dx, dy, dz, scale],
+    forward(point) {
+      const { x, y, z } = point;
+      point.x = scale * (r00 * x + r01 * y + r02 * z) + dx;
+      point.y = scale * (r10 * x + r11 * y + r12 * z) + dy;
+      point.z = scale * (r20 * x + r21 * y + r22 * z) + dz;
+    },
+    inverse(point) {
+      const x = (point.x - dx) / scale, y = (point.y - dy) / scale, z = (point.z - dz) / scale;
+      point.x = r00 * x + r10 * y + r20 * z;
+      point.y = r01 * x + r11 * y + r21 * z;
+      point.z = r02 * x + r12 * y + r22 * z;
+    }
+  };
+}
+
+// dist/projection/experimental/kinematic-helmert-flat.js
+function createKinematicHelmertFlat(coefficients, prepare, inverse) {
+  return (coordinates, dimension, epochs) => {
+    const float32 = coordinates instanceof Float32Array;
+    const epochBuffer = typeof epochs === "number" ? void 0 : epochs;
+    const batchEpoch = typeof epochs === "number" ? epochs : void 0;
+    let a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, j = 0;
+    let dx = 0, dy = 0, dz = 0, scale = 1;
+    for (let offset = 0, record = 0; offset < coordinates.length; offset += dimension, record++) {
+      let x = coordinates[offset], y = coordinates[offset + 1], z = coordinates[offset + 2];
+      const epoch = epochBuffer ? epochBuffer[record] : batchEpoch;
+      if (epochBuffer && !Number.isFinite(epoch))
+        throw new Error("Coordinate epoch must be a finite decimal year");
+      if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+        throw new Error("Pipeline coordinate must be finite");
+      if (epochBuffer || offset === 0) {
+        prepare(epoch);
+        a = coefficients[0];
+        b = coefficients[1];
+        c = coefficients[2];
+        d = coefficients[3];
+        e = coefficients[4];
+        f = coefficients[5];
+        g = coefficients[6];
+        h = coefficients[7];
+        j = coefficients[8];
+        dx = coefficients[9];
+        dy = coefficients[10];
+        dz = coefficients[11];
+        scale = coefficients[12];
+      }
+      let outX, outY, outZ;
+      if (inverse) {
+        x = (x - dx) / scale;
+        y = (y - dy) / scale;
+        z = (z - dz) / scale;
+        outX = a * x + d * y + g * z;
+        outY = b * x + e * y + h * z;
+        outZ = c * x + f * y + j * z;
+      } else {
+        outX = scale * (a * x + b * y + c * z) + dx;
+        outY = scale * (d * x + e * y + f * z) + dy;
+        outZ = scale * (g * x + h * y + j * z) + dz;
+      }
+      if (!Number.isFinite(outX) || !Number.isFinite(outY) || !Number.isFinite(outZ))
+        throw new Error("Pipeline coordinate must be finite");
+      if (float32 && Math.max(Math.abs(outX), Math.abs(outY), Math.abs(outZ)) > 34028234663852886e22)
+        throw new Error("Pipeline output exceeds Float32 range");
+      coordinates[offset] = outX;
+      coordinates[offset + 1] = outY;
+      coordinates[offset + 2] = outZ;
+    }
+  };
+}
+
+// dist/projection/experimental/kinematic-helmert.js
+function createKinematicHelmert(translation, rotation, scalePPM, rates, referenceEpoch, coordinateFrame, exact) {
+  const base = [...translation, ...rotation, scalePPM];
+  const velocity = [
+    ...rates.translation || [0, 0, 0],
+    ...rates.rotation || [0, 0, 0],
+    rates.scalePPM || 0
+  ];
+  const arcsecond = Math.PI / (180 * 3600);
+  const coefficients = new Float64Array(14);
+  coefficients[0] = coefficients[4] = coefficients[8] = coefficients[12] = 1;
+  coefficients[13] = NaN;
+  function prepare(epoch) {
+    if (typeof epoch !== "number" || !Number.isFinite(epoch))
+      throw new Error("Kinematic Helmert requires a finite coordinate epoch");
+    if (epoch === coefficients[13])
+      return;
+    const elapsed = epoch - referenceEpoch;
+    const x = base[0] + velocity[0] * elapsed, y = base[1] + velocity[1] * elapsed, z = base[2] + velocity[2] * elapsed, rx = (base[3] + velocity[3] * elapsed) * arcsecond, ry = (base[4] + velocity[4] * elapsed) * arcsecond, rz = (base[5] + velocity[5] * elapsed) * arcsecond, nextScale = 1 + (base[6] + velocity[6] * elapsed) / 1e6;
+    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z) || !Number.isFinite(rx) || !Number.isFinite(ry) || !Number.isFinite(rz) || !Number.isFinite(nextScale) || nextScale <= 0)
+      throw new Error("Invalid epoch-adjusted Helmert parameters or scale");
+    if (exact) {
+      const cx = Math.cos(rx), sx = Math.sin(rx), cy = Math.cos(ry), sy = Math.sin(ry), cz = Math.cos(rz), sz = Math.sin(rz);
+      coefficients[0] = cy * cz;
+      coefficients[1] = cx * sz + sx * sy * cz;
+      coefficients[2] = sx * sz - cx * sy * cz;
+      coefficients[3] = -cy * sz;
+      coefficients[4] = cx * cz - sx * sy * sz;
+      coefficients[5] = sx * cz + cx * sy * sz;
+      coefficients[6] = sy;
+      coefficients[7] = -sx * cy;
+      coefficients[8] = cx * cy;
+      if (!coordinateFrame) {
+        let saved = coefficients[1];
+        coefficients[1] = coefficients[3];
+        coefficients[3] = saved;
+        saved = coefficients[2];
+        coefficients[2] = coefficients[6];
+        coefficients[6] = saved;
+        saved = coefficients[5];
+        coefficients[5] = coefficients[7];
+        coefficients[7] = saved;
+      }
+    } else {
+      const sign = coordinateFrame ? -1 : 1;
+      coefficients[1] = -sign * rz;
+      coefficients[2] = sign * ry;
+      coefficients[3] = sign * rz;
+      coefficients[5] = -sign * rx;
+      coefficients[6] = -sign * ry;
+      coefficients[7] = sign * rx;
+    }
+    coefficients[9] = x;
+    coefficients[10] = y;
+    coefficients[11] = z;
+    coefficients[12] = nextScale;
+    coefficients[13] = epoch;
+  }
+  return {
+    forwardFlat: createKinematicHelmertFlat(coefficients, prepare, false),
+    inverseFlat: createKinematicHelmertFlat(coefficients, prepare, true),
+    forward(point, epoch) {
+      prepare(epoch);
+      const { x, y, z } = point;
+      point.x = coefficients[12] * (coefficients[0] * x + coefficients[1] * y + coefficients[2] * z) + coefficients[9];
+      point.y = coefficients[12] * (coefficients[3] * x + coefficients[4] * y + coefficients[5] * z) + coefficients[10];
+      point.z = coefficients[12] * (coefficients[6] * x + coefficients[7] * y + coefficients[8] * z) + coefficients[11];
+    },
+    inverse(point, epoch) {
+      prepare(epoch);
+      const x = (point.x - coefficients[9]) / coefficients[12], y = (point.y - coefficients[10]) / coefficients[12], z = (point.z - coefficients[11]) / coefficients[12];
+      point.x = coefficients[0] * x + coefficients[3] * y + coefficients[6] * z;
+      point.y = coefficients[1] * x + coefficients[4] * y + coefficients[7] * z;
+      point.z = coefficients[2] * x + coefficients[5] * y + coefficients[8] * z;
+    }
+  };
+}
+
+// dist/projection/experimental/projection-descriptor.js
+var CACHE_KEY = /* @__PURE__ */ Symbol.for("@math.gl/projection/projection-implementations");
+function cache() {
+  const scope = globalThis;
+  scope[CACHE_KEY] || (scope[CACHE_KEY] = /* @__PURE__ */ new WeakMap());
+  return scope[CACHE_KEY];
+}
+function getLoadedProjection(projection) {
+  var _a2;
+  return "create" in projection ? projection : (_a2 = cache().get(projection)) == null ? void 0 : _a2.implementation;
+}
+function preloadProjection(projection) {
+  if ("create" in projection)
+    return Promise.resolve(projection);
+  let state = cache().get(projection);
+  if (!state) {
+    state = { load: () => projection.preload() };
+    cache().set(projection, state);
+  }
+  if (state.implementation)
+    return Promise.resolve(state.implementation);
+  const entry = state;
+  entry.pending || (entry.pending = Promise.resolve().then(entry.load).then((plugin) => {
+    const key = (value) => value.toLowerCase().replace(/[\s_-]/g, "");
+    const supported = new Set([plugin.name, ...plugin.aliases || []].map(key));
+    if (typeof plugin.create !== "function" || ![projection.name, ...projection.aliases || []].every((name) => supported.has(key(name))))
+      throw new Error("Loaded projection does not match descriptor: " + projection.name);
+    entry.implementation = plugin;
+    return plugin;
+  }).catch((error) => {
+    entry.pending = void 0;
+    throw error;
+  }));
+  return entry.pending;
+}
+
+// dist/projection/experimental/vertical-datum.js
+function compileVerticalGrid(names, grids = {}) {
+  if (names === void 0)
+    return void 0;
+  const entries = [];
+  for (const entry of names.split(",")) {
+    const optional = entry.startsWith("@");
+    const name = optional ? entry.slice(1) : entry;
+    if (!name || /\s/.test(name))
+      throw new Error("Invalid vertical grid name");
+    if (name === "null") {
+      entries.push(null);
+      break;
+    }
+    const grid = Object.prototype.hasOwnProperty.call(grids, name) ? grids[name] : void 0;
+    if (grid) {
+      if (typeof grid.getOffset !== "function")
+        throw new Error("Invalid vertical grid: " + name);
+      entries.push(grid.getOffset.bind(grid));
+    } else if (!optional)
+      unsupportedStage("Required vertical grid is not registered: " + name);
+  }
+  return (longitude, latitude) => {
+    for (const sample of entries) {
+      if (!sample)
+        return 0;
+      const offset = sample(longitude, latitude);
+      if (offset === void 0)
+        continue;
+      if (!Number.isFinite(offset))
+        throw new Error("Vertical grid returned a non-finite offset");
+      return offset;
+    }
+    throw new Error("No vertical grid covers this coordinate");
+  };
+}
+
+// dist/projection/experimental/projection-pipeline.js
+var EMPTY_STACK = new Float64Array(0);
+var ordinaryByteLength = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
+function sharedBuffer(buffer) {
+  try {
+    ordinaryByteLength.call(buffer);
+    return false;
+  } catch {
+    return true;
+  }
+}
+function compileFlat(pairs) {
+  if (pairs.length === 1 && pairs[0].forwardFlat)
+    return pairs[0].forwardFlat;
+  return pairs.every((pair) => pair.forwardNumeric) && pairs.some((pair) => pair.forwardNumeric[0] !== 2) ? createNumericFlat(pairs.map((pair) => pair.forwardNumeric)) : void 0;
+}
+var factors = {
+  deg: Math.PI / 180,
+  rad: 1,
+  m: 1,
+  ft: 0.3048,
+  "us-ft": 1200 / 3937
+};
+var geometryKeys = ["ellps", "a", "b", "rf", "f", "R"];
+var angular = (unit) => unit === "deg" || unit === "rad";
+var own2 = (value, name) => Object.prototype.hasOwnProperty.call(value, name);
+function keys(value, allowed) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Expected operation object");
+  for (const name of Object.keys(value))
+    if (!allowed.includes(name))
+      unsupportedStage("Unsupported pipeline parameter: " + name);
+}
+function definition(name, parameters = {}) {
+  if (!/^[a-z][a-z0-9_]*$/i.test(name))
+    throw new Error("Invalid projection name");
+  return "+proj=" + name + Object.entries(parameters).map(([key, value]) => {
+    if (!/^[a-z][a-z0-9_]*$/i.test(key) || value !== void 0 && (typeof value !== "string" || !value || /[\s=]/.test(value) || /\+/.test(value.slice(1).replace(/[eE]\+/g, ""))))
+      throw new Error("Invalid pipeline projection parameter: " + key);
+    return " +" + key + (value === void 0 ? "" : "=" + value);
+  }).join("");
+}
+function finite(point) {
+  if (!Number.isFinite(point.x) || !Number.isFinite(point.y) || !Number.isFinite(point.z))
+    throw new Error("Pipeline coordinate must be finite");
+}
+function triple(values) {
+  if (!Array.isArray(values) || values.length !== 3 || !values.every(Number.isFinite))
+    throw new Error("Expected three finite Helmert parameters");
+}
+var ProjectionPipeline = class {
+  constructor(options) {
+    this.forwardFactories = [];
+    this.inverseFactories = [];
+    this.stackSize = 0;
+    this.coordinateScratch = new ProjectionScratch();
+    this.coordinateStacks = [];
+    this.required = [];
+    this.requiresZ = false;
+    this.requiresEpoch = false;
+    keys(options, ["input", "steps", "projections", "datumGrids", "verticalGrids"]);
+    keys(options.input, ["space", "units"]);
+    const { space, units } = options.input;
+    if (!["geographic", "projected", "geocentric"].includes(space) || !Array.isArray(units) || units.length !== 3 || units.some((unit) => !own2(factors, unit)) || angular(units[2]) || (space === "geographic" ? !angular(units[0]) || !angular(units[1]) : angular(units[0]) || angular(units[1])))
+      throw new Error("Invalid pipeline input space/units");
+    if (!Array.isArray(options.steps) || options.steps.length === 0)
+      throw new Error("Pipeline requires at least one step");
+    this.requiresZ = space === "geocentric";
+    this.input = Object.freeze({
+      space,
+      units: Object.freeze([...units])
+    });
+    const state = { space, units: [...units], stacks: [[], [], []] };
+    const projections = [...options.projections || []];
+    this.deferred = projections.some((projection) => !("create" in projection));
+    const caches = options.steps.map(() => ({}));
+    for (const [index, step] of options.steps.entries()) {
+      for (const name of ["inverse", "omitForward", "omitInverse"])
+        if ((step == null ? void 0 : step[name]) !== void 0 && typeof step[name] !== "boolean")
+          throw new Error("Invalid pipeline " + name + " flag");
+      if ((step == null ? void 0 : step.omitForward) && step.omitInverse)
+        throw new Error("A pipeline step cannot omit both directions");
+      if (!(step == null ? void 0 : step.omitForward))
+        this.forwardFactories.push(this.prepare(step, state, { ...options, projections }, caches[index]));
+    }
+    this.balanced(state);
+    this.output = Object.freeze({
+      space: state.space,
+      units: Object.freeze([...state.units])
+    });
+    const reverse = { space: state.space, units: [...state.units], stacks: [[], [], []] };
+    for (let index = options.steps.length - 1; index >= 0; index--) {
+      const step = options.steps[index];
+      if (!step.omitInverse)
+        this.inverseFactories.push(this.prepare({ ...step, inverse: !step.inverse }, reverse, { ...options, projections }, caches[index]));
+    }
+    this.balanced(reverse);
+    if (reverse.space !== space || reverse.units.some((unit, index) => unit !== units[index]))
+      throw new Error("Inverse pipeline output does not match declared input space/units");
+    if (this.required.every((projection) => getLoadedProjection(projection)))
+      this.compile();
+    this.project = this.project.bind(this);
+    this.unproject = this.unproject.bind(this);
+    this.projectSync = this.projectSync.bind(this);
+    this.unprojectSync = this.unprojectSync.bind(this);
+    this.projectTo = this.projectTo.bind(this);
+    this.unprojectTo = this.unprojectTo.bind(this);
+    this.projectToSync = this.projectToSync.bind(this);
+    this.unprojectToSync = this.unprojectToSync.bind(this);
+    this.projectFlat = this.projectFlat.bind(this);
+    this.unprojectFlat = this.unprojectFlat.bind(this);
+    this.projectFlatSync = this.projectFlatSync.bind(this);
+    this.unprojectFlatSync = this.unprojectFlatSync.bind(this);
+  }
+  /** Load only implementations named by pipeline steps; failures can be retried. */
+  preload() {
+    if (this.compiled)
+      return Promise.resolve(this);
+    this.pending || (this.pending = Promise.all(this.required.map(preloadProjection)).then(() => {
+      this.compile();
+      return this;
+    }).catch((error) => {
+      this.pending = void 0;
+      throw error;
+    }));
+    return this.pending;
+  }
+  project(coordinate, epoch) {
+    return this.deferred ? this.preload().then(() => this.projectSync(coordinate, epoch)) : this.projectSync(coordinate, epoch);
+  }
+  unproject(coordinate, epoch) {
+    return this.deferred ? this.preload().then(() => this.unprojectSync(coordinate, epoch)) : this.unprojectSync(coordinate, epoch);
+  }
+  /** Reuse a scalar output; the epoch remains separate from all coordinate ordinates. */
+  projectTo(coordinate, output, epoch) {
+    return this.deferred ? this.scalarToLoaded(coordinate, output, false, epoch) : this.projectToSync(coordinate, output, epoch);
+  }
+  unprojectTo(coordinate, output, epoch) {
+    return this.deferred ? this.scalarToLoaded(coordinate, output, true, epoch) : this.unprojectToSync(coordinate, output, epoch);
+  }
+  projectToSync(coordinate, output, epoch) {
+    validateScalarOutput(coordinate, output, coordinate.length);
+    return this.scalar(coordinate, false, epoch, output);
+  }
+  unprojectToSync(coordinate, output, epoch) {
+    validateScalarOutput(coordinate, output, coordinate.length);
+    return this.scalar(coordinate, true, epoch, output);
+  }
+  scalarToLoaded(coordinate, output, inverse, epoch) {
+    validateScalarOutput(coordinate, output, coordinate.length);
+    const input = coordinate.slice();
+    return this.preload().then(() => inverse ? this.unprojectToSync(input, output, epoch) : this.projectToSync(input, output, epoch));
+  }
+  projectFlat(coordinates, dimension = 2, epochs) {
+    return this.deferred ? this.preload().then(() => this.projectFlatSync(coordinates, dimension, epochs)) : this.projectFlatSync(coordinates, dimension, epochs);
+  }
+  unprojectFlat(coordinates, dimension = 2, epochs) {
+    return this.deferred ? this.preload().then(() => this.unprojectFlatSync(coordinates, dimension, epochs)) : this.unprojectFlatSync(coordinates, dimension, epochs);
+  }
+  projectSync(coordinate, epoch) {
+    return this.scalar(coordinate, false, epoch);
+  }
+  unprojectSync(coordinate, epoch) {
+    return this.scalar(coordinate, true, epoch);
+  }
+  projectFlatSync(coordinates, dimension = 2, epochs) {
+    return this.flat(coordinates, dimension, false, epochs);
+  }
+  unprojectFlatSync(coordinates, dimension = 2, epochs) {
+    return this.flat(coordinates, dimension, true, epochs);
+  }
+  compile() {
+    if (this.compiled)
+      return;
+    for (const registration of this.required)
+      if (!getLoadedProjection(registration))
+        unsupportedStage("Pipeline projection requires preload(): " + registration.name);
+    const forward = this.forwardFactories.map((factory) => factory()), inverse = this.inverseFactories.map((factory) => factory());
+    this.compiled = {
+      forward: forward.map((pair) => pair.forward),
+      inverse: inverse.map((pair) => pair.forward),
+      forwardFlat: compileFlat(forward),
+      inverseFlat: compileFlat(inverse)
+    };
+  }
+  operations(inverse) {
+    this.compile();
+    return inverse ? this.compiled.inverse : this.compiled.forward;
+  }
+  scalar(coordinate, inverse, epoch, output) {
+    var _a2;
+    this.coordinateEpoch(epoch);
+    if (coordinate.length < (this.requiresZ ? 3 : 2))
+      throw new Error("Pipeline requires " + (this.requiresZ ? "XYZ" : "XY") + " coordinates");
+    const operations = this.operations(inverse);
+    const point = this.coordinateScratch.acquire();
+    try {
+      point.x = coordinate[0];
+      point.y = coordinate[1];
+      point.z = coordinate.length >= 3 ? coordinate[2] : 0;
+      let stack = EMPTY_STACK;
+      if (this.stackSize) {
+        const depth = this.coordinateScratch.depth - 1;
+        stack = (_a2 = this.coordinateStacks)[depth] || (_a2[depth] = new Float64Array(this.stackSize));
+      }
+      this.run(point, operations, stack, epoch);
+      if (output)
+        return writeScalarOutput(coordinate, output, point, coordinate.length);
+      const result = [...coordinate];
+      result[0] = point.x;
+      result[1] = point.y;
+      if (coordinate.length >= 3)
+        result[2] = point.z;
+      return result;
+    } finally {
+      this.coordinateScratch.release(point);
+    }
+  }
+  flat(coordinates, dimension, inverse, epochs) {
+    var _a2;
+    if (!(coordinates instanceof Float32Array || coordinates instanceof Float64Array) || !Number.isSafeInteger(dimension) || dimension < (this.requiresZ ? 3 : 2) || coordinates.length % dimension)
+      throw new Error("Pipeline requires Float32Array/Float64Array and a valid XY/XYZ stride");
+    if (epochs === void 0)
+      this.coordinateEpoch(void 0);
+    else if (typeof epochs === "number")
+      this.coordinateEpoch(epochs);
+    else {
+      if (!(epochs instanceof Float32Array || epochs instanceof Float64Array) || epochs.length !== coordinates.length / dimension)
+        throw new Error("Epoch buffer requires one Float32/Float64 value per coordinate record");
+      if (epochs.byteOffset < coordinates.byteOffset + coordinates.byteLength && coordinates.byteOffset < epochs.byteOffset + epochs.byteLength && (epochs.buffer === coordinates.buffer || sharedBuffer(epochs.buffer) && sharedBuffer(coordinates.buffer)))
+        throw new Error("Epoch and coordinate buffers must not overlap or alias shared storage");
+    }
+    const operations = this.operations(inverse);
+    const specialized = inverse ? this.compiled.inverseFlat : this.compiled.forwardFlat;
+    if (specialized) {
+      specialized(coordinates, dimension, epochs);
+      return coordinates;
+    }
+    const point = this.coordinateScratch.acquire();
+    try {
+      const float32 = coordinates instanceof Float32Array;
+      let stack = EMPTY_STACK;
+      if (this.stackSize) {
+        const depth = this.coordinateScratch.depth - 1;
+        stack = (_a2 = this.coordinateStacks)[depth] || (_a2[depth] = new Float64Array(this.stackSize));
+      }
+      const epochBuffer = typeof epochs === "number" ? void 0 : epochs;
+      let epoch = typeof epochs === "number" ? epochs : void 0;
+      for (let i = 0; i < coordinates.length; i += dimension) {
+        point.x = coordinates[i];
+        point.y = coordinates[i + 1];
+        point.z = dimension >= 3 ? coordinates[i + 2] : 0;
+        if (epochBuffer) {
+          epoch = epochBuffer[i / dimension];
+          this.coordinateEpoch(epoch);
+        }
+        this.run(point, operations, stack, epoch);
+        if (float32 && Math.max(Math.abs(point.x), Math.abs(point.y), Math.abs(point.z)) > 34028234663852886e22)
+          throw new Error("Pipeline output exceeds Float32 range");
+        coordinates[i] = point.x;
+        coordinates[i + 1] = point.y;
+        if (dimension >= 3)
+          coordinates[i + 2] = point.z;
+      }
+      return coordinates;
+    } finally {
+      this.coordinateScratch.release(point);
+    }
+  }
+  coordinateEpoch(epoch) {
+    if (epoch === void 0) {
+      if (this.requiresEpoch)
+        throw new Error("Pipeline requires an explicit coordinate epoch");
+    } else if (typeof epoch !== "number" || !Number.isFinite(epoch))
+      throw new Error("Coordinate epoch must be a finite decimal year");
+  }
+  run(point, operations, stack, epoch) {
+    finite(point);
+    for (const operation of operations) {
+      operation(point, stack, epoch);
+      finite(point);
+    }
+  }
+  balanced(state) {
+    if (state.stacks.some((stack) => stack.length))
+      throw new Error("Pipeline stack has unbalanced push/pop operations");
+  }
+  prepare(step, state, options, cache2) {
+    var _a2, _b, _c;
+    const allowed = {
+      unitconvert: ["xy", "z"],
+      axisswap: ["order"],
+      projection: ["name", "parameters", "output"],
+      cart: ["ellipsoid"],
+      helmert: [
+        "translation",
+        "rotation",
+        "scalePPM",
+        "convention",
+        "exact",
+        "referenceEpoch",
+        "rates"
+      ],
+      deformation: ["model", "sourceEpoch", "targetEpoch"],
+      push: ["components"],
+      pop: ["components"],
+      hgridshift: ["grids"],
+      vgridshift: ["grids", "multiplier"]
+    };
+    if (!step || !own2(allowed, step.type))
+      unsupportedStage("Unsupported pipeline operation: " + (step == null ? void 0 : step.type));
+    keys(step, ["type", "inverse", "omitForward", "omitInverse", ...allowed[step.type]]);
+    if (step.inverse !== void 0 && typeof step.inverse !== "boolean")
+      throw new Error("Invalid pipeline inverse flag");
+    const inverse = Boolean(step.inverse);
+    const orient = (pair2) => inverse ? {
+      forward: pair2.inverse,
+      inverse: pair2.forward,
+      forwardNumeric: pair2.inverseNumeric,
+      inverseNumeric: pair2.forwardNumeric,
+      forwardFlat: pair2.inverseFlat,
+      inverseFlat: pair2.forwardFlat
+    } : pair2;
+    const pair = (forward, backward, forwardNumeric, inverseNumeric, forwardFlat, inverseFlat) => () => {
+      cache2.pair || (cache2.pair = {
+        forward,
+        inverse: backward,
+        forwardNumeric,
+        inverseNumeric,
+        forwardFlat,
+        inverseFlat
+      });
+      return orient(cache2.pair);
+    };
+    const requireState = (space, expected) => {
+      if (state.space !== space || expected.some((unit, index) => state.units[index] !== unit))
+        throw new Error("Pipeline step " + step.type + " requires " + space + " " + expected.join("/"));
+    };
+    switch (step.type) {
+      case "unitconvert": {
+        if (!step.xy && !step.z)
+          throw new Error("Empty unit conversion");
+        const scale = [1, 1, 1];
+        for (const [conversion, indices] of [
+          [step.xy, [0, 1]],
+          [step.z, [2]]
+        ]) {
+          if (!conversion)
+            continue;
+          keys(conversion, ["from", "to"]);
+          const { from, to } = conversion;
+          if (!own2(factors, from) || !own2(factors, to) || angular(from) !== angular(to))
+            throw new Error("Incompatible pipeline units");
+          for (const index of indices) {
+            if (state.units[index] !== (inverse ? to : from))
+              throw new Error("Pipeline unit mismatch");
+            state.units[index] = inverse ? from : to;
+            scale[index] = factors[from] / factors[to];
+          }
+        }
+        this.requiresZ || (this.requiresZ = Boolean(step.z));
+        const [xScale, yScale, zScale] = scale;
+        return pair((p) => {
+          p.x *= xScale;
+          p.y *= yScale;
+          p.z *= zScale;
+        }, (p) => {
+          p.x /= xScale;
+          p.y /= yScale;
+          p.z /= zScale;
+        }, [0, xScale, yScale, zScale], [1, xScale, yScale, zScale]);
+      }
+      case "axisswap": {
+        const order = [...step.order];
+        if (![2, 3].includes(order.length) || order.some((index) => !Number.isInteger(index) || Math.abs(index) < 1 || Math.abs(index) > order.length) || new Set(order.map(Math.abs)).size !== order.length)
+          throw new Error("Axis order must be a signed permutation");
+        if (order.length === 2)
+          order.push(3);
+        this.requiresZ || (this.requiresZ = step.order.length === 3);
+        const reverse = [0, 0, 0];
+        order.forEach((index, target) => {
+          reverse[Math.abs(index) - 1] = Math.sign(index) * (target + 1);
+        });
+        const selected = inverse ? reverse : order;
+        state.units = selected.map((index) => state.units[Math.abs(index) - 1]);
+        const operation = (indices) => {
+          const [a, b, c] = indices.map(Math.abs);
+          const [sx, sy, sz] = indices.map(Math.sign);
+          return (p) => {
+            const { x, y, z } = p;
+            p.x = sx * (a === 1 ? x : a === 2 ? y : z);
+            p.y = sy * (b === 1 ? x : b === 2 ? y : z);
+            p.z = sz * (c === 1 ? x : c === 2 ? y : z);
+          };
+        };
+        return pair(operation(order), operation(reverse), [2, order[0], order[1], order[2]], [2, reverse[0], reverse[1], reverse[2]]);
+      }
+      case "projection": {
+        const output = step.output === void 0 ? { space: "projected", unit: "m" } : { ...step.output };
+        keys(output, ["space", "unit"]);
+        if (output.space === "geographic" ? !["rad", "deg"].includes(output.unit) : output.space !== "projected" || output.unit !== "m")
+          throw new Error("Invalid projection output space/unit contract");
+        requireState(inverse ? output.space : "geographic", inverse ? [output.unit, output.unit] : ["rad", "rad"]);
+        state.space = inverse ? "geographic" : output.space;
+        state.units[0] = state.units[1] = inverse ? "rad" : output.unit;
+        const key = (name) => name.toLowerCase().replace(/[\s_-]/g, "");
+        if (typeof step.name !== "string")
+          throw new Error("Invalid projection name");
+        const registration = (_a2 = options.projections) == null ? void 0 : _a2.find((p) => [p.name, ...p.aliases || []].some((name) => key(name) === key(step.name)));
+        if (!registration)
+          unsupportedStage("Pipeline projection is not registered: " + step.name);
+        if (!this.required.includes(registration))
+          this.required.push(registration);
+        const parameters = { ...step.parameters };
+        for (const name of Object.keys(parameters))
+          if (CORE_PARAMETERS.includes(name) && !geometryKeys.includes(name) && name !== "over")
+            unsupportedStage("Unsupported pipeline parameter: " + name);
+        const oblique = key(registration.name) === "obtran";
+        const geographicChild = ["longlat", "latlong", "latlon", "lonlat", "identity"].includes(key(parameters["o_proj"] || ""));
+        if (oblique && (!step.output || !parameters["o_proj"]))
+          unsupportedStage("Oblique helper pipelines require an explicit output-unit contract and o_proj");
+        if ((oblique && geographicChild) !== (output.space === "geographic"))
+          throw new Error("Projection output contract does not match its algorithm");
+        const scale = geographicChild && output.unit === "rad" ? Math.PI / 180 : 1;
+        const normalized = normalizeCRS(definition(registration.name, parameters));
+        if (normalized.kind !== "projected")
+          unsupportedStage("Use a cart step for geocentric conversion");
+        return () => {
+          var _a3;
+          if (cache2.pair)
+            return orient(cache2.pair);
+          const plugin = getLoadedProjection(registration);
+          if (!plugin)
+            unsupportedStage("Pipeline projection requires preload(): " + registration.name);
+          if (key(plugin.name) === "obtran" !== oblique)
+            unsupportedStage("Pipeline projection requires a matching projected-metre output contract: " + plugin.name);
+          if ([
+            "geocent",
+            "geocentric",
+            "identity",
+            "longlat",
+            "latlong",
+            "latlon",
+            "lonlat"
+          ].includes(key(plugin.name)))
+            unsupportedStage("Pipeline projection requires a projected-metre output contract: " + plugin.name);
+          keys(parameters, [...geometryKeys, "over", ...plugin.parameters]);
+          for (const [name, value] of Object.entries(parameters)) {
+            const flag = name === "over" || ((_a3 = plugin.flags) == null ? void 0 : _a3.includes(name));
+            if (flag && value !== void 0)
+              throw new Error("Expected a flag without a value: " + name);
+            if (!flag && value === void 0)
+              throw new Error("Pipeline parameter requires a value: " + name);
+          }
+          const implementation = plugin.create({
+            parameters: { ...normalized.parameters, proj: plugin.name },
+            semiMajorAxis: normalized.ellipsoid.semiMajorAxis,
+            semiMinorAxis: normalized.ellipsoid.semiMinorAxis,
+            eccentricitySquared: normalized.ellipsoid.eccentricitySquared
+          });
+          const forward = projectionOperation(implementation, false), backward = projectionOperation(implementation, true);
+          cache2.pair = oblique ? {
+            forward: (p) => {
+              if (Math.abs(p.y) > Math.PI / 2)
+                throw new Error("Invalid geographic latitude");
+              forward(p);
+              p.x *= scale;
+              p.y *= scale;
+            },
+            inverse: (p) => {
+              if (geographicChild && Math.abs(p.y) > (output.unit === "deg" ? 90 : Math.PI / 2))
+                throw new Error("Invalid rotated geographic latitude");
+              p.x /= scale;
+              p.y /= scale;
+              backward(p);
+            }
+          } : { forward, inverse: backward };
+          return orient(cache2.pair);
+        };
+      }
+      case "cart": {
+        requireState(inverse ? "geocentric" : "geographic", inverse ? ["m", "m", "m"] : ["rad", "rad", "m"]);
+        state.space = inverse ? "geographic" : "geocentric";
+        state.units = inverse ? ["rad", "rad", "m"] : ["m", "m", "m"];
+        this.requiresZ = true;
+        keys(step.ellipsoid || {}, geometryKeys);
+        const ellipsoid = normalizeCRS(definition("longlat", step.ellipsoid)).ellipsoid;
+        return pair((p) => geodeticToGeocentricInPlace(p, ellipsoid), (p) => geocentricToGeodeticInPlace(p, ellipsoid));
+      }
+      case "helmert": {
+        requireState("geocentric", ["m", "m", "m"]);
+        this.requiresZ = true;
+        triple(step.translation);
+        if (step.rotation)
+          triple(step.rotation);
+        if ((step.rotation || ((_b = step.rates) == null ? void 0 : _b.rotation)) && !step.convention)
+          throw new Error("Helmert rotation requires a convention");
+        if (step.convention !== void 0 && !["position_vector", "coordinate_frame"].includes(step.convention))
+          throw new Error("Invalid Helmert convention");
+        const scale = step.scalePPM ?? 0;
+        if (!Number.isFinite(scale) || scale <= -1e6)
+          throw new Error("Helmert requires positive finite scale");
+        if (step.exact !== void 0 && typeof step.exact !== "boolean")
+          throw new Error("Invalid exact Helmert flag");
+        if (step.rates !== void 0) {
+          keys(step.rates, ["translation", "rotation", "scalePPM"]);
+          if (step.rates.translation === void 0 && step.rates.rotation === void 0 && step.rates.scalePPM === void 0)
+            throw new Error("Helmert rates require at least one parameter");
+          if (step.rates.translation !== void 0)
+            triple(step.rates.translation);
+          if (step.rates.rotation !== void 0)
+            triple(step.rates.rotation);
+          if (step.rates.scalePPM !== void 0 && !Number.isFinite(step.rates.scalePPM))
+            throw new Error("Helmert scale rate must be finite");
+          if (typeof step.referenceEpoch !== "number" || !Number.isFinite(step.referenceEpoch))
+            throw new Error("Helmert rates require a finite referenceEpoch");
+          this.requiresEpoch = true;
+          const operation = createKinematicHelmert(step.translation, step.rotation || [0, 0, 0], scale, step.rates, step.referenceEpoch, step.convention === "coordinate_frame", Boolean(step.exact));
+          return pair((p, _stack, epoch) => operation.forward(p, epoch), (p, _stack, epoch) => operation.inverse(p, epoch), void 0, void 0, operation.forwardFlat, operation.inverseFlat);
+        }
+        if (step.referenceEpoch !== void 0)
+          throw new Error("Helmert referenceEpoch requires rates");
+        if (step.exact) {
+          const exact = createExactHelmert(step.translation, step.rotation || [0, 0, 0], scale, step.convention === "coordinate_frame");
+          return pair(exact.forward, exact.inverse, void 0, void 0, createHelmertFlat(exact.coefficients, false, true), createHelmertFlat(exact.coefficients, true, true));
+        }
+        const sign = step.convention === "coordinate_frame" ? -1 : 1;
+        const values = [
+          ...step.translation,
+          ...(step.rotation || [0, 0, 0]).map((value) => sign * value),
+          scale
+        ];
+        const radians = Math.PI / (180 * 3600);
+        const coefficients = [
+          (values[3] || 0) * radians,
+          (values[4] || 0) * radians,
+          (values[5] || 0) * radians,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          values[0],
+          values[1],
+          values[2],
+          1 + (values[6] || 0) / 1e6
+        ];
+        return pair(createHelmert(values, false), createHelmert(values, true), void 0, void 0, createHelmertFlat(coefficients, false, false), createHelmertFlat(coefficients, true, false));
+      }
+      case "deformation": {
+        requireState("geocentric", ["m", "m", "m"]);
+        this.requiresZ = true;
+        const source = step.sourceEpoch, target = step.targetEpoch;
+        if (source !== "coordinate" && (typeof source !== "number" || !Number.isFinite(source)) || typeof target !== "number" || !Number.isFinite(target))
+          throw new Error("Explicit finite deformation source/target epochs required");
+        if (!step.model || typeof step.model.forward !== "function" || typeof step.model.inverse !== "function")
+          throw new Error("Prepared deformation model required");
+        this.requiresEpoch || (this.requiresEpoch = source === "coordinate");
+        const forward = step.model.forward.bind(step.model), backward = step.model.inverse.bind(step.model);
+        return pair((p, _stack, epoch) => forward(p, source === "coordinate" ? epoch : source, target), (p, _stack, epoch) => backward(p, source === "coordinate" ? epoch : source, target));
+      }
+      case "push":
+      case "pop": {
+        if (!Array.isArray(step.components) || !step.components.length || step.components.some((component) => !Number.isInteger(component) || component < 1 || component > 3) || new Set(step.components).size !== step.components.length)
+          throw new Error("Stack components must be distinct ordinates 1, 2 or 3");
+        const components = [...step.components];
+        this.requiresZ || (this.requiresZ = components.includes(3));
+        const pushing = step.type === "push" !== inverse;
+        const entries = components.map((component) => {
+          const index = component - 1;
+          if (pushing) {
+            const entry2 = { unit: state.units[index], space: state.space, slot: this.stackSize++ };
+            state.stacks[index].push(entry2);
+            return entry2;
+          }
+          const entry = state.stacks[index].pop();
+          if (!entry)
+            throw new Error("Pipeline stack underflow for ordinate " + component);
+          return entry;
+        });
+        if (!pushing) {
+          const horizontal = components.map((component, index) => ({ component, entry: entries[index] })).filter(({ component }) => component < 3);
+          const space = ((_c = horizontal[0]) == null ? void 0 : _c.entry.space) || state.space;
+          if (horizontal.some(({ entry }) => entry.space !== space) || horizontal.length === 1 && space !== state.space)
+            throw new Error("Stack restore would mix horizontal coordinate spaces");
+          state.space = space;
+          components.forEach((component, index) => {
+            state.units[component - 1] = entries[index].unit;
+          });
+        }
+        const save = (p, stack) => {
+          for (let index = 0; index < components.length; index++)
+            stack[entries[index].slot] = components[index] === 1 ? p.x : components[index] === 2 ? p.y : p.z;
+        };
+        const restore = (p, stack) => {
+          for (let index = 0; index < components.length; index++) {
+            const value = stack[entries[index].slot];
+            if (components[index] === 1)
+              p.x = value;
+            else if (components[index] === 2)
+              p.y = value;
+            else
+              p.z = value;
+          }
+        };
+        return () => pushing ? { forward: save, inverse: restore } : { forward: restore, inverse: save };
+      }
+      case "hgridshift": {
+        requireState("geographic", ["rad", "rad"]);
+        if (typeof step.grids !== "string")
+          throw new Error("Horizontal grid names required");
+        const crs = normalizeCRS(definition("longlat", { nadgrids: step.grids }));
+        if (!crs.datum.grids)
+          return pair(() => {
+          }, () => {
+          });
+        const grids = crs.datum.grids.map((reference) => {
+          const grid = own2(options.datumGrids || {}, reference.name) ? options.datumGrids[reference.name] : void 0;
+          if (reference.name !== "null" && !grid && !reference.optional)
+            unsupportedStage("Required datum grid is not registered: " + reference.name);
+          if (grid && typeof grid.shift !== "function")
+            throw new Error("Invalid datum grid: " + reference.name);
+          return { ...reference, grid };
+        });
+        const datum = { ...crs.datum, grids };
+        return pair((p) => applyDatumGrids(p, datum, false), (p) => applyDatumGrids(p, datum, true));
+      }
+      case "vgridshift": {
+        requireState("geographic", ["rad", "rad", "m"]);
+        this.requiresZ = true;
+        if (typeof step.grids !== "string")
+          throw new Error("Vertical grid names required");
+        const offset = compileVerticalGrid(step.grids, options.verticalGrids);
+        const multiplier = step.multiplier ?? -1;
+        if (!Number.isFinite(multiplier))
+          throw new Error("Vertical grid multiplier must be finite");
+        return pair((p) => {
+          p.z += multiplier * offset(p.x, p.y);
+        }, (p) => {
+          p.z -= multiplier * offset(p.x, p.y);
+        });
+      }
+      default:
+        throw new Error("Unsupported pipeline step");
+    }
+  }
+};
+//# sourceMappingURL=pipeline.cjs.map