giser-convert-crs 1.0.0 → 1.0.1

package/dist/giserConvertCrs.esm.js

@@ -1,454 +1,624 @@
-const PI = Math.PI;
-const X_PI = PI * 3000.0 / 180.0;
-const SEMI_MAJOR_AXIS = 6378245.0;
-const ECCENTRICITY_SQUARED = 0.00669342162296594323;
-
-const GPS = {
-  PI,
-  x_pi: X_PI,
-
-  delta(lat, lon) {
-    let dLat = this.transformLat(lon - 105.0, lat - 35.0);
-    let dLon = this.transformLon(lon - 105.0, lat - 35.0);
-    const radLat = lat / 180.0 * PI;
-    const sinLat = Math.sin(radLat);
-    const magic = 1 - ECCENTRICITY_SQUARED * sinLat * sinLat;
-    const sqrtMagic = Math.sqrt(magic);
-
-    dLat = (dLat * 180.0) / ((SEMI_MAJOR_AXIS * (1 - ECCENTRICITY_SQUARED)) / (magic * sqrtMagic) * PI);
-    dLon = (dLon * 180.0) / (SEMI_MAJOR_AXIS / sqrtMagic * Math.cos(radLat) * PI);
-
-    return { lat: dLat, lon: dLon };
-  },
-
-  wgs84_gcj02(wgsLon, wgsLat) {
-    this._assertLonLat(wgsLon, wgsLat);
-    if (this.outOfChina(wgsLat, wgsLon)) return [wgsLon, wgsLat];
-
-    const d = this.delta(wgsLat, wgsLon);
-    return [wgsLon + d.lon, wgsLat + d.lat];
-  },
-
-  gcj02_wgs84(gcjLon, gcjLat) {
-    this._assertLonLat(gcjLon, gcjLat);
-    if (this.outOfChina(gcjLat, gcjLon)) return [gcjLon, gcjLat];
-
-    const d = this.delta(gcjLat, gcjLon);
-    return [gcjLon - d.lon, gcjLat - d.lat];
-  },
-
-  gcj02_wgs84_precise(gcjLon, gcjLat) {
-    this._assertLonLat(gcjLon, gcjLat);
-    if (this.outOfChina(gcjLat, gcjLon)) return [gcjLon, gcjLat];
-
-    const threshold = 0.000000001;
-    let minLat = gcjLat - 0.01;
-    let minLon = gcjLon - 0.01;
-    let maxLat = gcjLat + 0.01;
-    let maxLon = gcjLon + 0.01;
-    let wgsLat = gcjLat;
-    let wgsLon = gcjLon;
-
-    for (let i = 0; i < 10000; i++) {
-      wgsLat = (minLat + maxLat) / 2;
-      wgsLon = (minLon + maxLon) / 2;
-      const [tmpLon, tmpLat] = this.wgs84_gcj02(wgsLon, wgsLat);
-      const dLat = tmpLat - gcjLat;
-      const dLon = tmpLon - gcjLon;
-
-      if (Math.abs(dLat) < threshold && Math.abs(dLon) < threshold) break;
-      if (dLat > 0) maxLat = wgsLat;
-      else minLat = wgsLat;
-      if (dLon > 0) maxLon = wgsLon;
-      else minLon = wgsLon;
-    }
-
-    return [wgsLon, wgsLat];
-  },
-
-  gcj02_bd09ll(gcjLon, gcjLat) {
-    this._assertLonLat(gcjLon, gcjLat);
-    const z = Math.sqrt(gcjLon * gcjLon + gcjLat * gcjLat) + 0.00002 * Math.sin(gcjLat * X_PI);
-    const theta = Math.atan2(gcjLat, gcjLon) + 0.000003 * Math.cos(gcjLon * X_PI);
-    return [z * Math.cos(theta) + 0.0065, z * Math.sin(theta) + 0.006];
-  },
-
-  bd09ll_gcj02(bdLon, bdLat) {
-    this._assertLonLat(bdLon, bdLat);
-    const x = bdLon - 0.0065;
-    const y = bdLat - 0.006;
-    const z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * X_PI);
-    const theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * X_PI);
-    return [z * Math.cos(theta), z * Math.sin(theta)];
-  },
-
-  wgs84_bd09ll(wgsLon, wgsLat) {
-    const gcj = this.wgs84_gcj02(wgsLon, wgsLat);
-    return this.gcj02_bd09ll(gcj[0], gcj[1]);
-  },
-
-  bd09ll_wgs84(bdLon, bdLat) {
-    const gcj = this.bd09ll_gcj02(bdLon, bdLat);
-    return this.gcj02_wgs84(gcj[0], gcj[1]);
-  },
-
-  bd09ll_wgs84_precise(bdLon, bdLat) {
-    const gcj = this.bd09ll_gcj02(bdLon, bdLat);
-    return this.gcj02_wgs84_precise(gcj[0], gcj[1]);
-  },
-
-  outOfChina(lat, lon) {
-    return lon < 72.004 || lon > 137.8347 || lat < 0.8293 || lat > 55.8271;
-  },
-
-  transformLat(x, y) {
-    let ret = -100 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * Math.sqrt(Math.abs(x));
-    ret += (20.0 * Math.sin(6.0 * x * PI) + 20.0 * Math.sin(2.0 * x * PI)) * 2.0 / 3.0;
-    ret += (20.0 * Math.sin(y * PI) + 40.0 * Math.sin(y / 3.0 * PI)) * 2.0 / 3.0;
-    ret += (160.0 * Math.sin(y / 12.0 * PI) + 320.0 * Math.sin(y * PI / 30.0)) * 2.0 / 3.0;
-    return ret;
-  },
-
-  transformLon(x, y) {
-    let ret = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * Math.sqrt(Math.abs(x));
-    ret += (20.0 * Math.sin(6.0 * x * PI) + 20.0 * Math.sin(2.0 * x * PI)) * 2.0 / 3.0;
-    ret += (20.0 * Math.sin(x * PI) + 40.0 * Math.sin(x / 3.0 * PI)) * 2.0 / 3.0;
-    ret += (150.0 * Math.sin(x / 12.0 * PI) + 300.0 * Math.sin(x / 30.0 * PI)) * 2.0 / 3.0;
-    return ret;
-  },
-
-  gcj_encrypt(wgsLat, wgsLon) {
-    const [lon, lat] = this.wgs84_gcj02(wgsLon, wgsLat);
-    return { lat, lon };
-  },
-
-  _assertLonLat(lon, lat) {
-    if (!Number.isFinite(lon) || !Number.isFinite(lat)) {
-      throw new Error('Invalid coordinate: longitude and latitude must be finite numbers.');
-    }
-  }
+const PI = Math.PI;
+const X_PI = PI * 3000.0 / 180.0;
+const SEMI_MAJOR_AXIS = 6378245.0;
+const ECCENTRICITY_SQUARED = 0.00669342162296594323;
+const EPSG3857_RADIUS = 6378137.0;
+const EPSG3857_MAX_LAT = 85.0511287798066;
+
+const GPS = {
+  PI,
+  x_pi: X_PI,
+  EARTH_RADIUS: EPSG3857_RADIUS,
+
+  delta(lat, lon) {
+    let dLat = this.transformLat(lon - 105.0, lat - 35.0);
+    let dLon = this.transformLon(lon - 105.0, lat - 35.0);
+    const radLat = lat / 180.0 * PI;
+    const sinLat = Math.sin(radLat);
+    const magic = 1 - ECCENTRICITY_SQUARED * sinLat * sinLat;
+    const sqrtMagic = Math.sqrt(magic);
+
+    dLat = (dLat * 180.0) / ((SEMI_MAJOR_AXIS * (1 - ECCENTRICITY_SQUARED)) / (magic * sqrtMagic) * PI);
+    dLon = (dLon * 180.0) / (SEMI_MAJOR_AXIS / sqrtMagic * Math.cos(radLat) * PI);
+
+    return { lat: dLat, lon: dLon };
+  },
+
+  wgs84_gcj02(wgsLon, wgsLat) {
+    this._assertLonLat(wgsLon, wgsLat);
+    if (this.outOfChina(wgsLat, wgsLon)) return [wgsLon, wgsLat];
+
+    const d = this.delta(wgsLat, wgsLon);
+    return [wgsLon + d.lon, wgsLat + d.lat];
+  },
+
+  gcj02_wgs84(gcjLon, gcjLat) {
+    this._assertLonLat(gcjLon, gcjLat);
+    if (this.outOfChina(gcjLat, gcjLon)) return [gcjLon, gcjLat];
+
+    const d = this.delta(gcjLat, gcjLon);
+    return [gcjLon - d.lon, gcjLat - d.lat];
+  },
+
+  gcj02_wgs84_precise(gcjLon, gcjLat) {
+    this._assertLonLat(gcjLon, gcjLat);
+    if (this.outOfChina(gcjLat, gcjLon)) return [gcjLon, gcjLat];
+
+    let wgsLon = gcjLon;
+    let wgsLat = gcjLat;
+
+    for (let i = 0; i < 5; i++) {
+      const [currLon, currLat] = this.wgs84_gcj02(wgsLon, wgsLat);
+      const dLon = currLon - gcjLon;
+      const dLat = currLat - gcjLat;
+      wgsLon -= dLon;
+      wgsLat -= dLat;
+      if (Math.abs(dLon) < 1e-11 && Math.abs(dLat) < 1e-11) break;
+    }
+
+    return [wgsLon, wgsLat];
+  },
+
+  gcj02_bd09ll(gcjLon, gcjLat) {
+    this._assertLonLat(gcjLon, gcjLat);
+    const z = Math.sqrt(gcjLon * gcjLon + gcjLat * gcjLat) + 0.00002 * Math.sin(gcjLat * X_PI);
+    const theta = Math.atan2(gcjLat, gcjLon) + 0.000003 * Math.cos(gcjLon * X_PI);
+    return [z * Math.cos(theta) + 0.0065, z * Math.sin(theta) + 0.006];
+  },
+
+  bd09ll_gcj02(bdLon, bdLat) {
+    this._assertLonLat(bdLon, bdLat);
+    const x = bdLon - 0.0065;
+    const y = bdLat - 0.006;
+    const z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * X_PI);
+    const theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * X_PI);
+    return [z * Math.cos(theta), z * Math.sin(theta)];
+  },
+
+  bd09ll_gcj02_precise(bdLon, bdLat) {
+    let [gLon, gLat] = this.bd09ll_gcj02(bdLon, bdLat);
+    for (let i = 0; i < 2; i++) {
+      const [tBdLon, tBdLat] = this.gcj02_bd09ll(gLon, gLat);
+      gLon -= (tBdLon - bdLon);
+      gLat -= (tBdLat - bdLat);
+    }
+    return [gLon, gLat];
+  },
+
+  wgs84_bd09ll(wgsLon, wgsLat) {
+    const gcj = this.wgs84_gcj02(wgsLon, wgsLat);
+    return this.gcj02_bd09ll(gcj[0], gcj[1]);
+  },
+
+  bd09ll_wgs84(bdLon, bdLat) {
+    const gcj = this.bd09ll_gcj02(bdLon, bdLat);
+    return this.gcj02_wgs84(gcj[0], gcj[1]);
+  },
+
+  bd09ll_wgs84_precise(bdLon, bdLat) {
+    const gcj = this.bd09ll_gcj02_precise(bdLon, bdLat);
+    return this.gcj02_wgs84_precise(gcj[0], gcj[1]);
+  },
+
+  wgs84_epsg3857(lon, lat) {
+    this._assertLonLat(lon, lat);
+    const clampedLat = Math.max(-EPSG3857_MAX_LAT, Math.min(EPSG3857_MAX_LAT, lat));
+    const x = lon * EPSG3857_RADIUS * PI / 180.0;
+    const radLat = clampedLat * PI / 180.0;
+    const y = EPSG3857_RADIUS * Math.log(Math.tan(PI / 4.0 + radLat / 2.0));
+    return [x, y];
+  },
+
+  epsg3857_wgs84(x, y) {
+    if (!Number.isFinite(x) || !Number.isFinite(y)) {
+      throw new Error('Invalid coordinate: x and y must be finite numbers.');
+    }
+    const lon = (x / (EPSG3857_RADIUS * PI)) * 180.0;
+    const lat = (2.0 * Math.atan(Math.exp(y / EPSG3857_RADIUS)) - PI / 2.0) * 180.0 / PI;
+    return [lon, lat];
+  },
+
+  gcj02_epsg3857(lon, lat) {
+    const wgs = this.gcj02_wgs84_precise(lon, lat);
+    return this.wgs84_epsg3857(wgs[0], wgs[1]);
+  },
+
+  epsg3857_gcj02(x, y) {
+    const wgs = this.epsg3857_wgs84(x, y);
+    return this.wgs84_gcj02(wgs[0], wgs[1]);
+  },
+
+  bd09ll_epsg3857(lon, lat) {
+    const wgs = this.bd09ll_wgs84_precise(lon, lat);
+    return this.wgs84_epsg3857(wgs[0], wgs[1]);
+  },
+
+  epsg3857_bd09ll(x, y) {
+    const wgs = this.epsg3857_wgs84(x, y);
+    return this.wgs84_bd09ll(wgs[0], wgs[1]);
+  },
+
+  outOfChina(lat, lon) {
+    if (Array.isArray(lat)) {
+      return this.outOfChina(lat[1], lat[0]);
+    }
+    return lon < 72.004 || lon > 137.8347 || lat < 0.8293 || lat > 55.8271;
+  },
+
+  transformLat(x, y) {
+    let ret = -100 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * Math.sqrt(Math.abs(x));
+    ret += (20.0 * Math.sin(6.0 * x * PI) + 20.0 * Math.sin(2.0 * x * PI)) * 2.0 / 3.0;
+    ret += (20.0 * Math.sin(y * PI) + 40.0 * Math.sin(y / 3.0 * PI)) * 2.0 / 3.0;
+    ret += (160.0 * Math.sin(y / 12.0 * PI) + 320.0 * Math.sin(y * PI / 30.0)) * 2.0 / 3.0;
+    return ret;
+  },
+
+  transformLon(x, y) {
+    let ret = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * Math.sqrt(Math.abs(x));
+    ret += (20.0 * Math.sin(6.0 * x * PI) + 20.0 * Math.sin(2.0 * x * PI)) * 2.0 / 3.0;
+    ret += (20.0 * Math.sin(x * PI) + 40.0 * Math.sin(x / 3.0 * PI)) * 2.0 / 3.0;
+    ret += (150.0 * Math.sin(x / 12.0 * PI) + 300.0 * Math.sin(x / 30.0 * PI)) * 2.0 / 3.0;
+    return ret;
+  },
+
+  gcj_encrypt(wgsLat, wgsLon) {
+    const [lon, lat] = this.wgs84_gcj02(wgsLon, wgsLat);
+    return { lat, lon };
+  },
+
+  _assertLonLat(lon, lat) {
+    if (!Number.isFinite(lon) || !Number.isFinite(lat)) {
+      throw new Error('Invalid coordinate: longitude and latitude must be finite numbers.');
+    }
+  }
 };
 
-const crs = {
-  bd09ll: '+proj=longlat +datum=BD09',
-  gcj02: '+proj=longlat +datum=GCJ02',
-  wgs84: '+proj=longlat +datum=WGS84 +no_defs'
-};
-
-const CRS_ALIASES = {
-  'bd-09': 'bd09ll',
-  'bd09': 'bd09ll',
-  'bd09ll': 'bd09ll',
-  'epsg:4326': 'wgs84',
-  'gcj-02': 'gcj02',
-  'gcj02': 'gcj02',
-  'wgs-84': 'wgs84',
-  'wgs84': 'wgs84'
-};
-
-const ProjectionTransform = {
-  crs,
-
-  transform(source, fromCRS, toCRS) {
-    if (source == null) return null;
-
-    const from = this._normalizeCRS(fromCRS);
-    const to = this._normalizeCRS(toCRS);
-
-    if (this._isCoord(source)) {
-      return this._transformCoordinate(source, from, to);
-    }
-
-    if (Array.isArray(source)) {
-      return this._transformCoordinateTree(source, from, to);
-    }
-
-    return this._transformGeoJSON(source, from, to);
-  },
-
-  _transformGeoJSON(geoJSON, fromCRS, toCRS) {
-    if (!geoJSON || typeof geoJSON !== 'object') {
-      throw new Error('Invalid GeoJSON object.');
-    }
-
-    if (geoJSON.type === 'Feature') {
-      return {
-        ...geoJSON,
-        geometry: geoJSON.geometry ? this.transform(geoJSON.geometry, fromCRS, toCRS) : null
-      };
-    }
-
-    if (geoJSON.type === 'FeatureCollection') {
-      if (!Array.isArray(geoJSON.features)) throw new Error('Invalid FeatureCollection: features must be an array.');
-      return {
-        ...geoJSON,
-        features: geoJSON.features.map(feature => this.transform(feature, fromCRS, toCRS))
-      };
-    }
-
-    if (geoJSON.type === 'GeometryCollection') {
-      if (!Array.isArray(geoJSON.geometries)) throw new Error('Invalid GeometryCollection: geometries must be an array.');
-      return {
-        ...geoJSON,
-        geometries: geoJSON.geometries.map(geometry => this.transform(geometry, fromCRS, toCRS))
-      };
-    }
-
-    if ('coordinates' in geoJSON) {
-      return {
-        ...geoJSON,
-        coordinates: this._transformCoordinateTree(geoJSON.coordinates, fromCRS, toCRS)
-      };
-    }
-
-    throw new Error(`Unsupported GeoJSON type: ${geoJSON.type || 'unknown'}.`);
-  },
-
-  _transformCoordinateTree(coordinates, fromCRS, toCRS) {
-    if (coordinates == null) return coordinates;
-    if (this._isCoord(coordinates)) return this._transformCoordinate(coordinates, fromCRS, toCRS);
-    if (!Array.isArray(coordinates)) throw new Error('Invalid coordinates: expected coordinate array.');
-    return coordinates.map(item => this._transformCoordinateTree(item, fromCRS, toCRS));
-  },
-
-  _transformCoordinate(coordinate, fromCRS, toCRS) {
-    const from = this._normalizeCRS(fromCRS);
-    const to = this._normalizeCRS(toCRS);
-    const lon = Number(coordinate[0]);
-    const lat = Number(coordinate[1]);
-
-    if (!Number.isFinite(lon) || !Number.isFinite(lat)) {
-      throw new Error('Invalid coordinate: longitude and latitude must be finite numbers.');
-    }
-
-    if (from === to) return [lon, lat, ...coordinate.slice(2)];
-
-    const method = `${from}_${to}`;
-    if (typeof GPS[method] !== 'function') {
-      throw new Error(`Unsupported CRS transform: ${fromCRS} -> ${toCRS}.`);
-    }
-
-    const transformed = GPS[method](lon, lat);
-    return [transformed[0], transformed[1], ...coordinate.slice(2)];
-  },
-
-  _normalizeCRS(value) {
-    if (!value) throw new Error('must provide a valid fromCRS and toCRS.');
-
-    if (typeof value === 'object') {
-      if (value.type === 'proj4' && value.properties && value.properties.proj) {
-        const crsName = this._toCRS(value.properties.proj);
-        if (crsName) return crsName;
-      }
-      throw new Error('Unsupported CRS object.');
-    }
-
-    const key = String(value).trim().toLowerCase();
-    const normalized = CRS_ALIASES[key];
-    if (!normalized) throw new Error(`Unsupported CRS: ${value}.`);
-    return normalized;
-  },
-
-  _toCRS(proj) {
-    for (const key in this.crs) {
-      if (proj === this.crs[key]) return key;
-    }
-    return null;
-  },
-
-  _isCoord(coordinate) {
-    return Array.isArray(coordinate) &&
-      coordinate.length >= 2 &&
-      Number.isFinite(Number(coordinate[0])) &&
-      Number.isFinite(Number(coordinate[1])) &&
-      !Array.isArray(coordinate[0]) &&
-      !Array.isArray(coordinate[1]);
-  }
+const crs = {
+  bd09ll: '+proj=longlat +datum=BD09',
+  gcj02: '+proj=longlat +datum=GCJ02',
+  wgs84: '+proj=longlat +datum=WGS84 +no_defs',
+  epsg3857: '+proj=merc +a=6378137 +b=6378137 +lat_ts=0 +lon_0=0 +x_0=0 +y_0=0 +k=1 +units=m +nadgrids=@null +wktext +no_defs'
 };
 
-const TYPE_MAP = {
-  POINT: 'Point',
-  LINESTRING: 'LineString',
-  POLYGON: 'Polygon',
-  MULTIPOINT: 'MultiPoint',
-  MULTILINESTRING: 'MultiLineString',
-  MULTIPOLYGON: 'MultiPolygon'
-};
-
-const REVERSE_TYPE_MAP = Object.fromEntries(
-  Object.entries(TYPE_MAP).map(([wktType, geoJSONType]) => [geoJSONType, wktType])
-);
-
-const WKT = {
-  parse(wkt) {
-    if (typeof wkt !== 'string' || !wkt.trim()) {
-      throw new Error('Invalid WKT string.');
-    }
-
-    const source = wkt.trim();
-    const header = source.match(/^([A-Za-z]+)(?:\s+(ZM|Z|M))?\s*/i);
-    if (!header) throw new Error('Invalid WKT string.');
-
-    const wktType = header[1].toUpperCase();
-    const geoJSONType = TYPE_MAP[wktType];
-    if (!geoJSONType) throw new Error(`Unsupported WKT type: ${wktType}.`);
-
-    const body = source.slice(header[0].length).trim();
-    if (/^EMPTY$/i.test(body)) {
-      return { type: geoJSONType, coordinates: this._emptyCoordinates(geoJSONType) };
-    }
-
-    if (!body.startsWith('(') || !body.endsWith(')')) {
-      throw new Error('Invalid WKT string: missing coordinate parentheses.');
-    }
-
-    const content = this._stripOuterParens(body);
-    return {
-      type: geoJSONType,
-      coordinates: this._parseCoordinates(content, geoJSONType)
-    };
-  },
-
-  stringify(geoJSON) {
-    if (!geoJSON || typeof geoJSON !== 'object' || !geoJSON.type) {
-      throw new Error('Invalid GeoJSON.');
-    }
-
-    const wktType = REVERSE_TYPE_MAP[geoJSON.type];
-    if (!wktType) throw new Error(`Unsupported geometry type: ${geoJSON.type}.`);
-
-    const coords = geoJSON.coordinates;
-    if (this._isEmpty(coords)) return `${wktType} EMPTY`;
-
-    return `${wktType}(${this._stringifyCoordinates(coords, geoJSON.type)})`;
-  },
-
-  _parseCoordinates(content, type) {
-    switch (type) {
-      case 'Point':
-        return this._parsePoint(content);
-      case 'LineString':
-        return this._parsePointList(content);
-      case 'Polygon':
-        return this._parsePolygon(content);
-      case 'MultiPoint':
-        return this._parseMultiPoint(content);
-      case 'MultiLineString':
-        return this._splitTopLevel(content).map(line => this._parsePointList(this._stripOptionalOuterParens(line)));
-      case 'MultiPolygon':
-        return this._splitTopLevel(content).map(poly => this._parsePolygon(this._stripOptionalOuterParens(poly)));
-      default:
-        throw new Error(`Unsupported geometry type: ${type}.`);
-    }
-  },
-
-  _parsePoint(value) {
-    const numbers = value.trim().split(/\s+/).filter(Boolean).map(Number);
-    if (numbers.length < 2 || numbers.some(n => !Number.isFinite(n))) {
-      throw new Error(`Invalid WKT coordinate: ${value}.`);
-    }
-    return numbers;
-  },
-
-  _parsePointList(value) {
-    const points = this._splitTopLevel(value).map(part => this._parsePoint(this._stripOptionalOuterParens(part)));
-    if (!points.length) throw new Error('Invalid WKT coordinate list.');
-    return points;
-  },
-
-  _parsePolygon(value) {
-    const rings = this._splitTopLevel(value).map(ring => this._parsePointList(this._stripOptionalOuterParens(ring)));
-    if (!rings.length) throw new Error('Invalid WKT polygon.');
-    return rings;
-  },
-
-  _parseMultiPoint(value) {
-    return this._splitTopLevel(value).map(point => this._parsePoint(this._stripOptionalOuterParens(point)));
-  },
-
-  _splitTopLevel(value) {
-    const parts = [];
-    let depth = 0;
-    let start = 0;
-
-    for (let i = 0; i < value.length; i++) {
-      const char = value[i];
-      if (char === '(') depth++;
-      else if (char === ')') depth--;
-
-      if (depth < 0) throw new Error('Invalid WKT string: unbalanced parentheses.');
-
-      if (char === ',' && depth === 0) {
-        parts.push(value.slice(start, i).trim());
-        start = i + 1;
-      }
-    }
-
-    if (depth !== 0) throw new Error('Invalid WKT string: unbalanced parentheses.');
-    const last = value.slice(start).trim();
-    if (last) parts.push(last);
-    return parts;
-  },
-
-  _stripOuterParens(value) {
-    const trimmed = value.trim();
-    if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) {
-      throw new Error('Invalid WKT string: missing coordinate parentheses.');
-    }
-    return trimmed.slice(1, -1).trim();
-  },
-
-  _stripOptionalOuterParens(value) {
-    const trimmed = value.trim();
-    if (!trimmed.startsWith('(')) return trimmed;
-    return this._stripOuterParens(trimmed);
-  },
-
-  _stringifyCoordinates(coords, type) {
-    switch (type) {
-      case 'Point':
-        return this._stringifyPoint(coords);
-      case 'LineString':
-        return this._stringifyPointList(coords);
-      case 'Polygon':
-        return this._stringifyPolygon(coords);
-      case 'MultiPoint':
-        return coords.map(point => `(${this._stringifyPoint(point)})`).join(', ');
-      case 'MultiLineString':
-        return coords.map(line => `(${this._stringifyPointList(line)})`).join(', ');
-      case 'MultiPolygon':
-        return coords.map(poly => `(${this._stringifyPolygon(poly)})`).join(', ');
-      default:
-        throw new Error(`Unsupported geometry type: ${type}.`);
-    }
-  },
-
-  _stringifyPoint(point) {
-    if (!Array.isArray(point) || point.length < 2) throw new Error('Invalid coordinate.');
-    return point.map(value => {
-      const number = Number(value);
-      if (!Number.isFinite(number)) throw new Error('Invalid coordinate value.');
-      return String(number);
-    }).join(' ');
-  },
-
-  _stringifyPointList(points) {
-    if (!Array.isArray(points)) throw new Error('Invalid coordinate list.');
-    return points.map(point => this._stringifyPoint(point)).join(', ');
-  },
-
-  _stringifyPolygon(rings) {
-    if (!Array.isArray(rings)) throw new Error('Invalid polygon coordinates.');
-    return rings.map(ring => `(${this._stringifyPointList(ring)})`).join(', ');
-  },
-
-  _emptyCoordinates(type) {
-    return type === 'Point' ? [] : [];
-  },
-
-  _isEmpty(coords) {
-    return Array.isArray(coords) && coords.length === 0;
-  }
+const CRS_ALIASES = {
+  'bd-09': 'bd09ll',
+  'bd09': 'bd09ll',
+  'bd09ll': 'bd09ll',
+  'bd-09ll': 'bd09ll',
+  'epsg:4326': 'wgs84',
+  'epsg4326': 'wgs84',
+  '4326': 'wgs84',
+  'cgcs2000': 'wgs84',
+  'cgcs-2000': 'wgs84',
+  'epsg:4490': 'wgs84',
+  'epsg4490': 'wgs84',
+  '4490': 'wgs84',
+  'gcj-02': 'gcj02',
+  'gcj02': 'gcj02',
+  'wgs-84': 'wgs84',
+  'wgs84': 'wgs84',
+  'epsg:3857': 'epsg3857',
+  'epsg3857': 'epsg3857',
+  '3857': 'epsg3857',
+  'epsg:900913': 'epsg3857',
+  'epsg900913': 'epsg3857',
+  '900913': 'epsg3857',
+  'mercator': 'epsg3857',
+  'webmercator': 'epsg3857'
+};
+
+const ProjectionTransform = {
+  crs,
+
+  transform(source, fromCRS, toCRS, options = {}) {
+    if (source == null) return null;
+
+    const from = this._normalizeCRS(fromCRS);
+    const to = this._normalizeCRS(toCRS);
+    const transformCoord = this._getCoordTransformer(from, to, options);
+
+    if (this._isCoord(source)) {
+      return transformCoord(source);
+    }
+
+    if (Array.isArray(source)) {
+      return this._transformCoordinateTree(source, transformCoord, options);
+    }
+
+    return this._transformGeoJSON(source, transformCoord, options);
+  },
+
+  _getCoordTransformer(from, to, options = {}) {
+    const isMutate = Boolean(options.mutate);
+    const isPrecise = options.precise !== false;
+
+    if (from === to) {
+      return isMutate
+        ? coord => coord
+        : coord => [Number(coord[0]), Number(coord[1]), ...coord.slice(2)];
+    }
+
+    let method;
+    if (isPrecise && (from === 'gcj02' || from === 'bd09ll') && to === 'wgs84') {
+      method = `${from}_wgs84_precise`;
+    } else {
+      method = `${from}_${to}`;
+    }
+
+    const fn = GPS[method];
+    if (typeof fn !== 'function') {
+      throw new Error(`Unsupported CRS transform: ${from} -> ${to}.`);
+    }
+
+    if (isMutate) {
+      return coord => {
+        const x = Number(coord[0]);
+        const y = Number(coord[1]);
+        if (!Number.isFinite(x) || !Number.isFinite(y)) {
+          throw new Error('Invalid coordinate: longitude and latitude must be finite numbers.');
+        }
+        const [tx, ty] = fn.call(GPS, x, y);
+        coord[0] = tx;
+        coord[1] = ty;
+        return coord;
+      };
+    }
+
+    return coord => {
+      const x = Number(coord[0]);
+      const y = Number(coord[1]);
+      if (!Number.isFinite(x) || !Number.isFinite(y)) {
+        throw new Error('Invalid coordinate: longitude and latitude must be finite numbers.');
+      }
+      const [tx, ty] = fn.call(GPS, x, y);
+      return [tx, ty, ...coord.slice(2)];
+    };
+  },
+
+  _transformGeoJSON(geoJSON, transformCoord, options = {}) {
+    if (!geoJSON || typeof geoJSON !== 'object') {
+      throw new Error('Invalid GeoJSON object.');
+    }
+
+    const result = options.mutate ? geoJSON : { ...geoJSON };
+
+    if (Array.isArray(geoJSON.bbox)) {
+      result.bbox = this._transformBbox(geoJSON.bbox, transformCoord);
+    }
+
+    if (geoJSON.type === 'Feature') {
+      result.geometry = geoJSON.geometry
+        ? this._transformGeoJSON(geoJSON.geometry, transformCoord, options)
+        : null;
+      return result;
+    }
+
+    if (geoJSON.type === 'FeatureCollection') {
+      if (!Array.isArray(geoJSON.features)) {
+        throw new Error('Invalid FeatureCollection: features must be an array.');
+      }
+      if (options.mutate) {
+        for (let i = 0; i < geoJSON.features.length; i++) {
+          geoJSON.features[i] = this._transformGeoJSON(geoJSON.features[i], transformCoord, options);
+        }
+        result.features = geoJSON.features;
+      } else {
+        result.features = geoJSON.features.map(f => this._transformGeoJSON(f, transformCoord, options));
+      }
+      return result;
+    }
+
+    if (geoJSON.type === 'GeometryCollection') {
+      if (!Array.isArray(geoJSON.geometries)) {
+        throw new Error('Invalid GeometryCollection: geometries must be an array.');
+      }
+      if (options.mutate) {
+        for (let i = 0; i < geoJSON.geometries.length; i++) {
+          geoJSON.geometries[i] = geoJSON.geometries[i]
+            ? this._transformGeoJSON(geoJSON.geometries[i], transformCoord, options)
+            : null;
+        }
+        result.geometries = geoJSON.geometries;
+      } else {
+        result.geometries = geoJSON.geometries.map(g => (g ? this._transformGeoJSON(g, transformCoord, options) : null));
+      }
+      return result;
+    }
+
+    if ('coordinates' in geoJSON) {
+      result.coordinates = this._transformCoordinateTree(geoJSON.coordinates, transformCoord, options);
+      return result;
+    }
+
+    throw new Error(`Unsupported GeoJSON type: ${geoJSON.type || 'unknown'}.`);
+  },
+
+  _transformCoordinateTree(coordinates, transformCoord, options = {}) {
+    if (coordinates == null) return coordinates;
+    if (this._isCoord(coordinates)) return transformCoord(coordinates);
+    if (!Array.isArray(coordinates)) throw new Error('Invalid coordinates: expected coordinate array.');
+
+    if (options.mutate) {
+      for (let i = 0; i < coordinates.length; i++) {
+        coordinates[i] = this._transformCoordinateTree(coordinates[i], transformCoord, options);
+      }
+      return coordinates;
+    }
+
+    return coordinates.map(item => this._transformCoordinateTree(item, transformCoord, options));
+  },
+
+  _transformBbox(bbox, transformCoord) {
+    if (!Array.isArray(bbox) || (bbox.length !== 4 && bbox.length !== 6)) {
+      return bbox;
+    }
+
+    if (bbox.length === 4) {
+      const [minX, minY, maxX, maxY] = bbox;
+      const p1 = transformCoord([minX, minY]);
+      const p2 = transformCoord([maxX, maxY]);
+      return [
+        Math.min(p1[0], p2[0]),
+        Math.min(p1[1], p2[1]),
+        Math.max(p1[0], p2[0]),
+        Math.max(p1[1], p2[1])
+      ];
+    }
+
+    const [minX, minY, minZ, maxX, maxY, maxZ] = bbox;
+    const p1 = transformCoord([minX, minY, minZ]);
+    const p2 = transformCoord([maxX, maxY, maxZ]);
+    return [
+      Math.min(p1[0], p2[0]),
+      Math.min(p1[1], p2[1]),
+      minZ,
+      Math.max(p1[0], p2[0]),
+      Math.max(p1[1], p2[1]),
+      maxZ
+    ];
+  },
+
+  _normalizeCRS(value) {
+    if (!value) throw new Error('must provide a valid fromCRS and toCRS.');
+
+    if (typeof value === 'object') {
+      if (value.type === 'proj4' && value.properties && value.properties.proj) {
+        const crsName = this._toCRS(value.properties.proj);
+        if (crsName) return crsName;
+      }
+      throw new Error('Unsupported CRS object.');
+    }
+
+    const key = String(value).trim().toLowerCase();
+    const normalized = CRS_ALIASES[key];
+    if (!normalized) throw new Error(`Unsupported CRS: ${value}.`);
+    return normalized;
+  },
+
+  _toCRS(proj) {
+    for (const key in this.crs) {
+      if (proj === this.crs[key]) return key;
+    }
+    return null;
+  },
+
+  _isCoord(coordinate) {
+    return Array.isArray(coordinate) &&
+      coordinate.length >= 2 &&
+      !Array.isArray(coordinate[0]) &&
+      !Array.isArray(coordinate[1]) &&
+      Number.isFinite(Number(coordinate[0])) &&
+      Number.isFinite(Number(coordinate[1]));
+  }
+};
+
+const TYPE_MAP = {
+  POINT: 'Point',
+  LINESTRING: 'LineString',
+  POLYGON: 'Polygon',
+  MULTIPOINT: 'MultiPoint',
+  MULTILINESTRING: 'MultiLineString',
+  MULTIPOLYGON: 'MultiPolygon',
+  GEOMETRYCOLLECTION: 'GeometryCollection'
+};
+
+const REVERSE_TYPE_MAP = Object.fromEntries(
+  Object.entries(TYPE_MAP).map(([wktType, geoJSONType]) => [geoJSONType, wktType])
+);
+
+const WKT = {
+  parse(wkt) {
+    if (typeof wkt !== 'string' || !wkt.trim()) {
+      throw new Error('Invalid WKT string.');
+    }
+
+    const source = wkt.trim();
+    const header = source.match(/^([A-Za-z]+)(?:\s+(ZM|Z|M))?\s*/i);
+    if (!header) throw new Error('Invalid WKT string.');
+
+    const wktType = header[1].toUpperCase();
+    const geoJSONType = TYPE_MAP[wktType];
+    if (!geoJSONType) throw new Error(`Unsupported WKT type: ${wktType}.`);
+
+    const body = source.slice(header[0].length).trim();
+    if (/^EMPTY$/i.test(body)) {
+      if (geoJSONType === 'GeometryCollection') {
+        return { type: geoJSONType, geometries: [] };
+      }
+      return { type: geoJSONType, coordinates: this._emptyCoordinates(geoJSONType) };
+    }
+
+    if (!body.startsWith('(') || !body.endsWith(')')) {
+      throw new Error('Invalid WKT string: missing coordinate parentheses.');
+    }
+
+    const content = this._stripOuterParens(body);
+
+    if (geoJSONType === 'GeometryCollection') {
+      return {
+        type: 'GeometryCollection',
+        geometries: this._splitTopLevel(content).map(item => this.parse(item))
+      };
+    }
+
+    return {
+      type: geoJSONType,
+      coordinates: this._parseCoordinates(content, geoJSONType)
+    };
+  },
+
+  stringify(geoJSON, options = {}) {
+    if (!geoJSON || typeof geoJSON !== 'object' || !geoJSON.type) {
+      throw new Error('Invalid GeoJSON.');
+    }
+
+    const wktType = REVERSE_TYPE_MAP[geoJSON.type];
+    if (!wktType) throw new Error(`Unsupported geometry type: ${geoJSON.type}.`);
+
+    const precision = typeof options === 'number' ? options : options?.precision;
+
+    if (geoJSON.type === 'GeometryCollection') {
+      if (!Array.isArray(geoJSON.geometries) || geoJSON.geometries.length === 0) {
+        return 'GEOMETRYCOLLECTION EMPTY';
+      }
+      return `GEOMETRYCOLLECTION(${geoJSON.geometries.map(geom => this.stringify(geom, options)).join(', ')})`;
+    }
+
+    const coords = geoJSON.coordinates;
+    if (this._isEmpty(coords)) return `${wktType} EMPTY`;
+
+    return `${wktType}(${this._stringifyCoordinates(coords, geoJSON.type, precision)})`;
+  },
+
+  _parseCoordinates(content, type) {
+    switch (type) {
+      case 'Point':
+        return this._parsePoint(content);
+      case 'LineString':
+        return this._parsePointList(content);
+      case 'Polygon':
+        return this._parsePolygon(content);
+      case 'MultiPoint':
+        return this._parseMultiPoint(content);
+      case 'MultiLineString':
+        return this._splitTopLevel(content).map(line => this._parsePointList(this._stripOptionalOuterParens(line)));
+      case 'MultiPolygon':
+        return this._splitTopLevel(content).map(poly => this._parsePolygon(this._stripOptionalOuterParens(poly)));
+      default:
+        throw new Error(`Unsupported geometry type: ${type}.`);
+    }
+  },
+
+  _parsePoint(value) {
+    const numbers = value.trim().split(/\s+/).filter(Boolean).map(Number);
+    if (numbers.length < 2 || numbers.some(n => !Number.isFinite(n))) {
+      throw new Error(`Invalid WKT coordinate: ${value}.`);
+    }
+    return numbers;
+  },
+
+  _parsePointList(value) {
+    const points = this._splitTopLevel(value).map(part => this._parsePoint(this._stripOptionalOuterParens(part)));
+    if (!points.length) throw new Error('Invalid WKT coordinate list.');
+    return points;
+  },
+
+  _parsePolygon(value) {
+    const rings = this._splitTopLevel(value).map(ring => this._parsePointList(this._stripOptionalOuterParens(ring)));
+    if (!rings.length) throw new Error('Invalid WKT polygon.');
+    return rings;
+  },
+
+  _parseMultiPoint(value) {
+    return this._splitTopLevel(value).map(point => this._parsePoint(this._stripOptionalOuterParens(point)));
+  },
+
+  _splitTopLevel(value) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+
+    for (let i = 0; i < value.length; i++) {
+      const char = value[i];
+      if (char === '(') depth++;
+      else if (char === ')') depth--;
+
+      if (depth < 0) throw new Error('Invalid WKT string: unbalanced parentheses.');
+
+      if (char === ',' && depth === 0) {
+        parts.push(value.slice(start, i).trim());
+        start = i + 1;
+      }
+    }
+
+    if (depth !== 0) throw new Error('Invalid WKT string: unbalanced parentheses.');
+    const last = value.slice(start).trim();
+    if (last) parts.push(last);
+    return parts;
+  },
+
+  _stripOuterParens(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) {
+      throw new Error('Invalid WKT string: missing coordinate parentheses.');
+    }
+    return trimmed.slice(1, -1).trim();
+  },
+
+  _stripOptionalOuterParens(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('(')) return trimmed;
+    return this._stripOuterParens(trimmed);
+  },
+
+  _stringifyCoordinates(coords, type, precision) {
+    switch (type) {
+      case 'Point':
+        return this._stringifyPoint(coords, precision);
+      case 'LineString':
+        return this._stringifyPointList(coords, precision);
+      case 'Polygon':
+        return this._stringifyPolygon(coords, precision);
+      case 'MultiPoint':
+        return coords.map(point => `(${this._stringifyPoint(point, precision)})`).join(', ');
+      case 'MultiLineString':
+        return coords.map(line => `(${this._stringifyPointList(line, precision)})`).join(', ');
+      case 'MultiPolygon':
+        return coords.map(poly => `(${this._stringifyPolygon(poly, precision)})`).join(', ');
+      default:
+        throw new Error(`Unsupported geometry type: ${type}.`);
+    }
+  },
+
+  _stringifyPoint(point, precision) {
+    if (!Array.isArray(point) || point.length < 2) throw new Error('Invalid coordinate.');
+    return point.map(value => {
+      const number = Number(value);
+      if (!Number.isFinite(number)) throw new Error('Invalid coordinate value.');
+      if (typeof precision === 'number' && precision >= 0) {
+        return Number(number.toFixed(precision)).toString();
+      }
+      return String(number);
+    }).join(' ');
+  },
+
+  _stringifyPointList(points, precision) {
+    if (!Array.isArray(points)) throw new Error('Invalid coordinate list.');
+    return points.map(point => this._stringifyPoint(point, precision)).join(', ');
+  },
+
+  _stringifyPolygon(rings, precision) {
+    if (!Array.isArray(rings)) throw new Error('Invalid polygon coordinates.');
+    return rings.map(ring => `(${this._stringifyPointList(ring, precision)})`).join(', ');
+  },
+
+  _emptyCoordinates(type) {
+    return [];
+  },
+
+  _isEmpty(coords) {
+    return Array.isArray(coords) && coords.length === 0;
+  }
 };
 
 const giserConvertCrs = {
@@ -456,32 +626,34 @@ const giserConvertCrs = {
   ProjectionTransform,
   WKT,
 
-  transform(input, fromCRS, toCRS) {
+  transform(input, fromCRS, toCRS, options) {
     if (input == null || input === '') return null;
 
     if (typeof input === 'string') {
       const geoJSON = WKT.parse(input);
-      return WKT.stringify(ProjectionTransform.transform(geoJSON, fromCRS, toCRS));
+      const transformed = ProjectionTransform.transform(geoJSON, fromCRS, toCRS, options);
+      return WKT.stringify(transformed, options);
     }
 
-    return ProjectionTransform.transform(input, fromCRS, toCRS);
+    return ProjectionTransform.transform(input, fromCRS, toCRS, options);
   },
 
-  transformPoint(coord, fromCRS, toCRS) {
-    return this.transform(coord, fromCRS, toCRS);
+  transformPoint(coord, fromCRS, toCRS, options) {
+    return this.transform(coord, fromCRS, toCRS, options);
   },
 
-  transformPoints(points, fromCRS, toCRS) {
-    return this.transform(points, fromCRS, toCRS);
+  transformPoints(points, fromCRS, toCRS, options) {
+    return this.transform(points, fromCRS, toCRS, options);
   },
 
-  transformGeoJSON(geoJSON, fromCRS, toCRS) {
-    return this.transform(geoJSON, fromCRS, toCRS);
+  transformGeoJSON(geoJSON, fromCRS, toCRS, options) {
+    return this.transform(geoJSON, fromCRS, toCRS, options);
   },
 
-  transformWKT(wkt, fromCRS, toCRS) {
-    return this.transform(wkt, fromCRS, toCRS);
+  transformWKT(wkt, fromCRS, toCRS, options) {
+    return this.transform(wkt, fromCRS, toCRS, options);
   }
 };
 
 export { GPS, ProjectionTransform, WKT, giserConvertCrs as default };
+//# sourceMappingURL=giserConvertCrs.esm.js.map