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

package/dist/projection/experimental/crs/wkt.cjs

@@ -0,0 +1,1229 @@
+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 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/projection/experimental/crs/wkt.js
+var wkt_exports = {};
+__export(wkt_exports, {
+  wktCRSParser: () => wktCRSParser
+});
+module.exports = __toCommonJS(wkt_exports);
+
+// 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/wkt-crs.js
+var WKTCRSSyntaxError = class extends SyntaxError {
+  /** Create a WKT syntax error at a source location. */
+  constructor(message, source, offset) {
+    const location = getSourceLocation(source, offset);
+    super(`${message} at ${location.line}:${location.column}`);
+    this.name = "WKTCRSSyntaxError";
+    this.offset = offset;
+    this.line = location.line;
+    this.column = location.column;
+  }
+};
+var WKTCRSValidationError = class extends Error {
+  /** Create an error from one or more validation issues. */
+  constructor(issues) {
+    var _a2;
+    super(((_a2 = issues[0]) == null ? void 0 : _a2.message) || "WKT validation failed");
+    this.name = "WKTCRSValidationError";
+    this.issues = issues;
+  }
+};
+var NUMBER_PATTERN = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[Ee][+-]?\d+)?$/;
+var KEYWORD_PATTERN = /^[A-Za-z][A-Za-z0-9_]*/;
+var WKT1_ROOT_KEYWORDS = /* @__PURE__ */ new Set([
+  "COMPD_CS",
+  "CONCAT_MT",
+  "FITTED_CS",
+  "GEOCCS",
+  "GEOGCS",
+  "INVERSE_MT",
+  "LOCAL_CS",
+  "PARAM_MT",
+  "PASSTHROUGH_MT",
+  "PROJCS",
+  "VERT_CS"
+]);
+var WKT1_KEYWORDS = /* @__PURE__ */ new Set([
+  ...WKT1_ROOT_KEYWORDS,
+  "AUTHORITY",
+  "AXIS",
+  "CONCAT_MT",
+  "DATUM",
+  "INVERSE_MT",
+  "LOCAL_DATUM",
+  "PARAMETER",
+  "PARAM_MT",
+  "PASSTHROUGH_MT",
+  "PRIMEM",
+  "PROJECTION",
+  "SPHEROID",
+  "TOWGS84",
+  "UNIT",
+  "VERT_DATUM"
+]);
+var GDAL_WKT1_ROOT_KEYWORDS = new Set(WKT1_ROOT_KEYWORDS);
+var GDAL_WKT1_KEYWORDS = /* @__PURE__ */ new Set([...WKT1_KEYWORDS, "EXTENSION"]);
+var ESRI_WKT1_ROOT_KEYWORDS = /* @__PURE__ */ new Set([...WKT1_ROOT_KEYWORDS, "COMPDCS", "LOCALCS", "VERTCS"]);
+var ESRI_WKT1_KEYWORDS = /* @__PURE__ */ new Set([...WKT1_KEYWORDS, "COMPDCS", "LOCALCS", "VDATUM", "VERTCS"]);
+var WKT2_2015_ROOT_KEYWORDS = /* @__PURE__ */ new Set([
+  "BOUNDCRS",
+  "COMPOUNDCRS",
+  "COORDINATEOPERATION",
+  "ENGCRS",
+  "ENGINEERINGCRS",
+  "GEODCRS",
+  "GEODETICCRS",
+  "PARAMETRICCRS",
+  "PROJCRS",
+  "PROJECTEDCRS",
+  "TIMECRS",
+  "VERTCRS",
+  "VERTICALCRS"
+]);
+var WKT2_2019_ROOT_KEYWORDS = /* @__PURE__ */ new Set([
+  ...WKT2_2015_ROOT_KEYWORDS,
+  "CONCATENATEDOPERATION",
+  "COORDINATEMETADATA",
+  "DERIVEDPROJCRS",
+  "GEOGCRS",
+  "GEOGRAPHICCRS",
+  "POINTMOTIONOPERATION"
+]);
+var WKT2_KEYWORDS = /* @__PURE__ */ new Set([
+  ...WKT2_2019_ROOT_KEYWORDS,
+  "ABRIDGEDTRANSFORMATION",
+  "ANCHOR",
+  "ANGLEUNIT",
+  "AREA",
+  "AXIS",
+  "BASEENGCRS",
+  "BASEGEODCRS",
+  "BASEGEOGCRS",
+  "BASEPARAMCRS",
+  "BASEPROJCRS",
+  "BASETIMECRS",
+  "BASEVERTCRS",
+  "BBOX",
+  "BEARING",
+  "CALENDAR",
+  "CITATION",
+  "CONVERSION",
+  "COORDEPOCH",
+  "CS",
+  "DATUM",
+  "DERIVINGCONVERSION",
+  "DYNAMIC",
+  "EDATUM",
+  "ELLIPSOID",
+  "ENGINEERINGDATUM",
+  "ENSEMBLE",
+  "ENSEMBLEACCURACY",
+  "EPOCH",
+  "FRAMEEPOCH",
+  "GEODETICDATUM",
+  "GEOIDMODEL",
+  "ID",
+  "INTERPOLATIONCRS",
+  "LENGTHUNIT",
+  "MEMBER",
+  "MERIDIAN",
+  "METHOD",
+  "MODEL",
+  "OPERATIONACCURACY",
+  "ORDER",
+  "PARAMETER",
+  "PARAMETERFILE",
+  "PARAMETRICDATUM",
+  "PARAMETRICUNIT",
+  "PDATUM",
+  "PRIMEM",
+  "PRIMEMERIDIAN",
+  "REMARK",
+  "SCALEUNIT",
+  "SCOPE",
+  "SOURCECRS",
+  "STEP",
+  "TARGETCRS",
+  "TDATUM",
+  "TEMPORALQUANTITY",
+  "TIMEEXTENT",
+  "TIMEORIGIN",
+  "TIMEUNIT",
+  "TIMEDATUM",
+  "TRIAXIAL",
+  "TRF",
+  "URI",
+  "USAGE",
+  "VDATUM",
+  "VERSION",
+  "VERTICALDATUM",
+  "VERTICALEXTENT",
+  "VELOCITYGRID",
+  "VRF"
+]);
+var WKT2_2019_ADDITION_KEYWORDS = /* @__PURE__ */ new Set([
+  "BASEGEOGCRS",
+  "CALENDAR",
+  "CONCATENATEDOPERATION",
+  "COORDEPOCH",
+  "COORDINATEMETADATA",
+  "DERIVEDPROJCRS",
+  "DYNAMIC",
+  "ENSEMBLE",
+  "ENSEMBLEACCURACY",
+  "EPOCH",
+  "FRAMEEPOCH",
+  "GEOGCRS",
+  "GEOGRAPHICCRS",
+  "GEOIDMODEL",
+  "MEMBER",
+  "MODEL",
+  "POINTMOTIONOPERATION",
+  "STEP",
+  "TEMPORALQUANTITY",
+  "TRF",
+  "TRIAXIAL",
+  "VELOCITYGRID",
+  "VRF"
+]);
+var WKT2_2015_KEYWORDS = new Set([...WKT2_KEYWORDS].filter((keyword) => !WKT2_2019_ADDITION_KEYWORDS.has(keyword)));
+var PROFILE_ROOT_KEYWORDS = {
+  wkt1: WKT1_ROOT_KEYWORDS,
+  gdal: GDAL_WKT1_ROOT_KEYWORDS,
+  esri: ESRI_WKT1_ROOT_KEYWORDS,
+  "wkt2:2015": WKT2_2015_ROOT_KEYWORDS,
+  "wkt2:2019": WKT2_2019_ROOT_KEYWORDS
+};
+var PROFILE_KEYWORDS = {
+  wkt1: WKT1_KEYWORDS,
+  gdal: GDAL_WKT1_KEYWORDS,
+  esri: ESRI_WKT1_KEYWORDS,
+  "wkt2:2015": WKT2_2015_KEYWORDS,
+  "wkt2:2019": WKT2_KEYWORDS
+};
+function parseWKTCRS(text, options) {
+  const parser = new WKTParser(text);
+  const ast = { type: "wkt-crs", root: parser.parse() };
+  if (options == null ? void 0 : options.strict) {
+    const issues = validateWKTCRS(ast, {
+      profile: options.profile,
+      allowExtensions: false
+    });
+    if (issues.length > 0) {
+      throw new WKTCRSValidationError(issues);
+    }
+  }
+  return ast;
+}
+function validateWKTCRS(ast, options) {
+  var _a2;
+  if (!ast || ast.type !== "wkt-crs" || ((_a2 = ast.root) == null ? void 0 : _a2.type) !== "node") {
+    throw new TypeError("validateWKTCRS expects a WKTCRSAst");
+  }
+  const profile = resolveProfile(ast.root.keyword, (options == null ? void 0 : options.profile) || "auto");
+  const rootKeywords = PROFILE_ROOT_KEYWORDS[profile];
+  const knownKeywords = PROFILE_KEYWORDS[profile];
+  const issues = [];
+  const rootKeyword = ast.root.keyword.toUpperCase();
+  if (!rootKeywords.has(rootKeyword)) {
+    issues.push({
+      code: "invalid-root",
+      message: `${ast.root.keyword} is not a ${profile} root keyword`,
+      path: [],
+      keyword: ast.root.keyword
+    });
+  }
+  visitNode(ast.root, [], (node) => {
+    const keyword = node.node.keyword.toUpperCase();
+    if (!(options == null ? void 0 : options.allowExtensions) && !knownKeywords.has(keyword)) {
+      issues.push({
+        code: "unknown-keyword",
+        message: `${node.node.keyword} is not defined by the ${profile} profile`,
+        path: node.path,
+        keyword: node.node.keyword
+      });
+    }
+    if (node.node.values.length === 0) {
+      issues.push({
+        code: "empty-node",
+        message: `${node.node.keyword} must contain at least one value`,
+        path: node.path,
+        keyword: node.node.keyword
+      });
+    }
+    const grammarMessage = validateNodeValues(node.node);
+    if (grammarMessage) {
+      issues.push({
+        code: "invalid-value",
+        message: grammarMessage,
+        path: node.path,
+        keyword: node.node.keyword
+      });
+    }
+  });
+  return issues;
+}
+var WKTParser = class {
+  constructor(source) {
+    this.offset = 0;
+    this.source = source;
+  }
+  parse() {
+    this.skipWhitespace();
+    const root = this.parseNode();
+    this.skipWhitespace();
+    if (this.offset !== this.source.length) {
+      this.fail("Unexpected content after WKT root");
+    }
+    return root;
+  }
+  parseNode() {
+    const keyword = this.parseKeyword();
+    return this.parseNodeAfterKeyword(keyword);
+  }
+  parseNodeAfterKeyword(keyword) {
+    this.skipWhitespace();
+    const opening = this.source[this.offset];
+    if (opening !== "[" && opening !== "(") {
+      this.fail(`Expected '[' or '(' after ${keyword}`);
+    }
+    this.offset++;
+    const delimiter = opening === "[" ? "bracket" : "parenthesis";
+    const closing = opening === "[" ? "]" : ")";
+    const values = [];
+    this.skipWhitespace();
+    if (this.source[this.offset] === closing) {
+      this.offset++;
+      return { type: "node", keyword, delimiter, values };
+    }
+    while (this.offset < this.source.length) {
+      values.push(this.parseValue());
+      this.skipWhitespace();
+      const character = this.source[this.offset];
+      if (character === ",") {
+        this.offset++;
+        this.skipWhitespace();
+        if (this.source[this.offset] === closing) {
+          this.fail("Expected a WKT value after comma");
+        }
+        continue;
+      }
+      if (character === closing) {
+        this.offset++;
+        return { type: "node", keyword, delimiter, values };
+      }
+      if (character === "]" || character === ")") {
+        this.fail(`Expected '${closing}' to close ${keyword}`);
+      }
+      this.fail(`Expected ',' or '${closing}' in ${keyword}`);
+    }
+    this.fail(`Unterminated ${keyword} node`);
+  }
+  parseValue() {
+    this.skipWhitespace();
+    const character = this.source[this.offset];
+    if (character === '"') {
+      return this.parseString();
+    }
+    const start = this.offset;
+    while (this.offset < this.source.length && !/[\s,\[\]()"]/.test(this.source[this.offset])) {
+      this.offset++;
+    }
+    if (start === this.offset) {
+      this.fail("Expected a WKT value");
+    }
+    const value2 = this.source.slice(start, this.offset);
+    if (this.source[this.offset] === '"') {
+      this.fail("Unexpected quote in unquoted WKT value");
+    }
+    this.skipWhitespace();
+    if (this.source[this.offset] === "[" || this.source[this.offset] === "(") {
+      if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(value2)) {
+        this.fail(`Invalid WKT keyword '${value2}'`);
+      }
+      return this.parseNodeAfterKeyword(value2);
+    }
+    if (NUMBER_PATTERN.test(value2)) {
+      return { type: "number", value: Number(value2), raw: value2 };
+    }
+    return { type: "enumeration", value: value2 };
+  }
+  parseKeyword() {
+    const match = this.source.slice(this.offset).match(KEYWORD_PATTERN);
+    if (!match) {
+      this.fail("Expected a WKT keyword");
+    }
+    this.offset += match[0].length;
+    return match[0];
+  }
+  parseString() {
+    this.offset++;
+    let value2 = "";
+    while (this.offset < this.source.length) {
+      const character = this.source[this.offset++];
+      if (character === '"') {
+        if (this.source[this.offset] === '"') {
+          value2 += '"';
+          this.offset++;
+          continue;
+        }
+        return { type: "string", value: value2 };
+      }
+      value2 += character;
+    }
+    this.fail("Unterminated WKT string");
+  }
+  skipWhitespace() {
+    while (this.offset < this.source.length && /\s/.test(this.source[this.offset])) {
+      this.offset++;
+    }
+  }
+  fail(message) {
+    throw new WKTCRSSyntaxError(message, this.source, this.offset);
+  }
+};
+function resolveProfile(rootKeyword, profile) {
+  if (profile !== "auto") {
+    return profile;
+  }
+  return WKT1_ROOT_KEYWORDS.has(rootKeyword.toUpperCase()) ? "wkt1" : "wkt2:2019";
+}
+function validateNodeValues(node) {
+  const keyword = node.keyword.toUpperCase();
+  const values = node.values;
+  const typeAt = (index, ...types) => Boolean(values[index] && types.includes(values[index].type));
+  const exact = (length, ...types) => values.length === length && types.every((type, index) => typeAt(index, type));
+  if ([
+    "ANGLEUNIT",
+    "LENGTHUNIT",
+    "PARAMETRICUNIT",
+    "SCALEUNIT",
+    "TIMEUNIT",
+    "TEMPORALQUANTITY",
+    "UNIT"
+  ].includes(keyword) && !(values.length >= 2 && typeAt(0, "string") && typeAt(1, "number"))) {
+    return `${node.keyword} must start with a quoted name and numeric conversion factor`;
+  }
+  if (keyword === "CS" && !exact(2, "enumeration", "number")) {
+    return `${node.keyword} must contain a coordinate-system type and dimension`;
+  }
+  if (keyword === "BBOX" && !exact(4, "number", "number", "number", "number")) {
+    return `${node.keyword} must contain four numeric bounds`;
+  }
+  if ([
+    "ENSEMBLEACCURACY",
+    "EPOCH",
+    "COORDEPOCH",
+    "FRAMEEPOCH",
+    "OPERATIONACCURACY",
+    "ORDER"
+  ].includes(keyword) && !exact(1, "number")) {
+    return `${node.keyword} must contain one number`;
+  }
+  if (["ANCHOR", "AREA", "CALENDAR", "CITATION", "REMARK", "SCOPE", "URI", "VERSION"].includes(keyword) && !exact(1, "string")) {
+    return `${node.keyword} must contain one quoted string`;
+  }
+  if (["ELLIPSOID", "SPHEROID", "TRIAXIAL"].includes(keyword) && !(values.length >= 3 && typeAt(0, "string") && typeAt(1, "number") && typeAt(2, "number"))) {
+    return `${node.keyword} must start with a quoted name and numeric ellipsoid axes`;
+  }
+  if (["PARAMETER"].includes(keyword) && !(values.length >= 2 && typeAt(0, "string") && typeAt(1, "number"))) {
+    return `${node.keyword} must start with a quoted name and numeric value`;
+  }
+  if (keyword === "PARAMETERFILE" && !exact(2, "string", "string")) {
+    return `${node.keyword} must contain a quoted name and file name`;
+  }
+  if (["AUTHORITY", "ID"].includes(keyword) && !(values.length >= 2 && typeAt(0, "string") && typeAt(1, "string", "number"))) {
+    return `${node.keyword} must start with a quoted authority and identifier`;
+  }
+  if (["AXIS"].includes(keyword) && !(values.length >= 2 && typeAt(0, "string") && typeAt(1, "enumeration"))) {
+    return `${node.keyword} must start with a quoted name and axis direction`;
+  }
+  if (["METHOD", "PROJECTION"].includes(keyword) && !(values.length >= 1 && typeAt(0, "string"))) {
+    return `${node.keyword} must start with a quoted name`;
+  }
+  if (keyword === "TIMEEXTENT") {
+    const isTemporalValue = (index) => typeAt(index, "enumeration", "string");
+    if (values.length !== 2 || !isTemporalValue(0) || !isTemporalValue(1)) {
+      return `${node.keyword} must contain two date-time or quoted values`;
+    }
+  }
+  if (keyword === "VERTICALEXTENT") {
+    if (values.length < 2 || values.length > 3 || !typeAt(0, "number") || !typeAt(1, "number") || values.length === 3 && !typeAt(2, "node")) {
+      return `${node.keyword} must contain two numeric bounds and an optional unit`;
+    }
+  }
+  if (keyword === "COORDINATEMETADATA") {
+    if (values.length < 1 || values.length > 2 || !typeAt(0, "node") || values.length === 2 && (!typeAt(1, "node") || !["EPOCH", "COORDEPOCH"].includes(values[1].keyword.toUpperCase()))) {
+      return `${node.keyword} must contain a CRS and an optional coordinate epoch`;
+    }
+  }
+  if (keyword === "BOUNDCRS") {
+    const childKeywords = values.slice(0, 3).map((value2) => value2.type === "node" ? value2.keyword.toUpperCase() : "");
+    if (childKeywords[0] !== "SOURCECRS" || childKeywords[1] !== "TARGETCRS" || childKeywords[2] !== "ABRIDGEDTRANSFORMATION") {
+      return `${node.keyword} must start with SOURCECRS, TARGETCRS, and ABRIDGEDTRANSFORMATION`;
+    }
+  }
+  if ([
+    "COMPOUNDCRS",
+    "CONCATENATEDOPERATION",
+    "COORDINATEOPERATION",
+    "DERIVEDPROJCRS",
+    "ENGCRS",
+    "ENGINEERINGCRS",
+    "GEODCRS",
+    "GEODETICCRS",
+    "GEOGCRS",
+    "GEOGRAPHICCRS",
+    "PARAMETRICCRS",
+    "POINTMOTIONOPERATION",
+    "PROJCRS",
+    "PROJECTEDCRS",
+    "TIMECRS",
+    "VERTCRS",
+    "VERTICALCRS"
+  ].includes(keyword) && !typeAt(0, "string")) {
+    return `${node.keyword} must start with a quoted name`;
+  }
+  return null;
+}
+function visitNode(node, path, visitor) {
+  visitor({ node, path });
+  for (let index = 0; index < node.values.length; index++) {
+    const value2 = node.values[index];
+    if (value2.type === "node") {
+      visitNode(value2, [...path, index], visitor);
+    }
+  }
+}
+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)](value2) {
+    if (this !== _TypeScriptCRSError)
+      return Function.prototype[Symbol.hasInstance].call(this, value2);
+    return value2 instanceof Error && value2[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/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 key2 = datumNameKey(name);
+      if (!key2 || key2 === "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(key2);
+      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(key2, { definition, owner });
+      definitions[name] = definition;
+    }
+  });
+  resolved.set(options, { catalogs: options.datumCatalogs, definitions });
+  return definitions;
+}
+
+// dist/projection/experimental/parameters.js
+var DEGREES_TO_RADIANS = Math.PI / 180;
+
+// dist/projection/experimental/crs/structured.js
+function object(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2))
+    throw new Error("Expected a CRS object");
+  return value2;
+}
+function array(value2) {
+  return Array.isArray(value2) ? value2 : [];
+}
+function key(value2) {
+  return String(value2 || "").toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function finite(value2) {
+  if (typeof value2 !== "number" || !Number.isFinite(value2))
+    throw new Error("Expected a finite CRS parameter");
+  return value2;
+}
+function unit(value2, fallback) {
+  if (value2 === void 0)
+    return fallback;
+  if (typeof value2 === "object") {
+    const factor2 = finite(object(value2)["conversion_factor"]);
+    if (factor2 <= 0)
+      throw new Error("Unit conversion factor must be positive");
+    return factor2;
+  }
+  const factors = {
+    metre: 1,
+    meter: 1,
+    degree: DEGREES_TO_RADIANS,
+    radian: 1,
+    grad: Math.PI / 200,
+    gon: Math.PI / 200,
+    foot: 0.3048,
+    ussurveyfoot: 1200 / 3937,
+    kilometre: 1e3,
+    arcsecond: DEGREES_TO_RADIANS / 3600,
+    partspermillion: 1e-6,
+    unity: 1
+  };
+  const factor = factors[key(value2)];
+  if (!factor)
+    unsupportedStage("Unsupported CRS unit: " + String(value2));
+  return factor;
+}
+var METHODS = {
+  hotineobliquemercator: "omerc",
+  hotineobliquemercatorvarianta: "omerc",
+  hotineobliquemercatorvariantb: "omerc",
+  hotineobliquemercatorazimuthnaturalorigin: "omerc",
+  hotineobliquemercatorazimuthcenter: "omerc",
+  obliquemercator: "omerc",
+  krovak: "krovak",
+  krovaknorthorientated: "krovak",
+  quadrilateralizedsphericalcube: "qsc",
+  transversemercator: "tmerc",
+  transversemercatorsouthorientated: "unsupported-south-tmerc",
+  mercator: "merc",
+  mercator1sp: "merc",
+  mercator2sp: "merc",
+  mercatorvarianta: "merc",
+  mercatorvariantb: "merc",
+  mercatorauxiliarysphere: "webmerc",
+  popularvisualisationpseudomercator: "webmerc",
+  lambertconformalconic: "lcc",
+  lambertconformalconic1sp: "lcc",
+  lambertconformalconic2sp: "lcc",
+  lambertconicconformal1sp: "lcc",
+  lambertconicconformal2sp: "lcc",
+  albers: "aea",
+  albersconicequalarea: "aea",
+  albersequalarea: "aea",
+  equidistantconic: "eqdc",
+  lambertazimuthalequalarea: "laea",
+  stereographic: "stere",
+  stereographicnorthpole: "sterea",
+  stereographicsouthpole: "stere",
+  polarstereographic: "stere",
+  polarstereographicvarianta: "stere",
+  polarstereographicvariantb: "stere",
+  obliquestereographic: "sterea",
+  doublestereographic: "sterea",
+  azimuthalequidistant: "aeqd",
+  modifiedazimuthalequidistant: "aeqd",
+  equidistantcylindrical: "eqc",
+  equidistantcylindricalspherical: "eqc",
+  equirectangular: "eqc",
+  platecarree: "eqc",
+  bonne: "bonne",
+  cassinisoldner: "cass",
+  cassini: "cass",
+  cylindricalequalarea: "cea",
+  lambertcylindricalequalarea: "cea",
+  eckertvi: "eck6",
+  equalearth: "eqearth",
+  millercylindrical: "mill",
+  mollweide: "moll",
+  robinson: "robin",
+  sinusoidal: "sinu",
+  vandergrinten: "vandg",
+  vandergrinteni: "vandg",
+  gnomonic: "gnom",
+  orthographic: "ortho",
+  polyconic: "poly",
+  americanpolyconic: "poly",
+  newzealandmapgrid: "nzmg",
+  gaussschreibertransversemercator: "gstmerc"
+};
+var PARAMETERS = {
+  centralmeridian: "lon_0",
+  longitudeoforigin: "lon_0",
+  longitudeofcenter: "lon_0",
+  longitudeofnaturalorigin: "lon_0",
+  longitudeoffalseorigin: "lon_0",
+  longitudeofprojectioncentre: "lon_0",
+  straightverticalpolelongitude: "lon_0",
+  longitudeoforiginmeridian: "lon_0",
+  latitudeoforigin: "lat_0",
+  latitudeofcenter: "lat_0",
+  latitudeofnaturalorigin: "lat_0",
+  latitudeoffalseorigin: "lat_0",
+  latitudeofprojectioncentre: "lat_0",
+  standardparallel1: "lat_1",
+  latitudeof1ststandardparallel: "lat_1",
+  standardparallel2: "lat_2",
+  latitudeof2ndstandardparallel: "lat_2",
+  latitudeofstandardparallel: "lat_ts",
+  scalefactor: "k_0",
+  scalefactoratnaturalorigin: "k_0",
+  scalefactoratprojectionorigin: "k_0",
+  falseeasting: "x_0",
+  falsenorthing: "y_0",
+  eastingatfalseorigin: "x_0",
+  northingatfalseorigin: "y_0"
+};
+var METHOD_PARAMETERS = {
+  omerc: {
+    longitudeofcenter: "lonc",
+    longitudeofprojectioncentre: "lonc",
+    azimuth: "alpha",
+    azimuthatprojectioncentre: "alpha",
+    rectifiedgridangle: "gamma",
+    anglefromrectifiedtoskewgrid: "gamma",
+    scalefactoratprojectioncentre: "k_0",
+    eastingatprojectioncentre: "x_0",
+    northingatprojectioncentre: "y_0"
+  },
+  krovak: {
+    azimuth: "alpha",
+    colatitudeofconeaxis: "alpha",
+    pseudostandardparallel1: "lat_ts",
+    latitudeofpseudostandardparallel: "lat_ts",
+    scalefactoronpseudostandardparallel: "k_0"
+  }
+};
+var DIRECTIONS = {
+  east: "e",
+  west: "w",
+  north: "n",
+  south: "s",
+  up: "u",
+  down: "d",
+  geocentricx: "e",
+  geocentricy: "n",
+  geocentricz: "u"
+};
+function readStructuredCRS(crs, options) {
+  var _a2, _b, _c;
+  const type = String(crs["type"]);
+  const areaOfUse = readAreaOfUse(crs["bbox"]);
+  if (type === "CompoundCRS") {
+    if (options.mode !== "horizontal")
+      unsupportedStage("CompoundCRS requires explicit horizontal extraction");
+    const components = array(crs["components"]).map(object).filter((value2) => ["ProjectedCRS", "GeographicCRS", "GeodeticCRS", "BoundCRS"].includes(String(value2["type"])));
+    if (components.length !== 1)
+      throw new Error("CompoundCRS requires exactly one horizontal component");
+    const component = readStructuredCRS(components[0], options);
+    return { ...component, areaOfUse: areaOfUse ?? component.areaOfUse, lossy: true };
+  }
+  if (type === "BoundCRS") {
+    const source = readStructuredCRS(object(crs["source_crs"]), options);
+    const target = readStructuredCRS(object(crs["target_crs"]), options);
+    if (target.parameters["datum"] !== "WGS84" || !["longlat", "geocent"].includes(target.parameters["proj"]) || Number(target.parameters["pm"] || 0) !== 0 || target.parameters["towgs84"] || Number(target.parameters["a"]) !== 6378137 || !(Math.abs(Number(target.parameters["rf"]) - 298.257223563) <= 1e-9 || Math.abs(Number(target.parameters["b"]) - 6356752314245179e-9) <= 1e-6))
+      unsupportedStage("BoundCRS requires a WGS84 target");
+    const operation2 = object(crs["transformation"]);
+    const method = key(object(operation2["method"])["name"]);
+    const translation = method === "geocentrictranslations" || /^geocentrictranslationsgeog[23]ddomain$/.test(method);
+    const position = /^positionvector(?:transformation)?(?:geog[23]ddomain|geocentricdomain)?$/.test(method);
+    const frame = /^coordinateframe(?:rotation)?(?:geog[23]ddomain|geocentricdomain)?$/.test(method);
+    if (!translation && !position && !frame)
+      unsupportedStage("Unsupported BoundCRS transformation: " + method);
+    const names2 = [
+      "xaxistranslation",
+      "yaxistranslation",
+      "zaxistranslation",
+      "xaxisrotation",
+      "yaxisrotation",
+      "zaxisrotation",
+      "scaledifference"
+    ];
+    const values = new Array(translation ? 3 : 7).fill(void 0);
+    for (const entry of array(operation2["parameters"])) {
+      const parameter = object(entry), index = names2.indexOf(key(parameter["name"]));
+      if (index < 0 || index >= values.length || values[index] !== void 0)
+        unsupportedStage("Unsupported or duplicate Helmert parameter: " + String(parameter["name"]));
+      const base2 = index < 3 ? 1 : index < 6 ? DEGREES_TO_RADIANS / 3600 : 1e-6;
+      values[index] = finite(parameter["value"]) * unit(parameter["unit"], base2) / base2 * (frame && index >= 3 && index < 6 ? -1 : 1);
+    }
+    if (values.some((value2) => value2 === void 0))
+      throw new Error("Incomplete BoundCRS Helmert transformation");
+    const parameters2 = {
+      ...source.parameters,
+      towgs84: values.join(",")
+    };
+    delete parameters2["datum"];
+    return { ...source, parameters: parameters2, areaOfUse: areaOfUse ?? source.areaOfUse };
+  }
+  if (!["ProjectedCRS", "GeographicCRS", "GeodeticCRS"].includes(type))
+    unsupportedStage("Unsupported CRS type: " + type);
+  const base = type === "ProjectedCRS" ? object(crs["base_crs"]) : crs;
+  const datum = object(base["datum"] || base["datum_ensemble"]);
+  if (datum["type"] === "DynamicGeodeticReferenceFrame" || datum["frame_reference_epoch"] !== void 0 || crs["coordinate_epoch"] !== void 0)
+    unsupportedStage("Time-dependent datum transformations are not implemented");
+  const ellipsoid = object(datum["ellipsoid"]);
+  const major = finite(ellipsoid["semi_major_axis"] ?? ellipsoid["radius"]);
+  const parameters = {
+    proj: "longlat",
+    a: String(major * unit(ellipsoid["unit"], 1))
+  };
+  if (ellipsoid["inverse_flattening"] !== void 0)
+    parameters["rf"] = String(finite(ellipsoid["inverse_flattening"]));
+  else if (ellipsoid["semi_minor_axis"] !== void 0)
+    parameters["b"] = String(finite(ellipsoid["semi_minor_axis"]) * unit(ellipsoid["unit"], 1));
+  else if (ellipsoid["radius"] !== void 0)
+    parameters["b"] = parameters["a"];
+  else
+    throw new Error("Ellipsoid requires inverse flattening or semi-minor axis");
+  const datums = getDatumDefinitions(options);
+  const rawDatumName = String(datum["name"] || "");
+  const datumName = key(rawDatumName);
+  const names = Object.keys(datums);
+  const exactDatum = names.find((name) => datumNameKey(name) === datumNameKey(rawDatumName));
+  const matches = exactDatum ? [exactDatum] : names.filter((name) => key(name) === datumName || key(name) === datumName.replace(/^d/, ""));
+  const namedDatum = matches[0];
+  const first = datums[namedDatum];
+  if (first && matches.some((name) => {
+    const candidate = datums[name];
+    return candidate.ellipse !== first.ellipse || candidate.towgs84 !== first.towgs84 || candidate.nadgrids !== first.nadgrids;
+  }))
+    throw new Error("Ambiguous structured datum name: " + rawDatumName);
+  if (datumName)
+    parameters["datum"] = namedDatum || rawDatumName;
+  if (namedDatum && datumNameKey(namedDatum) === "wgs84")
+    parameters["datum"] = "WGS84";
+  if (namedDatum && ["nad83", "northamericandatum1983"].includes(datumNameKey(namedDatum)))
+    parameters["datum"] = "NAD83";
+  if (!namedDatum) {
+    if ([
+      "wgs84",
+      "worldgeodeticsystem1984",
+      "worldgeodeticsystem1984ensemble",
+      "dwgs1984",
+      "wgs1984"
+    ].includes(datumName))
+      parameters["datum"] = "WGS84";
+    if (["nad83", "northamericandatum1983", "dnorthamerican1983"].includes(datumName))
+      parameters["datum"] = "NAD83";
+    if (["nad27", "northamericandatum1927", "dnorthamerican1927"].includes(datumName))
+      parameters["datum"] = "NAD27";
+    const datumAlias = {
+      newzealand1949: "nzgd49",
+      belge1972: "rnb72"
+    };
+    const alias = datumAlias[datumName.replace(/^d/, "")];
+    if (alias)
+      parameters["datum"] = alias;
+  }
+  if (type === "ProjectedCRS" && base["id"]) {
+    const id = object(base["id"]);
+    const authorityDatum = String(id["authority"]) + "_" + String(id["code"]);
+    if (Object.prototype.hasOwnProperty.call(datums, authorityDatum))
+      parameters["datum"] = authorityDatum;
+  }
+  if (datum["towgs84"] !== void 0) {
+    parameters["towgs84"] = array(datum["towgs84"]).map(finite).join(",");
+    delete parameters["datum"];
+  }
+  const cs = crs["coordinate_system"] ? object(crs["coordinate_system"]) : {};
+  const axes = array(cs["axis"]).map(object);
+  const geocentric = key(cs["subtype"]) === "cartesian" && type === "GeodeticCRS";
+  if (type !== "ProjectedCRS" && !geocentric && cs["subtype"] && key(cs["subtype"]) !== "ellipsoidal")
+    unsupportedStage("Unsupported coordinate system subtype");
+  if (geocentric)
+    parameters["proj"] = "geocent";
+  const angularUnit = unit(base["angular_unit"], DEGREES_TO_RADIANS);
+  const factor = unit((_a2 = axes[0]) == null ? void 0 : _a2["unit"], type === "ProjectedCRS" || geocentric ? 1 : angularUnit);
+  if (axes[1] && unit(axes[1]["unit"], factor) !== factor)
+    unsupportedStage("Mixed horizontal axis units are not supported");
+  if (geocentric && axes[2] && unit(axes[2]["unit"], factor) !== factor)
+    unsupportedStage("Mixed geocentric axis units are not supported");
+  const pm = base["prime_meridian"] || datum["prime_meridian"];
+  if (pm) {
+    const meridian = object(pm);
+    parameters["pm"] = String(finite(meridian["longitude"]) * unit(meridian["unit"], angularUnit) / DEGREES_TO_RADIANS);
+  }
+  if (type === "ProjectedCRS") {
+    const conversion = object(crs["conversion"]), method = key(object(conversion["method"])["name"]);
+    const conversionParameters = array(conversion["parameters"]).map(object);
+    const polarTrueScale = method === "stereographicnorthpole" && !conversionParameters.some((parameter) => key(parameter["name"]).startsWith("scalefactor"));
+    const projection = polarTrueScale ? "stere" : METHODS[method];
+    const esriKrovak = conversionParameters.filter((parameter) => ["xscale", "yscale", "xyplanerotation"].includes(key(parameter["name"])));
+    if (esriKrovak.length) {
+      const expected = {
+        xscale: -1,
+        yscale: 1,
+        xyplanerotation: 90
+      };
+      if (projection !== "krovak" || esriKrovak.length !== 3 || new Set(esriKrovak.map((parameter) => key(parameter["name"]))).size !== 3 || esriKrovak.some((parameter) => {
+        const name = key(parameter["name"]);
+        const factor2 = name === "xyplanerotation" ? unit(parameter["unit"], angularUnit) / DEGREES_TO_RADIANS : unit(parameter["unit"], 1);
+        return Math.abs(finite(parameter["value"]) * factor2 - expected[name]) > 1e-10;
+      }))
+        unsupportedStage("Unsupported ESRI Krovak axis adjustment");
+    }
+    if (!projection || projection.startsWith("unsupported"))
+      unsupportedStage("Unsupported projection method: " + String(object(conversion["method"])["name"]));
+    parameters["proj"] = projection === "webmerc" ? "merc" : projection;
+    let hasSemiMinor = false;
+    for (const parameter of conversionParameters) {
+      const parameterName = key(parameter["name"]);
+      if (esriKrovak.includes(parameter))
+        continue;
+      if (parameterName === "auxiliaryspheretype" && projection === "webmerc" && parameter["value"] === 0)
+        continue;
+      if (parameterName === "semiminor" && projection === "webmerc") {
+        if (hasSemiMinor)
+          throw new Error("Duplicate conversion parameter: semi_minor");
+        hasSemiMinor = true;
+        const radius = finite(parameter["value"]) * unit(parameter["unit"], 1);
+        if (Math.abs(radius - Number(parameters["a"])) > 4 * Number.EPSILON * Number(parameters["a"]))
+          unsupportedStage("Pseudo-Mercator semi_minor must equal the semi-major axis");
+        continue;
+      }
+      let name = ((_b = METHOD_PARAMETERS[projection]) == null ? void 0 : _b[parameterName]) || PARAMETERS[parameterName];
+      if (!name)
+        unsupportedStage("Unsupported conversion parameter: " + String(parameter["name"]));
+      if (name === "lat_1" && method === "stereographicnorthpole" && !polarTrueScale)
+        name = "lat_0";
+      else if (name === "lat_1" && ["merc", "webmerc", "eqc", "stere", "cea"].includes(projection))
+        name = "lat_ts";
+      if (parameters[name] !== void 0)
+        throw new Error("Duplicate conversion parameter: " + name);
+      if (["merc", "webmerc"].includes(projection) && name === "lat_0" && parameter["value"] === 0)
+        continue;
+      const angle = name.startsWith("lat") || name.startsWith("lon") || name === "alpha" || name === "gamma";
+      const length = name === "x_0" || name === "y_0";
+      let converted = finite(parameter["value"]) * unit(parameter["unit"], angle ? angularUnit : length ? factor : 1) / (angle ? DEGREES_TO_RADIANS : 1);
+      if (name.startsWith("lat") && Math.abs(Math.abs(converted) - 90) <= 4 * Number.EPSILON * 90)
+        converted = Math.sign(converted) * 90;
+      parameters[name] = String(converted);
+    }
+    if (projection === "omerc" && [
+      "hotineobliquemercator",
+      "hotineobliquemercatorvarianta",
+      "hotineobliquemercatorazimuthnaturalorigin"
+    ].includes(method))
+      parameters["no_uoff"] = void 0;
+    if (projection === "omerc" && parameters["lon_0"] !== void 0 && parameters["lonc"] !== void 0) {
+      if (Math.abs(Number(parameters["lon_0"]) - Number(parameters["lonc"])) > 1e-10)
+        unsupportedStage("Oblique Mercator central meridian conflicts with projection centre");
+      delete parameters["lon_0"];
+    }
+    if (method === "stereographicnorthpole" && Math.abs(Number(parameters["lat_0"])) === 90)
+      parameters["proj"] = "stere";
+    if (projection === "lcc" && parameters["lat_1"] === void 0)
+      parameters["lat_1"] = parameters["lat_0"];
+    if (method === "polarstereographic" && parameters["lat_0"] !== void 0) {
+      if (parameters["lat_ts"] !== void 0)
+        throw new Error("Duplicate polar stereographic latitude of true scale");
+      parameters["lat_ts"] = parameters["lat_0"];
+      delete parameters["lat_0"];
+    }
+    if (projection === "stere" && (method.includes("polar") || method === "stereographicsouthpole" || polarTrueScale) && parameters["lat_0"] === void 0)
+      parameters["lat_0"] = Number(parameters["lat_ts"] || 90) < 0 ? "-90" : "90";
+    if (projection === "webmerc") {
+      parameters["b"] = parameters["a"];
+      delete parameters["rf"];
+      parameters["nadgrids"] = "@null";
+    }
+  }
+  let axis = axes.map((entry) => readAxisDirection(entry, parameters, type === "ProjectedCRS")).join("");
+  if (axis.length === 2)
+    axis += "u";
+  if (!geocentric && /[ud]/.test(axis.slice(0, 2)))
+    unsupportedStage("Structured CRS vertical-first axes require an explicit PROJ axis definition");
+  if (axis)
+    parameters["axis"] = axis;
+  if (type === "ProjectedCRS" || geocentric)
+    parameters["to_meter"] = String(factor);
+  return {
+    parameters,
+    areaOfUse,
+    angularUnit: type === "ProjectedCRS" || geocentric ? angularUnit : factor,
+    verticalUnit: geocentric ? 1 : unit((_c = axes[2]) == null ? void 0 : _c["unit"], 1)
+  };
+}
+function readAreaOfUse(bbox) {
+  let areaOfUse;
+  if (bbox !== void 0) {
+    const extent = object(bbox);
+    const west = finite(extent["west_longitude"]), south = finite(extent["south_latitude"]);
+    const east = finite(extent["east_longitude"]), north = finite(extent["north_latitude"]);
+    if (west < -180 || west > 180 || east < -180 || east > 180 || south < -90 || north > 90 || south >= north || west === east)
+      throw new Error("Invalid CRS geographic bounding box");
+    areaOfUse = [west, south, east, north];
+  }
+  return areaOfUse;
+}
+function readAxisDirection(entry, parameters, projected) {
+  var _a2;
+  let direction = String(entry["direction"]);
+  let meridian = entry["meridian"];
+  const along = /^(north|south) along ([+-]?(?:\d+(?:\.\d*)?|\.\d+)) deg(?: (east|west))?$/i.exec(direction);
+  if (along) {
+    if (meridian !== void 0)
+      throw new Error("Duplicate axis meridian");
+    direction = along[1];
+    meridian = {
+      longitude: Number(along[2]) * (((_a2 = along[3]) == null ? void 0 : _a2.toLowerCase()) === "west" ? -1 : 1)
+    };
+  }
+  if (meridian !== void 0) {
+    const latitude = Number(parameters["lat_0"]);
+    const north = latitude === 90;
+    if (!projected || parameters["proj"] !== "stere" || Math.abs(latitude) !== 90 || key(direction) !== (north ? "south" : "north"))
+      unsupportedStage("Axis meridians require an outward-facing polar stereographic axis");
+    const longitude = object(meridian)["longitude"];
+    const degrees = typeof longitude === "number" ? finite(longitude) : finite(object(longitude)["value"]) * unit(object(longitude)["unit"], DEGREES_TO_RADIANS) / DEGREES_TO_RADIANS;
+    const quarterTurns = finite((degrees - Number(parameters["lon_0"] || 0)) / 90);
+    if (Math.abs(quarterTurns - Math.round(quarterTurns)) > 1e-12)
+      unsupportedStage("Non-cardinal axis meridians require an orientation operation");
+    const quadrant = (Math.round(quarterTurns) % 4 + 4) % 4;
+    return (north ? "senw" : "nesw")[quadrant];
+  }
+  const result = DIRECTIONS[key(direction)];
+  if (!result)
+    unsupportedStage("Unsupported axis direction: " + direction);
+  return result;
+}
+
+// dist/projection/experimental/crs/wkt.js
+function children(node, ...names) {
+  return node.values.filter((value2) => value2.type === "node" && names.includes(value2.keyword.toUpperCase()));
+}
+function child(node, ...names) {
+  return children(node, ...names)[0];
+}
+function value(node, index = 0) {
+  const item = node.values[index];
+  return item && item.type !== "node" ? item.value : void 0;
+}
+function units(node) {
+  return node ? { name: value(node), conversion_factor: value(node, 1) } : void 0;
+}
+function legacyAxisDirection(axis, projected) {
+  const direction = value(axis, 1);
+  if (projected && String(direction).toLowerCase() === "unknown") {
+    const name = String(value(axis)).toLowerCase();
+    const match = /^(easting|northing|westing|southing)(?:\s*\([a-z]\))?$/.exec(name);
+    if (match)
+      return { easting: "east", northing: "north", westing: "west", southing: "south" }[match[1]];
+  }
+  return direction;
+}
+function axisMeridian(axis) {
+  const meridian = child(axis, "MERIDIAN");
+  if (!meridian)
+    return void 0;
+  return { longitude: { value: value(meridian), unit: units(child(meridian, "ANGLEUNIT")) } };
+}
+function operation(node) {
+  const method = child(node, "METHOD", "PROJECTION");
+  if (!method)
+    throw new Error("WKT conversion requires a METHOD or PROJECTION");
+  if (child(node, "PARAMETERFILE"))
+    unsupportedStage("Grid-based WKT operation is not implemented");
+  return {
+    method: { name: value(method) },
+    parameters: children(node, "PARAMETER").map((parameter) => ({
+      name: value(parameter),
+      value: value(parameter, 1),
+      unit: units(child(parameter, "ANGLEUNIT", "LENGTHUNIT", "SCALEUNIT"))
+    }))
+  };
+}
+function readWKT(node) {
+  const keyword = node.keyword.toUpperCase();
+  if (keyword === "COMPD_CS" || keyword === "COMPOUNDCRS") {
+    return {
+      type: "CompoundCRS",
+      components: children(node, "PROJCS", "PROJCRS", "GEOGCS", "GEOGCRS", "GEODCRS", "BOUNDCRS", "VERT_CS", "VERTCRS").map(readWKT)
+    };
+  }
+  if (keyword === "BOUNDCRS") {
+    const source = child(node, "SOURCECRS"), target = child(node, "TARGETCRS"), transform = child(node, "ABRIDGEDTRANSFORMATION");
+    if (!source || !target || !transform)
+      throw new Error("Incomplete WKT BoundCRS");
+    const root = (wrapper) => {
+      const entry = wrapper.values.find((value2) => value2.type === "node");
+      if (!entry)
+        throw new Error("Missing bound CRS component");
+      return entry;
+    };
+    const op = operation(transform);
+    const parameters = op["parameters"];
+    for (const parameter of parameters) {
+      if (String(parameter["name"]).toLowerCase() === "scale difference" && parameter["unit"] === void 0)
+        parameter["value"] = (Number(parameter["value"]) - 1) * 1e6;
+    }
+    return {
+      type: "BoundCRS",
+      source_crs: readWKT(root(source)),
+      target_crs: readWKT(root(target)),
+      transformation: op
+    };
+  }
+  if (["VERT_CS", "VERTCRS"].includes(keyword))
+    return { type: "VerticalCRS" };
+  const projected = ["PROJCS", "PROJCRS", "PROJECTEDCRS"].includes(keyword);
+  const geographic = [
+    "GEOGCS",
+    "GEOGCRS",
+    "GEODCRS",
+    "GEODETICCRS",
+    "GEOGRAPHICCRS",
+    "BASEGEOGCRS",
+    "BASEGEODCRS",
+    "GEOCCS"
+  ].includes(keyword);
+  if (!projected && !geographic)
+    unsupportedStage("Unsupported WKT CRS: " + keyword);
+  if (child(node, "DYNAMIC", "DERIVINGCONVERSION", "VELOCITYGRID", "EXTENSION"))
+    unsupportedStage("Unsupported WKT dynamic/extension operation");
+  const cs = child(node, "CS");
+  const geocentric = keyword === "GEOCCS" || String(value(cs || node)).toLowerCase() === "cartesian" && !projected;
+  const localUnit = child(node, projected || geocentric ? "LENGTHUNIT" : "ANGLEUNIT", "UNIT");
+  const axes = children(node, "AXIS").sort((a, b) => Number(value(child(a, "ORDER") || a)) - Number(value(child(b, "ORDER") || b))).map((axis, index) => ({
+    name: value(axis),
+    direction: keyword === "GEOCCS" ? ["geocentricX", "geocentricY", "geocentricZ"][index] : legacyAxisDirection(axis, projected),
+    unit: units(child(axis, "ANGLEUNIT", "LENGTHUNIT") || (!geocentric && !projected && /^(up|down)$/i.test(String(value(axis, 1))) ? void 0 : localUnit)),
+    meridian: axisMeridian(axis)
+  }));
+  if (!axes.length) {
+    for (const direction of geocentric ? ["geocentricX", "geocentricY", "geocentricZ"] : ["east", "north"])
+      axes.push({ name: direction, direction, unit: units(localUnit), meridian: void 0 });
+  }
+  const id = keyword === "GEOGCS" ? void 0 : child(node, "ID");
+  const result = {
+    type: projected ? "ProjectedCRS" : geocentric ? "GeodeticCRS" : "GeographicCRS",
+    name: value(node),
+    // WKT1 uses datum names; WKT2 base-CRS IDs select the upstream authority table.
+    id: id ? { authority: value(id), code: value(id, 1) } : void 0,
+    coordinate_system: { subtype: projected || geocentric ? "Cartesian" : "ellipsoidal", axis: axes }
+  };
+  const usage = child(node, "USAGE");
+  const bbox = child(usage || node, "BBOX");
+  if (bbox)
+    result["bbox"] = {
+      south_latitude: value(bbox, 0),
+      west_longitude: value(bbox, 1),
+      north_latitude: value(bbox, 2),
+      east_longitude: value(bbox, 3)
+    };
+  if (projected) {
+    const base = child(node, "GEOGCS", "BASEGEOGCRS", "BASEGEODCRS", "GEODCRS", "GEOGCRS");
+    if (!base)
+      throw new Error("Projected WKT requires a base geographic CRS");
+    result["base_crs"] = readWKT(base);
+    result["conversion"] = operation(child(node, "CONVERSION") || node);
+  } else {
+    const datum = child(node, "DATUM", "GEODETICDATUM", "ENSEMBLE");
+    if (!datum)
+      throw new Error("WKT requires a geodetic datum");
+    if (child(datum, "EXTENSION", "DYNAMIC"))
+      unsupportedStage("Unsupported datum extension");
+    const ellipsoid = child(datum, "SPHEROID", "ELLIPSOID");
+    if (!ellipsoid)
+      throw new Error("WKT datum requires an ellipsoid");
+    const shift = child(datum, "TOWGS84");
+    result["datum"] = {
+      name: value(datum),
+      ellipsoid: {
+        name: value(ellipsoid),
+        semi_major_axis: value(ellipsoid, 1),
+        inverse_flattening: value(ellipsoid, 2),
+        unit: units(child(ellipsoid, "LENGTHUNIT"))
+      },
+      towgs84: shift == null ? void 0 : shift.values.map((_, index) => value(shift, index))
+    };
+    const pm = child(node, "PRIMEM");
+    if (pm)
+      result["prime_meridian"] = {
+        name: value(pm),
+        longitude: value(pm, 1),
+        unit: units(child(pm, "ANGLEUNIT") || (geocentric ? void 0 : localUnit))
+      };
+    result["angular_unit"] = geocentric ? void 0 : units(localUnit);
+  }
+  return result;
+}
+var wktCRSParser = {
+  name: "wkt",
+  canParse: (definition) => inferCRSRepresentation(definition) === "wkt",
+  parse(definition, options) {
+    if (typeof definition !== "string")
+      throw new Error("Expected serialized WKT");
+    return readStructuredCRS(readWKT(parseWKTCRS(definition).root), options);
+  }
+};
+//# sourceMappingURL=wkt.cjs.map