clarity-pattern-parser 11.0.6 → 11.0.8

package/dist/index.d.ts

@@ -21,5 +21,6 @@ import { ParseResult } from "./patterns/ParseResult";
 import { grammar } from "./grammar/patterns/grammar";
 import { patterns } from "./grammar/patterns";
 import { Context } from "./patterns/Context";
-import { ExpressionPattern } from "./patterns/ExpressionPattern";
-export { Node, Grammar, AutoComplete, AutoCompleteOptions, Suggestion, SuggestionOption, Sequence, Cursor, CursorHistory, Match, Context, ExpressionPattern, Literal, Not, Options, Optional, ParseError, ParseResult, Pattern, Reference, Regex, Repeat, grammar, patterns, compact, remove };
+import { Expression } from "./patterns/Expression";
+import { RightAssociated } from "./patterns/RightAssociated";
+export { Node, Grammar, AutoComplete, AutoCompleteOptions, Suggestion, SuggestionOption, Sequence, Cursor, CursorHistory, Match, Context, Expression, Literal, Not, Options, Optional, ParseError, ParseResult, Pattern, Reference, RightAssociated, Regex, Repeat, grammar, patterns, compact, remove };

package/dist/index.esm.js

@@ -8,6 +8,9 @@ class Node {
     get name() {
         return this._name;
     }
+    get value() {
+        return this.toString();
+    }
     get firstIndex() {
         return this._firstIndex;
     }
@@ -32,9 +35,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;
@@ -122,15 +122,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 => {
@@ -140,6 +131,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) {
@@ -185,7 +185,7 @@ class Node {
         });
         return nodes;
     }
-    reduce() {
+    compact() {
         const value = this.toString();
         this.removeAllChildren();
         this._value = value;
@@ -216,10 +216,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;
@@ -391,10 +387,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) {
@@ -848,6 +844,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);
@@ -857,8 +855,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;
@@ -1044,9 +1070,6 @@ class Options {
         return null;
     }
     _tryToParse(cursor) {
-        if (this._isBeyondRecursiveAllowance()) {
-            return null;
-        }
         const results = [];
         for (const pattern of this._children) {
             cursor.moveTo(this._firstIndex);
@@ -1064,20 +1087,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) {
@@ -1188,7 +1197,6 @@ class FiniteRepeat {
     }
     parse(cursor) {
         this._firstIndex = cursor.index;
-        const startIndex = cursor.index;
         const nodes = [];
         const modulo = this._hasDivider ? 2 : 1;
         let matchCount = 0;
@@ -1224,12 +1232,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;
@@ -1353,7 +1361,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;
     }
@@ -1533,7 +1541,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));
         }
@@ -1734,10 +1742,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;
@@ -1801,20 +1805,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;
@@ -2126,13 +2116,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 });
 
@@ -2874,7 +2864,7 @@ class PrecedenceTree {
 }
 
 let indexId$1 = 0;
-class ExpressionPattern {
+class Expression {
     get id() {
         return this._id;
     }
@@ -2916,7 +2906,7 @@ class ExpressionPattern {
         this._type = "expression";
         this._name = name;
         this._parent = null;
-        this._firstIndex = -1;
+        this._firstIndex = 0;
         this._atomPatterns = [];
         this._prefixPatterns = [];
         this._prefixNames = [];
@@ -2961,10 +2951,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;
@@ -2972,7 +2962,7 @@ class ExpressionPattern {
                 else {
                     this._associationMap[name] = Association.left;
                 }
-                finalPatterns.push(clone);
+                finalPatterns.push(binary);
             }
         });
         return finalPatterns;
@@ -3058,10 +3048,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();
@@ -3192,20 +3178,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);
     }
@@ -3213,7 +3185,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)) {
@@ -3242,7 +3216,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)) {
@@ -3274,7 +3250,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;
     }
@@ -3284,7 +3260,7 @@ class ExpressionPattern {
 }
 
 let indexId = 0;
-class RightAssociatedPattern {
+class RightAssociated {
     get id() {
         return this._id;
     }
@@ -3323,7 +3299,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;
     }
@@ -3416,14 +3392,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);
@@ -3433,6 +3401,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) {
@@ -3549,7 +3525,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]);
@@ -3558,13 +3534,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])) {
@@ -3619,7 +3595,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;
@@ -3824,5 +3800,5 @@ function patterns(strings, ...values) {
     return result;
 }
 
-export { AutoComplete, Context, Cursor, CursorHistory, ExpressionPattern, Grammar, Literal, Node, Not, Optional, Options, ParseError, Reference, Regex, Repeat, Sequence, compact, grammar, patterns, remove };
+export { AutoComplete, Context, Cursor, CursorHistory, Expression, Grammar, Literal, Node, Not, Optional, Options, ParseError, Reference, Regex, Repeat, RightAssociated, Sequence, compact, grammar, patterns, remove };
 //# sourceMappingURL=index.esm.js.map