clarity-pattern-parser 10.2.13 → 10.3.0

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

@@ -167,7 +167,6 @@
         walkBreadthFirst(callback) {
             const queue = [this];
             while (queue.length > 0) {
-                // biome-ignore lint/style/noNonNullAssertion: This will never be undefined.
                 const current = queue.shift();
                 callback(current);
                 queue.push(...current.children);
@@ -221,6 +220,10 @@
             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;
@@ -532,6 +535,7 @@
             return [];
         }
         constructor(name, value) {
+            this.shouldCompactAst = false;
             if (value.length === 0) {
                 throw new Error("Value Cannot be empty.");
             }
@@ -601,6 +605,7 @@
         clone(name = this._name) {
             const clone = new Literal(name, this._token);
             clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
             return clone;
         }
         getTokens() {
@@ -664,6 +669,7 @@
             this._firstIndex = -1;
             this._substring = "";
             this._tokens = [];
+            this.shouldCompactAst = false;
             this._id = `regex-${idIndex$8++}`;
             this._type = "regex";
             this._name = name;
@@ -733,6 +739,7 @@
             const clone = new Regex(name, this._originalRegexString);
             clone._tokens = this._tokens.slice();
             clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
             return clone;
         }
         getTokens() {
@@ -813,6 +820,7 @@
             return this._children;
         }
         constructor(name) {
+            this.shouldCompactAst = false;
             this._id = `reference-${idIndex$7++}`;
             this._type = "reference";
             this._name = name;
@@ -933,6 +941,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;
@@ -1011,6 +1020,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.");
             }
@@ -1053,6 +1063,9 @@
             if (node != null) {
                 cursor.moveTo(node.lastIndex);
                 cursor.resolveError();
+                if (this.shouldCompactAst) {
+                    node.compact();
+                }
                 return node;
             }
             cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
@@ -1127,9 +1140,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]));
@@ -1163,6 +1177,7 @@
             return this._max;
         }
         constructor(name, pattern, options = {}) {
+            this.shouldCompactAst = false;
             this._id = `finite-repeat-${idIndex$5++}`;
             this._type = "finite-repeat";
             this._name = name;
@@ -1232,7 +1247,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);
@@ -1258,6 +1277,7 @@
                 trimDivider: this._trimDivider
             });
             clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
             return clone;
         }
         getTokens() {
@@ -1335,6 +1355,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;
@@ -1386,6 +1407,9 @@
                 if (node != null) {
                     cursor.moveTo(node.lastIndex);
                     cursor.recordMatch(this, node);
+                    if (this.shouldCompactAst) {
+                        node.compact();
+                    }
                 }
                 return node;
             }
@@ -1564,6 +1588,7 @@
                 trimDivider: this._trimDivider
             });
             clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
             return clone;
         }
         isEqual(pattern) {
@@ -1573,6 +1598,13 @@
 
     let idIndex$3 = 0;
     class Repeat {
+        get shouldCompactAst() {
+            return this._shouldCompactAst;
+        }
+        set shouldCompactAst(value) {
+            this._shouldCompactAst = value;
+            this._repeatPattern.shouldCompactAst = value;
+        }
         get id() {
             return this._id;
         }
@@ -1601,6 +1633,7 @@
             this._id = `repeat-${idIndex$3++}`;
             this._pattern = pattern;
             this._parent = null;
+            this._shouldCompactAst = false;
             this._options = Object.assign(Object.assign({}, options), { min: options.min == null ? 1 : options.min, max: options.max == null ? Infinity : options.max });
             if (this._options.max !== Infinity) {
                 this._repeatPattern = new FiniteRepeat(name, pattern, this._options);
@@ -1624,6 +1657,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() {
@@ -1699,6 +1733,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.");
             }
@@ -1742,6 +1777,9 @@
                 const node = this.createNode(cursor);
                 if (node !== null) {
                     cursor.recordMatch(this, node);
+                    if (this.shouldCompactAst) {
+                        node.compact();
+                    }
                 }
                 return node;
             }
@@ -1915,6 +1953,7 @@
         clone(name = this._name) {
             const clone = new Sequence(name, this._children);
             clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
             return clone;
         }
         isEqual(pattern) {
@@ -1974,6 +2013,7 @@
             return this._children;
         }
         constructor(name, pattern) {
+            this.shouldCompactAst = false;
             this._id = `optional-${idIndex$1++}`;
             this._type = "optional";
             this._name = name;
@@ -2004,13 +2044,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();
@@ -2159,13 +2203,17 @@
 
     const optionalSpaces$2 = new Optional("optional-spaces", spaces$1);
     const assignOperator = new Literal("assign-operator", "=");
+    const compact = new Literal("compact", "compact");
+    const compactModifier = new Sequence("compact-modifier", [lineSpaces$1, compact]);
+    const optionalCompactModifier = new Optional("optional-compact-modifier", compactModifier);
     const assignStatement = new Sequence("assign-statement", [
         optionalSpaces$2,
         name$1,
         optionalSpaces$2,
         assignOperator,
         optionalSpaces$2,
-        pattern
+        pattern,
+        optionalCompactModifier
     ]);
     const statement = new Options("statement", [assignStatement, name$1.clone("export-name")]);
 
@@ -2286,6 +2334,7 @@
             return this._children;
         }
         constructor(name, pattern) {
+            this.shouldCompactAst = false;
             this._id = `not-${idIndex++}`;
             this._type = "not";
             this._name = name;
@@ -2630,6 +2679,7 @@
             return Object.assign({}, this._patterns);
         }
         constructor(name, pattern, context = []) {
+            this.shouldCompactAst = false;
             this._id = `context-${contextId++}`;
             this._type = "context";
             this._name = name;
@@ -2653,6 +2703,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() {
@@ -2732,6 +2783,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.");
             }
@@ -2749,6 +2801,7 @@
             this._binaryAssociation = [];
             this._precedenceMap = {};
             this._originalPatterns = patterns;
+            this._shouldCompactPatternsMap = {};
             this._patterns = this._organizePatterns(patterns);
             if (this._unaryPatterns.length === 0) {
                 throw new Error("Need at least one operand pattern with an 'expression' pattern.");
@@ -2757,6 +2810,7 @@
         _organizePatterns(patterns) {
             const finalPatterns = [];
             patterns.forEach((pattern) => {
+                this._shouldCompactPatternsMap[pattern.name] = pattern.shouldCompactAst;
                 if (this._isBinary(pattern)) {
                     const binaryName = this._extractName(pattern);
                     const clone = this._extractDelimiter(pattern).clone();
@@ -2854,11 +2908,31 @@
             if (node != null) {
                 cursor.moveTo(node.lastIndex);
                 cursor.resolveError();
+                this._compactResult(node);
                 return node;
             }
             cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
             return null;
         }
+        _compactResult(node) {
+            if (node == null) {
+                return;
+            }
+            if (this.shouldCompactAst) {
+                node.compact();
+                return;
+            }
+            // This could be really expensive with large trees. So we optimize with these checks,
+            // as well as use breadth first as to not recompact nodes over and over again. 
+            const isCompactingNeeded = Object.values(this._shouldCompactPatternsMap).some(p => p);
+            if (isCompactingNeeded) {
+                node.walkBreadthFirst(n => {
+                    if (this._shouldCompactPatternsMap[n.name]) {
+                        n.compact();
+                    }
+                });
+            }
+        }
         _tryToParse(cursor) {
             if (depthCache.getDepth(this._id, this._firstIndex) > 2) {
                 cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
@@ -3099,6 +3173,7 @@
         clone(name = this._name) {
             const clone = new ExpressionPattern(name, this._originalPatterns);
             clone._id = this._id;
+            clone.shouldCompactAst = this.shouldCompactAst;
             return clone;
         }
         isEqual(pattern) {
@@ -3279,9 +3354,13 @@
         }
         _saveOptions(statementNode) {
             const nameNode = statementNode.find(n => n.name === "name");
+            const shouldCompactAst = statementNode.find(n => n.name === "compact");
             const name = nameNode.value;
             const optionsNode = statementNode.find(n => n.name === "options-literal");
             const options = this._buildOptions(name, optionsNode);
+            if (shouldCompactAst != null) {
+                options.shouldCompactAst = true;
+            }
             this._parseContext.patternsByName.set(name, options);
         }
         _buildOptions(name, node) {
@@ -3341,9 +3420,13 @@
         }
         _saveSequence(statementNode) {
             const nameNode = statementNode.find(n => n.name === "name");
+            const shouldCompactAst = statementNode.find(n => n.name === "compact");
             const name = nameNode.value;
             const sequenceNode = statementNode.find(n => n.name === "sequence-literal");
             const sequence = this._buildSequence(name, sequenceNode);
+            if (shouldCompactAst != null) {
+                sequence.shouldCompactAst = true;
+            }
             this._parseContext.patternsByName.set(name, sequence);
         }
         _buildSequence(name, node) {
@@ -3363,9 +3446,13 @@
         }
         _saveRepeat(statementNode) {
             const nameNode = statementNode.find(n => n.name === "name");
+            const shouldCompactAst = statementNode.find(n => n.name === "compact");
             const name = nameNode.value;
             const repeatNode = statementNode.find(n => n.name === "repeat-literal");
             const repeat = this._buildRepeat(name, repeatNode);
+            if (shouldCompactAst != null) {
+                repeat.shouldCompactAst = true;
+            }
             this._parseContext.patternsByName.set(name, repeat);
         }
         _buildRepeat(name, repeatNode) {
@@ -3518,10 +3605,14 @@
         }
         _saveAlias(statementNode) {
             const nameNode = statementNode.find(n => n.name === "name");
+            const shouldCompactAst = statementNode.find(n => n.name === "compact");
             const aliasNode = statementNode.find(n => n.name === "alias-literal");
             const aliasName = aliasNode.value;
             const name = nameNode.value;
             const alias = this._getPattern(aliasName).clone(name);
+            if (shouldCompactAst != null) {
+                alias.shouldCompactAst = true;
+            }
             this._parseContext.patternsByName.set(name, alias);
         }
         static parse(expression, options) {