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

package/dist/crs/index.cjs

@@ -0,0 +1,1252 @@
+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/crs/index.js
+var index_exports = {};
+__export(index_exports, {
+  CRSResolutionError: () => CRSResolutionError,
+  PROJJSON_SCHEMA_URL: () => PROJJSON_SCHEMA_URL,
+  PROJJSON_SCHEMA_VERSION: () => PROJJSON_SCHEMA_VERSION,
+  PROJStringSyntaxError: () => PROJStringSyntaxError,
+  WKTCRSSyntaxError: () => WKTCRSSyntaxError,
+  WKTCRSValidationError: () => WKTCRSValidationError,
+  createCRSDescriptor: () => createCRSDescriptor,
+  createCRSDictionaryProvider: () => createCRSDictionaryProvider,
+  createCRSExecutionIdentity: () => createCRSExecutionIdentity,
+  createCRSProjectionDomain: () => createCRSProjectionDomain,
+  createCRSResolver: () => createCRSResolver,
+  createSpatialReference: () => createSpatialReference,
+  encodePROJString: () => encodePROJString,
+  encodeWKTCRS: () => encodeWKTCRS,
+  getCRSExecutionKey: () => getCRSExecutionKey,
+  getCRSSignature: () => getCRSSignature,
+  inferCRSRepresentation: () => inferCRSRepresentation,
+  linearUnits: () => linearUnits,
+  parsePROJString: () => parsePROJString,
+  parseWKTCRS: () => parseWKTCRS,
+  validateWKTCRS: () => validateWKTCRS
+});
+module.exports = __toCommonJS(index_exports);
+
+// dist/crs/projjson-schema-constants.js
+var PROJJSON_SCHEMA_VERSION = "0.7";
+var PROJJSON_SCHEMA_URL = "https://proj.org/schemas/v0.7/projjson.schema.json";
+
+// dist/crs/spatial-reference.js
+function createSpatialReference(options = {}) {
+  if (options.coordinateEpoch !== void 0 && !Number.isFinite(options.coordinateEpoch)) {
+    throw new Error("Spatial reference coordinate epoch must be a finite decimal year");
+  }
+  return Object.freeze({
+    crs: freezeCRSReference(options.crs || { state: "absent", provenance: "unknown" }),
+    vertical: options.vertical ? freezeCRSReference(options.vertical) : void 0,
+    coordinateEpoch: options.coordinateEpoch,
+    coordinateFrame: options.coordinateFrame || "unknown",
+    coordinateOrder: Object.freeze([...options.coordinateOrder || []]),
+    units: options.units ? Object.freeze([...options.units]) : void 0
+  });
+}
+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";
+}
+function freezeCRSReference(reference) {
+  if (reference.state === "explicit" || reference.state === "default") {
+    return Object.freeze({
+      ...reference,
+      definition: cloneAndFreezeDefinition(reference.definition),
+      alternatives: reference.alternatives ? Object.freeze(reference.alternatives.map((alternative) => Object.freeze({
+        ...alternative,
+        definition: cloneAndFreezeDefinition(alternative.definition)
+      }))) : void 0
+    });
+  }
+  return Object.freeze({ ...reference });
+}
+function cloneAndFreezeDefinition(definition) {
+  return typeof definition === "string" ? definition : cloneAndFreezeJsonValue(definition);
+}
+function cloneAndFreezeJsonValue(value) {
+  if (Array.isArray(value)) {
+    return Object.freeze(value.map((item) => cloneAndFreezeJsonValue(item)));
+  }
+  if (value && typeof value === "object") {
+    return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, cloneAndFreezeJsonValue(item)])));
+  }
+  return value;
+}
+
+// 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 _a;
+    super(((_a = issues[0]) == null ? void 0 : _a.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 encodeWKTCRS(ast, options) {
+  var _a;
+  if (!ast || ast.type !== "wkt-crs" || ((_a = ast.root) == null ? void 0 : _a.type) !== "node") {
+    throw new TypeError("encodeWKTCRS expects a WKTCRSAst");
+  }
+  const format = (options == null ? void 0 : options.format) || "compact";
+  const indent = (options == null ? void 0 : options.indent) ?? 2;
+  if (!Number.isInteger(indent) || indent < 0) {
+    throw new RangeError("WKT indentation must be a non-negative integer");
+  }
+  validateEncodableNode(ast.root);
+  return encodeNode(ast.root, format, indent, 0);
+}
+function validateWKTCRS(ast, options) {
+  var _a;
+  if (!ast || ast.type !== "wkt-crs" || ((_a = ast.root) == null ? void 0 : _a.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 value = 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(value)) {
+        this.fail(`Invalid WKT keyword '${value}'`);
+      }
+      return this.parseNodeAfterKeyword(value);
+    }
+    if (NUMBER_PATTERN.test(value)) {
+      return { type: "number", value: Number(value), raw: value };
+    }
+    return { type: "enumeration", value };
+  }
+  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 value = "";
+    while (this.offset < this.source.length) {
+      const character = this.source[this.offset++];
+      if (character === '"') {
+        if (this.source[this.offset] === '"') {
+          value += '"';
+          this.offset++;
+          continue;
+        }
+        return { type: "string", value };
+      }
+      value += 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 encodeNode(node, format, indent, depth) {
+  const opening = node.delimiter === "bracket" ? "[" : "(";
+  const closing = node.delimiter === "bracket" ? "]" : ")";
+  if (node.values.length === 0) {
+    return `${node.keyword}${opening}${closing}`;
+  }
+  if (format === "compact") {
+    return `${node.keyword}${opening}${node.values.map((value) => encodeValue(value, format, indent, depth + 1)).join(",")}${closing}`;
+  }
+  const indentation = " ".repeat(indent * (depth + 1));
+  const closingIndentation = " ".repeat(indent * depth);
+  const values = node.values.map((value) => `${indentation}${encodeValue(value, format, indent, depth + 1)}`).join(",\n");
+  return `${node.keyword}${opening}
+${values}
+${closingIndentation}${closing}`;
+}
+function encodeValue(value, format, indent, depth) {
+  switch (value.type) {
+    case "node":
+      return encodeNode(value, format, indent, depth);
+    case "string":
+      return `"${value.value.replace(/"/g, '""')}"`;
+    case "number":
+      return value.raw;
+    case "enumeration":
+      return value.value;
+    default:
+      throw new TypeError("Invalid WKT value type");
+  }
+}
+function validateEncodableNode(node) {
+  if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(node.keyword)) {
+    throw new TypeError(`Invalid WKT keyword: ${node.keyword}`);
+  }
+  if (node.delimiter !== "bracket" && node.delimiter !== "parenthesis") {
+    throw new TypeError(`Invalid WKT delimiter: ${node.delimiter}`);
+  }
+  if (!Array.isArray(node.values)) {
+    throw new TypeError(`Invalid WKT values for ${node.keyword}`);
+  }
+  for (const value of node.values) {
+    if (!value || typeof value !== "object") {
+      throw new TypeError(`Invalid WKT value in ${node.keyword}`);
+    }
+    switch (value.type) {
+      case "node":
+        validateEncodableNode(value);
+        break;
+      case "string":
+        if (typeof value.value !== "string") {
+          throw new TypeError(`Invalid WKT string in ${node.keyword}`);
+        }
+        break;
+      case "number":
+        if (typeof value.raw !== "string" || !NUMBER_PATTERN.test(value.raw)) {
+          throw new TypeError(`Invalid WKT number lexeme: ${value.raw}`);
+        }
+        break;
+      case "enumeration":
+        if (typeof value.value !== "string" || !value.value || /[\s,\[\]()"]/.test(value.value)) {
+          throw new TypeError(`Invalid WKT enumeration: ${value.value}`);
+        }
+        break;
+      default:
+        throw new TypeError(`Invalid WKT value in ${node.keyword}`);
+    }
+  }
+}
+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((value) => value.type === "node" ? value.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 value = node.values[index];
+    if (value.type === "node") {
+      visitNode(value, [...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/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 = getSourceLocation2(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 };
+}
+function encodePROJString(ast, options) {
+  if (!ast || ast.type !== "proj-string" || !Array.isArray(ast.parameters)) {
+    throw new TypeError("encodePROJString expects a PROJStringAst");
+  }
+  if (ast.parameters.length === 0) {
+    throw new TypeError("encodePROJString expects at least one parameter");
+  }
+  const separator = (options == null ? void 0 : options.format) === "multiline" ? "\n" : " ";
+  return ast.parameters.map((parameter) => {
+    if (!parameter.name || /[\s+=]/.test(parameter.name)) {
+      throw new TypeError(`Invalid PROJ parameter name: ${parameter.name}`);
+    }
+    if (parameter.rawValue !== void 0) {
+      validateRawParameterValue(parameter.rawValue);
+      return `+${parameter.name}=${parameter.rawValue}`;
+    }
+    if (parameter.value !== void 0) {
+      return `+${parameter.name}=${encodeParameterValue(parameter.value)}`;
+    }
+    return `+${parameter.name}`;
+  }).join(separator);
+}
+var DMS_VALUE = /^[+-]?\d+(?:\.\d*)?d(?:\d+(?:\.\d*)?'(?:\d+(?:\.\d*)?")?)?[NSEW]?$/i;
+function validateRawParameterValue(rawValue) {
+  if (typeof rawValue !== "string") {
+    throw new TypeError("Invalid PROJ raw parameter value");
+  }
+  if (!rawValue) {
+    return;
+  }
+  const first = rawValue[0];
+  if (first !== '"' && first !== "'") {
+    if (/\s|["']/.test(rawValue) && !DMS_VALUE.test(rawValue)) {
+      throw new TypeError(`Invalid PROJ raw parameter value: ${rawValue}`);
+    }
+    return;
+  }
+  if (rawValue.length < 2) {
+    throw new TypeError(`Invalid PROJ raw parameter value: ${rawValue}`);
+  }
+  let escaped = false;
+  let closingQuoteFound = false;
+  for (let index = 1; index < rawValue.length; index++) {
+    const character = rawValue[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (character === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (character === first && index !== rawValue.length - 1) {
+      throw new TypeError(`Invalid PROJ raw parameter value: ${rawValue}`);
+    }
+    if (character === first) {
+      closingQuoteFound = true;
+    }
+  }
+  if (escaped || !closingQuoteFound || rawValue[rawValue.length - 1] !== first) {
+    throw new TypeError(`Invalid PROJ raw parameter value: ${rawValue}`);
+  }
+}
+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 encodeParameterValue(value) {
+  if (value && !/\s/.test(value) && !/["']/.test(value)) {
+    return value;
+  }
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function getSourceLocation2(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/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/crs/resolver.js
+var CRSResolutionError = class extends Error {
+  constructor(reason, identifier) {
+    super(`CRS resolution ${reason}: ${identifier}`);
+    this.reason = reason;
+    this.identifier = identifier;
+    this.name = "CRSResolutionError";
+  }
+};
+function createCRSDictionaryProvider(definitions, options = {}) {
+  const entries = new Map(Object.entries(definitions).map(([key, value]) => [key, snapshot(value)]));
+  return Object.freeze({
+    id: options.id ?? "dictionary",
+    version: options.version,
+    resolve: (identifier) => entries.get(identifier) ?? null
+  });
+}
+function createCRSResolver(options) {
+  const { maxCacheSize = 128, maxDepth = 16 } = options;
+  if (!Number.isSafeInteger(maxCacheSize) || maxCacheSize < 0 || !Number.isSafeInteger(maxDepth) || maxDepth < 0) {
+    throw new RangeError("Invalid CRS resolver cache size or alias depth");
+  }
+  const providers = options.providers.map((provider) => {
+    if (!provider.id.trim() || typeof provider.resolve !== "function") {
+      throw new TypeError("A CRS provider needs an id and resolve method");
+    }
+    return { id: provider.id, version: provider.version, resolve: provider.resolve.bind(provider) };
+  });
+  if (new Set(providers.map((provider) => provider.id)).size !== providers.length) {
+    throw new Error("CRS provider ids must be unique");
+  }
+  const cache = /* @__PURE__ */ new Map();
+  async function lookup(identifier, visited = /* @__PURE__ */ new Set()) {
+    if (visited.has(identifier))
+      throw new CRSResolutionError("cycle", identifier);
+    if (visited.size > maxDepth)
+      throw new CRSResolutionError("limit", identifier);
+    visited.add(identifier);
+    for (const provider of providers) {
+      const supplied = await provider.resolve(identifier);
+      if (supplied === null)
+        continue;
+      if (!(typeof supplied === "string" && supplied.trim()) && !(supplied && typeof supplied === "object" && !Array.isArray(supplied) && typeof supplied.type === "string")) {
+        throw new CRSResolutionError("invalid-result", identifier);
+      }
+      const definition = snapshot(supplied);
+      const entry = Object.freeze({ identifier, provider: provider.id, version: provider.version });
+      if (typeof definition === "string" && inferCRSRepresentation(definition) === "identifier") {
+        const next = await lookup(definition, visited);
+        return { definition: next.definition, lookups: Object.freeze([entry, ...next.lookups]) };
+      }
+      return { definition, lookups: Object.freeze([entry]) };
+    }
+    throw new CRSResolutionError("not-found", identifier);
+  }
+  function resolveDefinition(definition, representation = inferCRSRepresentation(definition)) {
+    if (typeof definition !== "string" || representation !== "identifier") {
+      return Promise.resolve({ definition, lookups: Object.freeze([]) });
+    }
+    const existing = cache.get(definition);
+    if (existing) {
+      cache.delete(definition);
+      cache.set(definition, existing);
+      return existing;
+    }
+    const pending = lookup(definition).catch((error) => {
+      if (cache.get(definition) === pending)
+        cache.delete(definition);
+      throw error;
+    });
+    if (maxCacheSize) {
+      cache.set(definition, pending);
+      if (cache.size > maxCacheSize)
+        cache.delete(cache.keys().next().value);
+    }
+    return pending;
+  }
+  return Object.freeze({
+    clear: () => cache.clear(),
+    async resolve(input) {
+      const captured = snapshot(input);
+      const lookups = [];
+      async function reference(ref) {
+        if (ref.state !== "explicit" && ref.state !== "default")
+          return ref;
+        const result = await resolveDefinition(ref.definition, ref.representation);
+        lookups.push(...result.lookups);
+        if (!result.lookups.length)
+          return ref;
+        return {
+          ...ref,
+          definition: result.definition,
+          representation: inferCRSRepresentation(result.definition),
+          alternatives: [
+            { definition: ref.definition, representation: ref.representation },
+            ...ref.alternatives ?? []
+          ]
+        };
+      }
+      let resolved;
+      if (typeof captured === "string" || "type" in captured) {
+        const result = await resolveDefinition(captured);
+        lookups.push(...result.lookups);
+        resolved = result.definition;
+      } else {
+        const metadata = captured;
+        resolved = "crs" in metadata ? createSpatialReference({
+          ...metadata,
+          crs: await reference(metadata.crs),
+          vertical: metadata.vertical ? await reference(metadata.vertical) : void 0
+        }) : snapshot(await reference(metadata));
+      }
+      return Object.freeze({ input: resolved, lookups: Object.freeze(lookups) });
+    }
+  });
+}
+function snapshot(value) {
+  if (Array.isArray(value))
+    return Object.freeze(value.map((item) => snapshot(item)));
+  if (value && typeof value === "object") {
+    return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, snapshot(item)])));
+  }
+  return value;
+}
+
+// dist/crs/projection-domain.js
+function createCRSProjectionDomain(domain) {
+  if (!domain || !Array.isArray(domain.polygons))
+    throw new RangeError("Invalid projection domain");
+  const polygons = Object.freeze(Array.from(domain.polygons, (polygon) => {
+    if (!polygon || polygon.holes !== void 0 && !Array.isArray(polygon.holes)) {
+      throw new RangeError("Invalid domain polygon");
+    }
+    return Object.freeze({
+      outer: copyRing(polygon.outer),
+      ...polygon.holes === void 0 ? {} : { holes: Object.freeze(Array.from(polygon.holes, copyRing)) }
+    });
+  }));
+  const period = domain.periodic;
+  if (period !== void 0 && (!period || period.axis !== 0 && period.axis !== 1 || !Number.isFinite(period.minimum) || !Number.isFinite(period.period) || period.period <= 0 || !Number.isFinite(period.minimum + period.period) || period.minimum + period.period <= period.minimum)) {
+    throw new RangeError("Invalid projection period");
+  }
+  return Object.freeze({
+    polygons,
+    ...period === void 0 ? {} : {
+      periodic: Object.freeze({
+        axis: period.axis,
+        minimum: period.minimum,
+        period: period.period
+      })
+    }
+  });
+}
+function copyRing(ring) {
+  if (!Array.isArray(ring) || ring.length < 4)
+    throw new RangeError("Invalid domain ring");
+  const points = Array.from(ring, (point) => {
+    if (!Array.isArray(point) || point.length !== 2 || !Array.from(point).every(Number.isFinite)) {
+      throw new RangeError("Invalid domain point");
+    }
+    return Object.freeze([point[0], point[1]]);
+  });
+  const first = points[0], last = points[points.length - 1];
+  if (first[0] !== last[0] || first[1] !== last[1])
+    throw new RangeError("Domain ring must be closed");
+  let area = 0;
+  for (let i = 1; i + 1 < points.length; i++) {
+    const a = points[i], b = points[i + 1];
+    area += (a[0] - first[0]) * (b[1] - first[1]) - (a[1] - first[1]) * (b[0] - first[0]);
+  }
+  if (!Number.isFinite(area) || area === 0)
+    throw new RangeError("Degenerate domain ring");
+  return Object.freeze(points);
+}
+
+// dist/crs/execution-identity.js
+function createCRSExecutionIdentity(identity) {
+  if (!identity || typeof identity !== "object")
+    throw new TypeError("Invalid execution identity");
+  const backend = nonempty(identity.backend);
+  const version = nonempty(identity.version);
+  const operation = nonempty(identity.operation);
+  const parameters = copyRecord(identity.parameters, false);
+  const resources = copyRecord(identity.resources, true);
+  return Object.freeze({
+    backend,
+    version,
+    operation,
+    parameters,
+    resources,
+    ...identity.revision === void 0 ? {} : { revision: nonempty(identity.revision) }
+  });
+}
+function getCRSExecutionKey(descriptor) {
+  if (descriptor.executionIdentity === void 0)
+    return null;
+  const identity = createCRSExecutionIdentity(descriptor.executionIdentity);
+  const domain = descriptor.projectionDomain === void 0 ? null : createCRSProjectionDomain(descriptor.projectionDomain);
+  return JSON.stringify([
+    "math.gl/crs-execution/v1",
+    descriptor.signature,
+    identity,
+    Object.keys(descriptor.converter).sort(),
+    domain
+  ]);
+}
+function nonempty(value) {
+  if (typeof value !== "string" || !value.trim())
+    throw new TypeError("Invalid execution identity string");
+  return value;
+}
+function copyRecord(value, stringsOnly) {
+  if (value === void 0)
+    return Object.freeze({});
+  if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+    throw new TypeError("Invalid execution identity record");
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(value).sort()) {
+    nonempty(key);
+    const item = value[key];
+    if (stringsOnly)
+      nonempty(item);
+    else if (!(item === null || typeof item === "string" || typeof item === "boolean" || typeof item === "number" && Number.isFinite(item)))
+      throw new TypeError("Invalid execution parameter");
+    if (Object.is(item, -0))
+      throw new TypeError("Execution parameters cannot contain negative zero");
+    result[key] = item;
+  }
+  return Object.freeze(result);
+}
+
+// dist/crs/crs-descriptor.js
+function createCRSDescriptor(options) {
+  const source = options.metadata;
+  requireValue(["geographic", "projected", "geocentric", "identity"].includes(source.coordinateFrame), "coordinateFrame");
+  requireValue(typeof source.projection === "string" && Boolean(source.projection.trim()), "projection");
+  requireValue(typeof source.lossy === "boolean", "lossy");
+  requireValue(typeof source.axis === "string" && source.axis.length === 3 && /^[ewnsud]+$/.test(source.axis) && /[ew]/.test(source.axis) && /[ns]/.test(source.axis) && /[ud]/.test(source.axis), "axis");
+  requireValue(positive(source.ellipsoid.semiMajorAxis) && positive(source.ellipsoid.semiMinorAxis), "ellipsoid");
+  requireValue(Boolean(source.parameters) && typeof source.parameters === "object" && !Array.isArray(source.parameters), "parameters");
+  const parameters = { ...source.parameters };
+  requireValue(Object.values(parameters).every((value) => value === void 0 || typeof value === "string"), "parameters");
+  const areaOfUse = source.areaOfUse && [...source.areaOfUse];
+  if (areaOfUse)
+    requireValue(areaOfUse.length === 4 && areaOfUse.every(Number.isFinite) && areaOfUse[1] <= areaOfUse[3], "areaOfUse");
+  const metadata = {
+    coordinateFrame: source.coordinateFrame,
+    projection: source.projection,
+    parameters: Object.freeze(parameters),
+    ellipsoid: Object.freeze({
+      semiMajorAxis: source.ellipsoid.semiMajorAxis,
+      semiMinorAxis: source.ellipsoid.semiMinorAxis
+    }),
+    axis: source.axis,
+    xUnit: copyUnit(source.xUnit),
+    yUnit: copyUnit(source.yUnit),
+    zUnit: copyUnit(source.zUnit),
+    lossy: source.lossy,
+    areaOfUse: areaOfUse && Object.freeze(areaOfUse)
+  };
+  const signature = options.signature ?? getCRSSignature(metadata);
+  requireValue(typeof signature === "string" && Boolean(signature.trim()), "signature");
+  const bounds = options.renderingBounds;
+  requireValue(Array.isArray(bounds) && bounds.length === 2 && [...bounds].every((row) => Array.isArray(row) && row.length === 3 && [...row].every(Number.isFinite)) && bounds[0].every((minimum, i) => minimum <= bounds[1][i]), "renderingBounds");
+  const renderingBounds = Object.freeze([
+    Object.freeze([...bounds[0]]),
+    Object.freeze([...bounds[1]])
+  ]);
+  const suppliedScale = options.renderingScale;
+  const renderingScale = typeof suppliedScale === "function" ? (coordinate) => {
+    const result = suppliedScale(coordinate);
+    return result === null ? null : copyScale(result);
+  } : copyScale(suppliedScale);
+  requireValue(Object.prototype.hasOwnProperty.call(options.converter, "WGS84"), "converter.WGS84");
+  const converter = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.getOwnPropertyNames(options.converter)) {
+    const operations = options.converter[key];
+    requireValue(Boolean(key.trim()), "converter key");
+    converter[key] = Object.freeze({
+      from: bindConversion(operations, "from"),
+      to: bindConversion(operations, "to"),
+      normalize: bindConversion(operations, "normalize")
+    });
+  }
+  return Object.freeze({
+    ...metadata,
+    signature,
+    ...options.executionIdentity === void 0 ? {} : { executionIdentity: createCRSExecutionIdentity(options.executionIdentity) },
+    renderingBounds,
+    ...options.projectionDomain === void 0 ? {} : { projectionDomain: createCRSProjectionDomain(options.projectionDomain) },
+    renderingScale,
+    getRenderingScale: (coordinate) => typeof renderingScale === "function" ? renderingScale(coordinate) : renderingScale,
+    converter: Object.freeze(converter)
+  });
+}
+function bindConversion(owner, key) {
+  const operation = owner == null ? void 0 : owner[key];
+  requireValue(typeof operation === "function", `converter.${key}`);
+  function convert(coordinate, output) {
+    const result = operation.call(owner, coordinate, output);
+    requireSynchronous(result);
+    requireValue(output === void 0 ? Array.isArray(result) : result === output, "converter result: synchronous array or supplied output required");
+    return result;
+  }
+  return convert;
+}
+function copyUnit(unit) {
+  requireValue(typeof unit.name === "string" && Boolean(unit.name.trim()) && (positive(unit.metersPerUnit) && unit.degreesPerUnit === void 0 || positive(unit.degreesPerUnit) && unit.metersPerUnit === void 0), "unit");
+  return Object.freeze(unit.metersPerUnit !== void 0 ? { name: unit.name, metersPerUnit: unit.metersPerUnit } : { name: unit.name, degreesPerUnit: unit.degreesPerUnit });
+}
+function copyScale(value) {
+  requireSynchronous(value);
+  requireValue(Array.isArray(value) && value.length === 3 && [...value].every(positive), "renderingScale");
+  return Object.freeze([...value]);
+}
+function positive(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function requireSynchronous(value) {
+  if (value && typeof value.then === "function") {
+    void Promise.resolve(value).catch(() => void 0);
+    throw new TypeError("Invalid CRS descriptor result: synchronous callbacks required");
+  }
+}
+function requireValue(condition, field) {
+  if (!condition)
+    throw new TypeError(`Invalid CRS descriptor ${field}`);
+}
+//# sourceMappingURL=index.cjs.map