giser-convert-crs 1.0.1 → 1.0.2

package/dist/giserConvertCrs.esm.js

@@ -5,178 +5,325 @@ 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]);
-  },
+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);
+  }
+}
 
-  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];
-  },
+function assertPlane(x, y) {
+  if (!Number.isFinite(x) || !Number.isFinite(y)) {
+    throw new Error(ERR_PLANE);
+  }
+}
 
-  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];
-  },
+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;
+  }
 
-  gcj02_epsg3857(lon, lat) {
-    const wgs = this.gcj02_wgs84_precise(lon, lat);
-    return this.wgs84_epsg3857(wgs[0], wgs[1]);
-  },
+  let wgsLon = gcjLon;
+  let wgsLat = gcjLat;
 
-  epsg3857_gcj02(x, y) {
-    const wgs = this.epsg3857_wgs84(x, y);
-    return this.wgs84_gcj02(wgs[0], wgs[1]);
-  },
+  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;
+  }
 
-  bd09ll_epsg3857(lon, lat) {
-    const wgs = this.bd09ll_wgs84_precise(lon, lat);
-    return this.wgs84_epsg3857(wgs[0], wgs[1]);
-  },
+  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]);
+};
 
-  epsg3857_bd09ll(x, y) {
-    const wgs = this.epsg3857_wgs84(x, y);
-    return this.wgs84_bd09ll(wgs[0], wgs[1]);
-  },
+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);
+};
 
-  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;
-  },
+const bd09ll_epsg3857 = (lon, lat, precise = true) => {
+  assertLonLat(lon, lat);
+  return bd09ll_epsg3857Into(lon, lat, [0, 0], precise);
+};
 
-  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;
-  },
+/**
+ * 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);
+}
 
-  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;
-  },
+const GPS = {
+  PI,
+  x_pi: X_PI,
+  EARTH_RADIUS: EPSG3857_RADIUS,
 
-  gcj_encrypt(wgsLat, wgsLon) {
-    const [lon, lat] = this.wgs84_gcj02(wgsLon, wgsLat);
-    return { lat, lon };
-  },
+  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
+};
 
-  _assertLonLat(lon, lat) {
-    if (!Number.isFinite(lon) || !Number.isFinite(lat)) {
-      throw new Error('Invalid coordinate: longitude and latitude must be finite numbers.');
-    }
-  }
+/**
+ * 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'
 };
 
@@ -190,6 +337,7 @@ const CRS_ALIASES = {
   '4326': 'wgs84',
   'cgcs2000': 'wgs84',
   'cgcs-2000': 'wgs84',
+  'cgcs 2000': 'wgs84',
   'epsg:4490': 'wgs84',
   'epsg4490': 'wgs84',
   '4490': 'wgs84',
@@ -207,6 +355,68 @@ const CRS_ALIASES = {
   '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
+};
+
+/** 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)
+};
+
+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,
 
@@ -235,18 +445,13 @@ const ProjectionTransform = {
     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}`;
+        : coord => (coord.length > 2
+          ? [Number(coord[0]), Number(coord[1]), ...coord.slice(2)]
+          : [Number(coord[0]), Number(coord[1])]);
     }
 
-    const fn = GPS[method];
-    if (typeof fn !== 'function') {
+    const into = resolveInto(from, to, isPrecise);
+    if (typeof into !== 'function') {
       throw new Error(`Unsupported CRS transform: ${from} -> ${to}.`);
     }
 
@@ -254,12 +459,10 @@ const ProjectionTransform = {
       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;
+        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;
       };
     }
@@ -267,11 +470,11 @@ const ProjectionTransform = {
     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)];
+      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]];
     };
   },
 
@@ -395,20 +598,41 @@ const ProjectionTransform = {
     return normalized;
   },
 
+  /**
+   * Resolves a proj4 definition to an internal CRS id, or `null`.
+   * Always returns an id already folded through `CRS_ALIASES`.
+   */
   _toCRS(proj) {
-    for (const key in this.crs) {
-      if (proj === this.crs[key]) return key;
+    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 null;
+
+    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]) &&
-      Number.isFinite(Number(coordinate[0])) &&
-      Number.isFinite(Number(coordinate[1]));
+      !Array.isArray(coordinate[1]);
   }
 };
 
@@ -627,9 +851,11 @@ const giserConvertCrs = {
   WKT,
 
   transform(input, fromCRS, toCRS, options) {
-    if (input == null || input === '') return null;
+    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);
       const transformed = ProjectionTransform.transform(geoJSON, fromCRS, toCRS, options);
       return WKT.stringify(transformed, options);