@math.gl/geospatial 5.0.0-alpha.18 → 5.0.0-alpha.19

package/dist/crs/index.cjs

@@ -0,0 +1,916 @@
+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, {
+  PROJJSON_SCHEMA_URL: () => PROJJSON_SCHEMA_URL,
+  PROJJSON_SCHEMA_VERSION: () => PROJJSON_SCHEMA_VERSION,
+  PROJStringSyntaxError: () => PROJStringSyntaxError,
+  WKTCRSSyntaxError: () => WKTCRSSyntaxError,
+  WKTCRSValidationError: () => WKTCRSValidationError,
+  createSpatialReference: () => createSpatialReference,
+  encodePROJString: () => encodePROJString,
+  encodeWKTCRS: () => encodeWKTCRS,
+  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
+  ]);
+}
+//# sourceMappingURL=index.cjs.map