@math.gl/projection 0.0.0-stage → 5.0.0-alpha.12

package/dist/pipeline.cjs

@@ -0,0 +1,3347 @@
+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/pipeline.js
+var pipeline_exports = {};
+__export(pipeline_exports, {
+  ProjectionPipeline: () => ProjectionPipeline
+});
+module.exports = __toCommonJS(pipeline_exports);
+
+// ../crs/src/spatial-reference.ts
+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";
+}
+
+// ../crs/src/proj-string.ts
+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/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/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/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/experimental/crs/datum-table.js
+var datums = {
+  wgs84: {
+    towgs84: "0,0,0",
+    ellipse: "WGS84",
+    datumName: "WGS84"
+  },
+  ch1903: {
+    towgs84: "674.374,15.056,405.346",
+    ellipse: "bessel",
+    datumName: "swiss"
+  },
+  ggrs87: {
+    towgs84: "-199.87,74.79,246.62",
+    ellipse: "GRS80",
+    datumName: "Greek_Geodetic_Reference_System_1987"
+  },
+  nad83: {
+    towgs84: "0,0,0",
+    ellipse: "GRS80",
+    datumName: "North_American_Datum_1983"
+  },
+  nad27: {
+    nadgrids: "@conus,@alaska,@ntv2_0.gsb,@ntv1_can.dat",
+    ellipse: "clrk66",
+    datumName: "North_American_Datum_1927"
+  },
+  potsdam: {
+    towgs84: "598.1,73.7,418.2,0.202,0.045,-2.455,6.7",
+    ellipse: "bessel",
+    datumName: "Potsdam Rauenberg 1950 DHDN"
+  },
+  carthage: {
+    towgs84: "-263.0,6.0,431.0",
+    ellipse: "clrk80ign",
+    datumName: "Carthage 1934 Tunisia"
+  },
+  hermannskogel: {
+    towgs84: "577.326,90.129,463.919,5.137,1.474,5.297,2.4232",
+    ellipse: "bessel",
+    datumName: "Hermannskogel"
+  },
+  mgi: {
+    towgs84: "577.326,90.129,463.919,5.137,1.474,5.297,2.4232",
+    ellipse: "bessel",
+    datumName: "Militar-Geographische Institut"
+  },
+  osni52: {
+    towgs84: "482.530,-130.596,564.557,-1.042,-0.214,-0.631,8.15",
+    ellipse: "airy",
+    datumName: "Irish National"
+  },
+  ire65: {
+    towgs84: "482.530,-130.596,564.557,-1.042,-0.214,-0.631,8.15",
+    ellipse: "mod_airy",
+    datumName: "Ireland 1965"
+  },
+  rassadiran: {
+    towgs84: "-133.63,-157.5,-158.62",
+    ellipse: "intl",
+    datumName: "Rassadiran"
+  },
+  nzgd49: {
+    towgs84: "59.47,-5.04,187.44,0.47,-0.1,1.024,-4.5993",
+    ellipse: "intl",
+    datumName: "New Zealand Geodetic Datum 1949"
+  },
+  osgb36: {
+    towgs84: "446.448,-125.157,542.060,0.1502,0.2470,0.8421,-20.4894",
+    ellipse: "airy",
+    datumName: "Ordnance Survey of Great Britain 1936"
+  },
+  s_jtsk: {
+    towgs84: "589,76,480",
+    ellipse: "bessel",
+    datumName: "S-JTSK (Ferro)"
+  },
+  beduaram: {
+    towgs84: "-106,-87,188",
+    ellipse: "clrk80",
+    datumName: "Beduaram"
+  },
+  gunung_segara: {
+    towgs84: "-403,684,41",
+    ellipse: "bessel",
+    datumName: "Gunung Segara Jakarta"
+  },
+  rnb72: {
+    towgs84: "106.869,-52.2978,103.724,-0.33657,0.456955,-1.84218,1",
+    ellipse: "intl",
+    datumName: "Reseau National Belge 1972"
+  },
+  EPSG_5451: {
+    towgs84: "6.41,-49.05,-11.28,1.5657,0.5242,6.9718,-5.7649"
+  },
+  IGNF_LURESG: {
+    towgs84: "-192.986,13.673,-39.309,-0.4099,-2.9332,2.6881,0.43"
+  },
+  EPSG_4614: {
+    towgs84: "-119.4248,-303.65872,-11.00061,1.164298,0.174458,1.096259,3.657065"
+  },
+  EPSG_4615: {
+    towgs84: "-494.088,-312.129,279.877,-1.423,-1.013,1.59,-0.748"
+  },
+  ESRI_37241: {
+    towgs84: "-76.822,257.457,-12.817,2.136,-0.033,-2.392,-0.031"
+  },
+  ESRI_37249: {
+    towgs84: "-440.296,58.548,296.265,1.128,10.202,4.559,-0.438"
+  },
+  ESRI_37245: {
+    towgs84: "-511.151,-181.269,139.609,1.05,2.703,1.798,3.071"
+  },
+  EPSG_4178: {
+    towgs84: "24.9,-126.4,-93.2,-0.063,-0.247,-0.041,1.01"
+  },
+  EPSG_4622: {
+    towgs84: "-472.29,-5.63,-304.12,0.4362,-0.8374,0.2563,1.8984"
+  },
+  EPSG_4625: {
+    towgs84: "126.93,547.94,130.41,-2.7867,5.1612,-0.8584,13.8227"
+  },
+  EPSG_5252: {
+    towgs84: "0.023,0.036,-0.068,0.00176,0.00912,-0.01136,0.00439"
+  },
+  EPSG_4314: {
+    towgs84: "597.1,71.4,412.1,0.894,0.068,-1.563,7.58"
+  },
+  EPSG_4282: {
+    towgs84: "-178.3,-316.7,-131.5,5.278,6.077,10.979,19.166"
+  },
+  EPSG_4231: {
+    towgs84: "-83.11,-97.38,-117.22,0.005693,-0.044698,0.044285,0.1218"
+  },
+  EPSG_4274: {
+    towgs84: "-230.994,102.591,25.199,0.633,-0.239,0.9,1.95"
+  },
+  EPSG_4134: {
+    towgs84: "-180.624,-225.516,173.919,-0.81,-1.898,8.336,16.71006"
+  },
+  EPSG_4254: {
+    towgs84: "18.38,192.45,96.82,0.056,-0.142,-0.2,-0.0013"
+  },
+  EPSG_4159: {
+    towgs84: "-194.513,-63.978,-25.759,-3.4027,3.756,-3.352,-0.9175"
+  },
+  EPSG_4687: {
+    towgs84: "0.072,-0.507,-0.245,0.0183,-0.0003,0.007,-0.0093"
+  },
+  EPSG_4227: {
+    towgs84: "-83.58,-397.54,458.78,-17.595,-2.847,4.256,3.225"
+  },
+  EPSG_4746: {
+    towgs84: "599.4,72.4,419.2,-0.062,-0.022,-2.723,6.46"
+  },
+  EPSG_4745: {
+    towgs84: "612.4,77,440.2,-0.054,0.057,-2.797,2.55"
+  },
+  EPSG_6311: {
+    towgs84: "8.846,-4.394,-1.122,-0.00237,-0.146528,0.130428,0.783926"
+  },
+  EPSG_4289: {
+    towgs84: "565.7381,50.4018,465.2904,-0.395026,0.330772,-1.876073,4.07244"
+  },
+  EPSG_4230: {
+    towgs84: "-68.863,-134.888,-111.49,-0.53,-0.14,0.57,-3.4"
+  },
+  EPSG_4154: {
+    towgs84: "-123.02,-158.95,-168.47"
+  },
+  EPSG_4156: {
+    towgs84: "570.8,85.7,462.8,4.998,1.587,5.261,3.56"
+  },
+  EPSG_4299: {
+    towgs84: "482.5,-130.6,564.6,-1.042,-0.214,-0.631,8.15"
+  },
+  EPSG_4179: {
+    towgs84: "33.4,-146.6,-76.3,-0.359,-0.053,0.844,-0.84"
+  },
+  EPSG_4313: {
+    towgs84: "-106.8686,52.2978,-103.7239,0.3366,-0.457,1.8422,-1.2747"
+  },
+  EPSG_4194: {
+    towgs84: "163.511,127.533,-159.789"
+  },
+  EPSG_4195: {
+    towgs84: "105,326,-102.5"
+  },
+  EPSG_4196: {
+    towgs84: "-45,417,-3.5"
+  },
+  EPSG_4611: {
+    towgs84: "-162.619,-276.959,-161.764,0.067753,-2.243648,-1.158828,-1.094246"
+  },
+  EPSG_4633: {
+    towgs84: "137.092,131.66,91.475,-1.9436,-11.5993,-4.3321,-7.4824"
+  },
+  EPSG_4641: {
+    towgs84: "-408.809,366.856,-412.987,1.8842,-0.5308,2.1655,-121.0993"
+  },
+  EPSG_4643: {
+    towgs84: "-480.26,-438.32,-643.429,16.3119,20.1721,-4.0349,-111.7002"
+  },
+  EPSG_4300: {
+    towgs84: "482.5,-130.6,564.6,-1.042,-0.214,-0.631,8.15"
+  },
+  EPSG_4188: {
+    towgs84: "482.5,-130.6,564.6,-1.042,-0.214,-0.631,8.15"
+  },
+  EPSG_4660: {
+    towgs84: "982.6087,552.753,-540.873,6.681627,-31.611492,-19.848161,16.805"
+  },
+  EPSG_4662: {
+    towgs84: "97.295,-263.247,310.882,-1.5999,0.8386,3.1409,13.3259"
+  },
+  EPSG_3906: {
+    towgs84: "577.88891,165.22205,391.18289,4.9145,-0.94729,-13.05098,7.78664"
+  },
+  EPSG_4307: {
+    towgs84: "-209.3622,-87.8162,404.6198,0.0046,3.4784,0.5805,-1.4547"
+  },
+  EPSG_6892: {
+    towgs84: "-76.269,-16.683,68.562,-6.275,10.536,-4.286,-13.686"
+  },
+  EPSG_4690: {
+    towgs84: "221.597,152.441,176.523,2.403,1.3893,0.884,11.4648"
+  },
+  EPSG_4691: {
+    towgs84: "218.769,150.75,176.75,3.5231,2.0037,1.288,10.9817"
+  },
+  EPSG_4629: {
+    towgs84: "72.51,345.411,79.241,-1.5862,-0.8826,-0.5495,1.3653"
+  },
+  EPSG_4630: {
+    towgs84: "165.804,216.213,180.26,-0.6251,-0.4515,-0.0721,7.4111"
+  },
+  EPSG_4692: {
+    towgs84: "217.109,86.452,23.711,0.0183,-0.0003,0.007,-0.0093"
+  },
+  EPSG_9333: {
+    towgs84: "0,0,0,-0.008393,0.000749,-0.010276,0"
+  },
+  EPSG_9059: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4312: {
+    towgs84: "601.705,84.263,485.227,4.7354,1.3145,5.393,-2.3887"
+  },
+  EPSG_4123: {
+    towgs84: "-96.062,-82.428,-121.753,4.801,0.345,-1.376,1.496"
+  },
+  EPSG_4309: {
+    towgs84: "-124.45,183.74,44.64,-0.4384,0.5446,-0.9706,-2.1365"
+  },
+  ESRI_104106: {
+    towgs84: "-283.088,-70.693,117.445,-1.157,0.059,-0.652,-4.058"
+  },
+  EPSG_4281: {
+    towgs84: "-219.247,-73.802,269.529"
+  },
+  EPSG_4322: {
+    towgs84: "0,0,4.5"
+  },
+  EPSG_4324: {
+    towgs84: "0,0,1.9"
+  },
+  EPSG_4284: {
+    towgs84: "43.822,-108.842,-119.585,1.455,-0.761,0.737,0.549"
+  },
+  EPSG_4277: {
+    towgs84: "446.448,-125.157,542.06,0.15,0.247,0.842,-20.489"
+  },
+  EPSG_4207: {
+    towgs84: "-282.1,-72.2,120,-1.529,0.145,-0.89,-4.46"
+  },
+  EPSG_4688: {
+    towgs84: "347.175,1077.618,2623.677,33.9058,-70.6776,9.4013,186.0647"
+  },
+  EPSG_4689: {
+    towgs84: "410.793,54.542,80.501,-2.5596,-2.3517,-0.6594,17.3218"
+  },
+  EPSG_4720: {
+    towgs84: "0,0,4.5"
+  },
+  EPSG_4273: {
+    towgs84: "278.3,93,474.5,7.889,0.05,-6.61,6.21"
+  },
+  EPSG_4240: {
+    towgs84: "204.64,834.74,293.8"
+  },
+  EPSG_4817: {
+    towgs84: "278.3,93,474.5,7.889,0.05,-6.61,6.21"
+  },
+  ESRI_104131: {
+    towgs84: "426.62,142.62,460.09,4.98,4.49,-12.42,-17.1"
+  },
+  EPSG_4265: {
+    towgs84: "-104.1,-49.1,-9.9,0.971,-2.917,0.714,-11.68"
+  },
+  EPSG_4263: {
+    towgs84: "-111.92,-87.85,114.5,1.875,0.202,0.219,0.032"
+  },
+  EPSG_4298: {
+    towgs84: "-689.5937,623.84046,-65.93566,-0.02331,1.17094,-0.80054,5.88536"
+  },
+  EPSG_4270: {
+    towgs84: "-253.4392,-148.452,386.5267,0.15605,0.43,-0.1013,-0.0424"
+  },
+  EPSG_4229: {
+    towgs84: "-121.8,98.1,-10.7"
+  },
+  EPSG_4220: {
+    towgs84: "-55.5,-348,-229.2"
+  },
+  EPSG_4214: {
+    towgs84: "12.646,-155.176,-80.863"
+  },
+  EPSG_4232: {
+    towgs84: "-345,3,223"
+  },
+  EPSG_4238: {
+    towgs84: "-1.977,-13.06,-9.993,0.364,0.254,0.689,-1.037"
+  },
+  EPSG_4168: {
+    towgs84: "-170,33,326"
+  },
+  EPSG_4131: {
+    towgs84: "199,931,318.9"
+  },
+  EPSG_4152: {
+    towgs84: "-0.9102,2.0141,0.5602,0.029039,0.010065,0.010101,0"
+  },
+  EPSG_5228: {
+    towgs84: "572.213,85.334,461.94,4.9732,1.529,5.2484,3.5378"
+  },
+  EPSG_8351: {
+    towgs84: "485.021,169.465,483.839,7.786342,4.397554,4.102655,0"
+  },
+  EPSG_4683: {
+    towgs84: "-127.62,-67.24,-47.04,-3.068,4.903,1.578,-1.06"
+  },
+  EPSG_4133: {
+    towgs84: "0,0,0"
+  },
+  EPSG_7373: {
+    towgs84: "0.819,-0.5762,-1.6446,-0.00378,-0.03317,0.00318,0.0693"
+  },
+  EPSG_9075: {
+    towgs84: "-0.9102,2.0141,0.5602,0.029039,0.010065,0.010101,0"
+  },
+  EPSG_9072: {
+    towgs84: "-0.9102,2.0141,0.5602,0.029039,0.010065,0.010101,0"
+  },
+  EPSG_9294: {
+    towgs84: "1.16835,-1.42001,-2.24431,-0.00822,-0.05508,0.01818,0.23388"
+  },
+  EPSG_4212: {
+    towgs84: "-267.434,173.496,181.814,-13.4704,8.7154,7.3926,14.7492"
+  },
+  EPSG_4191: {
+    towgs84: "-44.183,-0.58,-38.489,2.3867,2.7072,-3.5196,-8.2703"
+  },
+  EPSG_4237: {
+    towgs84: "52.684,-71.194,-13.975,-0.312,-0.1063,-0.3729,1.0191"
+  },
+  EPSG_4740: {
+    towgs84: "-1.08,-0.27,-0.9"
+  },
+  EPSG_4124: {
+    towgs84: "419.3836,99.3335,591.3451,0.850389,1.817277,-7.862238,-0.99496"
+  },
+  EPSG_5681: {
+    towgs84: "584.9636,107.7175,413.8067,1.1155,0.2824,-3.1384,7.9922"
+  },
+  EPSG_4141: {
+    towgs84: "23.772,17.49,17.859,-0.3132,-1.85274,1.67299,-5.4262"
+  },
+  EPSG_4204: {
+    towgs84: "-85.645,-273.077,-79.708,2.289,-1.421,2.532,3.194"
+  },
+  EPSG_4319: {
+    towgs84: "226.702,-193.337,-35.371,-2.229,-4.391,9.238,0.9798"
+  },
+  EPSG_4200: {
+    towgs84: "24.82,-131.21,-82.66"
+  },
+  EPSG_4130: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4127: {
+    towgs84: "-82.875,-57.097,-156.768,-2.158,1.524,-0.982,-0.359"
+  },
+  EPSG_4149: {
+    towgs84: "674.374,15.056,405.346"
+  },
+  EPSG_4617: {
+    towgs84: "-0.991,1.9072,0.5129,0.02579,0.00965,0.01166,0"
+  },
+  EPSG_4663: {
+    towgs84: "-210.502,-66.902,-48.476,2.094,-15.067,-5.817,0.485"
+  },
+  EPSG_4664: {
+    towgs84: "-211.939,137.626,58.3,-0.089,0.251,0.079,0.384"
+  },
+  EPSG_4665: {
+    towgs84: "-105.854,165.589,-38.312,-0.003,-0.026,0.024,-0.048"
+  },
+  EPSG_4666: {
+    towgs84: "631.392,-66.551,481.442,1.09,-4.445,-4.487,-4.43"
+  },
+  EPSG_4756: {
+    towgs84: "-192.873,-39.382,-111.202,-0.00205,-0.0005,0.00335,0.0188"
+  },
+  EPSG_4723: {
+    towgs84: "-179.483,-69.379,-27.584,-7.862,8.163,6.042,-13.925"
+  },
+  EPSG_4726: {
+    towgs84: "8.853,-52.644,180.304,-0.393,-2.323,2.96,-24.081"
+  },
+  EPSG_4267: {
+    towgs84: "-8.0,160.0,176.0"
+  },
+  EPSG_5365: {
+    towgs84: "-0.16959,0.35312,0.51846,0.03385,-0.16325,0.03446,0.03693"
+  },
+  EPSG_4218: {
+    towgs84: "304.5,306.5,-318.1"
+  },
+  EPSG_4242: {
+    towgs84: "-33.722,153.789,94.959,-8.581,-4.478,4.54,8.95"
+  },
+  EPSG_4216: {
+    towgs84: "-292.295,248.758,429.447,4.9971,2.99,6.6906,1.0289"
+  },
+  ESRI_104105: {
+    towgs84: "631.392,-66.551,481.442,1.09,-4.445,-4.487,-4.43"
+  },
+  ESRI_104129: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4673: {
+    towgs84: "174.05,-25.49,112.57"
+  },
+  EPSG_4202: {
+    towgs84: "-124,-60,154"
+  },
+  EPSG_4203: {
+    towgs84: "-117.763,-51.51,139.061,0.292,0.443,0.277,-0.191"
+  },
+  EPSG_3819: {
+    towgs84: "595.48,121.69,515.35,4.115,-2.9383,0.853,-3.408"
+  },
+  EPSG_8694: {
+    towgs84: "-93.799,-132.737,-219.073,-1.844,0.648,-6.37,-0.169"
+  },
+  EPSG_4145: {
+    towgs84: "275.57,676.78,229.6"
+  },
+  EPSG_4283: {
+    towgs84: "0.06155,-0.01087,-0.04019,0.039492,0.032722,0.032898,-0.009994"
+  },
+  EPSG_4317: {
+    towgs84: "2.3287,-147.0425,-92.0802,-0.309248,0.324822,0.497299,5.689063"
+  },
+  EPSG_4272: {
+    towgs84: "59.47,-5.04,187.44,0.47,-0.1,1.024,-4.5993"
+  },
+  EPSG_4248: {
+    towgs84: "-307.7,265.3,-363.5"
+  },
+  EPSG_5561: {
+    towgs84: "24,-121,-76"
+  },
+  EPSG_5233: {
+    towgs84: "-0.293,766.95,87.713,0.195704,1.695068,3.473016,-0.039338"
+  },
+  ESRI_104130: {
+    towgs84: "-86,-98,-119"
+  },
+  ESRI_104102: {
+    towgs84: "682,-203,480"
+  },
+  ESRI_37207: {
+    towgs84: "7,-10,-26"
+  },
+  EPSG_4675: {
+    towgs84: "59.935,118.4,-10.871"
+  },
+  ESRI_104109: {
+    towgs84: "-89.121,-348.182,260.871"
+  },
+  ESRI_104112: {
+    towgs84: "-185.583,-230.096,281.361"
+  },
+  ESRI_104113: {
+    towgs84: "25.1,-275.6,222.6"
+  },
+  IGNF_WGS72G: {
+    towgs84: "0,12,6"
+  },
+  IGNF_NTFG: {
+    towgs84: "-168,-60,320"
+  },
+  IGNF_EFATE57G: {
+    towgs84: "-127,-769,472"
+  },
+  IGNF_PGP50G: {
+    towgs84: "324.8,153.6,172.1"
+  },
+  IGNF_REUN47G: {
+    towgs84: "94,-948,-1262"
+  },
+  IGNF_CSG67G: {
+    towgs84: "-186,230,110"
+  },
+  IGNF_GUAD48G: {
+    towgs84: "-467,-16,-300"
+  },
+  IGNF_TAHI51G: {
+    towgs84: "162,117,154"
+  },
+  IGNF_TAHAAG: {
+    towgs84: "65,342,77"
+  },
+  IGNF_NUKU72G: {
+    towgs84: "84,274,65"
+  },
+  IGNF_PETRELS72G: {
+    towgs84: "365,194,166"
+  },
+  IGNF_WALL78G: {
+    towgs84: "253,-133,-127"
+  },
+  IGNF_MAYO50G: {
+    towgs84: "-382,-59,-262"
+  },
+  IGNF_TANNAG: {
+    towgs84: "-139,-967,436"
+  },
+  IGNF_IGN72G: {
+    towgs84: "-13,-348,292"
+  },
+  IGNF_ATIGG: {
+    towgs84: "1118,23,66"
+  },
+  IGNF_FANGA84G: {
+    towgs84: "150.57,158.33,118.32"
+  },
+  IGNF_RUSAT84G: {
+    towgs84: "202.13,174.6,-15.74"
+  },
+  IGNF_KAUE70G: {
+    towgs84: "126.74,300.1,-75.49"
+  },
+  IGNF_MOP90G: {
+    towgs84: "-10.8,-1.8,12.77"
+  },
+  IGNF_MHPF67G: {
+    towgs84: "338.08,212.58,-296.17"
+  },
+  IGNF_TAHI79G: {
+    towgs84: "160.61,116.05,153.69"
+  },
+  IGNF_ANAA92G: {
+    towgs84: "1.5,3.84,4.81"
+  },
+  IGNF_MARQUI72G: {
+    towgs84: "330.91,-13.92,58.56"
+  },
+  IGNF_APAT86G: {
+    towgs84: "143.6,197.82,74.05"
+  },
+  IGNF_TUBU69G: {
+    towgs84: "237.17,171.61,-77.84"
+  },
+  IGNF_STPM50G: {
+    towgs84: "11.363,424.148,373.13"
+  },
+  EPSG_4150: {
+    towgs84: "674.374,15.056,405.346"
+  },
+  EPSG_4754: {
+    towgs84: "-208.4058,-109.8777,-2.5764"
+  },
+  ESRI_104101: {
+    towgs84: "372.87,149.23,585.29"
+  },
+  EPSG_4693: {
+    towgs84: "0,-0.15,0.68"
+  },
+  EPSG_6207: {
+    towgs84: "293.17,726.18,245.36"
+  },
+  EPSG_4153: {
+    towgs84: "-133.63,-157.5,-158.62"
+  },
+  EPSG_4132: {
+    towgs84: "-241.54,-163.64,396.06"
+  },
+  EPSG_4221: {
+    towgs84: "-154.5,150.7,100.4"
+  },
+  EPSG_4266: {
+    towgs84: "-80.7,-132.5,41.1"
+  },
+  EPSG_4193: {
+    towgs84: "-70.9,-151.8,-41.4"
+  },
+  EPSG_5340: {
+    towgs84: "-0.41,0.46,-0.35"
+  },
+  EPSG_4246: {
+    towgs84: "-294.7,-200.1,525.5"
+  },
+  EPSG_4318: {
+    towgs84: "-3.2,-5.7,2.8"
+  },
+  EPSG_4121: {
+    towgs84: "-199.87,74.79,246.62"
+  },
+  EPSG_4223: {
+    towgs84: "-260.1,5.5,432.2"
+  },
+  EPSG_4158: {
+    towgs84: "-0.465,372.095,171.736"
+  },
+  EPSG_4285: {
+    towgs84: "-128.16,-282.42,21.93"
+  },
+  EPSG_4613: {
+    towgs84: "-404.78,685.68,45.47"
+  },
+  EPSG_4607: {
+    towgs84: "195.671,332.517,274.607"
+  },
+  EPSG_4475: {
+    towgs84: "-381.788,-57.501,-256.673"
+  },
+  EPSG_4208: {
+    towgs84: "-157.84,308.54,-146.6"
+  },
+  EPSG_4743: {
+    towgs84: "70.995,-335.916,262.898"
+  },
+  EPSG_4710: {
+    towgs84: "-323.65,551.39,-491.22"
+  },
+  EPSG_7881: {
+    towgs84: "-0.077,0.079,0.086"
+  },
+  EPSG_4682: {
+    towgs84: "283.729,735.942,261.143"
+  },
+  EPSG_4739: {
+    towgs84: "-156,-271,-189"
+  },
+  EPSG_4679: {
+    towgs84: "-80.01,253.26,291.19"
+  },
+  EPSG_4750: {
+    towgs84: "-56.263,16.136,-22.856"
+  },
+  EPSG_4644: {
+    towgs84: "-10.18,-350.43,291.37"
+  },
+  EPSG_4695: {
+    towgs84: "-103.746,-9.614,-255.95"
+  },
+  EPSG_4292: {
+    towgs84: "-355,21,72"
+  },
+  EPSG_4302: {
+    towgs84: "-61.702,284.488,472.052"
+  },
+  EPSG_4143: {
+    towgs84: "-124.76,53,466.79"
+  },
+  EPSG_4606: {
+    towgs84: "-153,153,307"
+  },
+  EPSG_4699: {
+    towgs84: "-770.1,158.4,-498.2"
+  },
+  EPSG_4247: {
+    towgs84: "-273.5,110.6,-357.9"
+  },
+  EPSG_4160: {
+    towgs84: "8.88,184.86,106.69"
+  },
+  EPSG_4161: {
+    towgs84: "-233.43,6.65,173.64"
+  },
+  EPSG_9251: {
+    towgs84: "-9.5,122.9,138.2"
+  },
+  EPSG_9253: {
+    towgs84: "-78.1,101.6,133.3"
+  },
+  EPSG_4297: {
+    towgs84: "-198.383,-240.517,-107.909"
+  },
+  EPSG_4269: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4301: {
+    towgs84: "-147,506,687"
+  },
+  EPSG_4618: {
+    towgs84: "-59,-11,-52"
+  },
+  EPSG_4612: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4678: {
+    towgs84: "44.585,-131.212,-39.544"
+  },
+  EPSG_4250: {
+    towgs84: "-130,29,364"
+  },
+  EPSG_4144: {
+    towgs84: "214,804,268"
+  },
+  EPSG_4147: {
+    towgs84: "-17.51,-108.32,-62.39"
+  },
+  EPSG_4259: {
+    towgs84: "-254.1,-5.36,-100.29"
+  },
+  EPSG_4164: {
+    towgs84: "-76,-138,67"
+  },
+  EPSG_4211: {
+    towgs84: "-378.873,676.002,-46.255"
+  },
+  EPSG_4182: {
+    towgs84: "-422.651,-172.995,84.02"
+  },
+  EPSG_4224: {
+    towgs84: "-143.87,243.37,-33.52"
+  },
+  EPSG_4225: {
+    towgs84: "-205.57,168.77,-4.12"
+  },
+  EPSG_5527: {
+    towgs84: "-67.35,3.88,-38.22"
+  },
+  EPSG_4752: {
+    towgs84: "98,390,-22"
+  },
+  EPSG_4310: {
+    towgs84: "-30,190,89"
+  },
+  EPSG_9248: {
+    towgs84: "-192.26,65.72,132.08"
+  },
+  EPSG_4680: {
+    towgs84: "124.5,-63.5,-281"
+  },
+  EPSG_4701: {
+    towgs84: "-79.9,-158,-168.9"
+  },
+  EPSG_4706: {
+    towgs84: "-146.21,112.63,4.05"
+  },
+  EPSG_4805: {
+    towgs84: "682,-203,480"
+  },
+  EPSG_4201: {
+    towgs84: "-165,-11,206"
+  },
+  EPSG_4210: {
+    towgs84: "-157,-2,-299"
+  },
+  EPSG_4183: {
+    towgs84: "-104,167,-38"
+  },
+  EPSG_4139: {
+    towgs84: "11,72,-101"
+  },
+  EPSG_4668: {
+    towgs84: "-86,-98,-119"
+  },
+  EPSG_4717: {
+    towgs84: "-2,151,181"
+  },
+  EPSG_4732: {
+    towgs84: "102,52,-38"
+  },
+  EPSG_4280: {
+    towgs84: "-377,681,-50"
+  },
+  EPSG_4209: {
+    towgs84: "-138,-105,-289"
+  },
+  EPSG_4261: {
+    towgs84: "31,146,47"
+  },
+  EPSG_4658: {
+    towgs84: "-73,46,-86"
+  },
+  EPSG_4721: {
+    towgs84: "265.025,384.929,-194.046"
+  },
+  EPSG_4222: {
+    towgs84: "-136,-108,-292"
+  },
+  EPSG_4601: {
+    towgs84: "-255,-15,71"
+  },
+  EPSG_4602: {
+    towgs84: "725,685,536"
+  },
+  EPSG_4603: {
+    towgs84: "72,213.7,93"
+  },
+  EPSG_4605: {
+    towgs84: "9,183,236"
+  },
+  EPSG_4621: {
+    towgs84: "137,248,-430"
+  },
+  EPSG_4657: {
+    towgs84: "-28,199,5"
+  },
+  EPSG_4316: {
+    towgs84: "103.25,-100.4,-307.19"
+  },
+  EPSG_4642: {
+    towgs84: "-13,-348,292"
+  },
+  EPSG_4698: {
+    towgs84: "145,-187,103"
+  },
+  EPSG_4192: {
+    towgs84: "-206.1,-174.7,-87.7"
+  },
+  EPSG_4311: {
+    towgs84: "-265,120,-358"
+  },
+  EPSG_4135: {
+    towgs84: "58,-283,-182"
+  },
+  ESRI_104138: {
+    towgs84: "198,-226,-347"
+  },
+  EPSG_4245: {
+    towgs84: "-11,851,5"
+  },
+  EPSG_4142: {
+    towgs84: "-125,53,467"
+  },
+  EPSG_4213: {
+    towgs84: "-106,-87,188"
+  },
+  EPSG_4253: {
+    towgs84: "-133,-77,-51"
+  },
+  EPSG_4129: {
+    towgs84: "-132,-110,-335"
+  },
+  EPSG_4713: {
+    towgs84: "-77,-128,142"
+  },
+  EPSG_4239: {
+    towgs84: "217,823,299"
+  },
+  EPSG_4146: {
+    towgs84: "295,736,257"
+  },
+  EPSG_4155: {
+    towgs84: "-83,37,124"
+  },
+  EPSG_4165: {
+    towgs84: "-173,253,27"
+  },
+  EPSG_4672: {
+    towgs84: "175,-38,113"
+  },
+  EPSG_4236: {
+    towgs84: "-637,-549,-203"
+  },
+  EPSG_4251: {
+    towgs84: "-90,40,88"
+  },
+  EPSG_4271: {
+    towgs84: "-2,374,172"
+  },
+  EPSG_4175: {
+    towgs84: "-88,4,101"
+  },
+  EPSG_4716: {
+    towgs84: "298,-304,-375"
+  },
+  EPSG_4315: {
+    towgs84: "-23,259,-9"
+  },
+  EPSG_4744: {
+    towgs84: "-242.2,-144.9,370.3"
+  },
+  EPSG_4244: {
+    towgs84: "-97,787,86"
+  },
+  EPSG_4293: {
+    towgs84: "616,97,-251"
+  },
+  EPSG_4714: {
+    towgs84: "-127,-769,472"
+  },
+  EPSG_4736: {
+    towgs84: "260,12,-147"
+  },
+  EPSG_6883: {
+    towgs84: "-235,-110,393"
+  },
+  EPSG_6894: {
+    towgs84: "-63,176,185"
+  },
+  EPSG_4205: {
+    towgs84: "-43,-163,45"
+  },
+  EPSG_4256: {
+    towgs84: "41,-220,-134"
+  },
+  EPSG_4262: {
+    towgs84: "639,405,60"
+  },
+  EPSG_4604: {
+    towgs84: "174,359,365"
+  },
+  EPSG_4169: {
+    towgs84: "-115,118,426"
+  },
+  EPSG_4620: {
+    towgs84: "-106,-129,165"
+  },
+  EPSG_4184: {
+    towgs84: "-203,141,53"
+  },
+  EPSG_4616: {
+    towgs84: "-289,-124,60"
+  },
+  EPSG_9403: {
+    towgs84: "-307,-92,127"
+  },
+  EPSG_4684: {
+    towgs84: "-133,-321,50"
+  },
+  EPSG_4708: {
+    towgs84: "-491,-22,435"
+  },
+  EPSG_4707: {
+    towgs84: "114,-116,-333"
+  },
+  EPSG_4709: {
+    towgs84: "145,75,-272"
+  },
+  EPSG_4712: {
+    towgs84: "-205,107,53"
+  },
+  EPSG_4711: {
+    towgs84: "124,-234,-25"
+  },
+  EPSG_4718: {
+    towgs84: "230,-199,-752"
+  },
+  EPSG_4719: {
+    towgs84: "211,147,111"
+  },
+  EPSG_4724: {
+    towgs84: "208,-435,-229"
+  },
+  EPSG_4725: {
+    towgs84: "189,-79,-202"
+  },
+  EPSG_4735: {
+    towgs84: "647,1777,-1124"
+  },
+  EPSG_4722: {
+    towgs84: "-794,119,-298"
+  },
+  EPSG_4728: {
+    towgs84: "-307,-92,127"
+  },
+  EPSG_4734: {
+    towgs84: "-632,438,-609"
+  },
+  EPSG_4727: {
+    towgs84: "912,-58,1227"
+  },
+  EPSG_4729: {
+    towgs84: "185,165,42"
+  },
+  EPSG_4730: {
+    towgs84: "170,42,84"
+  },
+  EPSG_4733: {
+    towgs84: "276,-57,149"
+  },
+  ESRI_37218: {
+    towgs84: "230,-199,-752"
+  },
+  ESRI_37240: {
+    towgs84: "-7,215,225"
+  },
+  ESRI_37221: {
+    towgs84: "252,-209,-751"
+  },
+  ESRI_4305: {
+    towgs84: "-123,-206,219"
+  },
+  ESRI_104139: {
+    towgs84: "-73,-247,227"
+  },
+  EPSG_4748: {
+    towgs84: "51,391,-36"
+  },
+  EPSG_4219: {
+    towgs84: "-384,664,-48"
+  },
+  EPSG_4255: {
+    towgs84: "-333,-222,114"
+  },
+  EPSG_4257: {
+    towgs84: "-587.8,519.75,145.76"
+  },
+  EPSG_4646: {
+    towgs84: "-963,510,-359"
+  },
+  EPSG_6881: {
+    towgs84: "-24,-203,268"
+  },
+  EPSG_6882: {
+    towgs84: "-183,-15,273"
+  },
+  EPSG_4715: {
+    towgs84: "-104,-129,239"
+  },
+  IGNF_RGF93GDD: {
+    towgs84: "0,0,0"
+  },
+  IGNF_RGM04GDD: {
+    towgs84: "0,0,0"
+  },
+  IGNF_RGSPM06GDD: {
+    towgs84: "0,0,0"
+  },
+  IGNF_RGTAAF07GDD: {
+    towgs84: "0,0,0"
+  },
+  IGNF_RGFG95GDD: {
+    towgs84: "0,0,0"
+  },
+  IGNF_RGNCG: {
+    towgs84: "0,0,0"
+  },
+  IGNF_RGPFGDD: {
+    towgs84: "0,0,0"
+  },
+  IGNF_ETRS89G: {
+    towgs84: "0,0,0"
+  },
+  IGNF_RGR92GDD: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4173: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4180: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4619: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4667: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4075: {
+    towgs84: "0,0,0"
+  },
+  EPSG_6706: {
+    towgs84: "0,0,0"
+  },
+  EPSG_7798: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4661: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4669: {
+    towgs84: "0,0,0"
+  },
+  EPSG_8685: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4151: {
+    towgs84: "0,0,0"
+  },
+  EPSG_9702: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4758: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4761: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4765: {
+    towgs84: "0,0,0"
+  },
+  EPSG_8997: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4023: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4670: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4694: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4148: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4163: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4167: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4189: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4190: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4176: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4659: {
+    towgs84: "0,0,0"
+  },
+  EPSG_3824: {
+    towgs84: "0,0,0"
+  },
+  EPSG_3889: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4046: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4081: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4558: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4483: {
+    towgs84: "0,0,0"
+  },
+  EPSG_5013: {
+    towgs84: "0,0,0"
+  },
+  EPSG_5264: {
+    towgs84: "0,0,0"
+  },
+  EPSG_5324: {
+    towgs84: "0,0,0"
+  },
+  EPSG_5354: {
+    towgs84: "0,0,0"
+  },
+  EPSG_5371: {
+    towgs84: "0,0,0"
+  },
+  EPSG_5373: {
+    towgs84: "0,0,0"
+  },
+  EPSG_5381: {
+    towgs84: "0,0,0"
+  },
+  EPSG_5393: {
+    towgs84: "0,0,0"
+  },
+  EPSG_5489: {
+    towgs84: "0,0,0"
+  },
+  EPSG_5593: {
+    towgs84: "0,0,0"
+  },
+  EPSG_6135: {
+    towgs84: "0,0,0"
+  },
+  EPSG_6365: {
+    towgs84: "0,0,0"
+  },
+  EPSG_5246: {
+    towgs84: "0,0,0"
+  },
+  EPSG_7886: {
+    towgs84: "0,0,0"
+  },
+  EPSG_8431: {
+    towgs84: "0,0,0"
+  },
+  EPSG_8427: {
+    towgs84: "0,0,0"
+  },
+  EPSG_8699: {
+    towgs84: "0,0,0"
+  },
+  EPSG_8818: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4757: {
+    towgs84: "0,0,0"
+  },
+  EPSG_9140: {
+    towgs84: "0,0,0"
+  },
+  EPSG_8086: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4686: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4737: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4702: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4747: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4749: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4674: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4755: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4759: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4762: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4763: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4764: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4166: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4170: {
+    towgs84: "0,0,0"
+  },
+  EPSG_5546: {
+    towgs84: "0,0,0"
+  },
+  EPSG_7844: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4818: {
+    towgs84: "589,76,480"
+  },
+  EPSG_10328: {
+    towgs84: "0,0,0"
+  },
+  EPSG_9782: {
+    towgs84: "0,0,0"
+  },
+  EPSG_9777: {
+    towgs84: "0,0,0"
+  },
+  EPSG_10690: {
+    towgs84: "0,0,0"
+  },
+  EPSG_10639: {
+    towgs84: "0,0,0"
+  },
+  EPSG_10739: {
+    towgs84: "0,0,0"
+  },
+  EPSG_7686: {
+    towgs84: "0,0,0"
+  },
+  EPSG_8900: {
+    towgs84: "0,0,0"
+  },
+  EPSG_5886: {
+    towgs84: "0,0,0"
+  },
+  EPSG_7683: {
+    towgs84: "0,0,0"
+  },
+  EPSG_6668: {
+    towgs84: "0,0,0"
+  },
+  EPSG_20046: {
+    towgs84: "0,0,0"
+  },
+  EPSG_10299: {
+    towgs84: "0,0,0"
+  },
+  EPSG_10310: {
+    towgs84: "0,0,0"
+  },
+  EPSG_10475: {
+    towgs84: "0,0,0"
+  },
+  EPSG_4742: {
+    towgs84: "0,0,0"
+  },
+  EPSG_10671: {
+    towgs84: "0,0,0"
+  },
+  EPSG_10762: {
+    towgs84: "0,0,0"
+  },
+  EPSG_10725: {
+    towgs84: "0,0,0"
+  },
+  EPSG_10791: {
+    towgs84: "0,0,0"
+  },
+  EPSG_10800: {
+    towgs84: "0,0,0"
+  },
+  EPSG_10305: {
+    towgs84: "0,0,0"
+  },
+  EPSG_10941: {
+    towgs84: "0,0,0"
+  },
+  EPSG_10968: {
+    towgs84: "0,0,0"
+  },
+  EPSG_10875: {
+    towgs84: "0,0,0"
+  },
+  EPSG_6318: {
+    towgs84: "0,0,0"
+  },
+  EPSG_10910: {
+    towgs84: "0,0,0"
+  }
+};
+for (const key in datums) {
+  const datum = datums[key];
+  if (!datum.datumName) {
+    continue;
+  }
+  datums[datum.datumName] = datum;
+}
+var datum_table_default = datums;
+
+// dist/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/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/experimental/crs/units-table.js
+var units_table_default = {
+  mm: { to_meter: 1e-3 },
+  cm: { to_meter: 0.01 },
+  ft: { to_meter: 0.3048 },
+  "us-ft": { to_meter: 1200 / 3937 },
+  fath: { to_meter: 1.8288 },
+  kmi: { to_meter: 1852 },
+  "us-ch": { to_meter: 20.1168402336805 },
+  "us-mi": { to_meter: 1609.34721869444 },
+  km: { to_meter: 1e3 },
+  "ind-ft": { to_meter: 0.30479841 },
+  "ind-yd": { to_meter: 0.91439523 },
+  mi: { to_meter: 1609.344 },
+  yd: { to_meter: 0.9144 },
+  ch: { to_meter: 20.1168 },
+  link: { to_meter: 0.201168 },
+  dm: { to_meter: 0.1 },
+  in: { to_meter: 0.0254 },
+  "ind-ch": { to_meter: 20.11669506 },
+  "us-in": { to_meter: 0.025400050800101 },
+  "us-yd": { to_meter: 0.914401828803658 }
+};
+
+// dist/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 resolved = resolveCRSInput(input, options);
+  let definition2 = resolved.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(datum_table_default, datumName) : void 0;
+  if (datumName && datumName !== "none" && !datum)
+    unsupportedStage("Unknown datum: " + datumName);
+  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)
+    }),
+    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 || resolved.lossy)
+  }), resolved.spatialReference);
+}
+function unitFactor(parameters, unitKey, factorKey) {
+  const unit = parameters[unitKey];
+  const table = units_table_default;
+  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].to_meter : 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
+  });
+}
+
+// ../core/src/spheroid.ts
+function spheroidToCartesian(point, geometry, result = point) {
+  const longitude = point.x, latitude = point.y, height = point.z;
+  const { semiMajorAxis: a, semiMinorAxis: b, eccentricitySquared: es } = geometry;
+  const sin = Math.sin(latitude), cos = Math.cos(latitude);
+  const ratio = b / a;
+  const radius = es < 0.9 ? a / Math.sqrt(1 - es * sin * sin) : a / Math.hypot(cos, ratio * sin);
+  const x = (radius + height) * cos * Math.cos(longitude);
+  const y = (radius + height) * cos * Math.sin(longitude);
+  const z = (radius * (es < 0.9 ? 1 - es : ratio * ratio) + height) * sin;
+  return commit(result, x, y, z);
+}
+function cartesianToSpheroid(point, geometry, result = point) {
+  const x = point.x, y = point.y, z = point.z;
+  const { semiMajorAxis: a, semiMinorAxis: b, eccentricitySquared: es } = geometry;
+  const p = Math.hypot(x, y), rr = Math.hypot(x, y, z);
+  if (!(rr > 0) || !Number.isFinite(rr)) return false;
+  if (es === 0) return commit(result, p === 0 ? 0 : Math.atan2(y, x), Math.atan2(z, p), rr - a);
+  if (p === 0) return commit(result, 0, Math.sign(z) * Math.PI / 2, Math.abs(z) - b);
+  if (es >= 0.9) return exteriorInverse(x, y, z, p, a, b, result);
+  const ct = z / rr, st = p / rr;
+  let rx = 1 / Math.sqrt(1 - es * (2 - es) * st * st);
+  let cos = st * (1 - es) * rx, sin = ct * rx;
+  for (let i = 0; i < 30; i++) {
+    const rn = a / Math.sqrt(1 - es * sin * sin);
+    const height = p * cos + z * sin - rn * (1 - es * sin * sin);
+    const rk = es * rn / (rn + height);
+    rx = 1 / Math.sqrt(1 - rk * (2 - rk) * st * st);
+    const nextCos = st * (1 - rk) * rx, nextSin = ct * rx;
+    if (Math.abs(nextSin * cos - nextCos * sin) <= 1e-12) {
+      if (!Number.isFinite(height) || !Number.isFinite(nextSin) || !Number.isFinite(nextCos)) break;
+      return commit(result, Math.atan2(y, x), Math.atan2(nextSin, Math.abs(nextCos)), height);
+    }
+    cos = nextCos;
+    sin = nextSin;
+  }
+  return exteriorInverse(x, y, z, p, a, b, result);
+}
+function exteriorInverse(x, y, z, p, a, b, result) {
+  const ratio = b / a, ratio2 = ratio * ratio, horizontal = p / a, vertical = z / a;
+  const norm = Math.hypot(horizontal, z / b);
+  if (!Number.isFinite(norm) || norm < 1 - 8 * Number.EPSILON || !(ratio2 > 0)) return false;
+  let lower = 0, upper = Math.hypot(horizontal, vertical * ratio);
+  if (!Number.isFinite(upper)) return false;
+  let multiplier = norm <= 1 + 8 * Number.EPSILON ? 0 : upper / 2;
+  for (let i = 0; i < 96; i++) {
+    const equatorial = 1 + multiplier, polar = ratio2 + multiplier;
+    const u = horizontal / equatorial, v = vertical * ratio / polar;
+    const length = Math.hypot(u, v);
+    const residual = length - 1;
+    if (Math.abs(residual) <= 4 * Number.EPSILON) {
+      const latitude = Math.atan2(vertical / polar, horizontal / equatorial);
+      const sin = Math.sin(latitude), cos = Math.cos(latitude);
+      const height = p * cos + z * sin - a * Math.hypot(cos, ratio * sin);
+      return commit(result, Math.atan2(y, x), latitude, height);
+    }
+    if (residual > 0) lower = multiplier;
+    else upper = multiplier;
+    const derivative = -(u * u / equatorial + v * v / polar) / length;
+    const next = multiplier - residual / derivative;
+    multiplier = Number.isFinite(next) && next > lower && next < upper ? next : (lower + upper) / 2;
+  }
+  return false;
+}
+function commit(result, x, y, z) {
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) return false;
+  result.x = x;
+  result.y = y;
+  result.z = z;
+  return true;
+}
+
+// dist/experimental/datum.js
+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 (!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 (!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/experimental/projection-scratch.js
+var ProjectionScratch = class {
+  constructor() {
+    this.point = { x: 0, y: 0, z: 0 };
+    this.busy = false;
+  }
+  acquire() {
+    if (this.busy)
+      return { x: 0, y: 0, z: 0 };
+    this.busy = true;
+    return this.point;
+  }
+  release(point) {
+    if (point === this.point)
+      this.busy = false;
+  }
+};
+
+// dist/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/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/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/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/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/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/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/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/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/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.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) {
+    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) {
+        if (point === this.coordinateScratch.point) {
+          this.coordinateStack || (this.coordinateStack = new Float64Array(this.stackSize));
+          stack = this.coordinateStack;
+        } else {
+          stack = 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) {
+    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) {
+        if (point === this.coordinateScratch.point) {
+          this.coordinateStack || (this.coordinateStack = new Float64Array(this.stackSize));
+          stack = this.coordinateStack;
+        } else
+          stack = 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