clarity-pattern-parser 10.2.12 → 10.2.14

package/dist/ast/Node.d.ts

@@ -50,6 +50,7 @@ export declare class Node {
     remove(): void;
     clone(): Node;
     normalize(startIndex?: number): number;
+    compact(): void;
     toString(): string;
     toCycleFreeObject(): CycleFreeNode;
     toJson(space?: number): string;

package/dist/index.browser.js

@@ -205,16 +205,26 @@
         }
         normalize(startIndex = this._firstIndex) {
             let length = 0;
+            let runningOffset = startIndex;
             if (this.children.length === 0) {
                 length = this._value.length;
             }
             else {
-                length = this.children.reduce((acc, c) => acc + c.normalize(acc + startIndex), startIndex) - startIndex;
+                for (let x = 0; x < this.children.length; x++) {
+                    const child = this.children[x];
+                    const childLength = child.normalize(runningOffset);
+                    runningOffset += childLength;
+                    length += childLength;
+                }
             }
             this._firstIndex = startIndex;
             this._lastIndex = Math.max(startIndex + length - 1, 0);
             return length;
         }
+        compact() {
+            this._value = this.toString();
+            this._children.length = 0;
+        }
         toString() {
             if (this._children.length === 0) {
                 return this._value;
@@ -526,6 +536,7 @@
             return [];
         }
         constructor(name, value) {
+            this.shouldCompactAst = false;
             if (value.length === 0) {
                 throw new Error("Value Cannot be empty.");
             }
@@ -595,6 +606,7 @@
         clone(name = this._name) {
             const clone = new Literal(name, this._token);
             clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
             return clone;
         }
         getTokens() {
@@ -658,6 +670,7 @@
             this._firstIndex = -1;
             this._substring = "";
             this._tokens = [];
+            this.shouldCompactAst = false;
             this._id = `regex-${idIndex$8++}`;
             this._type = "regex";
             this._name = name;
@@ -727,6 +740,7 @@
             const clone = new Regex(name, this._originalRegexString);
             clone._tokens = this._tokens.slice();
             clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
             return clone;
         }
         getTokens() {
@@ -807,6 +821,7 @@
             return this._children;
         }
         constructor(name) {
+            this.shouldCompactAst = false;
             this._id = `reference-${idIndex$7++}`;
             this._type = "reference";
             this._name = name;
@@ -927,6 +942,7 @@
         clone(name = this._name) {
             const clone = new Reference(name);
             clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
             // Optimize future clones, by caching the pattern we already found.
             if (this._pattern != null) {
                 clone._cachedPattern = this._pattern;
@@ -1005,6 +1021,7 @@
             return this._children;
         }
         constructor(name, options, isGreedy = false) {
+            this.shouldCompactAst = false;
             if (options.length === 0) {
                 throw new Error("Need at least one pattern with an 'options' pattern.");
             }
@@ -1047,6 +1064,9 @@
             if (node != null) {
                 cursor.moveTo(node.lastIndex);
                 cursor.resolveError();
+                if (this.shouldCompactAst) {
+                    node.compact();
+                }
                 return node;
             }
             cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
@@ -1121,9 +1141,10 @@
             return findPattern(this, predicate);
         }
         clone(name = this._name) {
-            const or = new Options(name, this._children, this._isGreedy);
-            or._id = this._id;
-            return or;
+            const clone = new Options(name, this._children, this._isGreedy);
+            clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
+            return clone;
         }
         isEqual(pattern) {
             return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
@@ -1157,6 +1178,7 @@
             return this._max;
         }
         constructor(name, pattern, options = {}) {
+            this.shouldCompactAst = false;
             this._id = `finite-repeat-${idIndex$5++}`;
             this._type = "finite-repeat";
             this._name = name;
@@ -1226,7 +1248,11 @@
             const lastIndex = nodes[nodes.length - 1].lastIndex;
             cursor.resolveError();
             cursor.moveTo(lastIndex);
-            return new Node(this._type, this.name, firstIndex, lastIndex, nodes);
+            const node = new Node(this._type, this.name, firstIndex, lastIndex, nodes);
+            if (this.shouldCompactAst) {
+                node.compact();
+            }
+            return node;
         }
         test(text) {
             const cursor = new Cursor(text);
@@ -1252,6 +1278,7 @@
                 trimDivider: this._trimDivider
             });
             clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
             return clone;
         }
         getTokens() {
@@ -1329,6 +1356,7 @@
             return this._min;
         }
         constructor(name, pattern, options = {}) {
+            this.shouldCompactAst = false;
             const min = options.min != null ? Math.max(options.min, 1) : 1;
             const divider = options.divider;
             let children;
@@ -1380,6 +1408,9 @@
                 if (node != null) {
                     cursor.moveTo(node.lastIndex);
                     cursor.recordMatch(this, node);
+                    if (this.shouldCompactAst) {
+                        node.compact();
+                    }
                 }
                 return node;
             }
@@ -1558,6 +1589,7 @@
                 trimDivider: this._trimDivider
             });
             clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
             return clone;
         }
         isEqual(pattern) {
@@ -1592,6 +1624,7 @@
             return this._options.max;
         }
         constructor(name, pattern, options = {}) {
+            this.shouldCompactAst = false;
             this._id = `repeat-${idIndex$3++}`;
             this._pattern = pattern;
             this._parent = null;
@@ -1602,6 +1635,7 @@
             else {
                 this._repeatPattern = new InfiniteRepeat(name, pattern, this._options);
             }
+            this._repeatPattern.shouldCompactAst = this.shouldCompactAst;
             this._children = [this._repeatPattern];
             this._repeatPattern.parent = this;
         }
@@ -1618,6 +1652,7 @@
             let min = this._options.min;
             const clone = new Repeat(name, this._pattern, Object.assign(Object.assign({}, this._options), { min }));
             clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
             return clone;
         }
         getTokens() {
@@ -1693,6 +1728,7 @@
             return this._children;
         }
         constructor(name, sequence) {
+            this.shouldCompactAst = false;
             if (sequence.length === 0) {
                 throw new Error("Need at least one pattern with a 'sequence' pattern.");
             }
@@ -1736,6 +1772,9 @@
                 const node = this.createNode(cursor);
                 if (node !== null) {
                     cursor.recordMatch(this, node);
+                    if (this.shouldCompactAst) {
+                        node.compact();
+                    }
                 }
                 return node;
             }
@@ -1909,6 +1948,7 @@
         clone(name = this._name) {
             const clone = new Sequence(name, this._children);
             clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
             return clone;
         }
         isEqual(pattern) {
@@ -1968,6 +2008,7 @@
             return this._children;
         }
         constructor(name, pattern) {
+            this.shouldCompactAst = false;
             this._id = `optional-${idIndex$1++}`;
             this._type = "optional";
             this._name = name;
@@ -1998,13 +2039,17 @@
                 return null;
             }
             else {
+                if (node != null && this.shouldCompactAst) {
+                    node.compact();
+                }
                 return node;
             }
         }
         clone(name = this._name) {
-            const optional = new Optional(name, this._children[0]);
-            optional._id = this._id;
-            return optional;
+            const clone = new Optional(name, this._children[0]);
+            clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
+            return clone;
         }
         getTokens() {
             return this._children[0].getTokens();
@@ -2280,6 +2325,7 @@
             return this._children;
         }
         constructor(name, pattern) {
+            this.shouldCompactAst = false;
             this._id = `not-${idIndex++}`;
             this._type = "not";
             this._name = name;
@@ -2624,6 +2670,7 @@
             return Object.assign({}, this._patterns);
         }
         constructor(name, pattern, context = []) {
+            this.shouldCompactAst = false;
             this._id = `context-${contextId++}`;
             this._type = "context";
             this._name = name;
@@ -2647,6 +2694,7 @@
         clone(name = this._name) {
             const clone = new Context(name, this._pattern, Object.values(this._patterns));
             clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
             return clone;
         }
         getTokens() {
@@ -2726,6 +2774,7 @@
             return this._recursivePatterns;
         }
         constructor(name, patterns) {
+            this.shouldCompactAst = false;
             if (patterns.length === 0) {
                 throw new Error("Need at least one pattern with an 'expression' pattern.");
             }
@@ -3093,6 +3142,7 @@
         clone(name = this._name) {
             const clone = new ExpressionPattern(name, this._originalPatterns);
             clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
             return clone;
         }
         isEqual(pattern) {