clarity-pattern-parser 11.0.6 → 11.0.7

package/TODO.md

@@ -1,8 +1,4 @@
-* Add a Context Pattern
-This will allow you to store a list of patterns and the pattern you want to start a parse from. This will hold the context of many patterns
-that perhaps are references but are by way of the context. This will be helpful with cpat files.
-
-* Optimizations We can add a map to the cursor where we can search through previous matches and if the match for this pattern with this id has already matched in other bracnhes of the parse it can just use the node and clone it and skip the full parse and speed up things tremendously
+* Fix infinite repeat recursion with a reference
 
 
 * Generate typescript files from cpat

package/dist/ast/Node.d.ts

@@ -16,6 +16,7 @@ export declare class Node {
     private _value;
     get type(): string;
     get name(): string;
+    get value(): string;
     get firstIndex(): number;
     get lastIndex(): number;
     get startIndex(): number;
@@ -24,7 +25,6 @@ export declare class Node {
     get children(): readonly Node[];
     get hasChildren(): boolean;
     get isLeaf(): boolean;
-    get value(): string;
     constructor(type: string, name: string, firstIndex: number, lastIndex: number, children?: Node[], value?: string);
     removeChild(node: Node): void;
     findChildIndex(node: Node): number;
@@ -38,19 +38,18 @@ export declare class Node {
     nextSibling(): Node | null;
     previousSibling(): Node | null;
     find(predicate: (node: Node) => boolean): Node | null;
-    findRoot(): Node;
     findAll(predicate: (node: Node) => boolean): Node[];
+    findRoot(): Node;
     findAncestor(predicate: (node: Node) => boolean): Node | null;
     walkUp(callback: (node: Node) => void): void;
     walkDown(callback: (node: Node) => void): void;
     walkBreadthFirst(callback: (node: Node) => void): void;
     transform(visitors: Record<string, (node: Node) => Node>): Node;
     flatten(): Node[];
-    reduce(): void;
+    compact(): void;
     remove(): void;
     clone(): Node;
     normalize(startIndex?: number): number;
-    compact(): void;
     toString(): string;
     toCycleFreeObject(): CycleFreeNode;
     toJson(space?: number): string;

package/dist/grammar/Grammar.d.ts

@@ -17,8 +17,8 @@ export declare class Grammar {
     constructor(options?: GrammarOptions);
     import(path: string): Promise<Record<string, Pattern>>;
     parse(expression: string): Promise<Record<string, Pattern>>;
-    private _buildPatternRecord;
     parseString(expression: string): Record<string, Pattern>;
+    private _buildPatternRecord;
     private _tryToParse;
     private _hasImports;
     private _buildPatterns;

package/dist/index.browser.js

@@ -14,6 +14,9 @@
         get name() {
             return this._name;
         }
+        get value() {
+            return this.toString();
+        }
         get firstIndex() {
             return this._firstIndex;
         }
@@ -38,9 +41,6 @@
         get isLeaf() {
             return !this.hasChildren;
         }
-        get value() {
-            return this.toString();
-        }
         constructor(type, name, firstIndex, lastIndex, children = [], value = "") {
             this._type = type;
             this._name = name;
@@ -128,15 +128,6 @@
         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 => {
@@ -146,6 +137,15 @@
             });
             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) {
@@ -191,7 +191,7 @@
             });
             return nodes;
         }
-        reduce() {
+        compact() {
             const value = this.toString();
             this.removeAllChildren();
             this._value = value;
@@ -222,10 +222,6 @@
             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;
@@ -397,10 +393,10 @@
                 }
             }
         }
-        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) {
@@ -1194,7 +1190,6 @@
         }
         parse(cursor) {
             this._firstIndex = cursor.index;
-            const startIndex = cursor.index;
             const nodes = [];
             const modulo = this._hasDivider ? 2 : 1;
             let matchCount = 0;
@@ -1230,12 +1225,12 @@
             }
             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;
@@ -1359,7 +1354,7 @@
             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;
         }
@@ -1539,7 +1534,7 @@
                 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));
             }
@@ -2132,13 +2127,13 @@
     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 });
 
@@ -2880,7 +2875,7 @@
     }
 
     let indexId$1 = 0;
-    class ExpressionPattern {
+    class Expression {
         get id() {
             return this._id;
         }
@@ -2922,7 +2917,7 @@
             this._type = "expression";
             this._name = name;
             this._parent = null;
-            this._firstIndex = -1;
+            this._firstIndex = 0;
             this._atomPatterns = [];
             this._prefixPatterns = [];
             this._prefixNames = [];
@@ -2967,10 +2962,10 @@
                 }
                 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;
@@ -2978,7 +2973,7 @@
                     else {
                         this._associationMap[name] = Association.left;
                     }
-                    finalPatterns.push(clone);
+                    finalPatterns.push(binary);
                 }
             });
             return finalPatterns;
@@ -3219,7 +3214,9 @@
             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)) {
@@ -3248,7 +3245,9 @@
             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)) {
@@ -3280,7 +3279,7 @@
             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;
         }
@@ -3290,7 +3289,7 @@
     }
 
     let indexId = 0;
-    class RightAssociatedPattern {
+    class RightAssociated {
         get id() {
             return this._id;
         }
@@ -3329,7 +3328,7 @@
             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;
         }
@@ -3422,14 +3421,6 @@
                 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);
@@ -3439,6 +3430,14 @@
             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) {
@@ -3555,7 +3554,7 @@
             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]);
@@ -3564,13 +3563,13 @@
             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])) {
@@ -3625,7 +3624,7 @@
             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;
@@ -3834,7 +3833,7 @@
     exports.Context = Context;
     exports.Cursor = Cursor;
     exports.CursorHistory = CursorHistory;
-    exports.ExpressionPattern = ExpressionPattern;
+    exports.Expression = Expression;
     exports.Grammar = Grammar;
     exports.Literal = Literal;
     exports.Node = Node;
@@ -3845,6 +3844,7 @@
     exports.Reference = Reference;
     exports.Regex = Regex;
     exports.Repeat = Repeat;
+    exports.RightAssociated = RightAssociated;
     exports.Sequence = Sequence;
     exports.compact = compact;
     exports.grammar = grammar;