clarity-pattern-parser 11.2.1 → 11.3.0

package/dist/index.esm.js

@@ -1,7 +1,11 @@
 function defaultVisitor(node) {
     return node;
 }
+let idIndex$b = 0;
 class Node {
+    get id() {
+        return this._id;
+    }
     get type() {
         return this._type;
     }
@@ -36,6 +40,7 @@ class Node {
         return !this.hasChildren;
     }
     constructor(type, name, firstIndex, lastIndex, children = [], value = "") {
+        this._id = String(idIndex$b++);
         this._type = type;
         this._name = name;
         this._firstIndex = firstIndex;
@@ -196,7 +201,8 @@ class Node {
         }
     }
     clone() {
-        return new Node(this._type, this._name, this._firstIndex, this._lastIndex, this._children.map((c) => c.clone()), this._value);
+        const node = new Node(this._type, this._name, this._firstIndex, this._lastIndex, this._children.map((c) => c.clone()), this._value);
+        return node;
     }
     normalize(startIndex = this._firstIndex) {
         let length = 0;
@@ -224,6 +230,7 @@ class Node {
     }
     toCycleFreeObject() {
         return {
+            id: this._id,
             type: this._type,
             name: this._name,
             value: this.toString(),
@@ -236,7 +243,12 @@ class Node {
         return JSON.stringify(this.toCycleFreeObject(), null, space);
     }
     isEqual(node) {
-        return node.toJson(0) === this.toJson(0);
+        return node._type === this._type &&
+            node._name === this._name &&
+            node._firstIndex === this._firstIndex &&
+            node._lastIndex === this._lastIndex &&
+            node._value === this._value &&
+            this._children.every((child, index) => child.isEqual(node._children[index]));
     }
     static createValueNode(type, name, value = "") {
         return new Node(type, name, 0, 0, [], value);
@@ -348,14 +360,15 @@ class CursorHistory {
         return this._patterns;
     }
     recordMatch(pattern, node) {
+        const record = {
+            pattern,
+            ast: node,
+            error: null
+        };
         if (this._isRecording) {
             this._patterns.push(pattern);
             this._nodes.push(node);
-            this._records.push({
-                pattern,
-                ast: node,
-                error: null
-            });
+            this._records.push(record);
         }
         this._rootMatch.pattern = pattern;
         this._rootMatch.node = node;
@@ -389,28 +402,29 @@ class CursorHistory {
     }
     recordErrorAt(startIndex, lastIndex, pattern) {
         const error = new ParseError(startIndex, lastIndex, pattern);
+        const record = {
+            pattern,
+            ast: null,
+            error
+        };
         this._currentError = error;
         if (this._furthestError === null || lastIndex > this._furthestError.lastIndex) {
             this._furthestError = error;
         }
         if (this._isRecording) {
             this._errors.push(error);
-            this.records.push({
-                pattern,
-                ast: null,
-                error
-            });
+            this.records.push(record);
         }
     }
+    resolveError() {
+        this._currentError = null;
+    }
     startRecording() {
         this._isRecording = true;
     }
     stopRecording() {
         this._isRecording = false;
     }
-    resolveError() {
-        this._currentError = null;
-    }
 }
 
 class Cursor {
@@ -507,8 +521,8 @@ class Cursor {
     recordMatch(pattern, node) {
         this._history.recordMatch(pattern, node);
     }
-    recordErrorAt(startIndex, endIndex, onPattern) {
-        this._history.recordErrorAt(startIndex, endIndex, onPattern);
+    recordErrorAt(startIndex, lastIndex, onPattern) {
+        this._history.recordErrorAt(startIndex, lastIndex, onPattern);
     }
     resolveError() {
         this._history.resolveError();
@@ -3206,15 +3220,16 @@ class TakeUntil {
         let foundMatch = false;
         this._startedOnIndex = cursor.index;
         let terminatingResult = this._terminatingPattern.parse(cursor);
+        cursor.resolveError();
         if (terminatingResult == null) {
             foundMatch = true;
             cursor.moveTo(cursorIndex);
             cursorIndex += 1;
             cursor.hasNext() && cursor.next();
-            cursor.resolveError();
         }
         while (true) {
             terminatingResult = this._terminatingPattern.parse(cursor);
+            cursor.resolveError();
             if (terminatingResult == null) {
                 cursor.moveTo(cursorIndex);
                 cursorIndex += 1;
@@ -3224,7 +3239,6 @@ class TakeUntil {
                 else {
                     break;
                 }
-                cursor.resolveError();
             }
             else {
                 break;
@@ -3233,10 +3247,11 @@ class TakeUntil {
         if (foundMatch) {
             cursor.moveTo(cursorIndex - 1);
             const value = cursor.getChars(this.startedOnIndex, cursorIndex - 1);
-            return Node.createValueNode(this._type, this._name, value);
+            const node = Node.createValueNode(this._type, this._name, value);
+            cursor.recordMatch(this, node);
+            return node;
         }
         else {
-            cursor.resolveError();
             cursor.moveTo(this.startedOnIndex);
             cursor.recordErrorAt(this._startedOnIndex, this._startedOnIndex, this);
             return null;