giser-convert-crs 1.0.1 → 1.0.2

package/dist/giserConvertCrs.umd.js

@@ -11,178 +11,325 @@
   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'
   };
 
@@ -196,6 +343,7 @@
     '4326': 'wgs84',
     'cgcs2000': 'wgs84',
     'cgcs-2000': 'wgs84',
+    'cgcs 2000': 'wgs84',
     'epsg:4490': 'wgs84',
     'epsg4490': 'wgs84',
     '4490': 'wgs84',
@@ -213,6 +361,68 @@
     '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,
 
@@ -241,18 +451,13 @@
       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}.`);
       }
 
@@ -260,12 +465,10 @@
         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;
         };
       }
@@ -273,11 +476,11 @@
       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]];
       };
     },
 
@@ -401,20 +604,41 @@
       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]);
     }
   };
 
@@ -633,9 +857,11 @@
     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);