clarity-pattern-parser 10.2.13 → 10.3.0

package/dist/index.esm.js

@@ -161,7 +161,6 @@ class Node {
     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);
@@ -215,6 +214,10 @@ class Node {
         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 +529,7 @@ class Literal {
         return [];
     }
     constructor(name, value) {
+        this.shouldCompactAst = false;
         if (value.length === 0) {
             throw new Error("Value Cannot be empty.");
         }
@@ -595,6 +599,7 @@ class Literal {
     clone(name = this._name) {
         const clone = new Literal(name, this._token);
         clone._id = this._id;
+        clone.shouldCompactAst = this.shouldCompactAst;
         return clone;
     }
     getTokens() {
@@ -658,6 +663,7 @@ class Regex {
         this._firstIndex = -1;
         this._substring = "";
         this._tokens = [];
+        this.shouldCompactAst = false;
         this._id = `regex-${idIndex$8++}`;
         this._type = "regex";
         this._name = name;
@@ -727,6 +733,7 @@ class Regex {
         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 +814,7 @@ class Reference {
         return this._children;
     }
     constructor(name) {
+        this.shouldCompactAst = false;
         this._id = `reference-${idIndex$7++}`;
         this._type = "reference";
         this._name = name;
@@ -927,6 +935,7 @@ class Reference {
     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 +1014,7 @@ class Options {
         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 +1057,9 @@ class Options {
         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 +1134,10 @@ class Options {
         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 +1171,7 @@ class FiniteRepeat {
         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 +1241,11 @@ class FiniteRepeat {
         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 +1271,7 @@ class FiniteRepeat {
             trimDivider: this._trimDivider
         });
         clone._id = this._id;
+        clone.shouldCompactAst = this.shouldCompactAst;
         return clone;
     }
     getTokens() {
@@ -1329,6 +1349,7 @@ class InfiniteRepeat {
         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 +1401,9 @@ class InfiniteRepeat {
             if (node != null) {
                 cursor.moveTo(node.lastIndex);
                 cursor.recordMatch(this, node);
+                if (this.shouldCompactAst) {
+                    node.compact();
+                }
             }
             return node;
         }
@@ -1558,6 +1582,7 @@ class InfiniteRepeat {
             trimDivider: this._trimDivider
         });
         clone._id = this._id;
+        clone.shouldCompactAst = this.shouldCompactAst;
         return clone;
     }
     isEqual(pattern) {
@@ -1567,6 +1592,13 @@ class InfiniteRepeat {
 
 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;
     }
@@ -1595,6 +1627,7 @@ class Repeat {
         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);
@@ -1618,6 +1651,7 @@ class Repeat {
         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 +1727,7 @@ class Sequence {
         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 +1771,9 @@ class Sequence {
             const node = this.createNode(cursor);
             if (node !== null) {
                 cursor.recordMatch(this, node);
+                if (this.shouldCompactAst) {
+                    node.compact();
+                }
             }
             return node;
         }
@@ -1909,6 +1947,7 @@ class Sequence {
     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 +2007,7 @@ class Optional {
         return this._children;
     }
     constructor(name, pattern) {
+        this.shouldCompactAst = false;
         this._id = `optional-${idIndex$1++}`;
         this._type = "optional";
         this._name = name;
@@ -1998,13 +2038,17 @@ class Optional {
             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();
@@ -2153,13 +2197,17 @@ const pattern = new Options("pattern", [
 
 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")]);
 
@@ -2280,6 +2328,7 @@ class Not {
         return this._children;
     }
     constructor(name, pattern) {
+        this.shouldCompactAst = false;
         this._id = `not-${idIndex++}`;
         this._type = "not";
         this._name = name;
@@ -2624,6 +2673,7 @@ class Context {
         return Object.assign({}, this._patterns);
     }
     constructor(name, pattern, context = []) {
+        this.shouldCompactAst = false;
         this._id = `context-${contextId++}`;
         this._type = "context";
         this._name = name;
@@ -2647,6 +2697,7 @@ class Context {
     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 +2777,7 @@ class ExpressionPattern {
         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.");
         }
@@ -2743,6 +2795,7 @@ class ExpressionPattern {
         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.");
@@ -2751,6 +2804,7 @@ class ExpressionPattern {
     _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();
@@ -2848,11 +2902,31 @@ class ExpressionPattern {
         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);
@@ -3093,6 +3167,7 @@ class ExpressionPattern {
     clone(name = this._name) {
         const clone = new ExpressionPattern(name, this._originalPatterns);
         clone._id = this._id;
+        clone.shouldCompactAst = this.shouldCompactAst;
         return clone;
     }
     isEqual(pattern) {
@@ -3273,9 +3348,13 @@ class Grammar {
     }
     _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) {
@@ -3335,9 +3414,13 @@ class Grammar {
     }
     _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) {
@@ -3357,9 +3440,13 @@ class Grammar {
     }
     _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) {
@@ -3512,10 +3599,14 @@ class Grammar {
     }
     _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) {