wkt-parse-and-geojson 1.0.4 → 1.0.6

package/README.md

@@ -83,8 +83,12 @@ npm install wkt-parse-and-geojson
 // CommonJS
 const { parse, build, wktToFeature } = require('wkt-parse-and-geojson');
 
-// ES Module
+// ES Module - 按需导入
 import { parse, build, wktToFeature } from 'wkt-parse-and-geojson';
+
+// ES Module - 命名空间导入（避免命名冲突）
+import WKT from 'wkt-parse-and-geojson';
+const geom = WKT.parse('POINT (116.39 39.91)');
 ```
 
 ### 浏览器 (script 标签)
@@ -93,13 +97,13 @@ import { parse, build, wktToFeature } from 'wkt-parse-and-geojson';
 <!-- UMD 方式：通过 script 标签直接引入，全局变量 WKTGeoJSON -->
 <script src="https://unpkg.com/wkt-parse-and-geojson/dist/index.umd.js"></script>
 <script>
+  // 方式一：使用命名空间（推荐，避免命名冲突）
   const geom = WKTGeoJSON.parse('POINT (116.39 39.91)');
   console.log(geom);
-  // → { type: 'Point', coordinates: [116.39, 39.91] }
 
-  const wkt = WKTGeoJSON.build(geom);
-  console.log(wkt);
-  // → "POINT (116.39 39.91)"
+  // 方式二：解构赋值（需注意命名冲突）
+  const { parse, build } = WKTGeoJSON;
+  const wkt = build(geom);
 </script>
 ```
 

package/dist/index.cjs.js

@@ -1,5 +1,9 @@
 'use strict';
 
+var types = /*#__PURE__*/Object.freeze({
+    __proto__: null
+});
+
 // Precompiled regex for better performance
 const RE_WHITESPACE = /\s/;
 const RE_NUMBER_START = /[0-9\-]/;
@@ -316,16 +320,21 @@ function parse(wkt) {
     return parser.parse(wkt);
 }
 
+var wktParser = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    WKTParser: WKTParser,
+    parse: parse
+});
+
 /**
  * 将坐标数值格式化为字符串，避免科学计数法（WKT 不支持）。
  * 例：1e-7 → "0.0000001"，1.50000 → "1.5"，1.0 → "1"
  */
 function formatNumber(v) {
-    // 有小数则最多保留 15 位有效位，再去掉尾零
     if (v % 1 !== 0) {
-        return parseFloat(v.toFixed(15)).toString();
+        return Number(v.toFixed(15)).toString();
     }
-    return v.toFixed(0);
+    return String(v);
 }
 function positionToWkt(pos) {
     return pos.map(formatNumber).join(' ');
@@ -333,6 +342,28 @@ function positionToWkt(pos) {
 function coordsToWkt(coords) {
     return coords.map(positionToWkt).join(', ');
 }
+// 检查坐标是否包含 Z（3个分量）
+function hasZ(coordinates) {
+    if (!Array.isArray(coordinates))
+        return false;
+    if (coordinates.length === 0)
+        return false;
+    const first = coordinates[0];
+    if (Array.isArray(first)) {
+        if (typeof first[0] === 'number') {
+            return first.length === 3;
+        }
+        if (Array.isArray(first[0])) {
+            const firstRing = first;
+            return firstRing.length > 0 && firstRing[0].length === 3;
+        }
+    }
+    return false;
+}
+// 获取 Z 后缀字符串
+function zSuffix(coordinates) {
+    return hasZ(coordinates) ? ' Z' : '';
+}
 class WKTBuilder {
     build(geometry) {
         switch (geometry.type) {
@@ -355,21 +386,18 @@ class WKTBuilder {
         }
     }
     buildPoint(geom) {
-        const hasZ = geom.coordinates.length === 3;
-        return `POINT${hasZ ? ' Z' : ''} (${positionToWkt(geom.coordinates)})`;
+        return `POINT${zSuffix(geom.coordinates)} (${positionToWkt(geom.coordinates)})`;
     }
     buildLineString(geom) {
         if (geom.coordinates.length === 0)
             return 'LINESTRING EMPTY';
-        const hasZ = geom.coordinates[0].length === 3;
-        return `LINESTRING${hasZ ? ' Z' : ''} (${coordsToWkt(geom.coordinates)})`;
+        return `LINESTRING${zSuffix(geom.coordinates)} (${coordsToWkt(geom.coordinates)})`;
     }
     buildPolygon(geom) {
         if (geom.coordinates.length === 0)
             return 'POLYGON EMPTY';
-        const hasZ = geom.coordinates[0].length > 0 && geom.coordinates[0][0].length === 3;
         const ringStr = geom.coordinates.map(ring => `(${coordsToWkt(ring)})`).join(', ');
-        return `POLYGON${hasZ ? ' Z' : ''} (${ringStr})`;
+        return `POLYGON${zSuffix(geom.coordinates)} (${ringStr})`;
     }
     /**
      * 按 OGC/ISO WKT 标准，MULTIPOINT 每个点用括号包裹：
@@ -378,26 +406,23 @@ class WKTBuilder {
     buildMultiPoint(geom) {
         if (geom.coordinates.length === 0)
             return 'MULTIPOINT EMPTY';
-        const hasZ = geom.coordinates[0].length === 3;
         const pts = geom.coordinates.map(p => `(${positionToWkt(p)})`).join(', ');
-        return `MULTIPOINT${hasZ ? ' Z' : ''} (${pts})`;
+        return `MULTIPOINT${zSuffix(geom.coordinates)} (${pts})`;
     }
     buildMultiLineString(geom) {
         if (geom.coordinates.length === 0)
             return 'MULTILINESTRING EMPTY';
-        const hasZ = geom.coordinates[0].length > 0 && geom.coordinates[0][0].length === 3;
         const lines = geom.coordinates.map(line => `(${coordsToWkt(line)})`).join(', ');
-        return `MULTILINESTRING${hasZ ? ' Z' : ''} (${lines})`;
+        return `MULTILINESTRING${zSuffix(geom.coordinates)} (${lines})`;
     }
     buildMultiPolygon(geom) {
         if (geom.coordinates.length === 0)
             return 'MULTIPOLYGON EMPTY';
-        const hasZ = geom.coordinates[0].length > 0 && geom.coordinates[0][0].length > 0 && geom.coordinates[0][0][0].length === 3;
         const polys = geom.coordinates.map(poly => {
             const rings = poly.map(ring => `(${coordsToWkt(ring)})`).join(', ');
             return `(${rings})`;
         }).join(', ');
-        return `MULTIPOLYGON${hasZ ? ' Z' : ''} (${polys})`;
+        return `MULTIPOLYGON${zSuffix(geom.coordinates)} (${polys})`;
     }
     buildGeometryCollection(geom) {
         if (geom.geometries.length === 0)
@@ -408,8 +433,16 @@ class WKTBuilder {
 }
 /** 将 GeoJSON Geometry 对象转换为 WKT 字符串 */
 function build(geometry) {
-    return new WKTBuilder().build(geometry);
+    return WKT_BUILDER.build(geometry);
 }
+// 单例实例，避免重复创建
+const WKT_BUILDER = new WKTBuilder();
+
+var wktBuilder = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    WKTBuilder: WKTBuilder,
+    build: build
+});
 
 // ─── 内部工具：判断是否为 Position（[number, number] 或 [number, number, number]）
 function isPosition(v) {
@@ -557,6 +590,18 @@ function createGeometryCollection(geometries) {
     return _builder.createGeometryCollection(geometries);
 }
 
+var geojsonBuilder = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    GeoJSONBuilder: GeoJSONBuilder,
+    createGeometryCollection: createGeometryCollection,
+    createLineString: createLineString,
+    createMultiLineString: createMultiLineString,
+    createMultiPoint: createMultiPoint,
+    createMultiPolygon: createMultiPolygon,
+    createPoint: createPoint,
+    createPolygon: createPolygon
+});
+
 /**
  * 将 WKT 字符串转换为 GeoJSON Geometry 对象。
  *
@@ -608,6 +653,13 @@ function wktToFeatureCollection(wkts, properties) {
     return { type: 'FeatureCollection', features };
 }
 
+var wktToGeojson = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    wktToFeature: wktToFeature,
+    wktToFeatureCollection: wktToFeatureCollection,
+    wktToGeoJSON: wktToGeoJSON
+});
+
 /**
  * 将 GeoJSON Geometry 对象转换为 WKT 字符串。
  *
@@ -653,6 +705,19 @@ function featureCollectionToWkt(fc) {
     });
 }
 
+var geojsonToWkt$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    featureCollectionToWkt: featureCollectionToWkt,
+    featureToWkt: featureToWkt,
+    geojsonToWkt: geojsonToWkt
+});
+
+// 预定义常量，避免重复创建
+const VALID_GEOMETRY_TYPES = [
+    'Point', 'LineString', 'Polygon',
+    'MultiPoint', 'MultiLineString', 'MultiPolygon',
+    'GeometryCollection'
+];
 /**
  * 校验 WKT 字符串格式是否合法
  */
@@ -685,13 +750,8 @@ function validateGeoJSON(geojson) {
         return { valid: false, error: 'GeoJSON must have a "type" property' };
     }
     const type = obj.type;
-    const validTypes = [
-        'Point', 'LineString', 'Polygon',
-        'MultiPoint', 'MultiLineString', 'MultiPolygon',
-        'GeometryCollection'
-    ];
-    if (!validTypes.includes(type)) {
-        return { valid: false, error: `Invalid geometry type: "${type}". Must be one of: ${validTypes.join(', ')}` };
+    if (!VALID_GEOMETRY_TYPES.includes(type)) {
+        return { valid: false, error: `Invalid geometry type: "${type}". Must be one of: ${VALID_GEOMETRY_TYPES.join(', ')}` };
     }
     // GeometryCollection 特殊处理
     if (type === 'GeometryCollection') {
@@ -794,11 +854,14 @@ function tryFixWKT(wkt) {
     if (!trimmed) {
         return { fixed: wkt, changed: false };
     }
-    // 检查是否有尾部多余字符
-    const result = validateWKT(trimmed);
-    if (result.valid) {
+    // 先尝试直接解析，如果成功则不需要修复
+    try {
+        parse(trimmed);
         return { fixed: trimmed, changed: false };
     }
+    catch {
+        // 解析失败，尝试修复
+    }
     // 尝试找到最后一个有效的 geometry 结束位置
     const patterns = [
         /\)\s*[A-Z]/i, // 括号后跟字母 (如 POLYGON ((...)) POINT )
@@ -809,23 +872,30 @@ function tryFixWKT(wkt) {
         const match = trimmed.match(pattern);
         if (match) {
             const fixed = trimmed.slice(0, match.index + (match[0].match(/\)/)?.[0].length || 0));
-            if (validateWKT(fixed).valid) {
+            try {
+                parse(fixed);
                 return { fixed, changed: true };
             }
+            catch {
+                // 这个修复方案不行，尝试下一个
+            }
         }
     }
     // 尝试去除尾部垃圾字符
     const lastValidIndex = findLastValidPosition(trimmed);
     if (lastValidIndex > 0) {
         const fixed = trimmed.slice(0, lastValidIndex + 1);
-        if (validateWKT(fixed).valid) {
+        try {
+            parse(fixed);
             return { fixed, changed: true };
         }
+        catch {
+            // 修复失败
+        }
     }
     return { fixed: wkt, changed: false };
 }
 function findLastValidPosition(wkt) {
-    // 从后往前找第一个有效的右括号位置
     let depth = 0;
     for (let i = wkt.length - 1; i >= 0; i--) {
         const c = wkt[i];
@@ -833,15 +903,9 @@ function findLastValidPosition(wkt) {
             depth++;
         else if (c === '(')
             depth--;
-        else if (c === ' ' && depth === 0 && i < wkt.length - 1) {
-            // 检查这个空格是否在有效位置
-            const afterSpace = wkt.slice(i + 1).trim();
-            if (!afterSpace)
-                continue;
-            if (!/^[A-Z]/.test(afterSpace))
-                continue;
-            // 如果空格后面是字母开头，可能是垃圾字符
-            if (i > 5 && /[A-Z]$/.test(wkt.slice(0, i).trim())) {
+        else if (c === ' ' && depth === 0 && /[A-Z]/.test(wkt.slice(i + 1))) {
+            // 如果空格后面是字母开头，可能是垃圾字符的起点
+            if (wkt.slice(0, i).trimEnd().match(/[A-Z]\s*$/)) {
                 return i - 1;
             }
         }
@@ -860,10 +924,43 @@ function cloneGeometry(geometry) {
 function geometryEquals(a, b) {
     if (a.type !== b.type)
         return false;
+    // Point 比较最常见，单独优化
+    if (a.type === 'Point') {
+        const aCoords = a.coordinates;
+        const bCoords = b.coordinates;
+        return aCoords.length === bCoords.length &&
+            aCoords[0] === bCoords[0] &&
+            aCoords[1] === bCoords[1] &&
+            (aCoords.length === 2 || aCoords[2] === bCoords[2]);
+    }
+    // 其他类型使用 JSON.stringify 比较
     return JSON.stringify(a) === JSON.stringify(b);
 }
 
+var validate = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    cloneGeometry: cloneGeometry,
+    geometryEquals: geometryEquals,
+    tryFixWKT: tryFixWKT,
+    validateGeoJSON: validateGeoJSON,
+    validateWKT: validateWKT
+});
+
+// 命名空间导出 - 所有公共 API 汇总
+// 使用方式: import WKT from 'wkt-parse-and-geojson';
+//          WKT.parse(...), WKT.build(...), etc.
+const WKT = {
+    ...types,
+    ...wktParser,
+    ...wktBuilder,
+    ...geojsonBuilder,
+    ...wktToGeojson,
+    ...geojsonToWkt$1,
+    ...validate,
+};
+
 exports.GeoJSONBuilder = GeoJSONBuilder;
+exports.WKT = WKT;
 exports.WKTBuilder = WKTBuilder;
 exports.WKTParser = WKTParser;
 exports.build = build;

package/dist/index.d.ts

@@ -5,3 +5,4 @@ export { createPoint, createLineString, createPolygon, createMultiPoint, createM
 export { wktToGeoJSON, wktToFeature, wktToFeatureCollection } from './wkt-to-geojson';
 export { geojsonToWkt, featureToWkt, featureCollectionToWkt } from './geojson-to-wkt';
 export { validateWKT, validateGeoJSON, tryFixWKT, cloneGeometry, geometryEquals, type ValidationResult, } from './validate';
+export { default as WKT } from './namespace';

package/dist/index.esm.js

@@ -1,3 +1,7 @@
+var types = /*#__PURE__*/Object.freeze({
+    __proto__: null
+});
+
 // Precompiled regex for better performance
 const RE_WHITESPACE = /\s/;
 const RE_NUMBER_START = /[0-9\-]/;
@@ -314,16 +318,21 @@ function parse(wkt) {
     return parser.parse(wkt);
 }
 
+var wktParser = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    WKTParser: WKTParser,
+    parse: parse
+});
+
 /**
  * 将坐标数值格式化为字符串，避免科学计数法（WKT 不支持）。
  * 例：1e-7 → "0.0000001"，1.50000 → "1.5"，1.0 → "1"
  */
 function formatNumber(v) {
-    // 有小数则最多保留 15 位有效位，再去掉尾零
     if (v % 1 !== 0) {
-        return parseFloat(v.toFixed(15)).toString();
+        return Number(v.toFixed(15)).toString();
     }
-    return v.toFixed(0);
+    return String(v);
 }
 function positionToWkt(pos) {
     return pos.map(formatNumber).join(' ');
@@ -331,6 +340,28 @@ function positionToWkt(pos) {
 function coordsToWkt(coords) {
     return coords.map(positionToWkt).join(', ');
 }
+// 检查坐标是否包含 Z（3个分量）
+function hasZ(coordinates) {
+    if (!Array.isArray(coordinates))
+        return false;
+    if (coordinates.length === 0)
+        return false;
+    const first = coordinates[0];
+    if (Array.isArray(first)) {
+        if (typeof first[0] === 'number') {
+            return first.length === 3;
+        }
+        if (Array.isArray(first[0])) {
+            const firstRing = first;
+            return firstRing.length > 0 && firstRing[0].length === 3;
+        }
+    }
+    return false;
+}
+// 获取 Z 后缀字符串
+function zSuffix(coordinates) {
+    return hasZ(coordinates) ? ' Z' : '';
+}
 class WKTBuilder {
     build(geometry) {
         switch (geometry.type) {
@@ -353,21 +384,18 @@ class WKTBuilder {
         }
     }
     buildPoint(geom) {
-        const hasZ = geom.coordinates.length === 3;
-        return `POINT${hasZ ? ' Z' : ''} (${positionToWkt(geom.coordinates)})`;
+        return `POINT${zSuffix(geom.coordinates)} (${positionToWkt(geom.coordinates)})`;
     }
     buildLineString(geom) {
         if (geom.coordinates.length === 0)
             return 'LINESTRING EMPTY';
-        const hasZ = geom.coordinates[0].length === 3;
-        return `LINESTRING${hasZ ? ' Z' : ''} (${coordsToWkt(geom.coordinates)})`;
+        return `LINESTRING${zSuffix(geom.coordinates)} (${coordsToWkt(geom.coordinates)})`;
     }
     buildPolygon(geom) {
         if (geom.coordinates.length === 0)
             return 'POLYGON EMPTY';
-        const hasZ = geom.coordinates[0].length > 0 && geom.coordinates[0][0].length === 3;
         const ringStr = geom.coordinates.map(ring => `(${coordsToWkt(ring)})`).join(', ');
-        return `POLYGON${hasZ ? ' Z' : ''} (${ringStr})`;
+        return `POLYGON${zSuffix(geom.coordinates)} (${ringStr})`;
     }
     /**
      * 按 OGC/ISO WKT 标准，MULTIPOINT 每个点用括号包裹：
@@ -376,26 +404,23 @@ class WKTBuilder {
     buildMultiPoint(geom) {
         if (geom.coordinates.length === 0)
             return 'MULTIPOINT EMPTY';
-        const hasZ = geom.coordinates[0].length === 3;
         const pts = geom.coordinates.map(p => `(${positionToWkt(p)})`).join(', ');
-        return `MULTIPOINT${hasZ ? ' Z' : ''} (${pts})`;
+        return `MULTIPOINT${zSuffix(geom.coordinates)} (${pts})`;
     }
     buildMultiLineString(geom) {
         if (geom.coordinates.length === 0)
             return 'MULTILINESTRING EMPTY';
-        const hasZ = geom.coordinates[0].length > 0 && geom.coordinates[0][0].length === 3;
         const lines = geom.coordinates.map(line => `(${coordsToWkt(line)})`).join(', ');
-        return `MULTILINESTRING${hasZ ? ' Z' : ''} (${lines})`;
+        return `MULTILINESTRING${zSuffix(geom.coordinates)} (${lines})`;
     }
     buildMultiPolygon(geom) {
         if (geom.coordinates.length === 0)
             return 'MULTIPOLYGON EMPTY';
-        const hasZ = geom.coordinates[0].length > 0 && geom.coordinates[0][0].length > 0 && geom.coordinates[0][0][0].length === 3;
         const polys = geom.coordinates.map(poly => {
             const rings = poly.map(ring => `(${coordsToWkt(ring)})`).join(', ');
             return `(${rings})`;
         }).join(', ');
-        return `MULTIPOLYGON${hasZ ? ' Z' : ''} (${polys})`;
+        return `MULTIPOLYGON${zSuffix(geom.coordinates)} (${polys})`;
     }
     buildGeometryCollection(geom) {
         if (geom.geometries.length === 0)
@@ -406,8 +431,16 @@ class WKTBuilder {
 }
 /** 将 GeoJSON Geometry 对象转换为 WKT 字符串 */
 function build(geometry) {
-    return new WKTBuilder().build(geometry);
+    return WKT_BUILDER.build(geometry);
 }
+// 单例实例，避免重复创建
+const WKT_BUILDER = new WKTBuilder();
+
+var wktBuilder = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    WKTBuilder: WKTBuilder,
+    build: build
+});
 
 // ─── 内部工具：判断是否为 Position（[number, number] 或 [number, number, number]）
 function isPosition(v) {
@@ -555,6 +588,18 @@ function createGeometryCollection(geometries) {
     return _builder.createGeometryCollection(geometries);
 }
 
+var geojsonBuilder = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    GeoJSONBuilder: GeoJSONBuilder,
+    createGeometryCollection: createGeometryCollection,
+    createLineString: createLineString,
+    createMultiLineString: createMultiLineString,
+    createMultiPoint: createMultiPoint,
+    createMultiPolygon: createMultiPolygon,
+    createPoint: createPoint,
+    createPolygon: createPolygon
+});
+
 /**
  * 将 WKT 字符串转换为 GeoJSON Geometry 对象。
  *
@@ -606,6 +651,13 @@ function wktToFeatureCollection(wkts, properties) {
     return { type: 'FeatureCollection', features };
 }
 
+var wktToGeojson = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    wktToFeature: wktToFeature,
+    wktToFeatureCollection: wktToFeatureCollection,
+    wktToGeoJSON: wktToGeoJSON
+});
+
 /**
  * 将 GeoJSON Geometry 对象转换为 WKT 字符串。
  *
@@ -651,6 +703,19 @@ function featureCollectionToWkt(fc) {
     });
 }
 
+var geojsonToWkt$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    featureCollectionToWkt: featureCollectionToWkt,
+    featureToWkt: featureToWkt,
+    geojsonToWkt: geojsonToWkt
+});
+
+// 预定义常量，避免重复创建
+const VALID_GEOMETRY_TYPES = [
+    'Point', 'LineString', 'Polygon',
+    'MultiPoint', 'MultiLineString', 'MultiPolygon',
+    'GeometryCollection'
+];
 /**
  * 校验 WKT 字符串格式是否合法
  */
@@ -683,13 +748,8 @@ function validateGeoJSON(geojson) {
         return { valid: false, error: 'GeoJSON must have a "type" property' };
     }
     const type = obj.type;
-    const validTypes = [
-        'Point', 'LineString', 'Polygon',
-        'MultiPoint', 'MultiLineString', 'MultiPolygon',
-        'GeometryCollection'
-    ];
-    if (!validTypes.includes(type)) {
-        return { valid: false, error: `Invalid geometry type: "${type}". Must be one of: ${validTypes.join(', ')}` };
+    if (!VALID_GEOMETRY_TYPES.includes(type)) {
+        return { valid: false, error: `Invalid geometry type: "${type}". Must be one of: ${VALID_GEOMETRY_TYPES.join(', ')}` };
     }
     // GeometryCollection 特殊处理
     if (type === 'GeometryCollection') {
@@ -792,11 +852,14 @@ function tryFixWKT(wkt) {
     if (!trimmed) {
         return { fixed: wkt, changed: false };
     }
-    // 检查是否有尾部多余字符
-    const result = validateWKT(trimmed);
-    if (result.valid) {
+    // 先尝试直接解析，如果成功则不需要修复
+    try {
+        parse(trimmed);
         return { fixed: trimmed, changed: false };
     }
+    catch {
+        // 解析失败，尝试修复
+    }
     // 尝试找到最后一个有效的 geometry 结束位置
     const patterns = [
         /\)\s*[A-Z]/i, // 括号后跟字母 (如 POLYGON ((...)) POINT )
@@ -807,23 +870,30 @@ function tryFixWKT(wkt) {
         const match = trimmed.match(pattern);
         if (match) {
             const fixed = trimmed.slice(0, match.index + (match[0].match(/\)/)?.[0].length || 0));
-            if (validateWKT(fixed).valid) {
+            try {
+                parse(fixed);
                 return { fixed, changed: true };
             }
+            catch {
+                // 这个修复方案不行，尝试下一个
+            }
         }
     }
     // 尝试去除尾部垃圾字符
     const lastValidIndex = findLastValidPosition(trimmed);
     if (lastValidIndex > 0) {
         const fixed = trimmed.slice(0, lastValidIndex + 1);
-        if (validateWKT(fixed).valid) {
+        try {
+            parse(fixed);
             return { fixed, changed: true };
         }
+        catch {
+            // 修复失败
+        }
     }
     return { fixed: wkt, changed: false };
 }
 function findLastValidPosition(wkt) {
-    // 从后往前找第一个有效的右括号位置
     let depth = 0;
     for (let i = wkt.length - 1; i >= 0; i--) {
         const c = wkt[i];
@@ -831,15 +901,9 @@ function findLastValidPosition(wkt) {
             depth++;
         else if (c === '(')
             depth--;
-        else if (c === ' ' && depth === 0 && i < wkt.length - 1) {
-            // 检查这个空格是否在有效位置
-            const afterSpace = wkt.slice(i + 1).trim();
-            if (!afterSpace)
-                continue;
-            if (!/^[A-Z]/.test(afterSpace))
-                continue;
-            // 如果空格后面是字母开头，可能是垃圾字符
-            if (i > 5 && /[A-Z]$/.test(wkt.slice(0, i).trim())) {
+        else if (c === ' ' && depth === 0 && /[A-Z]/.test(wkt.slice(i + 1))) {
+            // 如果空格后面是字母开头，可能是垃圾字符的起点
+            if (wkt.slice(0, i).trimEnd().match(/[A-Z]\s*$/)) {
                 return i - 1;
             }
         }
@@ -858,7 +922,39 @@ function cloneGeometry(geometry) {
 function geometryEquals(a, b) {
     if (a.type !== b.type)
         return false;
+    // Point 比较最常见，单独优化
+    if (a.type === 'Point') {
+        const aCoords = a.coordinates;
+        const bCoords = b.coordinates;
+        return aCoords.length === bCoords.length &&
+            aCoords[0] === bCoords[0] &&
+            aCoords[1] === bCoords[1] &&
+            (aCoords.length === 2 || aCoords[2] === bCoords[2]);
+    }
+    // 其他类型使用 JSON.stringify 比较
     return JSON.stringify(a) === JSON.stringify(b);
 }
 
-export { GeoJSONBuilder, WKTBuilder, WKTParser, build, cloneGeometry, createGeometryCollection, createLineString, createMultiLineString, createMultiPoint, createMultiPolygon, createPoint, createPolygon, featureCollectionToWkt, featureToWkt, geojsonToWkt, geometryEquals, parse, tryFixWKT, validateGeoJSON, validateWKT, wktToFeature, wktToFeatureCollection, wktToGeoJSON };
+var validate = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    cloneGeometry: cloneGeometry,
+    geometryEquals: geometryEquals,
+    tryFixWKT: tryFixWKT,
+    validateGeoJSON: validateGeoJSON,
+    validateWKT: validateWKT
+});
+
+// 命名空间导出 - 所有公共 API 汇总
+// 使用方式: import WKT from 'wkt-parse-and-geojson';
+//          WKT.parse(...), WKT.build(...), etc.
+const WKT = {
+    ...types,
+    ...wktParser,
+    ...wktBuilder,
+    ...geojsonBuilder,
+    ...wktToGeojson,
+    ...geojsonToWkt$1,
+    ...validate,
+};
+
+export { GeoJSONBuilder, WKT, WKTBuilder, WKTParser, build, cloneGeometry, createGeometryCollection, createLineString, createMultiLineString, createMultiPoint, createMultiPolygon, createPoint, createPolygon, featureCollectionToWkt, featureToWkt, geojsonToWkt, geometryEquals, parse, tryFixWKT, validateGeoJSON, validateWKT, wktToFeature, wktToFeatureCollection, wktToGeoJSON };

package/dist/index.umd.js

@@ -4,6 +4,10 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.WKTGeoJSON = {}));
 })(this, (function (exports) { 'use strict';
 
+    var types = /*#__PURE__*/Object.freeze({
+        __proto__: null
+    });
+
     // Precompiled regex for better performance
     const RE_WHITESPACE = /\s/;
     const RE_NUMBER_START = /[0-9\-]/;
@@ -320,16 +324,21 @@
         return parser.parse(wkt);
     }
 
+    var wktParser = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        WKTParser: WKTParser,
+        parse: parse
+    });
+
     /**
      * 将坐标数值格式化为字符串，避免科学计数法（WKT 不支持）。
      * 例：1e-7 → "0.0000001"，1.50000 → "1.5"，1.0 → "1"
      */
     function formatNumber(v) {
-        // 有小数则最多保留 15 位有效位，再去掉尾零
         if (v % 1 !== 0) {
-            return parseFloat(v.toFixed(15)).toString();
+            return Number(v.toFixed(15)).toString();
         }
-        return v.toFixed(0);
+        return String(v);
     }
     function positionToWkt(pos) {
         return pos.map(formatNumber).join(' ');
@@ -337,6 +346,28 @@
     function coordsToWkt(coords) {
         return coords.map(positionToWkt).join(', ');
     }
+    // 检查坐标是否包含 Z（3个分量）
+    function hasZ(coordinates) {
+        if (!Array.isArray(coordinates))
+            return false;
+        if (coordinates.length === 0)
+            return false;
+        const first = coordinates[0];
+        if (Array.isArray(first)) {
+            if (typeof first[0] === 'number') {
+                return first.length === 3;
+            }
+            if (Array.isArray(first[0])) {
+                const firstRing = first;
+                return firstRing.length > 0 && firstRing[0].length === 3;
+            }
+        }
+        return false;
+    }
+    // 获取 Z 后缀字符串
+    function zSuffix(coordinates) {
+        return hasZ(coordinates) ? ' Z' : '';
+    }
     class WKTBuilder {
         build(geometry) {
             switch (geometry.type) {
@@ -359,21 +390,18 @@
             }
         }
         buildPoint(geom) {
-            const hasZ = geom.coordinates.length === 3;
-            return `POINT${hasZ ? ' Z' : ''} (${positionToWkt(geom.coordinates)})`;
+            return `POINT${zSuffix(geom.coordinates)} (${positionToWkt(geom.coordinates)})`;
         }
         buildLineString(geom) {
             if (geom.coordinates.length === 0)
                 return 'LINESTRING EMPTY';
-            const hasZ = geom.coordinates[0].length === 3;
-            return `LINESTRING${hasZ ? ' Z' : ''} (${coordsToWkt(geom.coordinates)})`;
+            return `LINESTRING${zSuffix(geom.coordinates)} (${coordsToWkt(geom.coordinates)})`;
         }
         buildPolygon(geom) {
             if (geom.coordinates.length === 0)
                 return 'POLYGON EMPTY';
-            const hasZ = geom.coordinates[0].length > 0 && geom.coordinates[0][0].length === 3;
             const ringStr = geom.coordinates.map(ring => `(${coordsToWkt(ring)})`).join(', ');
-            return `POLYGON${hasZ ? ' Z' : ''} (${ringStr})`;
+            return `POLYGON${zSuffix(geom.coordinates)} (${ringStr})`;
         }
         /**
          * 按 OGC/ISO WKT 标准，MULTIPOINT 每个点用括号包裹：
@@ -382,26 +410,23 @@
         buildMultiPoint(geom) {
             if (geom.coordinates.length === 0)
                 return 'MULTIPOINT EMPTY';
-            const hasZ = geom.coordinates[0].length === 3;
             const pts = geom.coordinates.map(p => `(${positionToWkt(p)})`).join(', ');
-            return `MULTIPOINT${hasZ ? ' Z' : ''} (${pts})`;
+            return `MULTIPOINT${zSuffix(geom.coordinates)} (${pts})`;
         }
         buildMultiLineString(geom) {
             if (geom.coordinates.length === 0)
                 return 'MULTILINESTRING EMPTY';
-            const hasZ = geom.coordinates[0].length > 0 && geom.coordinates[0][0].length === 3;
             const lines = geom.coordinates.map(line => `(${coordsToWkt(line)})`).join(', ');
-            return `MULTILINESTRING${hasZ ? ' Z' : ''} (${lines})`;
+            return `MULTILINESTRING${zSuffix(geom.coordinates)} (${lines})`;
         }
         buildMultiPolygon(geom) {
             if (geom.coordinates.length === 0)
                 return 'MULTIPOLYGON EMPTY';
-            const hasZ = geom.coordinates[0].length > 0 && geom.coordinates[0][0].length > 0 && geom.coordinates[0][0][0].length === 3;
             const polys = geom.coordinates.map(poly => {
                 const rings = poly.map(ring => `(${coordsToWkt(ring)})`).join(', ');
                 return `(${rings})`;
             }).join(', ');
-            return `MULTIPOLYGON${hasZ ? ' Z' : ''} (${polys})`;
+            return `MULTIPOLYGON${zSuffix(geom.coordinates)} (${polys})`;
         }
         buildGeometryCollection(geom) {
             if (geom.geometries.length === 0)
@@ -412,8 +437,16 @@
     }
     /** 将 GeoJSON Geometry 对象转换为 WKT 字符串 */
     function build(geometry) {
-        return new WKTBuilder().build(geometry);
+        return WKT_BUILDER.build(geometry);
     }
+    // 单例实例，避免重复创建
+    const WKT_BUILDER = new WKTBuilder();
+
+    var wktBuilder = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        WKTBuilder: WKTBuilder,
+        build: build
+    });
 
     // ─── 内部工具：判断是否为 Position（[number, number] 或 [number, number, number]）
     function isPosition(v) {
@@ -561,6 +594,18 @@
         return _builder.createGeometryCollection(geometries);
     }
 
+    var geojsonBuilder = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        GeoJSONBuilder: GeoJSONBuilder,
+        createGeometryCollection: createGeometryCollection,
+        createLineString: createLineString,
+        createMultiLineString: createMultiLineString,
+        createMultiPoint: createMultiPoint,
+        createMultiPolygon: createMultiPolygon,
+        createPoint: createPoint,
+        createPolygon: createPolygon
+    });
+
     /**
      * 将 WKT 字符串转换为 GeoJSON Geometry 对象。
      *
@@ -612,6 +657,13 @@
         return { type: 'FeatureCollection', features };
     }
 
+    var wktToGeojson = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        wktToFeature: wktToFeature,
+        wktToFeatureCollection: wktToFeatureCollection,
+        wktToGeoJSON: wktToGeoJSON
+    });
+
     /**
      * 将 GeoJSON Geometry 对象转换为 WKT 字符串。
      *
@@ -657,6 +709,19 @@
         });
     }
 
+    var geojsonToWkt$1 = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        featureCollectionToWkt: featureCollectionToWkt,
+        featureToWkt: featureToWkt,
+        geojsonToWkt: geojsonToWkt
+    });
+
+    // 预定义常量，避免重复创建
+    const VALID_GEOMETRY_TYPES = [
+        'Point', 'LineString', 'Polygon',
+        'MultiPoint', 'MultiLineString', 'MultiPolygon',
+        'GeometryCollection'
+    ];
     /**
      * 校验 WKT 字符串格式是否合法
      */
@@ -689,13 +754,8 @@
             return { valid: false, error: 'GeoJSON must have a "type" property' };
         }
         const type = obj.type;
-        const validTypes = [
-            'Point', 'LineString', 'Polygon',
-            'MultiPoint', 'MultiLineString', 'MultiPolygon',
-            'GeometryCollection'
-        ];
-        if (!validTypes.includes(type)) {
-            return { valid: false, error: `Invalid geometry type: "${type}". Must be one of: ${validTypes.join(', ')}` };
+        if (!VALID_GEOMETRY_TYPES.includes(type)) {
+            return { valid: false, error: `Invalid geometry type: "${type}". Must be one of: ${VALID_GEOMETRY_TYPES.join(', ')}` };
         }
         // GeometryCollection 特殊处理
         if (type === 'GeometryCollection') {
@@ -798,11 +858,14 @@
         if (!trimmed) {
             return { fixed: wkt, changed: false };
         }
-        // 检查是否有尾部多余字符
-        const result = validateWKT(trimmed);
-        if (result.valid) {
+        // 先尝试直接解析，如果成功则不需要修复
+        try {
+            parse(trimmed);
             return { fixed: trimmed, changed: false };
         }
+        catch {
+            // 解析失败，尝试修复
+        }
         // 尝试找到最后一个有效的 geometry 结束位置
         const patterns = [
             /\)\s*[A-Z]/i, // 括号后跟字母 (如 POLYGON ((...)) POINT )
@@ -813,23 +876,30 @@
             const match = trimmed.match(pattern);
             if (match) {
                 const fixed = trimmed.slice(0, match.index + (match[0].match(/\)/)?.[0].length || 0));
-                if (validateWKT(fixed).valid) {
+                try {
+                    parse(fixed);
                     return { fixed, changed: true };
                 }
+                catch {
+                    // 这个修复方案不行，尝试下一个
+                }
             }
         }
         // 尝试去除尾部垃圾字符
         const lastValidIndex = findLastValidPosition(trimmed);
         if (lastValidIndex > 0) {
             const fixed = trimmed.slice(0, lastValidIndex + 1);
-            if (validateWKT(fixed).valid) {
+            try {
+                parse(fixed);
                 return { fixed, changed: true };
             }
+            catch {
+                // 修复失败
+            }
         }
         return { fixed: wkt, changed: false };
     }
     function findLastValidPosition(wkt) {
-        // 从后往前找第一个有效的右括号位置
         let depth = 0;
         for (let i = wkt.length - 1; i >= 0; i--) {
             const c = wkt[i];
@@ -837,15 +907,9 @@
                 depth++;
             else if (c === '(')
                 depth--;
-            else if (c === ' ' && depth === 0 && i < wkt.length - 1) {
-                // 检查这个空格是否在有效位置
-                const afterSpace = wkt.slice(i + 1).trim();
-                if (!afterSpace)
-                    continue;
-                if (!/^[A-Z]/.test(afterSpace))
-                    continue;
-                // 如果空格后面是字母开头，可能是垃圾字符
-                if (i > 5 && /[A-Z]$/.test(wkt.slice(0, i).trim())) {
+            else if (c === ' ' && depth === 0 && /[A-Z]/.test(wkt.slice(i + 1))) {
+                // 如果空格后面是字母开头，可能是垃圾字符的起点
+                if (wkt.slice(0, i).trimEnd().match(/[A-Z]\s*$/)) {
                     return i - 1;
                 }
             }
@@ -864,10 +928,43 @@
     function geometryEquals(a, b) {
         if (a.type !== b.type)
             return false;
+        // Point 比较最常见，单独优化
+        if (a.type === 'Point') {
+            const aCoords = a.coordinates;
+            const bCoords = b.coordinates;
+            return aCoords.length === bCoords.length &&
+                aCoords[0] === bCoords[0] &&
+                aCoords[1] === bCoords[1] &&
+                (aCoords.length === 2 || aCoords[2] === bCoords[2]);
+        }
+        // 其他类型使用 JSON.stringify 比较
         return JSON.stringify(a) === JSON.stringify(b);
     }
 
+    var validate = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        cloneGeometry: cloneGeometry,
+        geometryEquals: geometryEquals,
+        tryFixWKT: tryFixWKT,
+        validateGeoJSON: validateGeoJSON,
+        validateWKT: validateWKT
+    });
+
+    // 命名空间导出 - 所有公共 API 汇总
+    // 使用方式: import WKT from 'wkt-parse-and-geojson';
+    //          WKT.parse(...), WKT.build(...), etc.
+    const WKT = {
+        ...types,
+        ...wktParser,
+        ...wktBuilder,
+        ...geojsonBuilder,
+        ...wktToGeojson,
+        ...geojsonToWkt$1,
+        ...validate,
+    };
+
     exports.GeoJSONBuilder = GeoJSONBuilder;
+    exports.WKT = WKT;
     exports.WKTBuilder = WKTBuilder;
     exports.WKTParser = WKTParser;
     exports.build = build;

package/dist/namespace.d.ts

@@ -0,0 +1,34 @@
+import * as types from './types';
+import * as wktParser from './wkt-parser';
+import * as wktBuilder from './wkt-builder';
+import * as geojsonBuilder from './geojson-builder';
+import * as validate from './validate';
+declare const WKT: {
+    validateWKT(wkt: string): validate.ValidationResult;
+    validateGeoJSON(geojson: unknown): validate.ValidationResult;
+    tryFixWKT(wkt: string): {
+        fixed: string;
+        changed: boolean;
+    };
+    cloneGeometry<G extends types.Geometry>(geometry: G): G;
+    geometryEquals(a: types.Geometry, b: types.Geometry): boolean;
+    geojsonToWkt(geojson: types.Geometry): string;
+    featureToWkt(feature: types.Feature): string;
+    featureCollectionToWkt(fc: types.FeatureCollection): Array<string | null>;
+    wktToGeoJSON(wkt: string): types.Geometry;
+    wktToFeature(wkt: string, properties?: Record<string, unknown> | null, id?: string | number): types.Feature;
+    wktToFeatureCollection(wkts: string[], properties?: Array<Record<string, unknown> | null>): types.FeatureCollection;
+    createPoint(x: number, y: number, z?: number): types.Point;
+    createLineString(coordinates: types.Position[]): types.LineString;
+    createPolygon(coordinates: types.Position[] | types.Position[][]): types.Polygon;
+    createMultiPoint(coordinates: types.Position | types.Position[]): types.MultiPoint;
+    createMultiLineString(coordinates: types.Position[] | types.Position[][]): types.MultiLineString;
+    createMultiPolygon(coordinates: types.Position[][] | types.Position[][][]): types.MultiPolygon;
+    createGeometryCollection(geometries: types.Geometry | types.Geometry[]): types.GeometryCollection;
+    GeoJSONBuilder: typeof geojsonBuilder.GeoJSONBuilder;
+    build(geometry: types.Geometry): string;
+    WKTBuilder: typeof wktBuilder.WKTBuilder;
+    parse(wkt: string): types.Geometry;
+    WKTParser: typeof wktParser.WKTParser;
+};
+export default WKT;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wkt-parse-and-geojson",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "type": "module",
   "description": "Zero-dependency WKT parser/builder and WKT↔GeoJSON converter",
   "main": "dist/index.cjs.js",