clarity-pattern-parser 11.2.1 → 11.3.0

package/TODO.md

@@ -1,9 +1,7 @@
-* Fix Grammar with alias reference, by adding an additional parameter to the constructor of Reference to be the name and then the cloned name of the pattern eventually found.
-
 * We should make a Block, Segments Pattern. These will be breadth first patterns. It look something like this.
 
 ```ts
-new Block(startPattern,contentPattern,endPattern);
+new Block("block", startPattern,endPattern);
 ```
 
 ```

package/dist/ast/Node.d.ts

@@ -1,4 +1,5 @@
 export interface CycleFreeNode {
+    id: string;
     type: string;
     name: string;
     startIndex: number;
@@ -7,6 +8,7 @@ export interface CycleFreeNode {
     children: CycleFreeNode[];
 }
 export declare class Node {
+    private _id;
     private _type;
     private _name;
     private _firstIndex;
@@ -14,6 +16,7 @@ export declare class Node {
     private _parent;
     private _children;
     private _value;
+    get id(): string;
     get type(): string;
     get name(): string;
     get value(): string;

package/dist/index.browser.js

@@ -7,7 +7,11 @@
     function defaultVisitor(node) {
         return node;
     }
+    let idIndex$b = 0;
     class Node {
+        get id() {
+            return this._id;
+        }
         get type() {
             return this._type;
         }
@@ -42,6 +46,7 @@
             return !this.hasChildren;
         }
         constructor(type, name, firstIndex, lastIndex, children = [], value = "") {
+            this._id = String(idIndex$b++);
             this._type = type;
             this._name = name;
             this._firstIndex = firstIndex;
@@ -202,7 +207,8 @@
             }
         }
         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;
@@ -230,6 +236,7 @@
         }
         toCycleFreeObject() {
             return {
+                id: this._id,
                 type: this._type,
                 name: this._name,
                 value: this.toString(),
@@ -242,7 +249,12 @@
             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);
@@ -354,14 +366,15 @@
             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;
@@ -395,28 +408,29 @@
         }
         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 {
@@ -513,8 +527,8 @@
         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();
@@ -3212,15 +3226,16 @@
             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;
@@ -3230,7 +3245,6 @@
                     else {
                         break;
                     }
-                    cursor.resolveError();
                 }
                 else {
                     break;
@@ -3239,10 +3253,11 @@
             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;