clarity-pattern-parser 11.0.23 → 11.0.25

package/dist/index.browser.js

@@ -529,20 +529,31 @@
 
     function execPattern(pattern, text, record = false) {
         const cursor = new Cursor(text);
+        if (cursor.length === 0) {
+            return { ast: null, cursor };
+        }
         record && cursor.startRecording();
-        const ast = pattern.parse(cursor);
-        const isMatch = (ast === null || ast === void 0 ? void 0 : ast.value.length) === text.length;
+        let ast = pattern.parse(cursor);
+        const resultLength = ast == null ? 0 : ast.value.length;
+        if (ast != null) {
+            const isMatch = ast.value === text;
+            if (!isMatch && !cursor.hasError) {
+                ast = null;
+                cursor.recordErrorAt(resultLength, cursor.length, pattern);
+            }
+        }
+        else {
+            cursor.recordErrorAt(resultLength, cursor.length, pattern);
+        }
         return {
-            ast: isMatch ? ast : null,
+            ast: ast,
             cursor
         };
     }
 
     function testPattern(pattern, text, record = false) {
-        const cursor = new Cursor(text);
-        record && cursor.startRecording();
-        const ast = pattern.parse(cursor);
-        return (ast === null || ast === void 0 ? void 0 : ast.value.length) === text.length;
+        const result = execPattern(pattern, text, record);
+        return !result.cursor.hasError;
     }
 
     let idIndex$9 = 0;
@@ -606,9 +617,6 @@
         _tryToParse(cursor) {
             let passed = false;
             const literalRuneLength = this._runes.length;
-            if (!cursor.hasNext) {
-                return false;
-            }
             for (let i = 0; i < literalRuneLength; i++) {
                 const literalRune = this._runes[i];
                 const cursorRune = cursor.currentChar;
@@ -1992,19 +2000,11 @@
             this._children = [pattern.clone()];
             this._children[0].parent = this;
         }
-        test(text) {
-            const cursor = new Cursor(text);
-            this.parse(cursor);
-            return !cursor.hasError;
+        test(text, record = false) {
+            return testPattern(this, text, record);
         }
         exec(text, record = false) {
-            const cursor = new Cursor(text);
-            record && cursor.startRecording();
-            const ast = this.parse(cursor);
-            return {
-                ast: (ast === null || ast === void 0 ? void 0 : ast.value) === text ? ast : null,
-                cursor
-            };
+            return execPattern(this, text, record);
         }
         parse(cursor) {
             const firstIndex = cursor.index;
@@ -2824,12 +2824,15 @@
             }
             return pattern.name === this.name;
         }
-        parse(cursor) {
-            this._firstIndex = cursor.index;
+        build() {
             if (!this._hasOrganized) {
                 this._hasOrganized = true;
                 this._organizePatterns(this._originalPatterns);
             }
+        }
+        parse(cursor) {
+            this._firstIndex = cursor.index;
+            this.build();
             // If there are not any atom nodes then nothing can be found.
             if (this._atomPatterns.length < 1) {
                 cursor.moveTo(this._firstIndex);