giser-convert-crs 1.0.0

package/README.md

@@ -0,0 +1,231 @@
+# giserConvertCrs
+
+`giserConvertCrs` 是一个几何坐标系转换工具库，支持 WGS-84、GCJ-02、BD-09 之间的点、线、面、数组、GeoJSON 和 WKT 转换。
+
+> 注意：npm 包名需要保持小写，因此发布包名仍为 `giser-convert-crs`；代码变量、浏览器全局变量、构建文件名统一使用 `giserConvertCrs`。
+
+## 坐标系写法
+
+所有转换方法的 `fromCRS` 和 `toCRS` 都支持下面这些写法：
+
+| 坐标系 | 可用写法 |
+| --- | --- |
+| WGS-84 | `wgs84`, `wgs-84`, `EPSG:4326`, `epsg:4326` |
+| GCJ-02 | `gcj02`, `gcj-02` |
+| BD-09 | `bd09ll`, `bd09`, `bd-09` |
+
+```js
+giserConvertCrs.transform([116.397, 39.908], 'wgs84', 'gcj02');
+giserConvertCrs.transform([116.397, 39.908], 'EPSG:4326', 'bd09');
+giserConvertCrs.transform([116.397, 39.908], 'bd-09', 'wgs84');
+```
+
+坐标顺序固定为 `[lon, lat]`，即经度在前、纬度在后。三维坐标也支持，例如 `[lon, lat, height]`，转换后会保留高度值。
+
+## 支持的输入
+
+### 单个点
+
+```js
+[116.397, 39.908]
+[116.397, 39.908, 45]
+```
+
+### 点数组
+
+```js
+[
+  [116.397, 39.908],
+  [117.2, 40.1]
+]
+```
+
+### GeoJSON
+
+`giserConvertCrs.transformGeoJSON(geojson, 'wgs84', 'gcj02')` 里的 `geojson` 是标准 GeoJSON 几何对象、Feature 或 FeatureCollection。
+
+Point：
+
+```js
+const geojson = {
+  type: 'Point',
+  coordinates: [116.397, 39.908]
+};
+
+giserConvertCrs.transformGeoJSON(geojson, 'wgs84', 'gcj02');
+```
+
+LineString：
+
+```js
+const geojson = {
+  type: 'LineString',
+  coordinates: [
+    [116.397, 39.908],
+    [117.2, 40.1]
+  ]
+};
+
+giserConvertCrs.transformGeoJSON(geojson, 'wgs84', 'gcj02');
+```
+
+Polygon：
+
+```js
+const geojson = {
+  type: 'Polygon',
+  coordinates: [[
+    [116.0, 39.9],
+    [116.1, 39.9],
+    [116.1, 40.0],
+    [116.0, 39.9]
+  ]]
+};
+
+giserConvertCrs.transformGeoJSON(geojson, 'wgs84', 'gcj02');
+```
+
+FeatureCollection：
+
+```js
+const geojson = {
+  type: 'FeatureCollection',
+  features: [
+    {
+      type: 'Feature',
+      properties: { name: '点' },
+      geometry: {
+        type: 'Point',
+        coordinates: [116.397, 39.908]
+      }
+    },
+    {
+      type: 'Feature',
+      properties: { name: '线' },
+      geometry: {
+        type: 'LineString',
+        coordinates: [
+          [116.397, 39.908],
+          [117.2, 40.1]
+        ]
+      }
+    }
+  ]
+};
+
+giserConvertCrs.transformGeoJSON(geojson, 'wgs84', 'gcj02');
+```
+
+还支持 `MultiPoint`、`MultiLineString`、`MultiPolygon`、`GeometryCollection`。
+
+### WKT
+
+```js
+'POINT(116.397 39.908)'
+'LINESTRING(116 39, 117 40)'
+'POLYGON((116 39, 117 39, 117 40, 116 39))'
+'MULTIPOINT((116 39), (117 40))'
+'MULTILINESTRING((116 39, 117 40), (118 41, 119 42))'
+'MULTIPOLYGON(((116 39, 117 39, 117 40, 116 39)))'
+```
+
+## 安装
+
+```bash
+npm install giser-convert-crs
+```
+
+## 引入方式
+
+### ES Module
+
+```js
+import giserConvertCrs, { WKT, GPS } from 'giser-convert-crs';
+
+const point = giserConvertCrs.transform([116.397, 39.908], 'wgs84', 'gcj02');
+const geometry = WKT.parse('LINESTRING(116 39, 117 40)');
+const bd09 = GPS.wgs84_bd09ll(116.397, 39.908);
+```
+
+### Script
+
+```html
+<script src="https://unpkg.com/giser-convert-crs/dist/giserConvertCrs.umd.js"></script>
+<script>
+  const point = giserConvertCrs.transform([116.397, 39.908], 'wgs84', 'gcj02');
+</script>
+```
+
+## API
+
+### `giserConvertCrs.transform(input, fromCRS, toCRS)`
+
+统一转换入口，会根据输入类型自动处理：
+
+- 输入坐标数组时，返回坐标数组。
+- 输入 GeoJSON 时，返回同结构的新 GeoJSON。
+- 输入 WKT 字符串时，返回 WKT 字符串。
+
+```js
+giserConvertCrs.transform([116.397, 39.908], 'wgs84', 'gcj02');
+giserConvertCrs.transform([[116.397, 39.908], [117.2, 40.1]], 'wgs84', 'bd09ll');
+giserConvertCrs.transform('LINESTRING(116 39, 117 40)', 'wgs84', 'gcj02');
+```
+
+### `giserConvertCrs.transformPoint(coord, fromCRS, toCRS)`
+
+```js
+giserConvertCrs.transformPoint([116.397, 39.908], 'wgs84', 'gcj02');
+```
+
+### `giserConvertCrs.transformPoints(points, fromCRS, toCRS)`
+
+```js
+giserConvertCrs.transformPoints([[116.397, 39.908], [117.2, 40.1]], 'wgs84', 'gcj02');
+```
+
+### `giserConvertCrs.transformGeoJSON(geojson, fromCRS, toCRS)`
+
+```js
+const result = giserConvertCrs.transformGeoJSON(geojson, 'wgs84', 'gcj02');
+```
+
+### `giserConvertCrs.transformWKT(wkt, fromCRS, toCRS)`
+
+```js
+giserConvertCrs.transformWKT('POINT(116.397 39.908)', 'wgs84', 'gcj02');
+giserConvertCrs.transformWKT('POLYGON((116 39, 117 39, 117 40, 116 39))', 'wgs84', 'gcj02');
+```
+
+### `giserConvertCrs.WKT`
+
+```js
+const geojson = giserConvertCrs.WKT.parse('MULTIPOINT((116 39), (117 40))');
+const wkt = giserConvertCrs.WKT.stringify({
+  type: 'LineString',
+  coordinates: [[116, 39, 10], [117, 40, 20]]
+});
+```
+
+### `giserConvertCrs.GPS`
+
+```js
+giserConvertCrs.GPS.wgs84_gcj02(116.397, 39.908);
+giserConvertCrs.GPS.gcj02_wgs84(116.403243, 39.909403);
+giserConvertCrs.GPS.gcj02_wgs84_precise(116.403243, 39.909403);
+giserConvertCrs.GPS.gcj02_bd09ll(116.403243, 39.909403);
+giserConvertCrs.GPS.bd09ll_gcj02(116.409, 39.915);
+giserConvertCrs.GPS.wgs84_bd09ll(116.397, 39.908);
+giserConvertCrs.GPS.bd09ll_wgs84(116.409, 39.915);
+```
+
+## 注意事项
+
+1. 坐标顺序固定为 `[lon, lat]`。
+2. WGS-84 和 GCJ-02 的加偏转换只对中国范围内坐标生效，中国境外坐标会原样返回。
+3. `gcj02_wgs84` 是常规近似反算，`gcj02_wgs84_precise` 是更高精度反算。
+4. 不支持的坐标系会抛出错误，例如 `epsg:3857`。
+
+## License
+
+MIT

package/dist/giserConvertCrs.esm.js

@@ -0,0 +1,487 @@
+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 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 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 giserConvertCrs = {
+  GPS,
+  ProjectionTransform,
+  WKT,
+
+  transform(input, fromCRS, toCRS) {
+    if (input == null || input === '') return null;
+
+    if (typeof input === 'string') {
+      const geoJSON = WKT.parse(input);
+      return WKT.stringify(ProjectionTransform.transform(geoJSON, fromCRS, toCRS));
+    }
+
+    return ProjectionTransform.transform(input, fromCRS, toCRS);
+  },
+
+  transformPoint(coord, fromCRS, toCRS) {
+    return this.transform(coord, fromCRS, toCRS);
+  },
+
+  transformPoints(points, fromCRS, toCRS) {
+    return this.transform(points, fromCRS, toCRS);
+  },
+
+  transformGeoJSON(geoJSON, fromCRS, toCRS) {
+    return this.transform(geoJSON, fromCRS, toCRS);
+  },
+
+  transformWKT(wkt, fromCRS, toCRS) {
+    return this.transform(wkt, fromCRS, toCRS);
+  }
+};
+
+export { GPS, ProjectionTransform, WKT, giserConvertCrs as default };

package/dist/giserConvertCrs.umd.js

@@ -0,0 +1,495 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.giserConvertCrs = factory());
+})(this, (function () { 'use strict';
+
+  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 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 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 giserConvertCrs = {
+    GPS,
+    ProjectionTransform,
+    WKT,
+
+    transform(input, fromCRS, toCRS) {
+      if (input == null || input === '') return null;
+
+      if (typeof input === 'string') {
+        const geoJSON = WKT.parse(input);
+        return WKT.stringify(ProjectionTransform.transform(geoJSON, fromCRS, toCRS));
+      }
+
+      return ProjectionTransform.transform(input, fromCRS, toCRS);
+    },
+
+    transformPoint(coord, fromCRS, toCRS) {
+      return this.transform(coord, fromCRS, toCRS);
+    },
+
+    transformPoints(points, fromCRS, toCRS) {
+      return this.transform(points, fromCRS, toCRS);
+    },
+
+    transformGeoJSON(geoJSON, fromCRS, toCRS) {
+      return this.transform(geoJSON, fromCRS, toCRS);
+    },
+
+    transformWKT(wkt, fromCRS, toCRS) {
+      return this.transform(wkt, fromCRS, toCRS);
+    }
+  };
+
+  return giserConvertCrs;
+
+}));

package/dist/index.d.ts

@@ -0,0 +1,117 @@
+export type CRS =
+  | 'wgs84'
+  | 'wgs-84'
+  | 'EPSG:4326'
+  | 'epsg:4326'
+  | 'gcj02'
+  | 'gcj-02'
+  | 'bd09ll'
+  | 'bd09'
+  | 'bd-09'
+  | {
+      type: 'proj4';
+      properties: {
+        proj: string;
+      };
+    };
+
+export type Position = [number, number] | [number, number, number] | number[];
+
+export interface Point {
+  type: 'Point';
+  coordinates: Position;
+}
+
+export interface LineString {
+  type: 'LineString';
+  coordinates: Position[];
+}
+
+export interface Polygon {
+  type: 'Polygon';
+  coordinates: Position[][];
+}
+
+export interface MultiPoint {
+  type: 'MultiPoint';
+  coordinates: Position[];
+}
+
+export interface MultiLineString {
+  type: 'MultiLineString';
+  coordinates: Position[][];
+}
+
+export interface MultiPolygon {
+  type: 'MultiPolygon';
+  coordinates: Position[][][];
+}
+
+export interface GeometryCollection {
+  type: 'GeometryCollection';
+  geometries: Geometry[];
+}
+
+export type Geometry =
+  | Point
+  | LineString
+  | Polygon
+  | MultiPoint
+  | MultiLineString
+  | MultiPolygon
+  | GeometryCollection;
+
+export interface Feature<G = Geometry> {
+  type: 'Feature';
+  geometry: G | null;
+  properties?: Record<string, unknown> | null;
+  id?: string | number;
+}
+
+export interface FeatureCollection<G = Geometry> {
+  type: 'FeatureCollection';
+  features: Feature<G>[];
+}
+
+export type GeoJSON = Geometry | Feature | FeatureCollection;
+
+export interface GPSApi {
+  wgs84_gcj02(lon: number, lat: number): [number, number];
+  gcj02_wgs84(lon: number, lat: number): [number, number];
+  gcj02_wgs84_precise(lon: number, lat: number): [number, number];
+  gcj02_bd09ll(lon: number, lat: number): [number, number];
+  bd09ll_gcj02(lon: number, lat: number): [number, number];
+  wgs84_bd09ll(lon: number, lat: number): [number, number];
+  bd09ll_wgs84(lon: number, lat: number): [number, number];
+  bd09ll_wgs84_precise(lon: number, lat: number): [number, number];
+  outOfChina(lat: number, lon: number): boolean;
+}
+
+export interface ProjectionTransformApi {
+  crs: Record<'wgs84' | 'gcj02' | 'bd09ll', string>;
+  transform<T extends Position | Position[] | GeoJSON>(source: T, fromCRS: CRS, toCRS: CRS): T;
+}
+
+export interface WKTApi {
+  parse(wkt: string): Geometry;
+  stringify(geojson: Geometry): string;
+}
+
+export interface giserConvertCrs {
+  GPS: GPSApi;
+  ProjectionTransform: ProjectionTransformApi;
+  WKT: WKTApi;
+  transform(input: string, fromCRS: CRS, toCRS: CRS): string;
+  transform<T extends Position | Position[] | GeoJSON>(input: T, fromCRS: CRS, toCRS: CRS): T;
+  transformPoint<T extends Position>(coord: T, fromCRS: CRS, toCRS: CRS): T;
+  transformPoints<T extends Position[]>(points: T, fromCRS: CRS, toCRS: CRS): T;
+  transformGeoJSON<T extends GeoJSON>(geojson: T, fromCRS: CRS, toCRS: CRS): T;
+  transformWKT(wkt: string, fromCRS: CRS, toCRS: CRS): string;
+}
+
+export const GPS: GPSApi;
+export const ProjectionTransform: ProjectionTransformApi;
+export const WKT: WKTApi;
+
+declare const giserConvertCrs: giserConvertCrs;
+export default giserConvertCrs;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "giser-convert-crs",
+  "version": "1.0.0",
+  "description": "China CRS geometry conversion library for WGS-84, GCJ-02, BD-09, GeoJSON and WKT.",
+  "main": "dist/giserConvertCrs.umd.js",
+  "module": "dist/giserConvertCrs.esm.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rollup -c && node scripts/copy-types.js",
+    "dev": "rollup -c -w",
+    "test": "node scripts/test.js"
+  },
+  "type": "module",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "rollup": "^4.28.0"
+  },
+  "keywords": [
+    "coordinate",
+    "transform",
+    "wgs84",
+    "gcj02",
+    "bd09",
+    "wkt",
+    "geojson"
+  ],
+  "author": "",
+  "license": "MIT"
+}