clarity-pattern-parser 11.0.6 → 11.0.8

package/dist/index.js

@@ -12,6 +12,9 @@ class Node {
     get name() {
         return this._name;
     }
+    get value() {
+        return this.toString();
+    }
     get firstIndex() {
         return this._firstIndex;
     }
@@ -36,9 +39,6 @@ class Node {
     get isLeaf() {
         return !this.hasChildren;
     }
-    get value() {
-        return this.toString();
-    }
     constructor(type, name, firstIndex, lastIndex, children = [], value = "") {
         this._type = type;
         this._name = name;
@@ -126,15 +126,6 @@ class Node {
     find(predicate) {
         return this.findAll(predicate)[0] || null;
     }
-    findRoot() {
-        let pattern = this;
-        while (true) {
-            if (pattern.parent == null) {
-                return pattern;
-            }
-            pattern = pattern.parent;
-        }
-    }
     findAll(predicate) {
         const matches = [];
         this.walkUp(n => {
@@ -144,6 +135,15 @@ class Node {
         });
         return matches;
     }
+    findRoot() {
+        let pattern = this;
+        while (true) {
+            if (pattern.parent == null) {
+                return pattern;
+            }
+            pattern = pattern.parent;
+        }
+    }
     findAncestor(predicate) {
         let parent = this._parent;
         while (parent != null) {
@@ -189,7 +189,7 @@ class Node {
         });
         return nodes;
     }
-    reduce() {
+    compact() {
         const value = this.toString();
         this.removeAllChildren();
         this._value = value;
@@ -220,10 +220,6 @@ 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;
@@ -395,10 +391,10 @@ class CursorHistory {
             }
         }
     }
-    recordErrorAt(startIndex, endIndex, pattern) {
-        const error = new ParseError(startIndex, endIndex, pattern);
+    recordErrorAt(startIndex, lastIndex, pattern) {
+        const error = new ParseError(startIndex, lastIndex, pattern);
         this._currentError = error;
-        if (this._furthestError === null || endIndex > this._furthestError.lastIndex) {
+        if (this._furthestError === null || lastIndex > this._furthestError.lastIndex) {
             this._furthestError = error;
         }
         if (this._isRecording) {
@@ -852,6 +848,8 @@ class Reference {
         this._cachedPattern = null;
         this._children = [];
         this._firstIndex = 0;
+        this._cachedAncestors = false;
+        this._recursiveAncestors = [];
     }
     test(text, record = false) {
         return testPattern(this, text, record);
@@ -861,8 +859,36 @@ class Reference {
     }
     parse(cursor) {
         this._firstIndex = cursor.index;
+        this._cacheAncestors();
+        if (this._isBeyondRecursiveAllowance()) {
+            cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
+            return null;
+        }
         return this.getReferencePatternSafely().parse(cursor);
     }
+    _cacheAncestors() {
+        if (!this._cachedAncestors) {
+            let pattern = this.parent;
+            while (pattern != null) {
+                if (pattern.type === this.type && pattern.id === this._id) {
+                    this._recursiveAncestors.push(pattern);
+                }
+                pattern = pattern.parent;
+            }
+        }
+    }
+    _isBeyondRecursiveAllowance() {
+        let depth = 0;
+        for (let pattern of this._recursiveAncestors) {
+            if (pattern._firstIndex === this._firstIndex) {
+                depth++;
+                if (depth > 2) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
     getReferencePatternSafely() {
         if (this._pattern === null) {
             let pattern = null;
@@ -1048,9 +1074,6 @@ class Options {
         return null;
     }
     _tryToParse(cursor) {
-        if (this._isBeyondRecursiveAllowance()) {
-            return null;
-        }
         const results = [];
         for (const pattern of this._children) {
             cursor.moveTo(this._firstIndex);
@@ -1068,20 +1091,6 @@ class Options {
         nonNullResults.sort((a, b) => b.endIndex - a.endIndex);
         return nonNullResults[0] || null;
     }
-    _isBeyondRecursiveAllowance() {
-        let depth = 0;
-        let pattern = this;
-        while (pattern != null) {
-            if (pattern.id === this.id && pattern.startedOnIndex === this.startedOnIndex) {
-                depth++;
-            }
-            if (depth > 2) {
-                return true;
-            }
-            pattern = pattern.parent;
-        }
-        return false;
-    }
     getTokens() {
         const tokens = [];
         for (const pattern of this._children) {
@@ -1192,7 +1201,6 @@ class FiniteRepeat {
     }
     parse(cursor) {
         this._firstIndex = cursor.index;
-        const startIndex = cursor.index;
         const nodes = [];
         const modulo = this._hasDivider ? 2 : 1;
         let matchCount = 0;
@@ -1228,12 +1236,12 @@ class FiniteRepeat {
         }
         if (matchCount < this._min) {
             const lastIndex = cursor.index;
-            cursor.moveTo(startIndex);
-            cursor.recordErrorAt(startIndex, lastIndex, this);
+            cursor.moveTo(this._firstIndex);
+            cursor.recordErrorAt(this._firstIndex, lastIndex, this);
             return null;
         }
         if (nodes.length === 0 && !cursor.hasError) {
-            cursor.moveTo(startIndex);
+            cursor.moveTo(this._firstIndex);
             return null;
         }
         const firstIndex = nodes[0].firstIndex;
@@ -1357,7 +1365,7 @@ class InfiniteRepeat {
         this._children = children;
         this._pattern = children[0];
         this._divider = children[1];
-        this._firstIndex = -1;
+        this._firstIndex = 0;
         this._nodes = [];
         this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
     }
@@ -1537,7 +1545,7 @@ class InfiniteRepeat {
             patterns.push(this._children[0]);
         }
         // If there is no divider then suggest the repeating pattern and the next pattern after.
-        if (index === 0 && !this._divider && this._parent) {
+        if (index === 0 && this._divider == null && this._parent) {
             patterns.push(this._children[0]);
             patterns.push(...this._parent.getPatternsAfter(this));
         }
@@ -1738,10 +1746,6 @@ class Sequence {
         return null;
     }
     tryToParse(cursor) {
-        if (this._isBeyondRecursiveAllowance()) {
-            cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
-            return false;
-        }
         let passed = false;
         for (let i = 0; i < this._children.length; i++) {
             const runningCursorIndex = cursor.index;
@@ -1805,20 +1809,6 @@ class Sequence {
         }
         return nodes[nodes.length - 1];
     }
-    _isBeyondRecursiveAllowance() {
-        let depth = 0;
-        let pattern = this;
-        while (pattern != null) {
-            if (pattern.id === this.id && pattern.startedOnIndex === this.startedOnIndex) {
-                depth++;
-            }
-            if (depth > 1) {
-                return true;
-            }
-            pattern = pattern.parent;
-        }
-        return false;
-    }
     areRemainingPatternsOptional(fromIndex) {
         const startOnIndex = fromIndex + 1;
         const length = this._children.length;
@@ -2130,13 +2120,13 @@ const repeatLiteral = new Sequence("repeat-literal", [
 const optionalNot = new Optional("optional-not", new Literal("not", "!"));
 const optionalIsOptional$1 = new Optional("optional-is-optional", new Literal("is-optional", "?"));
 const patternName$1 = name$1.clone("pattern-name");
-const patterns$2 = new Options("and-patterns", [patternName$1, anonymousPattern]);
-const pattern$1 = new Sequence("and-child-pattern", [
+const patterns$2 = new Options("sequence-patterns", [patternName$1, anonymousPattern]);
+const pattern$1 = new Sequence("sequence-child-pattern", [
     optionalNot,
     patterns$2,
     optionalIsOptional$1,
 ]);
-const divider$1 = new Regex("and-divider", "\\s*[+]\\s*");
+const divider$1 = new Regex("sequence-divider", "\\s*[+]\\s*");
 divider$1.setTokens([" + "]);
 const sequenceLiteral = new Repeat("sequence-literal", pattern$1, { divider: divider$1, min: 2, trimDivider: true });
 
@@ -2878,7 +2868,7 @@ class PrecedenceTree {
 }
 
 let indexId$1 = 0;
-class ExpressionPattern {
+class Expression {
     get id() {
         return this._id;
     }
@@ -2920,7 +2910,7 @@ class ExpressionPattern {
         this._type = "expression";
         this._name = name;
         this._parent = null;
-        this._firstIndex = -1;
+        this._firstIndex = 0;
         this._atomPatterns = [];
         this._prefixPatterns = [];
         this._prefixNames = [];
@@ -2965,10 +2955,10 @@ class ExpressionPattern {
             }
             else if (this._isBinary(pattern)) {
                 const name = this._extractName(pattern);
-                const clone = this._extractBinary(pattern);
-                clone.parent = this;
+                const binary = this._extractBinary(pattern);
+                binary.parent = this;
                 this._precedenceMap[name] = this._binaryPatterns.length;
-                this._binaryPatterns.push(clone);
+                this._binaryPatterns.push(binary);
                 this._binaryNames.push(name);
                 if (pattern.type === "right-associated") {
                     this._associationMap[name] = Association.right;
@@ -2976,7 +2966,7 @@ class ExpressionPattern {
                 else {
                     this._associationMap[name] = Association.left;
                 }
-                finalPatterns.push(clone);
+                finalPatterns.push(binary);
             }
         });
         return finalPatterns;
@@ -3062,10 +3052,6 @@ class ExpressionPattern {
         return null;
     }
     _tryToParse(cursor) {
-        if (this._isBeyondRecursiveAllowance()) {
-            cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
-            return null;
-        }
         this._shouldStopParsing = false;
         while (true) {
             cursor.resolveError();
@@ -3196,20 +3182,6 @@ class ExpressionPattern {
             this._shouldStopParsing = true;
         }
     }
-    _isBeyondRecursiveAllowance() {
-        let depth = 0;
-        let pattern = this;
-        while (pattern != null) {
-            if (pattern.id === this.id && pattern.startedOnIndex === this.startedOnIndex) {
-                depth++;
-            }
-            if (depth > 2) {
-                return true;
-            }
-            pattern = pattern.parent;
-        }
-        return false;
-    }
     test(text, record = false) {
         return testPattern(this, text, record);
     }
@@ -3217,7 +3189,9 @@ class ExpressionPattern {
         return execPattern(this, text, record);
     }
     getTokens() {
-        return this.atomPatterns.map(p => p.getTokens()).flat();
+        const atomTokens = this._atomPatterns.map(p => p.getTokens()).flat();
+        const prefixTokens = this.prefixPatterns.map(p => p.getTokens()).flat();
+        return [...prefixTokens, ...atomTokens];
     }
     getTokensAfter(childReference) {
         if (this._prefixPatterns.includes(childReference) || this._binaryPatterns.includes(childReference)) {
@@ -3246,7 +3220,9 @@ class ExpressionPattern {
         return this._parent.getTokensAfter(this);
     }
     getPatterns() {
-        return this.atomPatterns.map(p => p.getPatterns()).flat();
+        const atomPatterns = this._atomPatterns.map(p => p.getPatterns()).flat();
+        const prefixPatterns = this.prefixPatterns.map(p => p.getPatterns()).flat();
+        return [...prefixPatterns, ...atomPatterns];
     }
     getPatternsAfter(childReference) {
         if (this._prefixPatterns.includes(childReference) || this._binaryPatterns.includes(childReference)) {
@@ -3278,7 +3254,7 @@ class ExpressionPattern {
         return findPattern(this, predicate);
     }
     clone(name = this._name) {
-        const clone = new ExpressionPattern(name, this._originalPatterns);
+        const clone = new Expression(name, this._originalPatterns);
         clone._id = this._id;
         return clone;
     }
@@ -3288,7 +3264,7 @@ class ExpressionPattern {
 }
 
 let indexId = 0;
-class RightAssociatedPattern {
+class RightAssociated {
     get id() {
         return this._id;
     }
@@ -3327,7 +3303,7 @@ class RightAssociatedPattern {
         return this.children[0].test(text, record);
     }
     clone(_name) {
-        const clone = new RightAssociatedPattern(this.children[0]);
+        const clone = new RightAssociated(this.children[0]);
         clone._id = this._id;
         return clone;
     }
@@ -3420,14 +3396,6 @@ class Grammar {
             return this._buildPatternRecord();
         });
     }
-    _buildPatternRecord() {
-        const patterns = {};
-        const allPatterns = Array.from(this._parseContext.patternsByName.values());
-        allPatterns.forEach(p => {
-            patterns[p.name] = new Context(p.name, p, allPatterns.filter(o => o !== p));
-        });
-        return patterns;
-    }
     parseString(expression) {
         this._parseContext = new ParseContext(this._params);
         const ast = this._tryToParse(expression);
@@ -3437,6 +3405,14 @@ class Grammar {
         this._buildPatterns(ast);
         return this._buildPatternRecord();
     }
+    _buildPatternRecord() {
+        const patterns = {};
+        const allPatterns = Array.from(this._parseContext.patternsByName.values());
+        allPatterns.forEach(p => {
+            patterns[p.name] = new Context(p.name, p, allPatterns.filter(o => o !== p));
+        });
+        return patterns;
+    }
     _tryToParse(expression) {
         const { ast, cursor, options, isComplete } = this._autoComplete.suggestFor(expression);
         if (!isComplete) {
@@ -3553,7 +3529,7 @@ class Grammar {
         const patterns = patternNodes.map(n => {
             const rightAssociated = n.find(n => n.name === "right-associated");
             if (rightAssociated != null) {
-                return new RightAssociatedPattern(this._buildPattern(n.children[0]));
+                return new RightAssociated(this._buildPattern(n.children[0]));
             }
             else {
                 return this._buildPattern(n.children[0]);
@@ -3562,13 +3538,13 @@ class Grammar {
         const hasRecursivePattern = patterns.some(p => this._isRecursive(name, p));
         if (hasRecursivePattern && !isGreedy) {
             try {
-                const expression = new ExpressionPattern(name, patterns);
+                const expression = new Expression(name, patterns);
                 return expression;
             }
             catch (_a) { }
         }
-        const or = new Options(name, patterns, isGreedy);
-        return or;
+        const options = new Options(name, patterns, isGreedy);
+        return options;
     }
     _isRecursive(name, pattern) {
         if (pattern.type === "right-associated" && this._isRecursivePattern(name, pattern.children[0])) {
@@ -3623,7 +3599,7 @@ class Grammar {
         this._parseContext.patternsByName.set(name, sequence);
     }
     _buildSequence(name, node) {
-        const patternNodes = node.children.filter(n => n.name !== "and-divider");
+        const patternNodes = node.children.filter(n => n.name !== "sequence-divider");
         const patterns = patternNodes.map(n => {
             const patternNode = n.children[0].name === "not" ? n.children[1] : n.children[0];
             const isNot = n.find(n => n.name === "not") != null;
@@ -3832,7 +3808,7 @@ exports.AutoComplete = AutoComplete;
 exports.Context = Context;
 exports.Cursor = Cursor;
 exports.CursorHistory = CursorHistory;
-exports.ExpressionPattern = ExpressionPattern;
+exports.Expression = Expression;
 exports.Grammar = Grammar;
 exports.Literal = Literal;
 exports.Node = Node;
@@ -3843,6 +3819,7 @@ exports.ParseError = ParseError;
 exports.Reference = Reference;
 exports.Regex = Regex;
 exports.Repeat = Repeat;
+exports.RightAssociated = RightAssociated;
 exports.Sequence = Sequence;
 exports.compact = compact;
 exports.grammar = grammar;