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

package/dist/experimental/lazy-projections/index.cjs

@@ -0,0 +1,3177 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/experimental/lazy-projections/index.js
+var index_exports = {};
+__export(index_exports, {
+  LazyProjection: () => LazyProjection,
+  lazyAlbersEqualArea: () => lazyAlbersEqualArea,
+  lazyAzimuthalEquidistant: () => lazyAzimuthalEquidistant,
+  lazyBonne: () => lazyBonne,
+  lazyCassiniSoldner: () => lazyCassiniSoldner,
+  lazyCylindricalEqualArea: () => lazyCylindricalEqualArea,
+  lazyEckertVI: () => lazyEckertVI,
+  lazyEqualEarth: () => lazyEqualEarth,
+  lazyEquidistantConic: () => lazyEquidistantConic,
+  lazyEquidistantCylindrical: () => lazyEquidistantCylindrical,
+  lazyEquirectangular: () => lazyEquirectangular,
+  lazyExtendedTransverseMercator: () => lazyExtendedTransverseMercator,
+  lazyGaussSchreiberTransverseMercator: () => lazyGaussSchreiberTransverseMercator,
+  lazyGeocentric: () => lazyGeocentric,
+  lazyGeostationary: () => lazyGeostationary,
+  lazyGnomonic: () => lazyGnomonic,
+  lazyKrovak: () => lazyKrovak,
+  lazyLambertAzimuthalEqualArea: () => lazyLambertAzimuthalEqualArea,
+  lazyLambertConformalConic: () => lazyLambertConformalConic,
+  lazyMercator: () => lazyMercator,
+  lazyMillerCylindrical: () => lazyMillerCylindrical,
+  lazyMollweide: () => lazyMollweide,
+  lazyNewZealandMapGrid: () => lazyNewZealandMapGrid,
+  lazyObliqueMercator: () => lazyObliqueMercator,
+  lazyObliqueStereographic: () => lazyObliqueStereographic,
+  lazyObliqueTransformation: () => lazyObliqueTransformation,
+  lazyOrthographic: () => lazyOrthographic,
+  lazyPolyconic: () => lazyPolyconic,
+  lazyQuadrilateralizedSphericalCube: () => lazyQuadrilateralizedSphericalCube,
+  lazyRobinson: () => lazyRobinson,
+  lazySinusoidal: () => lazySinusoidal,
+  lazyStereographic: () => lazyStereographic,
+  lazySwissObliqueMercator: () => lazySwissObliqueMercator,
+  lazyTiltedPerspective: () => lazyTiltedPerspective,
+  lazyTransverseMercator: () => lazyTransverseMercator,
+  lazyUniversalTransverseMercator: () => lazyUniversalTransverseMercator,
+  lazyVanDerGrinten: () => lazyVanDerGrinten
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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 key2 = (value) => value.toLowerCase().replace(/[\s_-]/g, "");
+    const supported = new Set([plugin.name, ...plugin.aliases || []].map(key2));
+    if (typeof plugin.create !== "function" || ![projection.name, ...projection.aliases || []].every((name) => supported.has(key2(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;
+}
+function createProjectionDescriptor(metadata, load) {
+  const descriptor = Object.freeze({
+    name: metadata.name,
+    aliases: metadata.aliases && Object.freeze([...metadata.aliases]),
+    preload: () => preloadProjection(descriptor)
+  });
+  cache().set(descriptor, { load });
+  return descriptor;
+}
+
+// dist/experimental/lazy-projections/merc.js
+var lazyMercator = /* @__PURE__ */ createProjectionDescriptor({
+  name: "merc",
+  aliases: [
+    "Mercator",
+    "Popular Visualisation Pseudo Mercator",
+    "Mercator_1SP",
+    "Mercator_Auxiliary_Sphere",
+    "Mercator_Variant_A"
+  ]
+}, async () => (await import("@math.gl/projection/projections/merc")).mercator);
+
+// dist/experimental/lazy-projections/eqc.js
+var lazyEquidistantCylindrical = /* @__PURE__ */ createProjectionDescriptor({
+  name: "eqc",
+  aliases: ["Equirectangular", "Equidistant_Cylindrical", "Equidistant_Cylindrical_Spherical"]
+}, async () => (await import("@math.gl/projection/projections/eqc")).equidistantCylindrical);
+
+// dist/experimental/lazy-projections/lcc.js
+var lazyLambertConformalConic = /* @__PURE__ */ createProjectionDescriptor({
+  name: "lcc",
+  aliases: [
+    "Lambert Tangential Conformal Conic Projection",
+    "Lambert_Conformal_Conic",
+    "Lambert_Conformal_Conic_1SP",
+    "Lambert_Conformal_Conic_2SP",
+    "Lambert Conic Conformal (1SP)",
+    "Lambert Conic Conformal (2SP)"
+  ]
+}, async () => (await import("@math.gl/projection/projections/lcc")).lambertConformalConic);
+
+// dist/experimental/lazy-projections/aea.js
+var lazyAlbersEqualArea = /* @__PURE__ */ createProjectionDescriptor({ name: "aea", aliases: ["Albers_Conic_Equal_Area", "Albers_Equal_Area", "Albers"] }, async () => (await import("@math.gl/projection/projections/aea")).albersEqualArea);
+
+// dist/experimental/lazy-projections/eqdc.js
+var lazyEquidistantConic = /* @__PURE__ */ createProjectionDescriptor({ name: "eqdc", aliases: ["Equidistant_Conic"] }, async () => (await import("@math.gl/projection/projections/eqdc")).equidistantConic);
+
+// dist/experimental/lazy-projections/laea.js
+var lazyLambertAzimuthalEqualArea = /* @__PURE__ */ createProjectionDescriptor({ name: "laea", aliases: ["Lambert Azimuthal Equal Area", "Lambert_Azimuthal_Equal_Area"] }, async () => (await import("@math.gl/projection/projections/laea")).lambertAzimuthalEqualArea);
+
+// dist/experimental/lazy-projections/stere.js
+var lazyStereographic = /* @__PURE__ */ createProjectionDescriptor({
+  name: "stere",
+  aliases: [
+    "Stereographic_South_Pole",
+    "Polar_Stereographic_variant_A",
+    "Polar_Stereographic_variant_B",
+    "Polar_Stereographic"
+  ]
+}, async () => (await import("@math.gl/projection/projections/stere")).stereographic);
+
+// dist/experimental/lazy-projections/sterea.js
+var lazyObliqueStereographic = /* @__PURE__ */ createProjectionDescriptor({
+  name: "sterea",
+  aliases: [
+    "Stereographic_North_Pole",
+    "Oblique_Stereographic",
+    "Oblique Stereographic Alternative",
+    "Double_Stereographic"
+  ]
+}, async () => (await import("@math.gl/projection/projections/sterea")).obliqueStereographic);
+
+// dist/experimental/lazy-projections/aeqd.js
+var lazyAzimuthalEquidistant = /* @__PURE__ */ createProjectionDescriptor({ name: "aeqd", aliases: ["Azimuthal_Equidistant"] }, async () => (await import("@math.gl/projection/projections/aeqd")).azimuthalEquidistant);
+
+// dist/experimental/lazy-projections/tmerc.js
+var lazyTransverseMercator = /* @__PURE__ */ createProjectionDescriptor({
+  name: "tmerc",
+  aliases: [
+    "Fast_Transverse_Mercator",
+    "Fast Transverse Mercator",
+    "Transverse_Mercator",
+    "Transverse Mercator",
+    "Gauss Kruger",
+    "Gauss_Kruger"
+  ]
+}, async () => (await import("@math.gl/projection/projections/tmerc")).transverseMercator);
+
+// dist/experimental/lazy-projections/etmerc.js
+var lazyExtendedTransverseMercator = /* @__PURE__ */ createProjectionDescriptor({ name: "etmerc", aliases: ["Extended_Transverse_Mercator", "Extended Transverse Mercator"] }, async () => (await import("@math.gl/projection/projections/etmerc")).extendedTransverseMercator);
+
+// dist/experimental/lazy-projections/utm.js
+var lazyUniversalTransverseMercator = /* @__PURE__ */ createProjectionDescriptor({ name: "utm", aliases: ["Universal Transverse Mercator System"] }, async () => (await import("@math.gl/projection/projections/utm")).universalTransverseMercator);
+
+// dist/experimental/lazy-projections/geocent.js
+var lazyGeocentric = /* @__PURE__ */ createProjectionDescriptor({ name: "geocent", aliases: ["Geocentric", "geocentric", "Geocent"] }, async () => (await import("@math.gl/projection/projections/geocent")).geocentric);
+
+// dist/experimental/lazy-projections/bonne.js
+var lazyBonne = /* @__PURE__ */ createProjectionDescriptor({ name: "bonne", aliases: ["Bonne (Werner lat_1=90)"] }, async () => (await import("@math.gl/projection/projections/bonne")).bonne);
+
+// dist/experimental/lazy-projections/cass.js
+var lazyCassiniSoldner = /* @__PURE__ */ createProjectionDescriptor({ name: "cass", aliases: ["Cassini", "Cassini_Soldner"] }, async () => (await import("@math.gl/projection/projections/cass")).cassiniSoldner);
+
+// dist/experimental/lazy-projections/cea.js
+var lazyCylindricalEqualArea = /* @__PURE__ */ createProjectionDescriptor({ name: "cea", aliases: [] }, async () => (await import("@math.gl/projection/projections/cea")).cylindricalEqualArea);
+
+// dist/experimental/lazy-projections/eck6.js
+var lazyEckertVI = /* @__PURE__ */ createProjectionDescriptor({ name: "eck6", aliases: ["Eckert_VI"] }, async () => (await import("@math.gl/projection/projections/eck6")).eckertVI);
+
+// dist/experimental/lazy-projections/eqearth.js
+var lazyEqualEarth = /* @__PURE__ */ createProjectionDescriptor({ name: "eqearth", aliases: ["Equal Earth", "Equal_Earth"] }, async () => (await import("@math.gl/projection/projections/eqearth")).equalEarth);
+
+// dist/experimental/lazy-projections/equi.js
+var lazyEquirectangular = /* @__PURE__ */ createProjectionDescriptor({ name: "equi", aliases: [] }, async () => (await import("@math.gl/projection/projections/equi")).equirectangular);
+
+// dist/experimental/lazy-projections/geos.js
+var lazyGeostationary = /* @__PURE__ */ createProjectionDescriptor({ name: "geos", aliases: ["Geostationary Satellite View", "Geostationary_Satellite"] }, async () => (await import("@math.gl/projection/projections/geos")).geostationary);
+
+// dist/experimental/lazy-projections/gnom.js
+var lazyGnomonic = /* @__PURE__ */ createProjectionDescriptor({ name: "gnom", aliases: [] }, async () => (await import("@math.gl/projection/projections/gnom")).gnomonic);
+
+// dist/experimental/lazy-projections/gstmerc.js
+var lazyGaussSchreiberTransverseMercator = /* @__PURE__ */ createProjectionDescriptor({ name: "gstmerc", aliases: ["gstmerg"] }, async () => (await import("@math.gl/projection/projections/gstmerc")).gaussSchreiberTransverseMercator);
+
+// dist/experimental/lazy-projections/krovak.js
+var lazyKrovak = /* @__PURE__ */ createProjectionDescriptor({
+  name: "krovak",
+  aliases: [
+    "Krovak",
+    "Krovak Modified",
+    "Krovak (North Orientated)",
+    "Krovak Modified (North Orientated)"
+  ]
+}, async () => (await import("@math.gl/projection/projections/krovak")).krovak);
+
+// dist/experimental/lazy-projections/mill.js
+var lazyMillerCylindrical = /* @__PURE__ */ createProjectionDescriptor({ name: "mill", aliases: ["Miller_Cylindrical"] }, async () => (await import("@math.gl/projection/projections/mill")).millerCylindrical);
+
+// dist/experimental/lazy-projections/moll.js
+var lazyMollweide = /* @__PURE__ */ createProjectionDescriptor({ name: "moll", aliases: ["Mollweide"] }, async () => (await import("@math.gl/projection/projections/moll")).mollweide);
+
+// dist/experimental/lazy-projections/nzmg.js
+var lazyNewZealandMapGrid = /* @__PURE__ */ createProjectionDescriptor({ name: "nzmg", aliases: ["New_Zealand_Map_Grid"] }, async () => (await import("@math.gl/projection/projections/nzmg")).newZealandMapGrid);
+
+// dist/experimental/lazy-projections/omerc.js
+var lazyObliqueMercator = /* @__PURE__ */ createProjectionDescriptor({
+  name: "omerc",
+  aliases: [
+    "Hotine_Oblique_Mercator",
+    "Hotine Oblique Mercator",
+    "Hotine_Oblique_Mercator_variant_A",
+    "Hotine_Oblique_Mercator_Variant_B",
+    "Hotine_Oblique_Mercator_Azimuth_Natural_Origin",
+    "Hotine_Oblique_Mercator_Two_Point_Natural_Origin",
+    "Hotine_Oblique_Mercator_Azimuth_Center",
+    "Oblique_Mercator"
+  ]
+}, async () => (await import("@math.gl/projection/projections/omerc")).obliqueMercator);
+
+// dist/experimental/lazy-projections/ortho.js
+var lazyOrthographic = /* @__PURE__ */ createProjectionDescriptor({ name: "ortho", aliases: [] }, async () => (await import("@math.gl/projection/projections/ortho")).orthographic);
+
+// dist/experimental/lazy-projections/poly.js
+var lazyPolyconic = /* @__PURE__ */ createProjectionDescriptor({ name: "poly", aliases: ["Polyconic", "American_Polyconic"] }, async () => (await import("@math.gl/projection/projections/poly")).polyconic);
+
+// dist/experimental/lazy-projections/qsc.js
+var lazyQuadrilateralizedSphericalCube = /* @__PURE__ */ createProjectionDescriptor({
+  name: "qsc",
+  aliases: ["Quadrilateralized Spherical Cube", "Quadrilateralized_Spherical_Cube"]
+}, async () => (await import("@math.gl/projection/projections/qsc")).quadrilateralizedSphericalCube);
+
+// dist/experimental/lazy-projections/robin.js
+var lazyRobinson = /* @__PURE__ */ createProjectionDescriptor({ name: "robin", aliases: ["Robinson"] }, async () => (await import("@math.gl/projection/projections/robin")).robinson);
+
+// dist/experimental/lazy-projections/sinu.js
+var lazySinusoidal = /* @__PURE__ */ createProjectionDescriptor({ name: "sinu", aliases: ["Sinusoidal"] }, async () => (await import("@math.gl/projection/projections/sinu")).sinusoidal);
+
+// dist/experimental/lazy-projections/somerc.js
+var lazySwissObliqueMercator = /* @__PURE__ */ createProjectionDescriptor({ name: "somerc", aliases: [] }, async () => (await import("@math.gl/projection/projections/somerc")).swissObliqueMercator);
+
+// dist/experimental/lazy-projections/tpers.js
+var lazyTiltedPerspective = /* @__PURE__ */ createProjectionDescriptor({ name: "tpers", aliases: ["Tilted_Perspective"] }, async () => (await import("@math.gl/projection/projections/tpers")).tiltedPerspective);
+
+// dist/experimental/lazy-projections/vandg.js
+var lazyVanDerGrinten = /* @__PURE__ */ createProjectionDescriptor({ name: "vandg", aliases: ["Van_der_Grinten_I", "VanDerGrinten", "Van_der_Grinten"] }, async () => (await import("@math.gl/projection/projections/vandg")).vanDerGrinten);
+
+// dist/experimental/lazy-projections/ob_tran.js
+function lazyObliqueTransformation(wrapped) {
+  return createProjectionDescriptor({
+    name: "ob_tran",
+    aliases: ["General Oblique Transformation", "General_Oblique_Transformation"]
+  }, async () => {
+    const [{ obliqueTransformation }, child] = await Promise.all([
+      import("@math.gl/projection/projections/ob_tran"),
+      typeof wrapped === "string" || "create" in wrapped ? wrapped : wrapped.preload()
+    ]);
+    return obliqueTransformation(child);
+  });
+}
+
+// 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/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;
+}
+
+// ../crs/src/spatial-reference.ts
+function inferCRSRepresentation(definition) {
+  if (typeof definition === "object") {
+    return "projjson";
+  }
+  const text = definition.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;
+}
+function wrapLongitude(longitude) {
+  if (Math.abs(longitude) <= Math.PI)
+    return longitude;
+  const circle = 2 * Math.PI;
+  return ((longitude + Math.PI) % circle + circle) % circle - Math.PI;
+}
+
+// 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 key2 in datums) {
+  const datum = datums[key2];
+  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 CORE_FLAGS = ["no_defs", "over"];
+var own = (object, key2) => Object.prototype.hasOwnProperty.call(object, key2);
+var keyOf = (value) => value.toLowerCase().replace(/[\s_-]/g, "");
+function lookup(table, name) {
+  const key2 = Object.keys(table).find((key3) => keyOf(key3) === keyOf(name));
+  return key2 === void 0 ? void 0 : table[key2];
+}
+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 definition = resolved.definition;
+  const aliases = options.aliases || {};
+  const visited = /* @__PURE__ */ new Set();
+  while (typeof definition === "string" && (own(aliases, definition) || own(ALIASES, definition))) {
+    if (visited.has(definition))
+      throw new Error("Circular CRS alias: " + definition);
+    visited.add(definition);
+    definition = own(aliases, definition) ? aliases[definition] : ALIASES[definition];
+  }
+  if (typeof definition === "string") {
+    const utm = /^EPSG:(326|327)(\d{2})$/.exec(definition);
+    if (utm && Number(utm[2]) >= 1 && Number(utm[2]) <= 60) {
+      definition = "+proj=utm +datum=WGS84 +zone=" + Number(utm[2]) + (utm[1] === "327" ? " +south" : "");
+    }
+    if (definition === "EPSG:5041" || definition === "EPSG:5042") {
+      definition = "+proj=stere +datum=WGS84 +lat_0=" + (definition === "EPSG:5041" ? 90 : -90) + " +k_0=0.994 +x_0=2000000 +y_0=2000000";
+    }
+  }
+  let parsed;
+  if (inferCRSRepresentation(definition) === "proj-string" && typeof definition === "string") {
+    const parameters2 = /* @__PURE__ */ Object.create(null);
+    for (const parameter of parsePROJString(definition).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(definition));
+    if (!parser) {
+      const serialized = ["wkt", "projjson"].includes(inferCRSRepresentation(definition));
+      throw new TypeScriptCRSError(serialized ? "missing-parser" : "unknown-syntax", "Unsupported CRS definition; register a WKT or PROJJSON parser for structured definitions");
+    }
+    parsed = parser.parse(definition, 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 definition = lookup(ellipsoid_table_default, name);
+  if (!definition)
+    throw new Error("Unsupported ellipsoid: " + name);
+  const a = numberParameter(parameters, "a", definition.a);
+  const f = numberParameter(parameters, "f", NaN);
+  const rf = numberParameter(parameters, "rf", Number.isNaN(f) ? definition.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 : definition.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);
+var WGS84 = {
+  ellipsoid: {
+    semiMajorAxis: 6378137,
+    semiMinorAxis: 6356752314245179e-9,
+    eccentricitySquared: 0.0066943799901413165
+  },
+  towgs84: [0, 0, 0]
+};
+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 shifted(datum) {
+  var _a2;
+  return Boolean((_a2 = datum.towgs84) == null ? void 0 : _a2.some((value) => value !== 0));
+}
+function createDatumTransform(source, destination) {
+  if (!source.towgs84 || !destination.towgs84)
+    return void 0;
+  if (source.grids || destination.grids) {
+    if (source.grids && destination.grids && source.ellipsoid.semiMajorAxis === destination.ellipsoid.semiMajorAxis && source.ellipsoid.eccentricitySquared === destination.ellipsoid.eccentricitySquared && source.grids.length === destination.grids.length && source.grids.every((entry, i) => entry.name === destination.grids[i].name && entry.optional === destination.grids[i].optional && entry.grid === destination.grids[i].grid))
+      return void 0;
+    const middle = createDatumTransform(source.grids ? WGS84 : source, destination.grids ? WGS84 : destination);
+    return (point) => {
+      if (source.grids)
+        applyDatumGrids(point, source, false);
+      middle == null ? void 0 : middle(point);
+      if (destination.grids)
+        applyDatumGrids(point, destination, true);
+    };
+  }
+  if (shifted(source) || shifted(destination)) {
+    const first = convertDatum(source, WGS84), second = convertDatum(WGS84, destination);
+    return (point) => {
+      first == null ? void 0 : first(point);
+      second == null ? void 0 : second(point);
+    };
+  }
+  return convertDatum(source, destination);
+}
+function convertDatum(from, to) {
+  if (!from.towgs84 || !to.towgs84)
+    return void 0;
+  const a = from.ellipsoid, b = to.ellipsoid;
+  let sameParameters = true;
+  for (let i = 0; i < 7; i++)
+    if ((from.towgs84[i] || 0) !== (to.towgs84[i] || 0))
+      sameParameters = false;
+  if (a.semiMajorAxis === b.semiMajorAxis && Math.abs(a.eccentricitySquared - b.eccentricitySquared) <= 5e-11 && sameParameters)
+    return void 0;
+  const sourceShift = shifted(from) ? createHelmert(from.towgs84, false) : void 0, targetShift = shifted(to) ? createHelmert(to.towgs84, true) : void 0;
+  return (point) => {
+    geodeticToGeocentricInPlace(point, a);
+    sourceShift == null ? void 0 : sourceShift(point);
+    targetShift == null ? void 0 : targetShift(point);
+    geocentricToGeodeticInPlace(point, b);
+  };
+}
+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/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/typescript-projection.js
+var ProjectionEngine = class _ProjectionEngine {
+  /** Resolve required descriptors once, then return an ordinary synchronous instance. */
+  static async create(options = {}) {
+    const projections = await Promise.all(requiredProjections(options).map(preloadProjection));
+    return new _ProjectionEngine({ ...options, projections });
+  }
+  constructor(options = {}) {
+    this.coordinateScratch = new ProjectionScratch();
+    const registrations = options.projections || [];
+    const plugins = registry(registrations);
+    if (registrations.some((projection) => !("create" in projection))) {
+      const from = normalizeCRS(options.from ?? "WGS84", options);
+      const to = normalizeCRS(options.to ?? "WGS84", options);
+      this.lossy = from.lossy || to.lossy;
+      this.deferred = { options: { ...options, projections: [...registrations] } };
+    } else {
+      const eager = options;
+      const eagerPlugins = plugins;
+      const from = compileCRS(eager.from ?? "WGS84", eagerPlugins, eager);
+      const to = compileCRS(eager.to ?? "WGS84", eagerPlugins, eager);
+      this.lossy = from.lossy || to.lossy;
+      if (this.lossy && (from.kind === "geocentric" || to.kind === "geocentric"))
+        unsupportedStage("Horizontal extraction cannot supply ellipsoidal height for geocentric coordinates");
+      if (this.lossy && (from.verticalGrid || to.verticalGrid))
+        unsupportedStage("Horizontal extraction cannot be combined with vertical grids");
+      this.forwardTransform = compileTransform(from, to, Boolean(options.enforceAxis));
+      this.inverseTransform = compileTransform(to, from, Boolean(options.enforceAxis));
+    }
+    this.project = this.project.bind(this);
+    this.unproject = this.unproject.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.projectSync = this.projectSync.bind(this);
+    this.unprojectSync = this.unprojectSync.bind(this);
+    this.projectFlatSync = this.projectFlatSync.bind(this);
+    this.unprojectFlatSync = this.unprojectFlatSync.bind(this);
+  }
+  load() {
+    const state = this.deferred;
+    if (!state)
+      return Promise.resolve(this);
+    if (state.implementation)
+      return Promise.resolve(state.implementation);
+    state.pending || (state.pending = _ProjectionEngine.create(state.options).then((projection) => {
+      state.implementation = projection;
+      return projection;
+    }).catch((error) => {
+      state.pending = void 0;
+      throw error;
+    }));
+    return state.pending;
+  }
+  loadSync() {
+    const state = this.deferred;
+    if (!state)
+      return this;
+    if (!state.implementation) {
+      const projections = requiredProjections(state.options).map((descriptor) => {
+        const plugin = getLoadedProjection(descriptor);
+        if (!plugin)
+          throw new Error("Projection is not preloaded: " + descriptor.name + ". Call preload() first.");
+        return plugin;
+      });
+      state.implementation = new _ProjectionEngine({ ...state.options, projections });
+    }
+    return state.implementation;
+  }
+  /** Synchronous variants never import algorithms; descriptors must be preloaded. */
+  projectSync(coordinate) {
+    return this.deferred ? this.loadSync().project(coordinate) : transformScalar(coordinate, this.forwardTransform, this.coordinateScratch);
+  }
+  unprojectSync(coordinate) {
+    return this.deferred ? this.loadSync().unproject(coordinate) : transformScalar(coordinate, this.inverseTransform, this.coordinateScratch);
+  }
+  projectFlatSync(coordinates, dimension = 2) {
+    return this.deferred ? this.loadSync().projectFlat(coordinates, dimension) : transformInPlace(coordinates, dimension, this.forwardTransform, this.coordinateScratch);
+  }
+  unprojectFlatSync(coordinates, dimension = 2) {
+    return this.deferred ? this.loadSync().unprojectFlat(coordinates, dimension) : transformInPlace(coordinates, dimension, this.inverseTransform, this.coordinateScratch);
+  }
+  /** Optional warm-up. Coordinate methods also load automatically on first use. */
+  async preload() {
+    await this.load();
+  }
+  /** Eager plugins return arrays; descriptor-backed instances return promises. */
+  project(coordinate) {
+    const result = this.deferred ? this.projectLoaded(coordinate, false) : transformScalar(coordinate, this.forwardTransform, this.coordinateScratch);
+    return result;
+  }
+  unproject(coordinate) {
+    const result = this.deferred ? this.projectLoaded(coordinate, true) : transformScalar(coordinate, this.inverseTransform, this.coordinateScratch);
+    return result;
+  }
+  /** Write one coordinate into caller-owned storage; return that same output. */
+  projectTo(coordinate, output) {
+    return this.deferred ? this.projectToLoaded(coordinate, output, false) : this.projectToSync(coordinate, output);
+  }
+  unprojectTo(coordinate, output) {
+    return this.deferred ? this.projectToLoaded(coordinate, output, true) : this.unprojectToSync(coordinate, output);
+  }
+  projectToSync(coordinate, output) {
+    if (this.deferred)
+      return this.loadSync().projectTo(coordinate, output);
+    validateScalarOutput(coordinate, output, Math.max(coordinate.length, this.forwardTransform.geocentricOutput ? 3 : 2));
+    return transformScalar(coordinate, this.forwardTransform, this.coordinateScratch, output);
+  }
+  unprojectToSync(coordinate, output) {
+    if (this.deferred)
+      return this.loadSync().unprojectTo(coordinate, output);
+    validateScalarOutput(coordinate, output, Math.max(coordinate.length, this.inverseTransform.geocentricOutput ? 3 : 2));
+    return transformScalar(coordinate, this.inverseTransform, this.coordinateScratch, output);
+  }
+  projectToLoaded(coordinate, output, inverse) {
+    validateScalarOutput(coordinate, output, coordinate.length);
+    const input = coordinate.slice();
+    return this.load().then((projection) => inverse ? projection.unprojectTo(input, output) : projection.projectTo(input, output));
+  }
+  projectLoaded(coordinate, inverse) {
+    const input = coordinate.slice();
+    return this.load().then((projection) => inverse ? projection.unproject(input) : projection.project(input));
+  }
+  /** In-place; descriptor callers must await completion before reusing the buffer. */
+  projectFlat(coordinates, dimension = 2) {
+    const result = this.deferred ? this.load().then((projection) => projection.projectFlat(coordinates, dimension)) : transformInPlace(coordinates, dimension, this.forwardTransform, this.coordinateScratch);
+    return result;
+  }
+  unprojectFlat(coordinates, dimension = 2) {
+    const result = this.deferred ? this.load().then((projection) => projection.unprojectFlat(coordinates, dimension)) : transformInPlace(coordinates, dimension, this.inverseTransform, this.coordinateScratch);
+    return result;
+  }
+};
+function requiredProjections(options) {
+  const available = registry(options.projections || []);
+  const required = /* @__PURE__ */ new Set();
+  for (const definition of [options.from ?? "WGS84", options.to ?? "WGS84"]) {
+    const crs = normalizeCRS(definition, options);
+    if (["geographic", "identity"].includes(crs.kind))
+      continue;
+    const projection = available.get(pluginKey(crs.projection));
+    if (!projection)
+      throw new TypeScriptCRSError("missing-plugin", "Projection plugin is not registered: " + crs.projection);
+    required.add(projection);
+  }
+  return [...required];
+}
+var pluginKey = (name) => name.toLowerCase().replace(/[\s_-]/g, "");
+function registry(projections) {
+  const plugins = /* @__PURE__ */ new Map();
+  for (const plugin of projections) {
+    for (const name of new Set([plugin.name, ...plugin.aliases || []].map(pluginKey))) {
+      if (!name || ["longlat", "latlong", "latlon", "lonlat", "identity"].includes(name) || plugins.has(name))
+        throw new Error("Duplicate or reserved projection plugin: " + name);
+      plugins.set(name, plugin);
+    }
+  }
+  return plugins;
+}
+function compileCRS(definition, plugins, options) {
+  var _a2;
+  const crs = normalizeCRS(definition, options);
+  const plugin = plugins.get(pluginKey(crs.projection));
+  if (!["geographic", "identity"].includes(crs.kind) && !plugin)
+    throw new TypeScriptCRSError("missing-plugin", "Projection plugin is not registered: " + crs.projection);
+  const allowed = /* @__PURE__ */ new Set([...CORE_PARAMETERS, ...(plugin == null ? void 0 : plugin.parameters) || []]);
+  for (const key2 of Object.keys(crs.parameters)) {
+    if (!allowed.has(key2))
+      throw new TypeScriptCRSError("missing-transform-stage", "Unsupported PROJ parameter: +" + key2);
+    const flag = CORE_FLAGS.includes(key2) || ((_a2 = plugin == null ? void 0 : plugin.flags) == null ? void 0 : _a2.includes(key2));
+    if (flag && crs.parameters[key2] !== void 0)
+      throw new Error("Expected a flag without a value: +" + key2);
+    if (!flag && !crs.parameters[key2])
+      throw new Error("PROJ parameter requires a value: +" + key2);
+  }
+  if (crs.parameters["type"] && crs.parameters["type"] !== "crs")
+    throw new Error("Only +type=crs is supported");
+  const parameters = pluginKey(crs.projection) === "fasttransversemercator" ? Object.freeze({ ...crs.parameters, approx: void 0 }) : crs.parameters;
+  const implementation = plugin == null ? void 0 : plugin.create({ ...crs.ellipsoid, parameters });
+  if (crs.kind === "geocentric" && (!(implementation == null ? void 0 : implementation.forward3D) || !(implementation == null ? void 0 : implementation.inverse3D)))
+    throw new Error("Geocentric plugin must implement 3D operations");
+  const references = crs.datum.grids;
+  const nullIndex = (references == null ? void 0 : references.findIndex((reference) => reference.name === "null")) ?? -1;
+  const grids = references == null ? void 0 : references.slice(0, nullIndex < 0 ? void 0 : nullIndex + 1).map((reference) => {
+    const grid = Object.prototype.hasOwnProperty.call(options.datumGrids || {}, reference.name) ? options.datumGrids[reference.name] : void 0;
+    if (grid && typeof grid.shift !== "function")
+      throw new Error("Invalid prepared datum grid: " + reference.name);
+    return Object.freeze({ ...reference, grid });
+  });
+  for (const reference of grids || []) {
+    if (reference.name === "null")
+      break;
+    if (!reference.optional && !reference.grid)
+      unsupportedStage("Required datum grid is not registered: " + reference.name);
+  }
+  const datum = grids ? Object.freeze({ ...crs.datum, grids: Object.freeze(grids) }) : crs.datum;
+  const verticalGrid = compileVerticalGrid(crs.parameters["geoidgrids"], options.verticalGrids);
+  if (verticalGrid && (crs.kind === "geocentric" || crs.kind === "identity" || crs.lossy))
+    unsupportedStage("Vertical grids require a non-lossy geographic or projected CRS");
+  return { ...crs, datum, implementation, verticalGrid };
+}
+function finite(point) {
+  return Number.isFinite(point.x) && Number.isFinite(point.y) && Number.isFinite(point.z);
+}
+function compileAxis(axis, inverse) {
+  if (axis === "enu")
+    return void 0;
+  const indexes = [0, 0, 0], signs = [0, 0, 0];
+  for (let i = 0; i < 3; i++) {
+    const char = axis[i], component = "ew".includes(char) ? 0 : "ns".includes(char) ? 1 : 2;
+    indexes[inverse ? i : component] = inverse ? component : i;
+    signs[inverse ? i : component] = "wsd".includes(char) ? -1 : 1;
+  }
+  return (point) => {
+    const x = point.x, y = point.y, z = point.z;
+    point.x = signs[0] * (indexes[0] === 0 ? x : indexes[0] === 1 ? y : z);
+    point.y = signs[1] * (indexes[1] === 0 ? x : indexes[1] === 1 ? y : z);
+    point.z = signs[2] * (indexes[2] === 0 ? x : indexes[2] === 1 ? y : z);
+  };
+}
+function compileTransform(from, to, enforceAxis) {
+  var _a2, _b, _c, _d;
+  const fromAxis = from.storedAxis || (enforceAxis ? from.axis : "enu");
+  const toAxis = to.storedAxis || (enforceAxis ? to.axis : "enu");
+  const inputAxis = compileAxis(fromAxis, false), outputAxis = compileAxis(toAxis, true);
+  const source = from.implementation && projectionOperation(from.implementation, true, from.kind === "geocentric");
+  const target = to.implementation && projectionOperation(to.implementation, false, to.kind === "geocentric");
+  const datum = createDatumTransform(from.datum, to.datum);
+  const horizontalOnly = from.lossy || to.lossy;
+  const fromGeocentric = from.kind === "geocentric";
+  const inputScale = from.kind === "geographic" ? from.angularUnit : from.toMeter;
+  const outputScale = to.kind === "geographic" ? to.angularUnit : to.toMeter;
+  const inputVerticalScale = fromGeocentric ? 1 : from.verticalUnit, outputVerticalScale = to.kind === "geocentric" ? outputScale : to.verticalUnit;
+  const fromPrime = from.primeMeridian, toPrime = to.primeMeridian;
+  const longitudeWrap = to.kind === "geographic" ? to.longitudeWrap : void 0;
+  let flat;
+  if (!datum && !from.verticalGrid && !to.verticalGrid && !horizontalOnly && !inputAxis && !outputAxis && !fromPrime && !toPrime && from.verticalUnit === 1 && to.verticalUnit === 1 && longitudeWrap === void 0) {
+    const context = Object.freeze({ inputScale, outputScale });
+    if (from.kind === "geographic" && to.kind === "projected")
+      flat = (_b = (_a2 = to.implementation) == null ? void 0 : _a2.createForwardFlat) == null ? void 0 : _b.call(_a2, context);
+    if (from.kind === "projected" && to.kind === "geographic")
+      flat = (_d = (_c = from.implementation) == null ? void 0 : _c.createInverseFlat) == null ? void 0 : _d.call(_c, context);
+  }
+  return {
+    flat,
+    requiresInputZ: Boolean(from.verticalGrid || to.verticalGrid) || from.kind === "geocentric" || /[ud]/.test(fromAxis.slice(0, 2)) || /[ud]/.test(toAxis.slice(0, 2)),
+    geocentricOutput: to.kind === "geocentric",
+    run(point) {
+      if (!finite(point))
+        throw new Error("Coordinates must contain finite x, y and optional z values");
+      inputAxis == null ? void 0 : inputAxis(point);
+      const preservedHeight = point.z;
+      if (horizontalOnly)
+        point.z = 0;
+      if (inputScale !== 1) {
+        point.x *= inputScale;
+        point.y *= inputScale;
+        if (fromGeocentric)
+          point.z *= inputScale;
+      }
+      source == null ? void 0 : source(point);
+      if (inputVerticalScale !== 1)
+        point.z *= inputVerticalScale;
+      if (Math.abs(point.y) > Math.PI / 2 || !finite(point))
+        throw new Error("Coordinate is outside the geographic domain");
+      point.x += fromPrime;
+      if (from.verticalGrid)
+        point.z += from.verticalGrid(point.x, point.y);
+      datum == null ? void 0 : datum(point);
+      if (to.verticalGrid)
+        point.z -= to.verticalGrid(point.x, point.y);
+      point.x -= toPrime;
+      if (longitudeWrap !== void 0)
+        point.x = longitudeWrap + wrapLongitude(point.x - longitudeWrap);
+      target == null ? void 0 : target(point);
+      if (outputScale !== 1) {
+        point.x /= outputScale;
+        point.y /= outputScale;
+      }
+      if (outputVerticalScale !== 1)
+        point.z /= outputVerticalScale;
+      if (horizontalOnly)
+        point.z = preservedHeight;
+      outputAxis == null ? void 0 : outputAxis(point);
+      if (!finite(point))
+        throw new Error("Projection produced non-finite coordinates");
+    }
+  };
+}
+function transformScalar(coordinate, operation, scratch, output) {
+  if (coordinate.length < 2)
+    throw new Error("Coordinates must contain finite x, y and optional z values");
+  if (coordinate.length < 3 && operation.requiresInputZ)
+    throw new Error("This transform requires three ordinates");
+  const length = Math.max(coordinate.length, operation.geocentricOutput ? 3 : 2);
+  const point = scratch.acquire();
+  try {
+    point.x = coordinate[0];
+    point.y = coordinate[1];
+    point.z = coordinate.length >= 3 ? coordinate[2] : 0;
+    operation.run(point);
+    if (output)
+      return writeScalarOutput(coordinate, output, point, length);
+    const result = coordinate.slice();
+    result[0] = point.x;
+    result[1] = point.y;
+    if (coordinate.length >= 3 || operation.geocentricOutput)
+      result[2] = point.z;
+    return result;
+  } finally {
+    scratch.release(point);
+  }
+}
+function transformInPlace(coordinates, dimension, operation, scratch) {
+  if (!(coordinates instanceof Float32Array || coordinates instanceof Float64Array))
+    throw new Error("In-place projection requires a Float32Array or Float64Array");
+  if (!Number.isSafeInteger(dimension) || dimension < 2 || coordinates.length % dimension !== 0)
+    throw new Error("Dimension must be an integer >= 2 and divide the typed array length");
+  if (dimension < 3 && (operation.requiresInputZ || operation.geocentricOutput))
+    throw new Error("This transform requires a dimension of at least 3");
+  if (operation.flat) {
+    operation.flat(coordinates, dimension);
+    return coordinates;
+  }
+  const point = scratch.acquire();
+  try {
+    const float32 = coordinates instanceof Float32Array;
+    for (let offset = 0; offset < coordinates.length; offset += dimension) {
+      point.x = coordinates[offset];
+      point.y = coordinates[offset + 1];
+      point.z = dimension >= 3 ? coordinates[offset + 2] : 0;
+      operation.run(point);
+      if (float32 && (Math.abs(point.x) > 34028234663852886e22 || Math.abs(point.y) > 34028234663852886e22 || dimension >= 3 && Math.abs(point.z) > 34028234663852886e22))
+        throw new Error("Projected coordinate exceeds Float32 range");
+      coordinates[offset] = point.x;
+      coordinates[offset + 1] = point.y;
+      if (dimension >= 3)
+        coordinates[offset + 2] = point.z;
+    }
+    return coordinates;
+  } finally {
+    scratch.release(point);
+  }
+}
+
+// dist/experimental/lazy-projection.js
+var catalogue = [
+  lazyAlbersEqualArea,
+  lazyAzimuthalEquidistant,
+  lazyBonne,
+  lazyCassiniSoldner,
+  lazyCylindricalEqualArea,
+  lazyEckertVI,
+  lazyEquidistantCylindrical,
+  lazyEquidistantConic,
+  lazyEqualEarth,
+  lazyEquirectangular,
+  lazyExtendedTransverseMercator,
+  lazyGeocentric,
+  lazyGeostationary,
+  lazyGnomonic,
+  lazyGaussSchreiberTransverseMercator,
+  lazyKrovak,
+  lazyLambertAzimuthalEqualArea,
+  lazyLambertConformalConic,
+  lazyMercator,
+  lazyMillerCylindrical,
+  lazyMollweide,
+  lazyNewZealandMapGrid,
+  lazyObliqueMercator,
+  lazyOrthographic,
+  lazyPolyconic,
+  lazyQuadrilateralizedSphericalCube,
+  lazyRobinson,
+  lazySinusoidal,
+  lazySwissObliqueMercator,
+  lazyStereographic,
+  lazyObliqueStereographic,
+  lazyTransverseMercator,
+  lazyTiltedPerspective,
+  lazyUniversalTransverseMercator,
+  lazyVanDerGrinten
+];
+var key = (name) => name.toLowerCase().replace(/[\s_-]/g, "");
+var LazyProjection = class extends ProjectionEngine {
+  constructor(options = {}) {
+    super({ ...options, projections: configuredProjections(options) });
+  }
+  /** Resolve this catalogue into an ordinary synchronous engine instance. */
+  static async create(options = {}) {
+    return ProjectionEngine.create({ ...options, projections: configuredProjections(options) });
+  }
+};
+function configuredProjections(options) {
+  const children = /* @__PURE__ */ new Map();
+  for (const definition of [options.from ?? "WGS84", options.to ?? "WGS84"]) {
+    const crs = normalizeCRS(definition, options);
+    if (key(crs.projection) !== "obtran")
+      continue;
+    const requested = crs.parameters["o_proj"];
+    if (!requested)
+      throw new Error("Oblique transformation requires +o_proj");
+    const name = key(requested);
+    if (children.has(name))
+      continue;
+    const child = ["longlat", "latlong", "latlon", "lonlat", "identity"].includes(name) ? "longlat" : catalogue.find((p) => [p.name, ...p.aliases || []].some((alias) => key(alias) === name));
+    if (!child)
+      throw new Error("Unknown oblique transformation projection: " + requested);
+    children.set(name, lazyObliqueTransformation(child));
+  }
+  const projections = [...catalogue];
+  if (children.size) {
+    projections.push(createProjectionDescriptor({ name: "ob_tran" }, async () => {
+      const plugins = /* @__PURE__ */ new Map();
+      await Promise.all([...children].map(async ([name, descriptor]) => {
+        plugins.set(name, await preloadProjection(descriptor));
+      }));
+      return {
+        name: "ob_tran",
+        parameters: [...new Set([...plugins.values()].flatMap((p) => p.parameters))],
+        flags: [...new Set([...plugins.values()].flatMap((p) => p.flags || []))],
+        create(context) {
+          const plugin = plugins.get(key(context.parameters["o_proj"] || ""));
+          if (!plugin)
+            throw new Error("Unregistered oblique transformation child");
+          const allowed = /* @__PURE__ */ new Set([...CORE_PARAMETERS, ...plugin.parameters]);
+          for (const parameter of Object.keys(context.parameters)) {
+            if (!allowed.has(parameter))
+              throw new Error("Unsupported PROJ parameter: +" + parameter);
+          }
+          return plugin.create(context);
+        }
+      };
+    }));
+  }
+  return projections;
+}
+//# sourceMappingURL=index.cjs.map