@math.gl/geospatial 5.0.0-alpha.8 → 5.0.0-beta.1

package/dist/projection/experimental/core.cjs

@@ -0,0 +1,1995 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/projection/experimental/core.js
+var core_exports = {};
+__export(core_exports, {
+  ConfigurableProjectionEngine: () => ConfigurableProjectionEngine,
+  ProjectionTransform: () => ProjectionTransform,
+  TypeScriptCRSError: () => TypeScriptCRSError,
+  checkProjectionCompatibility: () => checkProjectionCompatibility,
+  createProjectionDescriptor: () => createProjectionDescriptor,
+  createProjectionEngine: () => createProjectionEngine,
+  getLoadedProjection: () => getLoadedProjection,
+  normalizeCRS: () => normalizeCRS,
+  preloadProjection: () => preloadProjection
+});
+module.exports = __toCommonJS(core_exports);
+
+// dist/projection/experimental/rendering-profile/geographic-bounds.js
+var RADIANS = Math.PI / 180;
+function createAngularRanges(west, south, east, north) {
+  return [
+    [west, south],
+    [east, north]
+  ];
+}
+function normalizeLongitude(longitude) {
+  return longitude >= -180 && longitude < 180 ? longitude : ((longitude + 180) % 360 + 360) % 360 - 180;
+}
+function getLongitudeSpan(bounds) {
+  const span = bounds[2] - bounds[0];
+  return span < 0 ? span + 360 : span;
+}
+function containsGeographicPoint(bounds, point) {
+  const [west, south, east, north] = bounds;
+  const longitude = normalizeLongitude(point[0]);
+  return point[1] >= south && point[1] <= north && (west <= east ? longitude >= west && longitude <= east || longitude === -180 && east === 180 : longitude >= west || longitude <= east);
+}
+function clampGeographicPoint(bounds, point) {
+  let longitude = normalizeLongitude(point[0]);
+  const latitude = Math.max(bounds[1], Math.min(bounds[3], point[1]));
+  if (!containsGeographicPoint(bounds, [longitude, latitude])) {
+    const westDistance = Math.abs(normalizeLongitude(longitude - bounds[0]));
+    const eastDistance = Math.abs(normalizeLongitude(longitude - bounds[2]));
+    longitude = westDistance <= eastDistance ? bounds[0] : bounds[2];
+  }
+  return [longitude, latitude];
+}
+function getAngularRanges(bounds, primeMeridian2 = 0, origin = 0) {
+  const width = getLongitudeSpan(bounds);
+  const west = bounds[0] * RADIANS - primeMeridian2;
+  const middle = west + width * RADIANS / 2;
+  const shift = Math.round((origin - middle) / (2 * Math.PI)) * 2 * Math.PI;
+  return createAngularRanges(width === 360 ? origin - Math.PI : west + shift, bounds[1] * RADIANS, width === 360 ? origin + Math.PI : west + shift + width * RADIANS, bounds[3] * RADIANS);
+}
+
+// dist/projection/experimental/rendering-profile/rendering-profile.js
+function resolveRenderingProfile(getRenderingProfile, coverage) {
+  if (coverage) {
+    try {
+      const profile2 = getRenderingProfile(coverage);
+      return resolveBounds(profile2);
+    } catch {
+    }
+  }
+  const profile = getRenderingProfile();
+  return resolveBounds(profile);
+}
+function resolveBounds(profile) {
+  var _a2;
+  const bounds = profile.bounds;
+  if (bounds.some((corner) => corner.some((value) => !Number.isFinite(value))))
+    throw new Error("Projection rendering bounds must be finite");
+  return { bounds, normalize: (_a2 = profile.normalize) == null ? void 0 : _a2.bind(profile) };
+}
+
+// dist/projection/experimental/rendering-profile/identity-rendering-profile.js
+function getIdentityRenderingProfile() {
+  return {
+    bounds: [
+      [-1, -1, 0],
+      [1, 1, 0]
+    ]
+  };
+}
+
+// dist/projection/experimental/projection-descriptor.js
+var CACHE_KEY = /* @__PURE__ */ Symbol.for("@math.gl/projection/projection-implementations");
+function cache() {
+  const scope = globalThis;
+  scope[CACHE_KEY] || (scope[CACHE_KEY] = /* @__PURE__ */ new WeakMap());
+  return scope[CACHE_KEY];
+}
+function getLoadedProjection(projection) {
+  var _a2;
+  return "create" in projection ? projection : (_a2 = cache().get(projection)) == null ? void 0 : _a2.implementation;
+}
+function preloadProjection(projection) {
+  if ("create" in projection)
+    return Promise.resolve(projection);
+  let state = cache().get(projection);
+  if (!state) {
+    state = { load: () => projection.preload() };
+    cache().set(projection, state);
+  }
+  if (state.implementation)
+    return Promise.resolve(state.implementation);
+  const entry = state;
+  entry.pending || (entry.pending = Promise.resolve().then(entry.load).then((plugin) => {
+    const key = (value) => value.toLowerCase().replace(/[\s_-]/g, "");
+    const supported = new Set([plugin.name, ...plugin.aliases || []].map(key));
+    if (typeof plugin.create !== "function" || ![projection.name, ...projection.aliases || []].every((name) => supported.has(key(name))))
+      throw new Error("Loaded projection does not match descriptor: " + projection.name);
+    entry.implementation = plugin;
+    return plugin;
+  }).catch((error) => {
+    entry.pending = void 0;
+    throw error;
+  }));
+  return entry.pending;
+}
+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/projection/experimental/projection-scratch.js
+function createPoint() {
+  return { x: 0, y: 0, z: 0 };
+}
+var ProjectionScratch = class {
+  constructor() {
+    this.point = createPoint();
+    this.points = [this.point];
+    this.active = 0;
+  }
+  get depth() {
+    return this.active;
+  }
+  acquire() {
+    var _a2;
+    const index = this.active++;
+    (_a2 = this.points)[index] || (_a2[index] = createPoint());
+    return this.points[index];
+  }
+  release(point) {
+    if (this.active > 0 && this.points[this.active - 1] === point)
+      this.active--;
+  }
+};
+
+// dist/projection/experimental/mutable-projection.js
+function projectionOperation(implementation, inverse, geocentric = false) {
+  const mutable = inverse ? implementation.inverseInPlace : implementation.forwardInPlace;
+  if (mutable)
+    return mutable.bind(implementation);
+  if (geocentric) {
+    const operation2 = inverse ? implementation.inverse3D : implementation.forward3D;
+    return (point) => {
+      const output = operation2.call(implementation, [point.x, point.y, point.z]);
+      point.x = output[0];
+      point.y = output[1];
+      point.z = output[2];
+    };
+  }
+  const operation = inverse ? implementation.inverse : implementation.forward;
+  return (point) => {
+    const output = operation.call(implementation, point.x, point.y);
+    point.x = output[0];
+    point.y = output[1];
+  };
+}
+
+// dist/projection/experimental/scalar-output.js
+var FLOAT32_MAX = 34028234663852886e22;
+function validateScalarOutput(coordinate, output, length) {
+  if (!(Array.isArray(coordinate) || coordinate instanceof Float32Array || coordinate instanceof Float64Array))
+    throw new Error("Scalar input requires a number array, Float32Array or Float64Array");
+  if (!(Array.isArray(output) || output instanceof Float32Array || output instanceof Float64Array) || output.length < length)
+    throw new Error("Scalar output requires a preallocated number array, Float32Array or Float64Array with sufficient capacity");
+  if (coordinate === output || Array.isArray(coordinate) || Array.isArray(output))
+    return;
+  const input = coordinate;
+  const result = output;
+  const shared = typeof SharedArrayBuffer !== "undefined" && input.buffer instanceof SharedArrayBuffer && result.buffer instanceof SharedArrayBuffer;
+  if ((input.buffer === result.buffer || shared) && input.byteOffset < result.byteOffset + length * result.BYTES_PER_ELEMENT && result.byteOffset < input.byteOffset + input.byteLength)
+    throw new Error("Scalar input/output views overlap; use the same view for in-place projection");
+}
+function writeScalarOutput(coordinate, output, point, length) {
+  if (output instanceof Float32Array) {
+    if (Math.abs(point.x) > FLOAT32_MAX || Math.abs(point.y) > FLOAT32_MAX || length >= 3 && Math.abs(point.z) > FLOAT32_MAX)
+      throw new Error("Projected coordinate exceeds Float32 range");
+    for (let i = 3; i < coordinate.length; i++) {
+      const value = coordinate[i];
+      if (Number.isFinite(value) && Math.abs(value) > FLOAT32_MAX)
+        throw new Error("Trailing ordinate exceeds Float32 range");
+    }
+  }
+  for (let i = 3; i < coordinate.length; i++)
+    output[i] = coordinate[i];
+  output[0] = point.x;
+  output[1] = point.y;
+  if (length >= 3)
+    output[2] = point.z;
+  return output;
+}
+
+// dist/crs/spatial-reference.js
+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";
+}
+
+// dist/crs/proj-string.js
+var PROJStringSyntaxError = class extends SyntaxError {
+  /** Create a PROJ string syntax error at a source location. */
+  constructor(message, source, offset) {
+    const location = getSourceLocation(source, offset);
+    super(`${message} at ${location.line}:${location.column}`);
+    this.name = "PROJStringSyntaxError";
+    this.offset = offset;
+    this.line = location.line;
+    this.column = location.column;
+  }
+};
+function parsePROJString(text) {
+  const tokens = tokenizePROJString(text);
+  if (tokens.length === 0) {
+    throw new PROJStringSyntaxError("PROJ string is empty", text, 0);
+  }
+  const parameters = tokens.map((token) => parseParameter(token.raw, token.offset, text));
+  return { type: "proj-string", parameters };
+}
+var DMS_VALUE = /^[+-]?\d+(?:\.\d*)?d(?:\d+(?:\.\d*)?'(?:\d+(?:\.\d*)?")?)?[NSEW]?$/i;
+function parseParameter(rawToken, offset, source) {
+  const token = rawToken.startsWith("+") ? rawToken.slice(1) : rawToken;
+  if (!token) {
+    throw new PROJStringSyntaxError("Expected a parameter after '+'", source, offset);
+  }
+  const equalsIndex = token.indexOf("=");
+  const name = equalsIndex < 0 ? token : token.slice(0, equalsIndex);
+  if (!name || /[\s+=]/.test(name)) {
+    throw new PROJStringSyntaxError(`Invalid PROJ parameter name '${name}'`, source, offset);
+  }
+  if (equalsIndex < 0) {
+    return { type: "parameter", name };
+  }
+  const rawValue = token.slice(equalsIndex + 1);
+  const value = decodeParameterValue(rawValue, source, offset + equalsIndex + 1);
+  return { type: "parameter", name, value, rawValue };
+}
+function tokenizePROJString(source) {
+  const tokens = [];
+  let offset = 0;
+  while (offset < source.length) {
+    while (offset < source.length && /\s/.test(source[offset])) {
+      offset++;
+    }
+    if (offset >= source.length) {
+      break;
+    }
+    const start = offset;
+    let quote = null;
+    let escaped = false;
+    while (offset < source.length) {
+      const character = source[offset];
+      if (escaped) {
+        escaped = false;
+        offset++;
+        continue;
+      }
+      if (character === "\\" && quote) {
+        escaped = true;
+        offset++;
+        continue;
+      }
+      if (quote) {
+        if (character === quote) {
+          quote = null;
+        }
+        offset++;
+        continue;
+      }
+      if ((character === '"' || character === "'") && source[offset - 1] === "=") {
+        quote = character;
+        offset++;
+        continue;
+      }
+      if (/\s/.test(character)) {
+        break;
+      }
+      offset++;
+    }
+    if (quote) {
+      throw new PROJStringSyntaxError("Unterminated quoted PROJ value", source, start);
+    }
+    tokens.push({ raw: source.slice(start, offset), offset: start });
+  }
+  return tokens;
+}
+function decodeParameterValue(rawValue, source, offset) {
+  if (!rawValue) {
+    return "";
+  }
+  const first = rawValue[0];
+  if (first !== '"' && first !== "'") {
+    if ((rawValue.includes('"') || rawValue.includes("'")) && !DMS_VALUE.test(rawValue)) {
+      throw new PROJStringSyntaxError("Quote must begin a PROJ parameter value", source, offset);
+    }
+    return rawValue;
+  }
+  if (rawValue[rawValue.length - 1] !== first) {
+    throw new PROJStringSyntaxError("Unterminated quoted PROJ value", source, offset);
+  }
+  let value = "";
+  for (let index = 1; index < rawValue.length - 1; index++) {
+    const character = rawValue[index];
+    if (character === "\\" && index + 1 < rawValue.length - 1) {
+      value += rawValue[++index];
+    } else {
+      value += character;
+    }
+  }
+  return value;
+}
+function getSourceLocation(source, offset) {
+  let line = 1;
+  let column = 1;
+  for (let index = 0; index < offset && index < source.length; index++) {
+    if (source[index] === "\n") {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+  return { line, column };
+}
+
+// dist/projection/experimental/crs/types.js
+var _a;
+var CRS_ERROR = /* @__PURE__ */ Symbol.for("@math.gl/projection/TypeScriptCRSError");
+var TypeScriptCRSError = class _TypeScriptCRSError extends Error {
+  static [(_a = CRS_ERROR, Symbol.hasInstance)](value) {
+    if (this !== _TypeScriptCRSError)
+      return Function.prototype[Symbol.hasInstance].call(this, value);
+    return value instanceof Error && value[CRS_ERROR] === true;
+  }
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+    this[_a] = true;
+    this.name = "TypeScriptCRSError";
+  }
+};
+function unsupportedStage(message) {
+  throw new TypeScriptCRSError("missing-transform-stage", message);
+}
+
+// dist/projection/experimental/crs/spatial-reference.js
+function resolveCRSInput(input, options) {
+  if (typeof input === "string" || "type" in input)
+    return { definition: input, lossy: false };
+  const metadata = input;
+  const spatialReference = "crs" in metadata ? metadata : void 0;
+  const reference = "crs" in metadata ? metadata.crs : metadata;
+  if (reference.state !== "explicit" && reference.state !== "default")
+    throw new TypeScriptCRSError("unknown-syntax", "Cannot transform an " + reference.state + " CRS reference");
+  let lossy = false;
+  if ((spatialReference == null ? void 0 : spatialReference.coordinateEpoch) !== void 0)
+    unsupportedStage("Coordinate epochs require a time-dependent transformation");
+  if ((spatialReference == null ? void 0 : spatialReference.vertical) && spatialReference.vertical.state !== "absent") {
+    if (options.mode !== "horizontal")
+      unsupportedStage("A separately declared vertical CRS requires explicit horizontal extraction");
+    lossy = true;
+  }
+  return { definition: reference.definition, spatialReference, lossy };
+}
+function applySpatialReference(crs, reference) {
+  var _a2;
+  if (!reference)
+    return crs;
+  if (reference.coordinateFrame !== "unknown" && reference.coordinateFrame !== crs.kind)
+    throw new Error("SpatialReference coordinate frame disagrees with its CRS");
+  const order = reference.coordinateOrder;
+  const names = crs.kind === "geocentric" ? { x: "e", y: "n", z: "u" } : {
+    longitude: "e",
+    lon: "e",
+    latitude: "n",
+    lat: "n",
+    easting: "e",
+    northing: "n",
+    height: "u",
+    altitude: "u",
+    x: "e",
+    y: "n",
+    z: "u"
+  };
+  let storedAxis;
+  if (order.length) {
+    storedAxis = order.slice(0, 3).map((name) => names[name.toLowerCase()] || "?").join("");
+    if (storedAxis.length === 2)
+      storedAxis += "u";
+    if (storedAxis.length !== 3 || !storedAxis.includes("e") || !storedAxis.includes("n") || !storedAxis.includes("u"))
+      unsupportedStage("Unsupported SpatialReference coordinate order");
+    if (order.length > 4 || order.length > 3 && !["m", "measure"].includes(order[3]))
+      unsupportedStage("Unsupported fourth coordinate component");
+  }
+  if ((_a2 = reference.units) == null ? void 0 : _a2.length) {
+    const units = {
+      m: 1,
+      meter: 1,
+      metre: 1,
+      meters: 1,
+      metres: 1,
+      km: 1e3,
+      ft: 0.3048,
+      "us-ft": 1200 / 3937,
+      degree: Math.PI / 180,
+      degrees: Math.PI / 180,
+      radian: 1,
+      radians: 1,
+      grad: Math.PI / 200
+    };
+    for (let i = 0; i < Math.min(reference.units.length, 3); i++) {
+      const vertical = (storedAxis || "enu")[i] === "u";
+      const expected = crs.kind === "geocentric" ? crs.toMeter : vertical ? crs.verticalUnit : crs.kind === "geographic" ? crs.angularUnit : crs.toMeter;
+      if (Math.abs((units[reference.units[i]] ?? NaN) - expected) > 1e-12 || units[reference.units[i]] === void 0)
+        unsupportedStage("SpatialReference units disagree with its CRS");
+    }
+  }
+  return Object.freeze({ ...crs, storedAxis });
+}
+
+// dist/projection/experimental/parameters.js
+var DEGREES_TO_RADIANS = Math.PI / 180;
+function numberParameter(parameters, name, fallback) {
+  if (!Object.prototype.hasOwnProperty.call(parameters, name))
+    return fallback;
+  const value = parameters[name];
+  if (typeof value !== "string" || !/^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i.test(value)) {
+    throw new Error(`Invalid numeric PROJ parameter: +${name}`);
+  }
+  const number = Number(value);
+  if (!Number.isFinite(number))
+    throw new Error(`Invalid numeric PROJ parameter: +${name}`);
+  return number;
+}
+function wrapLongitude(longitude, over = false) {
+  if (over || Math.abs(longitude) <= Math.PI)
+    return longitude;
+  const circle = 2 * Math.PI;
+  return ((longitude + Math.PI) % circle + circle) % circle - Math.PI;
+}
+
+// dist/projection/experimental/crs/datum-catalog.js
+var wgs84 = { towgs84: "0,0,0", ellipse: "WGS84" };
+var nad83 = { towgs84: "0,0,0", ellipse: "GRS80" };
+var builtins = {
+  wgs84,
+  WGS84: wgs84,
+  nad83,
+  North_American_Datum_1983: nad83
+};
+var resolved = /* @__PURE__ */ new WeakMap();
+var datumNameKey = (name) => name.toLowerCase().replace(/[\s_-]/g, "");
+function getDatumDefinitions(options) {
+  var _a2;
+  if (!((_a2 = options.datumCatalogs) == null ? void 0 : _a2.length))
+    return builtins;
+  const cached = resolved.get(options);
+  if ((cached == null ? void 0 : cached.catalogs) === options.datumCatalogs)
+    return cached.definitions;
+  const definitions = Object.assign(/* @__PURE__ */ Object.create(null), builtins);
+  const names = new Map(Object.entries(builtins).map(([name, definition]) => [
+    datumNameKey(name),
+    { definition, owner: -1 }
+  ]));
+  options.datumCatalogs.forEach((catalog, owner) => {
+    if (!catalog.name || !catalog.datums)
+      throw new Error("Invalid datum catalogue plugin");
+    for (const [name, definition] of Object.entries(catalog.datums)) {
+      const key = datumNameKey(name);
+      if (!key || key === "none" || !definition || ["ellipse", "towgs84", "nadgrids"].some((field) => definition[field] !== void 0 && typeof definition[field] !== "string"))
+        throw new Error("Invalid datum definition: " + name);
+      const previous = names.get(key);
+      if (previous && (previous.owner !== owner || previous.definition.ellipse !== definition.ellipse || previous.definition.towgs84 !== definition.towgs84 || previous.definition.nadgrids !== definition.nadgrids))
+        throw new Error("Conflicting datum registration: " + name);
+      names.set(key, { definition, owner });
+      definitions[name] = definition;
+    }
+  });
+  resolved.set(options, { catalogs: options.datumCatalogs, definitions });
+  return definitions;
+}
+
+// dist/projection/experimental/crs/ellipsoid-table.js
+var ellipsoids = {
+  MERIT: {
+    a: 6378137,
+    rf: 298.257,
+    ellipseName: "MERIT 1983"
+  },
+  SGS85: {
+    a: 6378136,
+    rf: 298.257,
+    ellipseName: "Soviet Geodetic System 85"
+  },
+  GRS80: {
+    a: 6378137,
+    rf: 298.257222101,
+    ellipseName: "GRS 1980(IUGG, 1980)"
+  },
+  IAU76: {
+    a: 6378140,
+    rf: 298.257,
+    ellipseName: "IAU 1976"
+  },
+  airy: {
+    a: 6377563396e-3,
+    b: 635625691e-2,
+    ellipseName: "Airy 1830"
+  },
+  APL4: {
+    a: 6378137,
+    rf: 298.25,
+    ellipseName: "Appl. Physics. 1965"
+  },
+  NWL9D: {
+    a: 6378145,
+    rf: 298.25,
+    ellipseName: "Naval Weapons Lab., 1965"
+  },
+  mod_airy: {
+    a: 6377340189e-3,
+    b: 6356034446e-3,
+    ellipseName: "Modified Airy"
+  },
+  andrae: {
+    a: 637710443e-2,
+    rf: 300,
+    ellipseName: "Andrae 1876 (Den., Iclnd.)"
+  },
+  aust_SA: {
+    a: 6378160,
+    rf: 298.25,
+    ellipseName: "Australian Natl & S. Amer. 1969"
+  },
+  GRS67: {
+    a: 6378160,
+    rf: 298.247167427,
+    ellipseName: "GRS 67(IUGG 1967)"
+  },
+  bessel: {
+    a: 6377397155e-3,
+    rf: 299.1528128,
+    ellipseName: "Bessel 1841"
+  },
+  bess_nam: {
+    a: 6377483865e-3,
+    rf: 299.1528128,
+    ellipseName: "Bessel 1841 (Namibia)"
+  },
+  clrk66: {
+    a: 63782064e-1,
+    b: 63565838e-1,
+    ellipseName: "Clarke 1866"
+  },
+  clrk80: {
+    a: 6378249145e-3,
+    rf: 293.4663,
+    ellipseName: "Clarke 1880 mod."
+  },
+  clrk80ign: {
+    a: 63782492e-1,
+    b: 6356515,
+    rf: 293.4660213,
+    ellipseName: "Clarke 1880 (IGN)"
+  },
+  clrk58: {
+    a: 6378293645208759e-9,
+    rf: 294.2606763692654,
+    ellipseName: "Clarke 1858"
+  },
+  CPM: {
+    a: 63757387e-1,
+    rf: 334.29,
+    ellipseName: "Comm. des Poids et Mesures 1799"
+  },
+  delmbr: {
+    a: 6376428,
+    rf: 311.5,
+    ellipseName: "Delambre 1810 (Belgium)"
+  },
+  engelis: {
+    a: 637813605e-2,
+    rf: 298.2566,
+    ellipseName: "Engelis 1985"
+  },
+  evrst30: {
+    a: 6377276345e-3,
+    rf: 300.8017,
+    ellipseName: "Everest 1830"
+  },
+  evrst48: {
+    a: 6377304063e-3,
+    rf: 300.8017,
+    ellipseName: "Everest 1948"
+  },
+  evrst56: {
+    a: 6377301243e-3,
+    rf: 300.8017,
+    ellipseName: "Everest 1956"
+  },
+  evrst69: {
+    a: 6377295664e-3,
+    rf: 300.8017,
+    ellipseName: "Everest 1969"
+  },
+  evrstSS: {
+    a: 6377298556e-3,
+    rf: 300.8017,
+    ellipseName: "Everest (Sabah & Sarawak)"
+  },
+  fschr60: {
+    a: 6378166,
+    rf: 298.3,
+    ellipseName: "Fischer (Mercury Datum) 1960"
+  },
+  fschr60m: {
+    a: 6378155,
+    rf: 298.3,
+    ellipseName: "Fischer 1960"
+  },
+  fschr68: {
+    a: 6378150,
+    rf: 298.3,
+    ellipseName: "Fischer 1968"
+  },
+  helmert: {
+    a: 6378200,
+    rf: 298.3,
+    ellipseName: "Helmert 1906"
+  },
+  hough: {
+    a: 6378270,
+    rf: 297,
+    ellipseName: "Hough"
+  },
+  intl: {
+    a: 6378388,
+    rf: 297,
+    ellipseName: "International 1909 (Hayford)"
+  },
+  kaula: {
+    a: 6378163,
+    rf: 298.24,
+    ellipseName: "Kaula 1961"
+  },
+  lerch: {
+    a: 6378139,
+    rf: 298.257,
+    ellipseName: "Lerch 1979"
+  },
+  mprts: {
+    a: 6397300,
+    rf: 191,
+    ellipseName: "Maupertius 1738"
+  },
+  new_intl: {
+    a: 63781575e-1,
+    b: 63567722e-1,
+    ellipseName: "New International 1967"
+  },
+  plessis: {
+    a: 6376523,
+    b: 6355863,
+    ellipseName: "Plessis 1817 (France)"
+  },
+  krass: {
+    a: 6378245,
+    rf: 298.3,
+    ellipseName: "Krassovsky, 1942"
+  },
+  SEasia: {
+    a: 6378155,
+    b: 63567733205e-4,
+    ellipseName: "Southeast Asia"
+  },
+  walbeck: {
+    a: 6376896,
+    b: 63558348467e-4,
+    ellipseName: "Walbeck"
+  },
+  WGS60: {
+    a: 6378165,
+    rf: 298.3,
+    ellipseName: "WGS 60"
+  },
+  WGS66: {
+    a: 6378145,
+    rf: 298.25,
+    ellipseName: "WGS 66"
+  },
+  WGS72: {
+    a: 6378135,
+    rf: 298.26,
+    ellipseName: "WGS 72"
+  },
+  WGS84: {
+    a: 6378137,
+    rf: 298.257223563,
+    ellipseName: "WGS 84"
+  },
+  sphere: {
+    a: 6370997,
+    b: 6370997,
+    ellipseName: "Normal Sphere (r=6370997)"
+  }
+};
+var ellipsoid_table_default = ellipsoids;
+
+// dist/projection/experimental/crs/primemeridian-table.js
+var primeMeridian = {};
+primeMeridian["greenwich"] = 0;
+primeMeridian["lisbon"] = -9.131906111111;
+primeMeridian["paris"] = 2.337229166667;
+primeMeridian["bogota"] = -74.080916666667;
+primeMeridian["madrid"] = -3.687938888889;
+primeMeridian["rome"] = 12.452333333333;
+primeMeridian["bern"] = 7.439583333333;
+primeMeridian["jakarta"] = 106.807719444444;
+primeMeridian["ferro"] = -17.666666666667;
+primeMeridian["brussels"] = 4.367975;
+primeMeridian["stockholm"] = 18.058277777778;
+primeMeridian["athens"] = 23.7163375;
+primeMeridian["oslo"] = 10.722916666667;
+var primemeridian_table_default = primeMeridian;
+
+// dist/crs/units-table.js
+var linearUnits = {
+  m: { name: "meters", metersPerUnit: 1 },
+  mm: { name: "millimeters", metersPerUnit: 1e-3 },
+  cm: { name: "centimeters", metersPerUnit: 0.01 },
+  ft: { name: "feet", metersPerUnit: 0.3048 },
+  "us-ft": { name: "us-survey-feet", metersPerUnit: 1200 / 3937 },
+  fath: { name: "fathoms", metersPerUnit: 1.8288 },
+  kmi: { name: "nautical-miles", metersPerUnit: 1852 },
+  "us-ch": { name: "us-survey-chains", metersPerUnit: 20.1168402336805 },
+  "us-mi": { name: "us-survey-miles", metersPerUnit: 1609.34721869444 },
+  km: { name: "kilometers", metersPerUnit: 1e3 },
+  "ind-ft": { name: "indian-feet", metersPerUnit: 0.30479841 },
+  "ind-yd": { name: "indian-yards", metersPerUnit: 0.91439523 },
+  mi: { name: "miles", metersPerUnit: 1609.344 },
+  yd: { name: "yards", metersPerUnit: 0.9144 },
+  ch: { name: "chains", metersPerUnit: 20.1168 },
+  link: { name: "links", metersPerUnit: 0.201168 },
+  dm: { name: "decimeters", metersPerUnit: 0.1 },
+  in: { name: "inches", metersPerUnit: 0.0254 },
+  "ind-ch": { name: "indian-chains", metersPerUnit: 20.11669506 },
+  "us-in": { name: "us-survey-inches", metersPerUnit: 0.025400050800101 },
+  "us-yd": { name: "us-survey-yards", metersPerUnit: 0.914401828803658 }
+};
+
+// dist/crs/crs-metadata.js
+function getCRSSignature(crs) {
+  return JSON.stringify([
+    crs.coordinateFrame,
+    crs.projection,
+    Object.keys(crs.parameters).sort().map((key) => [key, crs.parameters[key]]),
+    [crs.ellipsoid.semiMajorAxis, crs.ellipsoid.semiMinorAxis],
+    crs.axis,
+    [crs.xUnit.name, crs.xUnit.metersPerUnit, crs.xUnit.degreesPerUnit],
+    [crs.yUnit.name, crs.yUnit.metersPerUnit, crs.yUnit.degreesPerUnit],
+    [crs.zUnit.name, crs.zUnit.metersPerUnit, crs.zUnit.degreesPerUnit],
+    crs.lossy,
+    crs.areaOfUse
+  ]);
+}
+
+// dist/projection/experimental/crs/normalize.js
+var ALIASES = {
+  WGS84: "+proj=longlat +datum=WGS84",
+  "EPSG:4326": "+proj=longlat +datum=WGS84",
+  "EPSG:4269": "+proj=longlat +datum=NAD83",
+  "EPSG:4978": "+proj=geocent +datum=WGS84",
+  "EPSG:4979": "+proj=longlat +datum=WGS84",
+  "EPSG:3857": "+proj=merc +a=6378137 +b=6378137 +nadgrids=@null +units=m",
+  "EPSG:3785": "EPSG:3857",
+  GOOGLE: "EPSG:3857",
+  "EPSG:900913": "EPSG:3857",
+  "EPSG:102113": "EPSG:3857"
+};
+var CORE_PARAMETERS = [
+  "proj",
+  "datum",
+  "ellps",
+  "a",
+  "b",
+  "rf",
+  "f",
+  "R",
+  "units",
+  "to_meter",
+  "vunits",
+  "vto_meter",
+  "no_defs",
+  "type",
+  "title",
+  "towgs84",
+  "nadgrids",
+  "geoidgrids",
+  "axis",
+  "pm",
+  "over",
+  "lon_wrap"
+];
+var CORE_FLAGS = ["no_defs", "over"];
+var own = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
+var keyOf = (value) => value.toLowerCase().replace(/[\s_-]/g, "");
+function lookup(table, name) {
+  const key = Object.keys(table).find((key2) => keyOf(key2) === keyOf(name));
+  return key === void 0 ? void 0 : table[key];
+}
+function parseAngle(text) {
+  if (/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(text)) {
+    const value = Number(text);
+    if (Number.isFinite(value))
+      return value;
+  }
+  if (/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?r$/i.test(text)) {
+    const value = Number(text.slice(0, -1)) / DEGREES_TO_RADIANS;
+    if (Number.isFinite(value))
+      return value;
+  }
+  const dms = /^([+-]?)(\d+(?:\.\d*)?)(?:d(?:(\d+(?:\.\d*)?)'(?:(\d+(?:\.\d*)?)")?)?)?([NSEW])?$/i.exec(text);
+  if (dms && (/d/i.test(text) || dms[5])) {
+    const minutes = Number(dms[3] || 0), seconds = Number(dms[4] || 0);
+    if (minutes < 60 && seconds < 60) {
+      const sign = dms[1] === "-" ? -1 : 1;
+      const direction = /[SW]/i.test(dms[5] || "") ? -1 : 1;
+      const value = sign * direction * (Number(dms[2]) + minutes / 60 + seconds / 3600);
+      if (Number.isFinite(value))
+        return value;
+    }
+  }
+  throw new Error("Invalid angular parameter: " + text);
+}
+function resolveLocalCRSDefinition(input, options = {}) {
+  let definition = input;
+  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";
+    }
+  }
+  return definition;
+}
+function normalizeCRS(input, options = {}) {
+  var _a2;
+  const datums = getDatumDefinitions(options);
+  const resolved2 = resolveCRSInput(input, options);
+  const definition = resolveLocalCRSDefinition(resolved2.definition, options);
+  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", inferCRSRepresentation(definition) === "identifier" ? "Unsupported CRS definition: " + definition + "; resolve it first" : "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(datums, datumName) : void 0;
+  if (datumName && datumName !== "none" && !datum)
+    unsupportedStage("Unknown datum: " + datumName + "; register a datumCatalogs plugin");
+  const ellipsoid = getEllipsoid(parameters, datum == null ? void 0 : datum.ellipse);
+  const grids = parameters["nadgrids"] ?? (datum == null ? void 0 : datum.nadgrids);
+  const gridReferences = grids === void 0 ? void 0 : grids.split(",").map((entry) => {
+    const optional = entry.startsWith("@");
+    const name2 = optional ? entry.slice(1) : entry;
+    if (!name2 || /\s/.test(name2))
+      throw new Error("Invalid datum grid name");
+    return Object.freeze({ name: name2, optional });
+  });
+  const rawShift = parameters["towgs84"] ?? (datum == null ? void 0 : datum.towgs84);
+  let shift;
+  if (rawShift !== void 0) {
+    shift = rawShift.split(",").map((value) => numberParameter({ value }, "value", NaN));
+    if (![3, 7].includes(shift.length) || shift.some((value) => !Number.isFinite(value)) || shift.length === 7 && shift[6] <= -1e6) {
+      throw new Error("+towgs84 requires three or seven finite values and positive scale");
+    }
+  }
+  if (datumName === "none")
+    shift = void 0;
+  if (gridReferences && datumName !== "none")
+    shift = [0, 0, 0];
+  const datumEllipsoid = grids === "@null" || grids === "null" ? getEllipsoid({ ellps: "WGS84" }) : ellipsoid;
+  const axis = parameters["axis"] || "enu";
+  if (axis.length !== 3 || !/[ew]/.test(axis) || !/[ns]/.test(axis) || !/[ud]/.test(axis))
+    throw new Error("Invalid axis: " + axis);
+  const angularUnit = parsed.angularUnit ?? DEGREES_TO_RADIANS;
+  if (kind === "geographic" && (parameters["units"] && parameters["units"] !== "degrees" || own(parameters, "to_meter")))
+    throw new Error("Geographic coordinates must use angular units");
+  if (kind !== "geographic" && parameters["units"] === "degrees")
+    throw new Error("Linear coordinates require linear units");
+  const toMeter = unitFactor(parameters, "units", "to_meter");
+  const verticalUnit = parsed.verticalUnit ?? unitFactor(parameters, "vunits", "vto_meter");
+  if (!(verticalUnit > 0) || !Number.isFinite(verticalUnit))
+    throw new Error("Invalid vertical unit");
+  if (!(angularUnit > 0) || !Number.isFinite(angularUnit))
+    throw new Error("Invalid angular unit");
+  const pm = parameters["pm"];
+  const primeMeridian2 = pm === void 0 ? 0 : (lookup(primemeridian_table_default, pm) ?? parseAngle(pm)) * DEGREES_TO_RADIANS;
+  return applySpatialReference(Object.freeze({
+    kind,
+    projection: name,
+    parameters: Object.freeze(parameters),
+    ellipsoid,
+    datum: Object.freeze({
+      ellipsoid: datumEllipsoid,
+      towgs84: shift && Object.freeze(shift),
+      grids: datumName === "none" || grids === "@null" || grids === "null" ? void 0 : gridReferences && Object.freeze(gridReferences)
+    }),
+    areaOfUse: parsed.areaOfUse,
+    angularUnit,
+    toMeter,
+    verticalUnit,
+    primeMeridian: primeMeridian2,
+    axis,
+    longitudeWrap: parameters["lon_wrap"] === void 0 ? void 0 : Number(parameters["lon_wrap"]) * DEGREES_TO_RADIANS,
+    lossy: Boolean(parsed.lossy || resolved2.lossy)
+  }), resolved2.spatialReference);
+}
+function unitFactor(parameters, unitKey, factorKey) {
+  const unit = parameters[unitKey];
+  const table = linearUnits;
+  if (unitKey === "vunits" && unit === "degrees")
+    throw new Error("Height requires linear units");
+  if (unit && !["m", "degrees"].includes(unit) && !own(table, unit))
+    throw new Error("Unsupported units: " + unit);
+  const factor = numberParameter(parameters, factorKey, unit && table[unit] ? table[unit].metersPerUnit : 1);
+  if (!(factor > 0))
+    throw new Error("+" + factorKey + " must be positive");
+  return factor;
+}
+function getEllipsoid(parameters, datumEllipsoid) {
+  const name = datumEllipsoid || parameters["ellps"] || "WGS84";
+  const 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
+  });
+}
+
+// dist/projection/experimental/datum.js
+var import_core = require("@math.gl/core");
+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 (!(0, import_core.spheroidToCartesian)(point, ellipsoid))
+    throw new Error("Geocentric coordinate must be finite");
+}
+function geocentricToGeodeticInPlace(point, ellipsoid) {
+  const x = point.x, y = point.y, z = point.z;
+  const { semiMajorAxis: a, semiMinorAxis: b, eccentricitySquared: es } = ellipsoid;
+  if (x === 0 && y === 0 && z === 0)
+    throw new Error("Geodetic coordinates are undefined at the Earth center");
+  if (es !== 0 && Math.abs(x) < 1e-12 * a && Math.abs(y) < 1e-12 * a && Math.hypot(x, y) < 1e-12 * a) {
+    if (!Number.isFinite(Math.hypot(x, y, z)))
+      throw new Error("Geocentric radius must be finite");
+    point.x = 0;
+    point.y = Math.sign(z) * Math.PI / 2;
+    point.z = Math.abs(z) - b;
+    return;
+  }
+  if (!(0, import_core.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/projection/experimental/rendering-profile/rectangular-rendering-profile.js
+function normalizeCoverage(point, coverage, center = 0, over = false) {
+  const span = getLongitudeSpan(coverage);
+  const west = span === 360 ? center - 180 : coverage[0] + Math.round((center - coverage[0] - span / 2) / 360) * 360;
+  const east = west + span;
+  if (over) {
+    point.x = Math.max(west, Math.min(east, point.x));
+    point.y = Math.max(coverage[1], Math.min(coverage[3], point.y));
+    return;
+  }
+  const best = clampGeographicPoint(coverage, [point.x, point.y]);
+  let longitude = best[0];
+  if (best[0] === normalizeLongitude(point.x) && point.x >= west && point.x <= east)
+    longitude = point.x;
+  else if (longitude < west || longitude > east)
+    longitude += Math.round(((west + east) / 2 - longitude) / 360) * 360;
+  const offset = longitude - center;
+  point.x = Math.abs(offset) <= 180 ? longitude : center + normalizeLongitude(offset);
+  point.y = best[1];
+}
+function createRectangleRenderingProfile(resolveBounds2, coverage, origin = 0, primeMeridian2 = 0, over = false) {
+  const center = (origin + primeMeridian2) * 180 / Math.PI;
+  return {
+    get bounds() {
+      return resolveBounds2(getAngularRanges(coverage, primeMeridian2, origin));
+    },
+    normalize(point) {
+      normalizeCoverage(point, coverage, center, over);
+    }
+  };
+}
+
+// dist/projection/experimental/rendering-profile/rendering-bounds.js
+function longitudeRange(parameters, origin, over = false) {
+  const low = parameters[0][0] - origin, high = parameters[1][0] - origin;
+  if (over)
+    return [low, high];
+  const span = high - low;
+  if (span >= 2 * Math.PI - 1e-12)
+    return [-Math.PI, Math.PI];
+  let west = wrapLongitude(low);
+  if (span > 0 && Math.abs(west - Math.PI) < 1e-12)
+    west = -Math.PI;
+  const east = west + span;
+  return east > Math.PI + 1e-12 ? [-Math.PI, Math.PI] : [west, Math.min(east, Math.PI)];
+}
+
+// dist/projection/experimental/rendering-profile/geographic-rendering-profile.js
+function createGeographicProfile(parameters, primeMeridian2 = 0) {
+  const center = numberParameter(parameters, "lon_wrap", 0) * DEGREES_TO_RADIANS;
+  return (coverage) => createRectangleRenderingProfile((ranges) => {
+    const longitude = longitudeRange(ranges, center);
+    return [
+      [center + longitude[0], ranges[0][1], 0],
+      [center + longitude[1], ranges[1][1], 0]
+    ];
+  }, coverage ?? [-180, -90, 180, 90], center, primeMeridian2);
+}
+
+// dist/projection/experimental/vertical-datum.js
+function compileVerticalGrid(names, grids = {}) {
+  if (names === void 0)
+    return void 0;
+  const entries = [];
+  for (const entry of names.split(",")) {
+    const optional = entry.startsWith("@");
+    const name = optional ? entry.slice(1) : entry;
+    if (!name || /\s/.test(name))
+      throw new Error("Invalid vertical grid name");
+    if (name === "null") {
+      entries.push(null);
+      break;
+    }
+    const grid = Object.prototype.hasOwnProperty.call(grids, name) ? grids[name] : void 0;
+    if (grid) {
+      if (typeof grid.getOffset !== "function")
+        throw new Error("Invalid vertical grid: " + name);
+      entries.push(grid.getOffset.bind(grid));
+    } else if (!optional)
+      unsupportedStage("Required vertical grid is not registered: " + name);
+  }
+  return (longitude, latitude) => {
+    for (const sample of entries) {
+      if (!sample)
+        return 0;
+      const offset = sample(longitude, latitude);
+      if (offset === void 0)
+        continue;
+      if (!Number.isFinite(offset))
+        throw new Error("Vertical grid returned a non-finite offset");
+      return offset;
+    }
+    throw new Error("No vertical grid covers this coordinate");
+  };
+}
+
+// dist/projection/experimental/typescript-projection.js
+var ProjectionTransform = class _ProjectionTransform {
+  /** 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 _ProjectionTransform({ ...options, projections });
+  }
+  get targetProfile() {
+    return this.getTargetRenderingProfile(this.targetCoverage);
+  }
+  /** Resolve target rendering policy independently from coordinate conversion. @internal */
+  getTargetRenderingProfile(coverage) {
+    return this.targetRenderingProfile && resolveRenderingProfile(this.targetRenderingProfile, coverage);
+  }
+  constructor(options = {}) {
+    var _a2, _b, _c;
+    this.coordinateScratch = new ProjectionScratch();
+    this.targetLongitudeOrigin = 0;
+    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.targetRenderingProfile = ((_b = (_a2 = to.implementation) == null ? void 0 : _a2.getRenderingProfile) == null ? void 0 : _b.bind(to.implementation)) ?? (to.kind === "geographic" ? createGeographicProfile(to.parameters, to.primeMeridian) : to.kind === "identity" ? getIdentityRenderingProfile : void 0);
+      this.targetCoverage = to.areaOfUse;
+      this.targetLongitudeOrigin = ((_c = to.implementation) == null ? void 0 : _c.longitudeOrigin) ?? (to.kind === "geographic" ? to.longitudeWrap ?? 0 : 0);
+      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 = _ProjectionTransform.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 _ProjectionTransform({ ...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];
+}
+function checkProjectionCompatibility(definition, options = {}) {
+  try {
+    const crs = compileCRS(definition, registry(options.projections || []), options);
+    return { status: "supported", lossy: crs.lossy };
+  } catch (error) {
+    const reason = error instanceof TypeScriptCRSError ? error.reason : "invalid-definition";
+    return {
+      status: reason === "unknown-syntax" ? "unknown" : "unsupported",
+      lossy: false,
+      reason,
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+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 key of Object.keys(crs.parameters)) {
+    if (!allowed.has(key))
+      throw new TypeScriptCRSError("missing-transform-stage", "Unsupported PROJ parameter: +" + key);
+    const flag = CORE_FLAGS.includes(key) || ((_a2 = plugin == null ? void 0 : plugin.flags) == null ? void 0 : _a2.includes(key));
+    if (flag && crs.parameters[key] !== void 0)
+      throw new Error("Expected a flag without a value: +" + key);
+    if (!flag && !crs.parameters[key])
+      throw new Error("PROJ parameter requires a value: +" + key);
+  }
+  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,
+    primeMeridian: crs.primeMeridian
+  });
+  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/projection/numerical-derivative.js
+var NumericalDerivative = class {
+  constructor(sample) {
+    this.sample = sample;
+    this.result = [0, 0, 0];
+    this.samples = Array.from({ length: 4 }, () => [0, 0, 0]);
+    this.coarse = [0, 0, 0];
+    this.fine = [0, 0, 0];
+  }
+  evaluate(step, referenceScale, tolerance = 1e-6) {
+    if (!this.difference(step, this.coarse) || !this.difference(step / 2, this.fine))
+      return false;
+    const bound = tolerance * Math.max(referenceScale, Math.abs(this.fine[0]), Math.abs(this.fine[1]), Math.abs(this.fine[2]));
+    for (let i = 0; i < 3; i++) {
+      if (Math.abs(this.coarse[i] - this.fine[i]) > bound)
+        return false;
+      this.fine[i] += (this.fine[i] - this.coarse[i]) / 15;
+      if (!Number.isFinite(this.fine[i]))
+        return false;
+    }
+    for (let i = 0; i < 3; i++)
+      this.result[i] = this.fine[i];
+    return true;
+  }
+  difference(step, output) {
+    const [a, b, c, d] = this.samples;
+    if (!this.sample(-2 * step, a) || !this.sample(-step, b) || !this.sample(step, c) || !this.sample(2 * step, d))
+      return false;
+    for (let i = 0; i < 3; i++) {
+      output[i] = (a[i] - d[i] + 8 * (c[i] - b[i])) / (12 * step);
+      if (!Number.isFinite(output[i]))
+        return false;
+    }
+    return true;
+  }
+};
+
+// dist/projection/experimental/crs-rendering-scale.js
+var RADIANS2 = Math.PI / 180;
+var WGS842 = normalizeCRS("WGS84").ellipsoid;
+function validateScale(scale) {
+  if (scale.length !== 3 || scale.some((value) => !Number.isFinite(value) || value <= 0))
+    throw new Error("Invalid CRS rendering scale");
+  return scale;
+}
+function createRenderingScale(crs, projection, axis, center) {
+  if (crs.kind === "geocentric")
+    return validateScale([crs.toMeter, crs.toMeter, crs.toMeter]);
+  if (crs.kind === "identity") {
+    return validateScale([...axis].map((direction) => /[ud]/.test(direction) ? crs.verticalUnit : crs.toMeter));
+  }
+  const anchor = [0, 0, 0], input = [0, 0, 0], geographic = [0, 0, 0], sample = [0, 0, 0];
+  const derivatives = Array.from({ length: 3 }, () => [0, 0, 0]);
+  let component = 0, longitudeMeters = 0, latitudeMeters = 0, busy = false;
+  const numerical = new NumericalDerivative((offset, output) => {
+    for (let i = 0; i < 3; i++)
+      input[i] = anchor[i];
+    input[component] += offset;
+    projection.unprojectTo(input, sample);
+    const rawDelta = sample[0] - geographic[0];
+    const delta = Math.abs(rawDelta) <= 180 ? rawDelta : ((rawDelta + 180) % 360 + 360) % 360 - 180;
+    if (Math.abs(sample[1]) >= 90)
+      return false;
+    output[0] = delta * longitudeMeters;
+    output[1] = (sample[1] - geographic[1]) * latitudeMeters;
+    output[2] = sample[2] - geographic[2];
+    return output.every(Number.isFinite);
+  });
+  return (coordinate) => {
+    if (busy || coordinate.length < 2)
+      return null;
+    busy = true;
+    let scale;
+    try {
+      anchor[0] = coordinate[0];
+      anchor[1] = coordinate[1];
+      anchor[2] = coordinate[2] ?? 0;
+      if (!anchor.every(Number.isFinite))
+        return null;
+      projection.unprojectTo(anchor, geographic);
+      const latitude = geographic[1] * RADIANS2;
+      const a = WGS842.semiMajorAxis, es = WGS842.eccentricitySquared;
+      const denominator = 1 - es * Math.sin(latitude) ** 2;
+      longitudeMeters = a * Math.cos(latitude) / Math.sqrt(denominator) * RADIANS2;
+      latitudeMeters = a * (1 - es) / denominator ** 1.5 * RADIANS2;
+      if (!(longitudeMeters > a * RADIANS2 * 1e-8) || !(latitudeMeters > 0))
+        return null;
+      const offset = ((geographic[0] - center + 180) % 360 + 360) % 360 - 180;
+      const hasLongitudeSeam = crs.kind === "geographic" ? crs.longitudeWrap !== void 0 : !Object.prototype.hasOwnProperty.call(crs.parameters, "over");
+      if (hasLongitudeSeam && Math.abs(offset) + 2 / longitudeMeters >= 180 || Math.abs(geographic[1]) + 2 / latitudeMeters >= 90)
+        return null;
+      for (component = 0; component < 3; component++) {
+        const direction = axis[component];
+        const nominalMeters = /[ud]/.test(direction) ? crs.verticalUnit : crs.kind === "geographic" ? (/[ew]/.test(direction) ? longitudeMeters : latitudeMeters) * crs.angularUnit / RADIANS2 : crs.toMeter;
+        if (!numerical.evaluate(1 / nominalMeters, nominalMeters))
+          return null;
+        for (let i = 0; i < 3; i++)
+          derivatives[component][i] = numerical.result[i];
+      }
+      scale = derivatives.map((derivative) => Math.hypot(...derivative));
+      if (crs.kind === "projected") {
+        const east = derivatives[axis.search(/[ew]/)];
+        const north = derivatives[axis.search(/[ns]/)];
+        const inverseArea = Math.abs(east[0] * north[1] - east[1] * north[0]) / crs.toMeter ** 2;
+        scale[axis.search(/[ud]/)] = crs.verticalUnit * Math.sqrt(inverseArea);
+      }
+    } catch {
+      return null;
+    } finally {
+      busy = false;
+    }
+    return validateScale(scale);
+  };
+}
+
+// dist/projection/experimental/crs-descriptor.js
+var ANGULAR_UNITS = {
+  degrees: Math.PI / 180,
+  radians: 1,
+  gradians: Math.PI / 200
+};
+var LINEAR_UNITS = {
+  ...Object.fromEntries(Object.values(linearUnits).map((unit) => [unit.name, unit.metersPerUnit]))
+};
+async function resolveCRSDescriptor(engine, definition, normalization, options = {}, useDefinitionSignature = false, prepareInput) {
+  const captured = typeof definition === "string" ? definition : JSON.parse(JSON.stringify(definition));
+  const conventions = {
+    enforceAxis: normalization.enforceAxis,
+    mode: normalization.mode,
+    ...options,
+    converters: options.converters && [...options.converters]
+  };
+  const input = prepareInput ? await prepareInput(captured, { ...normalization, ...conventions }) : captured;
+  const crs = normalizeCRS(input, { ...normalization, ...conventions });
+  const projection = await engine.createProjectionAsync({
+    ...conventions,
+    from: "WGS84",
+    to: input
+  });
+  const axis = crs.storedAxis || (conventions.enforceAxis ? crs.axis : "enu");
+  const horizontalUnit = getUnit(crs.kind === "geographic" ? crs.angularUnit : crs.toMeter, crs.kind === "geographic");
+  const heightUnit = getUnit(crs.verticalUnit, false);
+  const units = [...axis].map((direction) => crs.kind !== "geocentric" && /[ud]/.test(direction) ? heightUnit : horizontalUnit);
+  const profile = projection.targetProfile;
+  if (!profile)
+    throw new Error("Projection must define a rendering profile for CRS retrieval");
+  const center = (projection.targetLongitudeOrigin + crs.primeMeridian) * 180 / Math.PI;
+  const bounds = adaptBounds(profile, crs, axis);
+  const normalizeWGS84 = createNormalization(profile.normalize);
+  const renderingScale = createRenderingScale(crs, projection, axis, center);
+  const sources = [.../* @__PURE__ */ new Set(["WGS84", ...conventions.converters || []])];
+  if (sources.some((source) => typeof source !== "string" || !source.trim()))
+    throw new Error("Converter source CRS must be a nonempty string");
+  const entries = await Promise.all(sources.map(async (source) => {
+    if (source === "WGS84")
+      return [source, createConverter(projection, normalizeWGS84)];
+    const [pair, geographic] = await Promise.all([
+      engine.createProjectionAsync({ ...conventions, from: source, to: input }),
+      engine.createProjectionAsync({ ...conventions, from: "WGS84", to: source })
+    ]);
+    return [
+      source,
+      createConverter(pair, createSourceNormalization(geographic, normalizeWGS84))
+    ];
+  }));
+  const converter = Object.assign(/* @__PURE__ */ Object.create(null), Object.fromEntries(entries));
+  const metadata = {
+    coordinateFrame: crs.kind,
+    projection: crs.projection,
+    parameters: crs.parameters,
+    ellipsoid: {
+      semiMajorAxis: crs.ellipsoid.semiMajorAxis,
+      semiMinorAxis: crs.ellipsoid.semiMinorAxis
+    },
+    axis,
+    xUnit: units[0],
+    yUnit: units[1],
+    zUnit: units[2],
+    areaOfUse: crs.areaOfUse,
+    lossy: crs.lossy
+  };
+  return {
+    ...metadata,
+    // Exact caller identity is sufficient under default execution conventions.
+    // Additional source converters do not change the target CRS.
+    signature: useDefinitionSignature && typeof input === "string" && !conventions.enforceAxis && !crs.lossy ? input : getCRSSignature(metadata),
+    renderingBounds: bounds,
+    renderingScale,
+    getRenderingScale: (coordinate) => typeof renderingScale === "function" ? renderingScale(coordinate) : renderingScale,
+    converter
+  };
+}
+function createConverter(projection, normalize) {
+  return {
+    from: createConversion(projection.project.bind(projection), projection.projectTo.bind(projection)),
+    to: createConversion(projection.unproject.bind(projection), projection.unprojectTo.bind(projection)),
+    normalize
+  };
+}
+function createSourceNormalization(geographic, normalizeWGS84) {
+  function normalize(coordinate, output) {
+    if (output !== void 0)
+      validateScalarOutput(coordinate, output, coordinate.length);
+    const wgs842 = geographic.unproject(Array.from(coordinate));
+    const [longitude, latitude, altitude] = wgs842;
+    normalizeWGS84(wgs842, wgs842);
+    if (wgs842[0] === longitude && wgs842[1] === latitude && wgs842[2] === altitude) {
+      return output === void 0 ? Array.from(coordinate) : writeScalarOutput(coordinate, output, { x: coordinate[0], y: coordinate[1], z: coordinate[2] ?? 0 }, coordinate.length);
+    }
+    return output === void 0 ? geographic.project(wgs842) : geographic.projectTo(wgs842, output);
+  }
+  return normalize;
+}
+function createConversion(allocate, write) {
+  function convert(coordinate, output) {
+    return output === void 0 ? allocate(Array.isArray(coordinate) ? coordinate : Array.from(coordinate)) : write(coordinate, output);
+  }
+  return convert;
+}
+function createNormalization(normalizeDomain) {
+  function normalize(coordinate, output) {
+    const result = output ?? new Array(coordinate.length);
+    validateScalarOutput(coordinate, result, coordinate.length);
+    const longitude = coordinate[0], latitude = coordinate[1], altitude = coordinate[2] ?? 0;
+    if (coordinate.length < 2 || !Number.isFinite(longitude) || !Number.isFinite(latitude) || !Number.isFinite(altitude))
+      throw new Error("Normalization requires finite longitude, latitude and altitude");
+    const point = { x: longitude, y: latitude, z: altitude };
+    normalizeDomain == null ? void 0 : normalizeDomain(point);
+    return writeScalarOutput(coordinate, result, point, coordinate.length);
+  }
+  return normalize;
+}
+function adaptBounds(profile, crs, axis) {
+  const horizontalUnit = crs.kind === "geographic" ? crs.angularUnit : crs.toMeter;
+  const units = [
+    horizontalUnit,
+    horizontalUnit,
+    crs.kind === "geocentric" ? crs.toMeter : crs.verticalUnit
+  ];
+  const bounds = profile.bounds;
+  const limits = [...axis].map((direction) => {
+    const index = /[ew]/.test(direction) ? 0 : /[ns]/.test(direction) ? 1 : 2;
+    const minimum = bounds[0][index] / units[index];
+    const maximum = bounds[1][index] / units[index];
+    return /[wsd]/.test(direction) ? [-maximum, -minimum] : [minimum, maximum];
+  });
+  return [
+    [limits[0][0], limits[1][0], limits[2][0]],
+    [limits[0][1], limits[1][1], limits[2][1]]
+  ];
+}
+function getUnit(factor, angular) {
+  const units = angular ? ANGULAR_UNITS : LINEAR_UNITS;
+  const name = Object.keys(units).find((candidate) => units[candidate] === factor) || "custom";
+  return angular ? { name, degreesPerUnit: factor / ANGULAR_UNITS["degrees"] } : { name, metersPerUnit: factor };
+}
+
+// dist/projection/experimental/engine-options.js
+function snapshotEngineOptions(options) {
+  return {
+    ...options,
+    projections: options.projections && [...options.projections],
+    parsers: options.parsers && [...options.parsers],
+    datumCatalogs: options.datumCatalogs && [...options.datumCatalogs],
+    aliases: options.aliases && JSON.parse(JSON.stringify(options.aliases)),
+    datumGrids: options.datumGrids && { ...options.datumGrids },
+    verticalGrids: options.verticalGrids && { ...options.verticalGrids }
+  };
+}
+function hasCRSOverrides(options) {
+  return Boolean(options.projections || options.parsers || options.datumCatalogs || options.aliases || options.datumGrids || options.verticalGrids || options.resolver);
+}
+
+// dist/projection/experimental/crs/resolve.js
+async function prepareEngineOptions(options) {
+  const captured = {
+    ...options,
+    from: capture(options.from ?? "WGS84"),
+    to: capture(options.to ?? "WGS84")
+  };
+  const [from, to] = await Promise.all([
+    prepareCRSInput(captured.from, captured),
+    prepareCRSInput(captured.to, captured)
+  ]);
+  return { ...captured, from, to };
+}
+async function prepareCRSInput(captured, options) {
+  var _a2;
+  const source = resolveCRSInput(captured, options);
+  const local = resolveLocalCRSDefinition(source.definition, options);
+  const reference = typeof captured === "string" || "type" in captured ? void 0 : "crs" in captured ? captured.crs : captured;
+  const representation = local === source.definition && reference ? reference.representation : inferCRSRepresentation(local);
+  if (representation !== "identifier" || ((_a2 = options.parsers) == null ? void 0 : _a2.some((p) => p.canParse(local)))) {
+    return captured;
+  }
+  const result = await options.resolver.resolve({
+    state: "explicit",
+    provenance: (reference == null ? void 0 : reference.provenance) ?? "unknown",
+    definition: local,
+    representation
+  });
+  const definition = resolveCRSInput(result.input, options).definition;
+  if (!reference)
+    return definition;
+  const metadata = captured;
+  const resolved2 = {
+    ...reference,
+    definition,
+    representation: inferCRSRepresentation(definition),
+    alternatives: [
+      { definition: reference.definition, representation: reference.representation },
+      ...reference.alternatives ?? []
+    ]
+  };
+  return "crs" in metadata ? { ...metadata, crs: resolved2 } : resolved2;
+}
+function capture(input) {
+  return typeof input === "string" ? input : JSON.parse(JSON.stringify(input));
+}
+
+// dist/projection/experimental/projection-engine.js
+var ConfigurableProjectionEngine = class {
+  constructor(options = {}) {
+    this.options = snapshotEngineOptions(options);
+    this.useDefinitionSignature = !hasCRSOverrides(options);
+  }
+  /** Resolve a CRS and load only its required algorithms before exposing sync conversions. */
+  getCRS(definition, options = {}) {
+    return resolveCRSDescriptor(this, definition, this.options, options, this.useDefinitionSignature, this.options.resolver ? prepareCRSInput : void 0);
+  }
+  /** Compile a CRS pair. Lazy descriptors remain unloaded until the transform is used. */
+  createProjection(options = {}) {
+    return new ProjectionTransform({ ...this.options, ...options });
+  }
+  /** Load only the algorithms required by this CRS pair and return a synchronous transform. */
+  async createProjectionAsync(options = {}) {
+    const config = { ...this.options, ...options };
+    return ProjectionTransform.create(config.resolver ? await prepareEngineOptions(config) : config);
+  }
+};
+function createProjectionEngine(options = {}) {
+  return new ConfigurableProjectionEngine(options);
+}
+//# sourceMappingURL=core.cjs.map