giser-convert-crs 1.0.0 → 1.0.2

package/dist/giserConvertCrs.esm.js

@@ -1,454 +1,848 @@
-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 ERR_LONLAT = 'Invalid coordinate: longitude and latitude must be finite numbers.';
+const ERR_PLANE = 'Invalid coordinate: x and y must be finite numbers.';
+
+/**
+ * Hot-path scratch buffers.
+ *
+ * Every write below is consumed within the same synchronous call frame
+ * (never across an await / callback boundary), so sharing these buffers is
+ * safe and removes the per-point allocations that dominated batch runs.
+ */
+const _delta = [0, 0];
+const _forward = [0, 0];
+const _back = [0, 0];
+
+function assertLonLat(lon, lat) {
+  if (!Number.isFinite(lon) || !Number.isFinite(lat)) {
+    throw new Error(ERR_LONLAT);
+  }
+}
+
+function assertPlane(x, y) {
+  if (!Number.isFinite(x) || !Number.isFinite(y)) {
+    throw new Error(ERR_PLANE);
+  }
+}
+
+function outOfChina(lat, lon) {
+  if (Array.isArray(lat)) {
+    return outOfChina(lat[1], lat[0]);
+  }
+  return lon < 72.004 || lon > 137.8347 || lat < 0.8293 || lat > 55.8271;
+}
+
+function 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;
+}
+
+function 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;
+}
+
+/**
+ * Writes the GCJ-02 offset for (lat, lon) into `out` as [dLat, dLon].
+ * Allocation-free core of the public `delta()`.
+ */
+function deltaInto(lat, lon, out) {
+  const x = lon - 105.0;
+  const y = lat - 35.0;
+  let dLat = transformLat(x, y);
+  let dLon = transformLon(x, y);
+  const radLat = lat / 180.0 * PI;
+  const sinLat = Math.sin(radLat);
+  const magic = 1 - ECCENTRICITY_SQUARED * sinLat * sinLat;
+  const sqrtMagic = Math.sqrt(magic);
+
+  out[0] = (dLat * 180.0) / ((SEMI_MAJOR_AXIS * (1 - ECCENTRICITY_SQUARED)) / (magic * sqrtMagic) * PI);
+  out[1] = (dLon * 180.0) / (SEMI_MAJOR_AXIS / sqrtMagic * Math.cos(radLat) * PI);
+}
+
+function delta(lat, lon) {
+  deltaInto(lat, lon, _delta);
+  return { lat: _delta[0], lon: _delta[1] };
+}
+
+/* ------------------------------------------------------------------ *
+ * Allocation-free transform cores: (lon, lat, out) => out
+ * ------------------------------------------------------------------ */
+
+function wgs84_gcj02Into(wgsLon, wgsLat, out) {
+  if (outOfChina(wgsLat, wgsLon)) {
+    out[0] = wgsLon;
+    out[1] = wgsLat;
+    return out;
+  }
+  deltaInto(wgsLat, wgsLon, _delta);
+  out[0] = wgsLon + _delta[1];
+  out[1] = wgsLat + _delta[0];
+  return out;
+}
+
+function gcj02_wgs84Into(gcjLon, gcjLat, out) {
+  if (outOfChina(gcjLat, gcjLon)) {
+    out[0] = gcjLon;
+    out[1] = gcjLat;
+    return out;
+  }
+  deltaInto(gcjLat, gcjLon, _delta);
+  out[0] = gcjLon - _delta[1];
+  out[1] = gcjLat - _delta[0];
+  return out;
+}
+
+function gcj02_wgs84_preciseInto(gcjLon, gcjLat, out) {
+  if (outOfChina(gcjLat, gcjLon)) {
+    out[0] = gcjLon;
+    out[1] = gcjLat;
+    return out;
+  }
+
+  let wgsLon = gcjLon;
+  let wgsLat = gcjLat;
+
+  for (let i = 0; i < 5; i++) {
+    wgs84_gcj02Into(wgsLon, wgsLat, _forward);
+    const dLon = _forward[0] - gcjLon;
+    const dLat = _forward[1] - gcjLat;
+    wgsLon -= dLon;
+    wgsLat -= dLat;
+    if (Math.abs(dLon) < 1e-11 && Math.abs(dLat) < 1e-11) break;
+  }
+
+  out[0] = wgsLon;
+  out[1] = wgsLat;
+  return out;
+}
+
+function gcj02_bd09llInto(gcjLon, gcjLat, out) {
+  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);
+  out[0] = z * Math.cos(theta) + 0.0065;
+  out[1] = z * Math.sin(theta) + 0.006;
+  return out;
+}
+
+function bd09ll_gcj02Into(bdLon, bdLat, out) {
+  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);
+  out[0] = z * Math.cos(theta);
+  out[1] = z * Math.sin(theta);
+  return out;
+}
+
+function bd09ll_gcj02_preciseInto(bdLon, bdLat, out) {
+  bd09ll_gcj02Into(bdLon, bdLat, out);
+  let gLon = out[0];
+  let gLat = out[1];
+  for (let i = 0; i < 2; i++) {
+    gcj02_bd09llInto(gLon, gLat, _back);
+    gLon -= (_back[0] - bdLon);
+    gLat -= (_back[1] - bdLat);
+  }
+  out[0] = gLon;
+  out[1] = gLat;
+  return out;
+}
+
+function wgs84_epsg3857Into(lon, lat, out) {
+  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;
+  out[0] = x;
+  out[1] = EPSG3857_RADIUS * Math.log(Math.tan(PI / 4.0 + radLat / 2.0));
+  return out;
+}
+
+function epsg3857_wgs84Into(x, y, out) {
+  out[0] = (x / (EPSG3857_RADIUS * PI)) * 180.0;
+  out[1] = (2.0 * Math.atan(Math.exp(y / EPSG3857_RADIUS)) - PI / 2.0) * 180.0 / PI;
+  return out;
+}
+
+/**
+ * GCJ-02 -> EPSG:3857. The datum shift is inverted before projecting, so
+ * `precise` selects the fixed-point inverse instead of the fast one-off
+ * approximation — mirroring `gcj02_wgs84_precise`. Defaults to `true`.
+ */
+function gcj02_epsg3857Into(lon, lat, out, precise = true) {
+  (precise ? gcj02_wgs84_preciseInto : gcj02_wgs84Into)(lon, lat, _back);
+  return wgs84_epsg3857Into(_back[0], _back[1], out);
+}
+
+/** BD-09 -> EPSG:3857. `precise` behaves as in {@link gcj02_epsg3857Into}. */
+function bd09ll_epsg3857Into(lon, lat, out, precise = true) {
+  if (precise) {
+    bd09ll_gcj02_preciseInto(lon, lat, _forward);
+    gcj02_wgs84_preciseInto(_forward[0], _forward[1], _back);
+    return wgs84_epsg3857Into(_back[0], _back[1], out);
+  }
+  bd09ll_gcj02Into(lon, lat, _forward);
+  gcj02_wgs84Into(_forward[0], _forward[1], _back);
+  return wgs84_epsg3857Into(_back[0], _back[1], out);
+}
+
+function wgs84_bd09llInto(wgsLon, wgsLat, out) {
+  wgs84_gcj02Into(wgsLon, wgsLat, _forward);
+  return gcj02_bd09llInto(_forward[0], _forward[1], out);
+}
+
+function bd09ll_wgs84Into(bdLon, bdLat, out) {
+  bd09ll_gcj02Into(bdLon, bdLat, _forward);
+  return gcj02_wgs84Into(_forward[0], _forward[1], out);
+}
+
+function bd09ll_wgs84_preciseInto(bdLon, bdLat, out) {
+  bd09ll_gcj02_preciseInto(bdLon, bdLat, _forward);
+  return gcj02_wgs84_preciseInto(_forward[0], _forward[1], out);
+}
+
+function epsg3857_gcj02Into(x, y, out) {
+  epsg3857_wgs84Into(x, y, _forward);
+  return wgs84_gcj02Into(_forward[0], _forward[1], out);
+}
+
+function epsg3857_bd09llInto(x, y, out) {
+  epsg3857_wgs84Into(x, y, _forward);
+  return wgs84_bd09llInto(_forward[0], _forward[1], out);
+}
+
+/* ------------------------------------------------------------------ *
+ * Public array-returning API (validated at the boundary)
+ * ------------------------------------------------------------------ */
+
+/** Validates then delegates to an allocation-free core. */
+const expose = (into, validate = assertLonLat) => (lon, lat) => {
+  validate(lon, lat);
+  return into(lon, lat, [0, 0]);
+};
+
+const wgs84_gcj02 = expose(wgs84_gcj02Into);
+const gcj02_wgs84 = expose(gcj02_wgs84Into);
+const gcj02_wgs84_precise = expose(gcj02_wgs84_preciseInto);
+const gcj02_bd09ll = expose(gcj02_bd09llInto);
+const bd09ll_gcj02 = expose(bd09ll_gcj02Into);
+const bd09ll_gcj02_precise = expose(bd09ll_gcj02_preciseInto);
+const wgs84_bd09ll = expose(wgs84_bd09llInto);
+const bd09ll_wgs84 = expose(bd09ll_wgs84Into);
+const bd09ll_wgs84_precise = expose(bd09ll_wgs84_preciseInto);
+const wgs84_epsg3857 = expose(wgs84_epsg3857Into);
+const epsg3857_wgs84 = expose(epsg3857_wgs84Into, assertPlane);
+const epsg3857_gcj02 = expose(epsg3857_gcj02Into, assertPlane);
+const epsg3857_bd09ll = expose(epsg3857_bd09llInto, assertPlane);
+
+const gcj02_epsg3857 = (lon, lat, precise = true) => {
+  assertLonLat(lon, lat);
+  return gcj02_epsg3857Into(lon, lat, [0, 0], precise);
+};
+
+const bd09ll_epsg3857 = (lon, lat, precise = true) => {
+  assertLonLat(lon, lat);
+  return bd09ll_epsg3857Into(lon, lat, [0, 0], precise);
+};
+
+/**
+ * WGS-84 -> GCJ-02 as `[lon, lat]`, matching every other entry point.
+ * Previously took `(lat, lon)` and returned a `{ lat, lon }` object.
+ */
+function gcj_encrypt(wgsLon, wgsLat) {
+  return wgs84_gcj02(wgsLon, wgsLat);
+}
+
+const GPS = {
+  PI,
+  x_pi: X_PI,
+  EARTH_RADIUS: EPSG3857_RADIUS,
+
+  delta,
+  transformLat,
+  transformLon,
+  outOfChina,
+
+  wgs84_gcj02,
+  gcj02_wgs84,
+  gcj02_wgs84_precise,
+  gcj02_bd09ll,
+  bd09ll_gcj02,
+  bd09ll_gcj02_precise,
+  wgs84_bd09ll,
+  bd09ll_wgs84,
+  bd09ll_wgs84_precise,
+  wgs84_epsg3857,
+  epsg3857_wgs84,
+  gcj02_epsg3857,
+  epsg3857_gcj02,
+  bd09ll_epsg3857,
+  epsg3857_bd09ll,
+
+  gcj_encrypt,
+
+  /** @deprecated internal helper, kept so existing callers keep working. */
+  _assertLonLat: assertLonLat
+};
+
+/**
+ * Allocation-free cores keyed by `<from>_<to>`, consumed by
+ * ProjectionTransform so batch runs never allocate a result array.
+ */
+GPS._into = {
+  wgs84_gcj02: wgs84_gcj02Into,
+  gcj02_wgs84: gcj02_wgs84Into,
+  gcj02_wgs84_precise: gcj02_wgs84_preciseInto,
+  gcj02_bd09ll: gcj02_bd09llInto,
+  bd09ll_gcj02: bd09ll_gcj02Into,
+  bd09ll_gcj02_precise: bd09ll_gcj02_preciseInto,
+  wgs84_bd09ll: wgs84_bd09llInto,
+  bd09ll_wgs84: bd09ll_wgs84Into,
+  bd09ll_wgs84_precise: bd09ll_wgs84_preciseInto,
+  wgs84_epsg3857: wgs84_epsg3857Into,
+  epsg3857_wgs84: epsg3857_wgs84Into,
+  gcj02_epsg3857: gcj02_epsg3857Into,
+  epsg3857_gcj02: epsg3857_gcj02Into,
+  bd09ll_epsg3857: bd09ll_epsg3857Into,
+  epsg3857_bd09ll: epsg3857_bd09llInto
+};
+
+const crs = {
+  bd09ll: '+proj=longlat +datum=BD09',
+  gcj02: '+proj=longlat +datum=GCJ02',
+  wgs84: '+proj=longlat +datum=WGS84 +no_defs',
+  cgcs2000: '+proj=longlat +ellps=GRS80 +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 CRS_ALIASES = {
+  'bd-09': 'bd09ll',
+  'bd09': 'bd09ll',
+  'bd09ll': 'bd09ll',
+  'bd-09ll': 'bd09ll',
+  'epsg:4326': 'wgs84',
+  'epsg4326': 'wgs84',
+  '4326': 'wgs84',
+  'cgcs2000': 'wgs84',
+  'cgcs-2000': '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'
+};
+
+/**
+ * proj4 strings accepted as input, mapped to a `crs` key.
+ *
+ * Keys are matched after whitespace collapsing + lowercasing, so the many
+ * spellings of the same datum in the wild all resolve. Values are normalised
+ * through `CRS_ALIASES` before use (CGCS2000 folds onto WGS-84 at民用精度).
+ */
+const PROJ4_TO_CRS = {
+  [crs.wgs84]: 'wgs84',
+  [crs.cgcs2000]: 'cgcs2000',
+  [crs.gcj02]: 'gcj02',
+  [crs.bd09ll]: 'bd09ll',
+  [crs.epsg3857]: 'epsg3857',
+
+  // common WGS-84 spellings
+  '+proj=longlat +datum=wgs84': 'wgs84',
+  '+proj=longlat +ellps=wgs84': 'wgs84',
+  '+proj=longlat +ellps=wgs84 +no_defs': 'wgs84',
+  '+proj=longlat +a=6378137 +b=6356752.314245 +no_defs': 'wgs84',
+  '+proj=longlat +a=6378137 +b=6356752.314245 +no_defs +towgs84=0,0,0': 'wgs84',
+
+  // common CGCS2000 / GRS80 spellings
+  '+proj=longlat +ellps=grs80': 'cgcs2000',
+  '+proj=longlat +ellps=grs80 +no_defs': 'cgcs2000',
+  '+proj=longlat +ellps=grs80 +towgs84=0,0,0,0,0,0,0 +no_defs': 'cgcs2000',
+  '+proj=longlat +a=6378137 +b=6356752.314140 +no_defs': 'cgcs2000',
+
+  // GCJ-02 / BD-09 are not standard EPSG datum codes, but these appear in configs
+  '+proj=longlat +ellps=wgs84 +nadgrids=@china': 'gcj02'
+};
+
+const ERR_COORD = 'Invalid coordinate: longitude and latitude must be finite numbers.';
+
+/** ProjectionTransform scratch buffer, kept module-level to avoid per-point allocation. */
+const _result = [0, 0];
+
+/**
+ * Explicit `precise` mapping, keyed by `<from>_<to>`.
+ *
+ * Only pairs whose datum shift has to be *inverted* appear here; everything
+ * else is a forward formula that has no precision mode. Keeping this as a
+ * table (rather than scattered `if`s) is what stops a new CRS pair from
+ * silently inheriting the approximate inverse.
+ */
+const PRECISE_CORES = {
+  gcj02_wgs84: GPS._into.gcj02_wgs84_precise,
+  bd09ll_wgs84: GPS._into.bd09ll_wgs84_precise,
+  bd09ll_gcj02: GPS._into.bd09ll_gcj02_precise
 };
 
-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]);
-  }
+/** Fast counterparts used when `precise: false`. */
+const FAST_CORES = {
+  gcj02_epsg3857: (lon, lat, out) => GPS._into.gcj02_epsg3857(lon, lat, out, false),
+  bd09ll_epsg3857: (lon, lat, out) => GPS._into.bd09ll_epsg3857(lon, lat, out, false)
 };
 
-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;
-  }
+function resolveInto(from, to, isPrecise) {
+  const key = `${from}_${to}`;
+  if (isPrecise) return PRECISE_CORES[key] || GPS._into[key];
+  return FAST_CORES[key] || GPS._into[key];
+}
+
+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 => (coord.length > 2
+          ? [Number(coord[0]), Number(coord[1]), ...coord.slice(2)]
+          : [Number(coord[0]), Number(coord[1])]);
+    }
+
+    const into = resolveInto(from, to, isPrecise);
+    if (typeof into !== '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(ERR_COORD);
+        into(x, y, _result);
+        coord[0] = _result[0];
+        coord[1] = _result[1];
+        return coord;
+      };
+    }
+
+    return coord => {
+      const x = Number(coord[0]);
+      const y = Number(coord[1]);
+      if (!Number.isFinite(x) || !Number.isFinite(y)) throw new Error(ERR_COORD);
+      into(x, y, _result);
+      return coord.length > 2
+        ? [_result[0], _result[1], ...coord.slice(2)]
+        : [_result[0], _result[1]];
+    };
+  },
+
+  _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;
+  },
+
+  /**
+   * Resolves a proj4 definition to an internal CRS id, or `null`.
+   * Always returns an id already folded through `CRS_ALIASES`.
+   */
+  _toCRS(proj) {
+    if (typeof proj !== 'string') return null;
+
+    const key = proj.trim().replace(/\s+/g, ' ').toLowerCase();
+    let crsName = PROJ4_TO_CRS[key];
+
+    if (!crsName) {
+      // honour caller-extended `crs` entries
+      for (const name in this.crs) {
+        if (key === String(this.crs[name]).trim().replace(/\s+/g, ' ').toLowerCase()) {
+          crsName = name;
+          break;
+        }
+      }
+    }
+
+    return crsName ? (CRS_ALIASES[crsName] || crsName) : null;
+  },
+
+  /**
+   * Structural position test only.
+   *
+   * Deliberately does *not* coerce with `Number()`: the coordinate
+   * transformer validates and coerces once, so validating here too would
+   * double the conversion cost on every point of a batch.
+   */
+  _isCoord(coordinate) {
+    return Array.isArray(coordinate) &&
+      coordinate.length >= 2 &&
+      !Array.isArray(coordinate[0]) &&
+      !Array.isArray(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 +850,36 @@ const giserConvertCrs = {
   ProjectionTransform,
   WKT,
 
-  transform(input, fromCRS, toCRS) {
-    if (input == null || input === '') return null;
+  transform(input, fromCRS, toCRS, options) {
+    if (input == null) return null;
 
     if (typeof input === 'string') {
+      // blank / whitespace-only WKT is treated as "no geometry", not an error
+      if (!input.trim()) return null;
       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