wkt-parse-and-geojson 1.0.2 → 1.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -21,6 +21,7 @@
   - [featureToWkt(feature)](#7-featuretowktfeature)
   - [featureCollectionToWkt(fc)](#8-featurecollectiontowktfc)
   - [GeoJSON 工厂方法](#9-geojson-工厂方法)
+  - [校验工具](#10-校验工具)
 - [类型定义](#类型定义)
 - [注意事项与边界行为](#注意事项与边界行为)
 - [本地调试](#本地调试)
@@ -480,6 +481,84 @@ createGeometryCollection([
 
 ---
 
+## 10. 校验工具
+
+### `validateWKT(wkt)`
+
+校验 WKT 字符串格式是否合法。
+
+```javascript
+import { validateWKT } from 'wkt-parse-and-geojson';
+
+validateWKT('POINT (30.5 40.5)')
+// → { valid: true }
+
+validateWKT('POINT EMPTY')
+// → { valid: false, error: 'POINT EMPTY cannot be represented...' }
+
+validateWKT('INVALID WKT')
+// → { valid: false, error: 'Unknown geometry type: INVALID' }
+```
+
+### `validateGeoJSON(geojson)`
+
+校验 GeoJSON Geometry 对象是否合法。
+
+```javascript
+import { validateGeoJSON } from 'wkt-parse-and-geojson';
+
+validateGeoJSON({ type: 'Point', coordinates: [30.5, 40.5] })
+// → { valid: true }
+
+validateGeoJSON({ type: 'Point' })
+// → { valid: false, error: 'Point must have "coordinates"' }
+
+validateGeoJSON({ type: 'InvalidType', coordinates: [] })
+// → { valid: false, error: 'Invalid geometry type: InvalidType...' }
+```
+
+### `tryFixWKT(wkt)`
+
+尝试修复不规范的 WKT 字符串（处理尾部多余字符）。
+
+```javascript
+import { tryFixWKT } from 'wkt-parse-and-geojson';
+
+tryFixWKT('POINT (30.5 40.5) garbage')
+// → { fixed: 'POINT (30.5 40.5)', changed: true }
+```
+
+### `cloneGeometry(geometry)`
+
+深度克隆几何对象，避免意外修改原对象。
+
+```javascript
+import { cloneGeometry } from 'wkt-parse-and-geojson';
+
+const original = { type: 'Point', coordinates: [0, 0] };
+const cloned = cloneGeometry(original);
+cloned.coordinates[0] = 100;
+// original.coordinates[0] === 0 (未改变)
+```
+
+### `geometryEquals(a, b)`
+
+判断两个几何对象是否相等。
+
+```javascript
+import { geometryEquals } from 'wkt-parse-and-geojson';
+
+const a = { type: 'Point', coordinates: [30.5, 40.5] };
+const b = { type: 'Point', coordinates: [30.5, 40.5] };
+geometryEquals(a, b)
+// → true
+
+geometryEquals(a, { type: 'Point', coordinates: [0, 0] })
+// → false
+```
+
+---
+
 ## 类型定义
 
 ```typescript

package/dist/index.cjs.js

@@ -1,5 +1,10 @@
 'use strict';
 
+// Precompiled regex for better performance
+const RE_WHITESPACE = /\s/;
+const RE_NUMBER_START = /[0-9\-]/;
+const RE_NUMBER_BODY = /[0-9\.\-eE\+]/;
+const RE_WORD_CHAR = /[a-zA-Z_]/;
 class Lexer {
     constructor(input) {
         this.pos = 0;
@@ -12,14 +17,13 @@ class Lexer {
         return this.input[this.pos++] || '';
     }
     isWhitespace(c) {
-        return /\s/.test(c);
+        return RE_WHITESPACE.test(c);
     }
-    /** 数字开头字符：数字 或 负号 */
     isNumberStart(c) {
-        return /[0-9\-]/.test(c);
+        return RE_NUMBER_START.test(c);
     }
     isNumberBody(c) {
-        return /[0-9\.\-eE\+]/.test(c);
+        return RE_NUMBER_BODY.test(c);
     }
     nextToken() {
         // skip whitespace
@@ -44,18 +48,18 @@ class Lexer {
         }
         // Number: starts with digit or minus
         if (this.isNumberStart(c)) {
-            let num = '';
+            const start = this.pos;
             while (this.pos < this.input.length && this.isNumberBody(this.peek())) {
-                num += this.advance();
+                this.pos++;
             }
-            return { type: 'NUMBER', value: num };
+            return { type: 'NUMBER', value: this.input.slice(start, this.pos) };
         }
         // Word (geometry type or EMPTY/Z/M keyword)
-        let word = '';
-        while (this.pos < this.input.length && /[a-zA-Z_]/.test(this.peek())) {
-            word += this.advance();
+        const start = this.pos;
+        while (this.pos < this.input.length && RE_WORD_CHAR.test(this.peek())) {
+            this.pos++;
         }
-        return { type: 'WORD', value: word.toUpperCase() };
+        return { type: 'WORD', value: this.input.slice(start, this.pos).toUpperCase() };
     }
 }
 class WKTParser {
@@ -250,11 +254,9 @@ class WKTParser {
         }
         this.advance(); // consume (
         const geometries = [];
-        while (this.peek().type !== 'RPAREN' && this.peek().type !== 'EOF') {
+        while (!this.isDone()) {
             geometries.push(this.parseGeometry());
-            if (this.peek().type === 'COMMA') {
-                this.advance();
-            }
+            this.skipComma();
         }
         this.consume('RPAREN');
         return { type: 'GeometryCollection', geometries };
@@ -300,11 +302,9 @@ class WKTParser {
             return [];
         this.advance(); // consume outer (
         const lists = [];
-        while (this.peek().type !== 'RPAREN' && this.peek().type !== 'EOF') {
+        while (!this.isDone()) {
             lists.push(this.parseCoordinatesList());
-            if (this.peek().type === 'COMMA') {
-                this.advance();
-            }
+            this.skipComma();
         }
         this.consume('RPAREN');
         return lists;
@@ -653,10 +653,221 @@ function featureCollectionToWkt(fc) {
     });
 }
 
+/**
+ * 校验 WKT 字符串格式是否合法
+ */
+function validateWKT(wkt) {
+    if (!wkt || typeof wkt !== 'string') {
+        return { valid: false, error: 'WKT must be a non-empty string' };
+    }
+    const trimmed = wkt.trim();
+    if (trimmed.length === 0) {
+        return { valid: false, error: 'WKT cannot be empty' };
+    }
+    try {
+        parse(wkt);
+        return { valid: true };
+    }
+    catch (e) {
+        return { valid: false, error: e.message };
+    }
+}
+/**
+ * 校验 GeoJSON Geometry 对象是否合法
+ */
+function validateGeoJSON(geojson) {
+    if (!geojson || typeof geojson !== 'object') {
+        return { valid: false, error: 'GeoJSON must be an object' };
+    }
+    const obj = geojson;
+    // 检查 type 字段
+    if (!obj.type || typeof obj.type !== 'string') {
+        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(', ')}` };
+    }
+    // GeometryCollection 特殊处理
+    if (type === 'GeometryCollection') {
+        if (!obj.geometries || !Array.isArray(obj.geometries)) {
+            return { valid: false, error: 'GeometryCollection must have a "geometries" array' };
+        }
+        for (let i = 0; i < obj.geometries.length; i++) {
+            const result = validateGeoJSON(obj.geometries[i]);
+            if (!result.valid) {
+                return { valid: false, error: `GeometryCollection[${i}]: ${result.error}` };
+            }
+        }
+        return { valid: true };
+    }
+    // 其他几何类型必须要有 coordinates
+    if (obj.coordinates === undefined) {
+        return { valid: false, error: `${type} must have "coordinates"` };
+    }
+    // 校验坐标格式
+    return validateCoordinates(type, obj.coordinates);
+}
+function validateCoordinates(type, coords) {
+    switch (type) {
+        case 'Point':
+            return validatePosition(coords);
+        case 'LineString':
+        case 'MultiPoint':
+            if (!Array.isArray(coords)) {
+                return { valid: false, error: `${type} coordinates must be an array` };
+            }
+            for (let i = 0; i < coords.length; i++) {
+                const result = validatePosition(coords[i]);
+                if (!result.valid) {
+                    return { valid: false, error: `${type}[${i}]: ${result.error}` };
+                }
+            }
+            return { valid: true };
+        case 'Polygon':
+        case 'MultiLineString':
+            if (!Array.isArray(coords)) {
+                return { valid: false, error: `${type} coordinates must be a nested array` };
+            }
+            for (let i = 0; i < coords.length; i++) {
+                if (!Array.isArray(coords[i])) {
+                    return { valid: false, error: `${type}[${i}] must be an array of positions` };
+                }
+                for (let j = 0; j < coords[i].length; j++) {
+                    const result = validatePosition(coords[i][j]);
+                    if (!result.valid) {
+                        return { valid: false, error: `${type}[${i}][${j}]: ${result.error}` };
+                    }
+                }
+            }
+            return { valid: true };
+        case 'MultiPolygon':
+            if (!Array.isArray(coords)) {
+                return { valid: false, error: `${type} coordinates must be a deeply nested array` };
+            }
+            for (let i = 0; i < coords.length; i++) {
+                if (!Array.isArray(coords[i])) {
+                    return { valid: false, error: `${type}[${i}] must be an array of rings` };
+                }
+                for (let j = 0; j < coords[i].length; j++) {
+                    if (!Array.isArray(coords[i][j])) {
+                        return { valid: false, error: `${type}[${i}][${j}] must be an array of positions` };
+                    }
+                    for (let k = 0; k < coords[i][j].length; k++) {
+                        const result = validatePosition(coords[i][j][k]);
+                        if (!result.valid) {
+                            return { valid: false, error: `${type}[${i}][${j}][${k}]: ${result.error}` };
+                        }
+                    }
+                }
+            }
+            return { valid: true };
+        default:
+            return { valid: true };
+    }
+}
+function validatePosition(pos) {
+    if (!Array.isArray(pos)) {
+        return { valid: false, error: 'Position must be an array of numbers' };
+    }
+    if (pos.length < 2 || pos.length > 3) {
+        return { valid: false, error: `Position must have 2 or 3 coordinates, got ${pos.length}` };
+    }
+    for (let i = 0; i < pos.length; i++) {
+        if (typeof pos[i] !== 'number' || isNaN(pos[i])) {
+            return { valid: false, error: `Position[${i}] must be a valid number` };
+        }
+    }
+    return { valid: true };
+}
+/**
+ * 尝试从可能不规范的 WKT 中恢复出有效结果
+ * 主要处理尾部多余字符的情况
+ */
+function tryFixWKT(wkt) {
+    const trimmed = wkt.trim();
+    if (!trimmed) {
+        return { fixed: wkt, changed: false };
+    }
+    // 检查是否有尾部多余字符
+    const result = validateWKT(trimmed);
+    if (result.valid) {
+        return { fixed: trimmed, changed: false };
+    }
+    // 尝试找到最后一个有效的 geometry 结束位置
+    const patterns = [
+        /\)\s*[A-Z]/i, // 括号后跟字母 (如 POLYGON ((...)) POINT )
+        /EMPTY\s+[A-Z]/i, // EMPTY 后跟字母
+        /\)\s*$/, // 括号结尾后有多余内容
+    ];
+    for (const pattern of patterns) {
+        const match = trimmed.match(pattern);
+        if (match) {
+            const fixed = trimmed.slice(0, match.index + (match[0].match(/\)/)?.[0].length || 0));
+            if (validateWKT(fixed).valid) {
+                return { fixed, changed: true };
+            }
+        }
+    }
+    // 尝试去除尾部垃圾字符
+    const lastValidIndex = findLastValidPosition(trimmed);
+    if (lastValidIndex > 0) {
+        const fixed = trimmed.slice(0, lastValidIndex + 1);
+        if (validateWKT(fixed).valid) {
+            return { fixed, changed: true };
+        }
+    }
+    return { fixed: wkt, changed: false };
+}
+function findLastValidPosition(wkt) {
+    // 从后往前找第一个有效的右括号位置
+    let depth = 0;
+    for (let i = wkt.length - 1; i >= 0; i--) {
+        const c = wkt[i];
+        if (c === ')')
+            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())) {
+                return i - 1;
+            }
+        }
+    }
+    return wkt.length - 1;
+}
+/**
+ * 深度克隆 GeoJSON 对象（用于避免意外修改原对象）
+ */
+function cloneGeometry(geometry) {
+    return JSON.parse(JSON.stringify(geometry));
+}
+/**
+ * 判断两个几何对象是否相等（坐标对比）
+ */
+function geometryEquals(a, b) {
+    if (a.type !== b.type)
+        return false;
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+
 exports.GeoJSONBuilder = GeoJSONBuilder;
 exports.WKTBuilder = WKTBuilder;
 exports.WKTParser = WKTParser;
 exports.build = build;
+exports.cloneGeometry = cloneGeometry;
 exports.createGeometryCollection = createGeometryCollection;
 exports.createLineString = createLineString;
 exports.createMultiLineString = createMultiLineString;
@@ -667,7 +878,11 @@ exports.createPolygon = createPolygon;
 exports.featureCollectionToWkt = featureCollectionToWkt;
 exports.featureToWkt = featureToWkt;
 exports.geojsonToWkt = geojsonToWkt;
+exports.geometryEquals = geometryEquals;
 exports.parse = parse;
+exports.tryFixWKT = tryFixWKT;
+exports.validateGeoJSON = validateGeoJSON;
+exports.validateWKT = validateWKT;
 exports.wktToFeature = wktToFeature;
 exports.wktToFeatureCollection = wktToFeatureCollection;
 exports.wktToGeoJSON = wktToGeoJSON;

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export { build, WKTBuilder } from './wkt-builder';
 export { createPoint, createLineString, createPolygon, createMultiPoint, createMultiLineString, createMultiPolygon, createGeometryCollection, GeoJSONBuilder, } from './geojson-builder';
 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';

package/dist/index.esm.js

@@ -1,3 +1,8 @@
+// Precompiled regex for better performance
+const RE_WHITESPACE = /\s/;
+const RE_NUMBER_START = /[0-9\-]/;
+const RE_NUMBER_BODY = /[0-9\.\-eE\+]/;
+const RE_WORD_CHAR = /[a-zA-Z_]/;
 class Lexer {
     constructor(input) {
         this.pos = 0;
@@ -10,14 +15,13 @@ class Lexer {
         return this.input[this.pos++] || '';
     }
     isWhitespace(c) {
-        return /\s/.test(c);
+        return RE_WHITESPACE.test(c);
     }
-    /** 数字开头字符：数字 或 负号 */
     isNumberStart(c) {
-        return /[0-9\-]/.test(c);
+        return RE_NUMBER_START.test(c);
     }
     isNumberBody(c) {
-        return /[0-9\.\-eE\+]/.test(c);
+        return RE_NUMBER_BODY.test(c);
     }
     nextToken() {
         // skip whitespace
@@ -42,18 +46,18 @@ class Lexer {
         }
         // Number: starts with digit or minus
         if (this.isNumberStart(c)) {
-            let num = '';
+            const start = this.pos;
             while (this.pos < this.input.length && this.isNumberBody(this.peek())) {
-                num += this.advance();
+                this.pos++;
             }
-            return { type: 'NUMBER', value: num };
+            return { type: 'NUMBER', value: this.input.slice(start, this.pos) };
         }
         // Word (geometry type or EMPTY/Z/M keyword)
-        let word = '';
-        while (this.pos < this.input.length && /[a-zA-Z_]/.test(this.peek())) {
-            word += this.advance();
+        const start = this.pos;
+        while (this.pos < this.input.length && RE_WORD_CHAR.test(this.peek())) {
+            this.pos++;
         }
-        return { type: 'WORD', value: word.toUpperCase() };
+        return { type: 'WORD', value: this.input.slice(start, this.pos).toUpperCase() };
     }
 }
 class WKTParser {
@@ -248,11 +252,9 @@ class WKTParser {
         }
         this.advance(); // consume (
         const geometries = [];
-        while (this.peek().type !== 'RPAREN' && this.peek().type !== 'EOF') {
+        while (!this.isDone()) {
             geometries.push(this.parseGeometry());
-            if (this.peek().type === 'COMMA') {
-                this.advance();
-            }
+            this.skipComma();
         }
         this.consume('RPAREN');
         return { type: 'GeometryCollection', geometries };
@@ -298,11 +300,9 @@ class WKTParser {
             return [];
         this.advance(); // consume outer (
         const lists = [];
-        while (this.peek().type !== 'RPAREN' && this.peek().type !== 'EOF') {
+        while (!this.isDone()) {
             lists.push(this.parseCoordinatesList());
-            if (this.peek().type === 'COMMA') {
-                this.advance();
-            }
+            this.skipComma();
         }
         this.consume('RPAREN');
         return lists;
@@ -651,4 +651,214 @@ function featureCollectionToWkt(fc) {
     });
 }
 
-export { GeoJSONBuilder, WKTBuilder, WKTParser, build, createGeometryCollection, createLineString, createMultiLineString, createMultiPoint, createMultiPolygon, createPoint, createPolygon, featureCollectionToWkt, featureToWkt, geojsonToWkt, parse, wktToFeature, wktToFeatureCollection, wktToGeoJSON };
+/**
+ * 校验 WKT 字符串格式是否合法
+ */
+function validateWKT(wkt) {
+    if (!wkt || typeof wkt !== 'string') {
+        return { valid: false, error: 'WKT must be a non-empty string' };
+    }
+    const trimmed = wkt.trim();
+    if (trimmed.length === 0) {
+        return { valid: false, error: 'WKT cannot be empty' };
+    }
+    try {
+        parse(wkt);
+        return { valid: true };
+    }
+    catch (e) {
+        return { valid: false, error: e.message };
+    }
+}
+/**
+ * 校验 GeoJSON Geometry 对象是否合法
+ */
+function validateGeoJSON(geojson) {
+    if (!geojson || typeof geojson !== 'object') {
+        return { valid: false, error: 'GeoJSON must be an object' };
+    }
+    const obj = geojson;
+    // 检查 type 字段
+    if (!obj.type || typeof obj.type !== 'string') {
+        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(', ')}` };
+    }
+    // GeometryCollection 特殊处理
+    if (type === 'GeometryCollection') {
+        if (!obj.geometries || !Array.isArray(obj.geometries)) {
+            return { valid: false, error: 'GeometryCollection must have a "geometries" array' };
+        }
+        for (let i = 0; i < obj.geometries.length; i++) {
+            const result = validateGeoJSON(obj.geometries[i]);
+            if (!result.valid) {
+                return { valid: false, error: `GeometryCollection[${i}]: ${result.error}` };
+            }
+        }
+        return { valid: true };
+    }
+    // 其他几何类型必须要有 coordinates
+    if (obj.coordinates === undefined) {
+        return { valid: false, error: `${type} must have "coordinates"` };
+    }
+    // 校验坐标格式
+    return validateCoordinates(type, obj.coordinates);
+}
+function validateCoordinates(type, coords) {
+    switch (type) {
+        case 'Point':
+            return validatePosition(coords);
+        case 'LineString':
+        case 'MultiPoint':
+            if (!Array.isArray(coords)) {
+                return { valid: false, error: `${type} coordinates must be an array` };
+            }
+            for (let i = 0; i < coords.length; i++) {
+                const result = validatePosition(coords[i]);
+                if (!result.valid) {
+                    return { valid: false, error: `${type}[${i}]: ${result.error}` };
+                }
+            }
+            return { valid: true };
+        case 'Polygon':
+        case 'MultiLineString':
+            if (!Array.isArray(coords)) {
+                return { valid: false, error: `${type} coordinates must be a nested array` };
+            }
+            for (let i = 0; i < coords.length; i++) {
+                if (!Array.isArray(coords[i])) {
+                    return { valid: false, error: `${type}[${i}] must be an array of positions` };
+                }
+                for (let j = 0; j < coords[i].length; j++) {
+                    const result = validatePosition(coords[i][j]);
+                    if (!result.valid) {
+                        return { valid: false, error: `${type}[${i}][${j}]: ${result.error}` };
+                    }
+                }
+            }
+            return { valid: true };
+        case 'MultiPolygon':
+            if (!Array.isArray(coords)) {
+                return { valid: false, error: `${type} coordinates must be a deeply nested array` };
+            }
+            for (let i = 0; i < coords.length; i++) {
+                if (!Array.isArray(coords[i])) {
+                    return { valid: false, error: `${type}[${i}] must be an array of rings` };
+                }
+                for (let j = 0; j < coords[i].length; j++) {
+                    if (!Array.isArray(coords[i][j])) {
+                        return { valid: false, error: `${type}[${i}][${j}] must be an array of positions` };
+                    }
+                    for (let k = 0; k < coords[i][j].length; k++) {
+                        const result = validatePosition(coords[i][j][k]);
+                        if (!result.valid) {
+                            return { valid: false, error: `${type}[${i}][${j}][${k}]: ${result.error}` };
+                        }
+                    }
+                }
+            }
+            return { valid: true };
+        default:
+            return { valid: true };
+    }
+}
+function validatePosition(pos) {
+    if (!Array.isArray(pos)) {
+        return { valid: false, error: 'Position must be an array of numbers' };
+    }
+    if (pos.length < 2 || pos.length > 3) {
+        return { valid: false, error: `Position must have 2 or 3 coordinates, got ${pos.length}` };
+    }
+    for (let i = 0; i < pos.length; i++) {
+        if (typeof pos[i] !== 'number' || isNaN(pos[i])) {
+            return { valid: false, error: `Position[${i}] must be a valid number` };
+        }
+    }
+    return { valid: true };
+}
+/**
+ * 尝试从可能不规范的 WKT 中恢复出有效结果
+ * 主要处理尾部多余字符的情况
+ */
+function tryFixWKT(wkt) {
+    const trimmed = wkt.trim();
+    if (!trimmed) {
+        return { fixed: wkt, changed: false };
+    }
+    // 检查是否有尾部多余字符
+    const result = validateWKT(trimmed);
+    if (result.valid) {
+        return { fixed: trimmed, changed: false };
+    }
+    // 尝试找到最后一个有效的 geometry 结束位置
+    const patterns = [
+        /\)\s*[A-Z]/i, // 括号后跟字母 (如 POLYGON ((...)) POINT )
+        /EMPTY\s+[A-Z]/i, // EMPTY 后跟字母
+        /\)\s*$/, // 括号结尾后有多余内容
+    ];
+    for (const pattern of patterns) {
+        const match = trimmed.match(pattern);
+        if (match) {
+            const fixed = trimmed.slice(0, match.index + (match[0].match(/\)/)?.[0].length || 0));
+            if (validateWKT(fixed).valid) {
+                return { fixed, changed: true };
+            }
+        }
+    }
+    // 尝试去除尾部垃圾字符
+    const lastValidIndex = findLastValidPosition(trimmed);
+    if (lastValidIndex > 0) {
+        const fixed = trimmed.slice(0, lastValidIndex + 1);
+        if (validateWKT(fixed).valid) {
+            return { fixed, changed: true };
+        }
+    }
+    return { fixed: wkt, changed: false };
+}
+function findLastValidPosition(wkt) {
+    // 从后往前找第一个有效的右括号位置
+    let depth = 0;
+    for (let i = wkt.length - 1; i >= 0; i--) {
+        const c = wkt[i];
+        if (c === ')')
+            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())) {
+                return i - 1;
+            }
+        }
+    }
+    return wkt.length - 1;
+}
+/**
+ * 深度克隆 GeoJSON 对象（用于避免意外修改原对象）
+ */
+function cloneGeometry(geometry) {
+    return JSON.parse(JSON.stringify(geometry));
+}
+/**
+ * 判断两个几何对象是否相等（坐标对比）
+ */
+function geometryEquals(a, b) {
+    if (a.type !== b.type)
+        return false;
+    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 };

package/dist/index.umd.js

@@ -4,6 +4,11 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.WKTGeoJSON = {}));
 })(this, (function (exports) { 'use strict';
 
+    // Precompiled regex for better performance
+    const RE_WHITESPACE = /\s/;
+    const RE_NUMBER_START = /[0-9\-]/;
+    const RE_NUMBER_BODY = /[0-9\.\-eE\+]/;
+    const RE_WORD_CHAR = /[a-zA-Z_]/;
     class Lexer {
         constructor(input) {
             this.pos = 0;
@@ -16,14 +21,13 @@
             return this.input[this.pos++] || '';
         }
         isWhitespace(c) {
-            return /\s/.test(c);
+            return RE_WHITESPACE.test(c);
         }
-        /** 数字开头字符：数字 或 负号 */
         isNumberStart(c) {
-            return /[0-9\-]/.test(c);
+            return RE_NUMBER_START.test(c);
         }
         isNumberBody(c) {
-            return /[0-9\.\-eE\+]/.test(c);
+            return RE_NUMBER_BODY.test(c);
         }
         nextToken() {
             // skip whitespace
@@ -48,18 +52,18 @@
             }
             // Number: starts with digit or minus
             if (this.isNumberStart(c)) {
-                let num = '';
+                const start = this.pos;
                 while (this.pos < this.input.length && this.isNumberBody(this.peek())) {
-                    num += this.advance();
+                    this.pos++;
                 }
-                return { type: 'NUMBER', value: num };
+                return { type: 'NUMBER', value: this.input.slice(start, this.pos) };
             }
             // Word (geometry type or EMPTY/Z/M keyword)
-            let word = '';
-            while (this.pos < this.input.length && /[a-zA-Z_]/.test(this.peek())) {
-                word += this.advance();
+            const start = this.pos;
+            while (this.pos < this.input.length && RE_WORD_CHAR.test(this.peek())) {
+                this.pos++;
             }
-            return { type: 'WORD', value: word.toUpperCase() };
+            return { type: 'WORD', value: this.input.slice(start, this.pos).toUpperCase() };
         }
     }
     class WKTParser {
@@ -254,11 +258,9 @@
             }
             this.advance(); // consume (
             const geometries = [];
-            while (this.peek().type !== 'RPAREN' && this.peek().type !== 'EOF') {
+            while (!this.isDone()) {
                 geometries.push(this.parseGeometry());
-                if (this.peek().type === 'COMMA') {
-                    this.advance();
-                }
+                this.skipComma();
             }
             this.consume('RPAREN');
             return { type: 'GeometryCollection', geometries };
@@ -304,11 +306,9 @@
                 return [];
             this.advance(); // consume outer (
             const lists = [];
-            while (this.peek().type !== 'RPAREN' && this.peek().type !== 'EOF') {
+            while (!this.isDone()) {
                 lists.push(this.parseCoordinatesList());
-                if (this.peek().type === 'COMMA') {
-                    this.advance();
-                }
+                this.skipComma();
             }
             this.consume('RPAREN');
             return lists;
@@ -657,10 +657,221 @@
         });
     }
 
+    /**
+     * 校验 WKT 字符串格式是否合法
+     */
+    function validateWKT(wkt) {
+        if (!wkt || typeof wkt !== 'string') {
+            return { valid: false, error: 'WKT must be a non-empty string' };
+        }
+        const trimmed = wkt.trim();
+        if (trimmed.length === 0) {
+            return { valid: false, error: 'WKT cannot be empty' };
+        }
+        try {
+            parse(wkt);
+            return { valid: true };
+        }
+        catch (e) {
+            return { valid: false, error: e.message };
+        }
+    }
+    /**
+     * 校验 GeoJSON Geometry 对象是否合法
+     */
+    function validateGeoJSON(geojson) {
+        if (!geojson || typeof geojson !== 'object') {
+            return { valid: false, error: 'GeoJSON must be an object' };
+        }
+        const obj = geojson;
+        // 检查 type 字段
+        if (!obj.type || typeof obj.type !== 'string') {
+            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(', ')}` };
+        }
+        // GeometryCollection 特殊处理
+        if (type === 'GeometryCollection') {
+            if (!obj.geometries || !Array.isArray(obj.geometries)) {
+                return { valid: false, error: 'GeometryCollection must have a "geometries" array' };
+            }
+            for (let i = 0; i < obj.geometries.length; i++) {
+                const result = validateGeoJSON(obj.geometries[i]);
+                if (!result.valid) {
+                    return { valid: false, error: `GeometryCollection[${i}]: ${result.error}` };
+                }
+            }
+            return { valid: true };
+        }
+        // 其他几何类型必须要有 coordinates
+        if (obj.coordinates === undefined) {
+            return { valid: false, error: `${type} must have "coordinates"` };
+        }
+        // 校验坐标格式
+        return validateCoordinates(type, obj.coordinates);
+    }
+    function validateCoordinates(type, coords) {
+        switch (type) {
+            case 'Point':
+                return validatePosition(coords);
+            case 'LineString':
+            case 'MultiPoint':
+                if (!Array.isArray(coords)) {
+                    return { valid: false, error: `${type} coordinates must be an array` };
+                }
+                for (let i = 0; i < coords.length; i++) {
+                    const result = validatePosition(coords[i]);
+                    if (!result.valid) {
+                        return { valid: false, error: `${type}[${i}]: ${result.error}` };
+                    }
+                }
+                return { valid: true };
+            case 'Polygon':
+            case 'MultiLineString':
+                if (!Array.isArray(coords)) {
+                    return { valid: false, error: `${type} coordinates must be a nested array` };
+                }
+                for (let i = 0; i < coords.length; i++) {
+                    if (!Array.isArray(coords[i])) {
+                        return { valid: false, error: `${type}[${i}] must be an array of positions` };
+                    }
+                    for (let j = 0; j < coords[i].length; j++) {
+                        const result = validatePosition(coords[i][j]);
+                        if (!result.valid) {
+                            return { valid: false, error: `${type}[${i}][${j}]: ${result.error}` };
+                        }
+                    }
+                }
+                return { valid: true };
+            case 'MultiPolygon':
+                if (!Array.isArray(coords)) {
+                    return { valid: false, error: `${type} coordinates must be a deeply nested array` };
+                }
+                for (let i = 0; i < coords.length; i++) {
+                    if (!Array.isArray(coords[i])) {
+                        return { valid: false, error: `${type}[${i}] must be an array of rings` };
+                    }
+                    for (let j = 0; j < coords[i].length; j++) {
+                        if (!Array.isArray(coords[i][j])) {
+                            return { valid: false, error: `${type}[${i}][${j}] must be an array of positions` };
+                        }
+                        for (let k = 0; k < coords[i][j].length; k++) {
+                            const result = validatePosition(coords[i][j][k]);
+                            if (!result.valid) {
+                                return { valid: false, error: `${type}[${i}][${j}][${k}]: ${result.error}` };
+                            }
+                        }
+                    }
+                }
+                return { valid: true };
+            default:
+                return { valid: true };
+        }
+    }
+    function validatePosition(pos) {
+        if (!Array.isArray(pos)) {
+            return { valid: false, error: 'Position must be an array of numbers' };
+        }
+        if (pos.length < 2 || pos.length > 3) {
+            return { valid: false, error: `Position must have 2 or 3 coordinates, got ${pos.length}` };
+        }
+        for (let i = 0; i < pos.length; i++) {
+            if (typeof pos[i] !== 'number' || isNaN(pos[i])) {
+                return { valid: false, error: `Position[${i}] must be a valid number` };
+            }
+        }
+        return { valid: true };
+    }
+    /**
+     * 尝试从可能不规范的 WKT 中恢复出有效结果
+     * 主要处理尾部多余字符的情况
+     */
+    function tryFixWKT(wkt) {
+        const trimmed = wkt.trim();
+        if (!trimmed) {
+            return { fixed: wkt, changed: false };
+        }
+        // 检查是否有尾部多余字符
+        const result = validateWKT(trimmed);
+        if (result.valid) {
+            return { fixed: trimmed, changed: false };
+        }
+        // 尝试找到最后一个有效的 geometry 结束位置
+        const patterns = [
+            /\)\s*[A-Z]/i, // 括号后跟字母 (如 POLYGON ((...)) POINT )
+            /EMPTY\s+[A-Z]/i, // EMPTY 后跟字母
+            /\)\s*$/, // 括号结尾后有多余内容
+        ];
+        for (const pattern of patterns) {
+            const match = trimmed.match(pattern);
+            if (match) {
+                const fixed = trimmed.slice(0, match.index + (match[0].match(/\)/)?.[0].length || 0));
+                if (validateWKT(fixed).valid) {
+                    return { fixed, changed: true };
+                }
+            }
+        }
+        // 尝试去除尾部垃圾字符
+        const lastValidIndex = findLastValidPosition(trimmed);
+        if (lastValidIndex > 0) {
+            const fixed = trimmed.slice(0, lastValidIndex + 1);
+            if (validateWKT(fixed).valid) {
+                return { fixed, changed: true };
+            }
+        }
+        return { fixed: wkt, changed: false };
+    }
+    function findLastValidPosition(wkt) {
+        // 从后往前找第一个有效的右括号位置
+        let depth = 0;
+        for (let i = wkt.length - 1; i >= 0; i--) {
+            const c = wkt[i];
+            if (c === ')')
+                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())) {
+                    return i - 1;
+                }
+            }
+        }
+        return wkt.length - 1;
+    }
+    /**
+     * 深度克隆 GeoJSON 对象（用于避免意外修改原对象）
+     */
+    function cloneGeometry(geometry) {
+        return JSON.parse(JSON.stringify(geometry));
+    }
+    /**
+     * 判断两个几何对象是否相等（坐标对比）
+     */
+    function geometryEquals(a, b) {
+        if (a.type !== b.type)
+            return false;
+        return JSON.stringify(a) === JSON.stringify(b);
+    }
+
     exports.GeoJSONBuilder = GeoJSONBuilder;
     exports.WKTBuilder = WKTBuilder;
     exports.WKTParser = WKTParser;
     exports.build = build;
+    exports.cloneGeometry = cloneGeometry;
     exports.createGeometryCollection = createGeometryCollection;
     exports.createLineString = createLineString;
     exports.createMultiLineString = createMultiLineString;
@@ -671,7 +882,11 @@
     exports.featureCollectionToWkt = featureCollectionToWkt;
     exports.featureToWkt = featureToWkt;
     exports.geojsonToWkt = geojsonToWkt;
+    exports.geometryEquals = geometryEquals;
     exports.parse = parse;
+    exports.tryFixWKT = tryFixWKT;
+    exports.validateGeoJSON = validateGeoJSON;
+    exports.validateWKT = validateWKT;
     exports.wktToFeature = wktToFeature;
     exports.wktToFeatureCollection = wktToFeatureCollection;
     exports.wktToGeoJSON = wktToGeoJSON;

package/dist/validate.d.ts

@@ -0,0 +1,29 @@
+import { Geometry } from './types';
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+}
+/**
+ * 校验 WKT 字符串格式是否合法
+ */
+export declare function validateWKT(wkt: string): ValidationResult;
+/**
+ * 校验 GeoJSON Geometry 对象是否合法
+ */
+export declare function validateGeoJSON(geojson: unknown): ValidationResult;
+/**
+ * 尝试从可能不规范的 WKT 中恢复出有效结果
+ * 主要处理尾部多余字符的情况
+ */
+export declare function tryFixWKT(wkt: string): {
+    fixed: string;
+    changed: boolean;
+};
+/**
+ * 深度克隆 GeoJSON 对象（用于避免意外修改原对象）
+ */
+export declare function cloneGeometry<G extends Geometry>(geometry: G): G;
+/**
+ * 判断两个几何对象是否相等（坐标对比）
+ */
+export declare function geometryEquals(a: Geometry, b: Geometry): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wkt-parse-and-geojson",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "type": "module",
   "description": "Zero-dependency WKT parser/builder and WKT↔GeoJSON converter",
   "main": "dist/index.cjs.js",
@@ -41,5 +41,8 @@
     "rollup": "^4.40.0",
     "tslib": "^2.8.1",
     "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "wkt-parse-and-geojson": "^1.0.3"
   }
 }