clarity-pattern-parser 5.0.0 → 6.0.2

package/dist/index.browser.js

@@ -29,6 +29,9 @@
         get children() {
             return this._children;
         }
+        get hasChildren() {
+            return this._children.length > 0;
+        }
         get value() {
             return this.toString();
         }
@@ -78,22 +81,54 @@
         }
         spliceChildren(index, deleteCount, ...items) {
             const removedItems = this._children.splice(index, deleteCount, ...items);
-            items.forEach(i => i._parent = this);
             removedItems.forEach(i => i._parent = null);
+            items.forEach(i => i._parent = this);
             return removedItems;
         }
-        find(isMatch) {
-            return this.findAll(isMatch)[0] || null;
+        nextSibling() {
+            if (this._parent == null) {
+                return null;
+            }
+            const children = this._parent._children;
+            const index = children.indexOf(this);
+            if (index > -1 && index < children.length - 1) {
+                return children[index + 1];
+            }
+            return null;
         }
-        findAll(isMatch) {
+        previousSibling() {
+            if (this._parent == null) {
+                return null;
+            }
+            const children = this._parent._children;
+            const index = children.indexOf(this);
+            if (index > -1 && index > 0) {
+                return children[index - 1];
+            }
+            return null;
+        }
+        find(predicate) {
+            return this.findAll(predicate)[0] || null;
+        }
+        findAll(predicate) {
             const matches = [];
             this.walkUp(n => {
-                if (isMatch(n)) {
+                if (predicate(n)) {
                     matches.push(n);
                 }
             });
             return matches;
         }
+        findAncester(predicate) {
+            let parent = this._parent;
+            while (parent != null) {
+                if (predicate(parent)) {
+                    return parent;
+                }
+                parent = parent._parent;
+            }
+            return null;
+        }
         walkUp(callback) {
             this.children.forEach(c => c.walkUp(callback));
             callback(this);
@@ -102,6 +137,20 @@
             callback(this);
             this.children.forEach(c => c.walkDown(callback));
         }
+        flatten() {
+            const nodes = [];
+            this.walkDown((node) => {
+                if (!node.hasChildren) {
+                    nodes.push(node);
+                }
+            });
+            return nodes;
+        }
+        reduce() {
+            const value = this.toString();
+            this.removeAllChildren();
+            this._value = value;
+        }
         clone() {
             return new Node(this._type, this._name, this._firstIndex, this._lastIndex, this._children.map((c) => c.clone()), this._value);
         }
@@ -146,15 +195,18 @@
             this._nodes = [];
             this._errors = [];
         }
+        get isRecording() {
+            return this._isRecording;
+        }
+        get rootMatch() {
+            return this._rootMatch;
+        }
         get leafMatch() {
             return this._leafMatch;
         }
         get furthestError() {
             return this._furthestError;
         }
-        get isRecording() {
-            return this._isRecording;
-        }
         get errors() {
             return this._errors;
         }
@@ -167,9 +219,6 @@
         get patterns() {
             return this._patterns;
         }
-        get rootMatch() {
-            return this._rootMatch;
-        }
         recordMatch(pattern, node) {
             if (this._isRecording) {
                 this._patterns.push(pattern);
@@ -212,17 +261,17 @@
             return this._index === 0;
         }
         get isOnLast() {
-            return this._index === this._getLastIndex();
+            return this._index === this.getLastIndex();
         }
         get isRecording() {
             return this._history.isRecording;
         }
-        get leafMatch() {
-            return this._history.leafMatch;
-        }
         get rootMatch() {
             return this._history.rootMatch;
         }
+        get leafMatch() {
+            return this._history.leafMatch;
+        }
         get furthestError() {
             return this._history.furthestError;
         }
@@ -253,14 +302,14 @@
         hasNext() {
             return this._index + 1 < this._length;
         }
-        hasPrevious() {
-            return this._index - 1 >= 0;
-        }
         next() {
             if (this.hasNext()) {
                 this._index++;
             }
         }
+        hasPrevious() {
+            return this._index - 1 >= 0;
+        }
         previous() {
             if (this.hasPrevious()) {
                 this._index--;
@@ -275,7 +324,10 @@
             this._index = 0;
         }
         moveToLastChar() {
-            this._index = this._getLastIndex();
+            this._index = this.getLastIndex();
+        }
+        getLastIndex() {
+            return this._length - 1;
         }
         getChars(first, last) {
             return this._text.slice(first, last + 1);
@@ -295,22 +347,6 @@
         stopRecording() {
             this._history.stopRecording();
         }
-        _getLastIndex() {
-            return this._length - 1;
-        }
-    }
-
-    function getNextPattern(pattern) {
-        const parent = pattern.parent;
-        if (parent == null) {
-            return null;
-        }
-        const patternIndex = parent.children.indexOf(pattern);
-        const nextPattern = parent.children[patternIndex + 1] || null;
-        if (nextPattern == null) {
-            return parent.getNextPattern();
-        }
-        return nextPattern;
     }
 
     class Regex {
@@ -337,8 +373,6 @@
             this._cursor = null;
             this._substring = "";
             this._tokens = [];
-            this._hasContextualTokenAggregation = false;
-            this._isRetrievingContextualTokens = false;
             this._type = "regex";
             this._name = name;
             this._isOptional = isOptional;
@@ -358,11 +392,16 @@
                 throw new Error("Invalid Arguments: The regex string cannot end with a '$' because it is expected to be in the middle of a string.");
             }
         }
-        parseText(text) {
+        test(text) {
+            const cursor = new Cursor(text);
+            const ast = this.parse(cursor);
+            return (ast === null || ast === void 0 ? void 0 : ast.value) === text;
+        }
+        exec(text) {
             const cursor = new Cursor(text);
             const ast = this.parse(cursor);
             return {
-                ast,
+                ast: (ast === null || ast === void 0 ? void 0 : ast.value) === text ? ast : null,
                 cursor
             };
         }
@@ -389,7 +428,7 @@
         processResult(cursor, result) {
             const currentIndex = cursor.index;
             const newIndex = currentIndex + result[0].length - 1;
-            this._node = new Node("regex", this._name, currentIndex, newIndex, [], result[0]);
+            this._node = new Node("regex", this._name, currentIndex, newIndex, undefined, result[0]);
             cursor.moveTo(newIndex);
             cursor.recordMatch(this, this._node);
         }
@@ -402,47 +441,38 @@
         clone(name = this._name, isOptional = this._isOptional) {
             const pattern = new Regex(name, this._originalRegexString, isOptional);
             pattern._tokens = this._tokens.slice();
-            pattern._hasContextualTokenAggregation =
-                this._hasContextualTokenAggregation;
             return pattern;
         }
         getTokens() {
-            const parent = this._parent;
-            if (this._hasContextualTokenAggregation &&
-                parent != null &&
-                !this._isRetrievingContextualTokens) {
-                this._isRetrievingContextualTokens = true;
-                const tokens = this._tokens;
-                const aggregateTokens = [];
-                const nextTokens = parent.getNextTokens(this);
-                for (let nextToken of nextTokens) {
-                    for (let token of tokens) {
-                        aggregateTokens.push(token + nextToken);
-                    }
-                }
-                this._isRetrievingContextualTokens = false;
-                return aggregateTokens;
-            }
             return this._tokens;
         }
-        getNextTokens(_reference) {
+        getTokensAfter(_childReference) {
             return [];
         }
-        getNextPattern() {
-            return getNextPattern(this);
+        getNextTokens() {
+            if (this.parent == null) {
+                return [];
+            }
+            return this.parent.getTokensAfter(this);
+        }
+        getPatterns() {
+            return [this];
         }
-        findPattern(_isMatch) {
+        getPatternsAfter(_childReference) {
+            return [];
+        }
+        getNextPatterns() {
+            if (this.parent == null) {
+                return [];
+            }
+            return this.parent.getPatternsAfter(this);
+        }
+        findPattern(_predicate) {
             return null;
         }
         setTokens(tokens) {
             this._tokens = tokens;
         }
-        enableContextualTokenAggregation() {
-            this._hasContextualTokenAggregation = true;
-        }
-        disableContextualTokenAggregation() {
-            this._hasContextualTokenAggregation = false;
-        }
     }
 
     function clonePatterns(patterns, isOptional) {
@@ -512,7 +542,6 @@
             this._parent = null;
             this._children = children;
             this._firstIndex = -1;
-            this._shouldReduceAst = false;
             this._nodes = [];
         }
         _assignChildrenToParent(children) {
@@ -520,11 +549,16 @@
                 child.parent = this;
             }
         }
-        parseText(text) {
+        test(text) {
+            const cursor = new Cursor(text);
+            const ast = this.parse(cursor);
+            return (ast === null || ast === void 0 ? void 0 : ast.value) === text;
+        }
+        exec(text) {
             const cursor = new Cursor(text);
             const ast = this.parse(cursor);
             return {
-                ast,
+                ast: (ast === null || ast === void 0 ? void 0 : ast.value) === text ? ast : null,
                 cursor
             };
         }
@@ -558,34 +592,43 @@
                     if (hasMorePatterns) {
                         if (hadMatch) {
                             if (cursor.hasNext()) {
+                                // We had a match. Increment the cursor and use the next pattern.
                                 cursor.next();
                                 continue;
                             }
                             else {
+                                // We are at the end of the text, it may still be valid, if all the
+                                // following patterns are optional.
                                 if (this.areRemainingPatternsOptional(i)) {
                                     passed = true;
                                     break;
                                 }
+                                // We didn't finish the parsing sequence.
                                 cursor.recordErrorAt(cursor.index + 1, this);
                                 break;
                             }
                         }
                         else {
+                            // An optional pattern did not matched, try from the same spot on the next
+                            // pattern.
                             cursor.moveTo(runningCursorIndex);
                             continue;
                         }
                     }
                     else {
+                        // If we don't have any results from what we parsed then record error.
                         const lastNode = this.getLastValidNode();
                         if (lastNode === null) {
                             cursor.recordErrorAt(cursor.index, this);
                             break;
                         }
+                        // The sequence was parsed fully.
                         passed = true;
                         break;
                     }
                 }
                 else {
+                    // The pattern failed.
                     cursor.moveTo(this._firstIndex);
                     break;
                 }
@@ -613,18 +656,9 @@
         createNode(cursor) {
             const children = filterOutNull(this._nodes);
             const lastIndex = children[children.length - 1].lastIndex;
-            const value = cursor.getChars(this._firstIndex, lastIndex);
+            cursor.getChars(this._firstIndex, lastIndex);
             cursor.moveTo(lastIndex);
-            if (this._shouldReduceAst) {
-                children.length = 0;
-            }
-            return new Node("and", this._name, this._firstIndex, lastIndex, children, this._shouldReduceAst ? value : undefined);
-        }
-        enableAstReduction() {
-            this._shouldReduceAst = true;
-        }
-        disableAstReduction() {
-            this._shouldReduceAst = false;
+            return new Node("and", this._name, this._firstIndex, lastIndex, children);
         }
         getTokens() {
             const tokens = [];
@@ -636,13 +670,35 @@
             }
             return tokens;
         }
-        getNextTokens(lastMatched) {
+        getTokensAfter(childReference) {
+            const patterns = this.getPatternsAfter(childReference);
+            const tokens = [];
+            patterns.forEach(p => tokens.push(...p.getTokens()));
+            return tokens;
+        }
+        getNextTokens() {
+            if (this.parent == null) {
+                return [];
+            }
+            return this.parent.getTokensAfter(this);
+        }
+        getPatterns() {
+            const patterns = [];
+            for (const pattern of this._children) {
+                patterns.push(...pattern.getPatterns());
+                if (!pattern.isOptional) {
+                    break;
+                }
+            }
+            return patterns;
+        }
+        getPatternsAfter(childReference) {
             let nextSibling = null;
             let nextSiblingIndex = -1;
             let index = -1;
-            const tokens = [];
+            const patterns = [];
             for (let i = 0; i < this._children.length; i++) {
-                if (this._children[i] === lastMatched) {
+                if (this._children[i] === childReference) {
                     if (i + 1 < this._children.length) {
                         nextSibling = this._children[i + 1];
                     }
@@ -651,39 +707,44 @@
                     break;
                 }
             }
+            // The child reference isn't one of the child patterns.
             if (index === -1) {
                 return [];
             }
+            // The reference pattern is the last child. So ask the parent for the next pattern.
             if (nextSiblingIndex === this._children.length && this._parent !== null) {
-                return this._parent.getNextTokens(this);
+                return this._parent.getPatternsAfter(this);
             }
+            // Next pattern isn't optional so send it back as the next patterns.
             if (nextSibling !== null && !nextSibling.isOptional) {
-                return nextSibling.getTokens();
+                return [nextSibling];
             }
+            // Send back as many optional patterns as possible.
             if (nextSibling !== null && nextSibling.isOptional) {
                 for (let i = nextSiblingIndex; i < this._children.length; i++) {
                     const child = this._children[i];
-                    tokens.push(...child.getTokens());
+                    patterns.push(child);
                     if (!child.isOptional) {
                         break;
                     }
                     if (i === this._children.length - 1 && this._parent !== null) {
-                        tokens.push(...this._parent.getNextTokens(this));
+                        patterns.push(...this._parent.getPatternsAfter(this));
                     }
                 }
             }
-            return tokens;
+            return patterns;
         }
-        getNextPattern() {
-            return getNextPattern(this);
+        getNextPatterns() {
+            if (this.parent == null) {
+                return [];
+            }
+            return this.parent.getPatternsAfter(this);
         }
-        findPattern(isMatch) {
-            return findPattern(this, isMatch);
+        findPattern(predicate) {
+            return findPattern(this, predicate);
         }
         clone(name = this._name, isOptional = this._isOptional) {
-            const and = new And(name, this._children, isOptional);
-            and._shouldReduceAst = this._shouldReduceAst;
-            return and;
+            return new And(name, this._children, isOptional);
         }
     }
 
@@ -718,14 +779,17 @@
             this._parent = null;
             this._firstIndex = 0;
             this._lastIndex = 0;
-            this._hasContextualTokenAggregation = false;
-            this._isRetrievingContextualTokens = false;
         }
-        parseText(text) {
+        test(text) {
+            const cursor = new Cursor(text);
+            const ast = this.parse(cursor);
+            return (ast === null || ast === void 0 ? void 0 : ast.value) === text;
+        }
+        exec(text) {
             const cursor = new Cursor(text);
             const ast = this.parse(cursor);
             return {
-                ast,
+                ast: (ast === null || ast === void 0 ? void 0 : ast.value) === text ? ast : null,
                 cursor
             };
         }
@@ -768,45 +832,38 @@
             return passed;
         }
         _createNode() {
-            return new Node("literal", this._name, this._firstIndex, this._lastIndex, [], this._literal);
+            return new Node("literal", this._name, this._firstIndex, this._lastIndex, undefined, this._literal);
         }
         clone(name = this._name, isOptional = this._isOptional) {
             const clone = new Literal(name, this._literal, isOptional);
-            clone._hasContextualTokenAggregation = this._hasContextualTokenAggregation;
             return clone;
         }
         getTokens() {
-            const parent = this._parent;
-            if (this._hasContextualTokenAggregation &&
-                parent != null &&
-                !this._isRetrievingContextualTokens) {
-                this._isRetrievingContextualTokens = true;
-                const aggregateTokens = [];
-                const nextTokens = parent.getNextTokens(this);
-                for (const nextToken of nextTokens) {
-                    aggregateTokens.push(this._literal + nextToken);
-                }
-                this._isRetrievingContextualTokens = false;
-                return aggregateTokens;
-            }
-            else {
-                return [this._literal];
-            }
+            return [this._literal];
         }
-        getNextTokens(_lastMatched) {
+        getTokensAfter(_lastMatched) {
             return [];
         }
-        getNextPattern() {
-            return getNextPattern(this);
+        getNextTokens() {
+            if (this.parent == null) {
+                return [];
+            }
+            return this.parent.getTokensAfter(this);
         }
-        findPattern(_isMatch) {
-            return null;
+        getPatterns() {
+            return [this];
+        }
+        getPatternsAfter() {
+            return [];
         }
-        enableContextualTokenAggregation() {
-            this._hasContextualTokenAggregation = true;
+        getNextPatterns() {
+            if (this.parent == null) {
+                return [];
+            }
+            return this.parent.getPatternsAfter(this);
         }
-        disableContextualTokenAggregation() {
-            this._hasContextualTokenAggregation = false;
+        findPattern(_predicate) {
+            return null;
         }
     }
 
@@ -817,9 +874,6 @@
         get name() {
             return this._name;
         }
-        get isOptional() {
-            return false;
-        }
         get parent() {
             return this._parent;
         }
@@ -829,6 +883,9 @@
         get children() {
             return this._children;
         }
+        get isOptional() {
+            return false;
+        }
         constructor(name, pattern) {
             this._type = "not";
             this._name = name;
@@ -836,7 +893,12 @@
             this._children = [pattern.clone(pattern.name, false)];
             this._children[0].parent = this;
         }
-        parseText(text) {
+        test(text) {
+            const cursor = new Cursor(text);
+            this.parse(cursor);
+            return !cursor.hasError;
+        }
+        exec(text) {
             const cursor = new Cursor(text);
             const ast = this.parse(cursor);
             return {
@@ -862,17 +924,44 @@
             const not = new Not(name, this._children[0]);
             return not;
         }
-        getNextPattern() {
-            return getNextPattern(this);
-        }
         getTokens() {
+            const parent = this._parent;
+            if (parent != null) {
+                return parent.getTokensAfter(this);
+            }
+            return [];
+        }
+        getTokensAfter(_childReference) {
+            const parent = this._parent;
+            if (parent != null) {
+                return parent.getTokensAfter(this);
+            }
             return [];
         }
-        getNextTokens(_lastMatched) {
+        getNextTokens() {
+            if (this.parent == null) {
+                return [];
+            }
+            return this.parent.getTokensAfter(this);
+        }
+        getPatterns() {
+            return [...this.getNextPatterns().map(p => p.getPatterns()).flat()];
+        }
+        getPatternsAfter(_childReference) {
+            const parent = this._parent;
+            if (parent != null) {
+                return parent.getPatternsAfter(this);
+            }
             return [];
         }
-        findPattern(isMatch) {
-            return isMatch(this._children[0]) ? this._children[0] : null;
+        getNextPatterns() {
+            if (this.parent == null) {
+                return [];
+            }
+            return this.parent.getPatternsAfter(this);
+        }
+        findPattern(predicate) {
+            return predicate(this._children[0]) ? this._children[0] : null;
         }
     }
 
@@ -906,7 +995,6 @@
             this._parent = null;
             this._children = children;
             this._isOptional = isOptional;
-            this._node = null;
             this._firstIndex = 0;
         }
         _assignChildrenToParent(children) {
@@ -914,17 +1002,21 @@
                 child.parent = this;
             }
         }
-        parseText(text) {
+        test(text) {
+            const cursor = new Cursor(text);
+            const ast = this.parse(cursor);
+            return (ast === null || ast === void 0 ? void 0 : ast.value) === text;
+        }
+        exec(text) {
             const cursor = new Cursor(text);
             const ast = this.parse(cursor);
             return {
-                ast,
+                ast: (ast === null || ast === void 0 ? void 0 : ast.value) === text ? ast : null,
                 cursor
             };
         }
         parse(cursor) {
             this._firstIndex = cursor.index;
-            this._node = null;
             const node = this._tryToParse(cursor);
             if (node != null) {
                 cursor.resolveError();
@@ -956,17 +1048,39 @@
             }
             return tokens;
         }
-        getNextTokens(_lastMatched) {
+        getTokensAfter(_childReference) {
+            if (this._parent === null) {
+                return [];
+            }
+            return this._parent.getTokensAfter(this);
+        }
+        getNextTokens() {
+            if (this._parent == null) {
+                return [];
+            }
+            return this._parent.getTokensAfter(this);
+        }
+        getPatterns() {
+            const patterns = [];
+            for (const pattern of this._children) {
+                patterns.push(...pattern.getPatterns());
+            }
+            return patterns;
+        }
+        getPatternsAfter(_childReference) {
             if (this._parent === null) {
                 return [];
             }
-            return this._parent.getNextTokens(this);
+            return this._parent.getPatternsAfter(this);
         }
-        getNextPattern() {
-            return getNextPattern(this);
+        getNextPatterns() {
+            if (this.parent == null) {
+                return [];
+            }
+            return this.parent.getPatternsAfter(this);
         }
-        findPattern(isMatch) {
-            return findPattern(this, isMatch);
+        findPattern(predicate) {
+            return findPattern(this, predicate);
         }
         clone(name = this._name, isOptional = this._isOptional) {
             const or = new Or(name, this._children, isOptional);
@@ -1005,7 +1119,6 @@
             this._pattern = children[0];
             this._divider = children[1];
             this._firstIndex = -1;
-            this._shouldReduceAst = false;
             this._nodes = [];
         }
         _assignChildrenToParent(children) {
@@ -1013,11 +1126,16 @@
                 child.parent = this;
             }
         }
-        parseText(text) {
+        test(text) {
+            const cursor = new Cursor(text);
+            const ast = this.parse(cursor);
+            return (ast === null || ast === void 0 ? void 0 : ast.value) === text;
+        }
+        exec(text) {
             const cursor = new Cursor(text);
             const ast = this.parse(cursor);
             return {
-                ast,
+                ast: (ast === null || ast === void 0 ? void 0 : ast.value) === text ? ast : null,
                 cursor
             };
         }
@@ -1028,7 +1146,7 @@
             if (passed) {
                 cursor.resolveError();
                 const node = this.createNode(cursor);
-                if (node) {
+                if (node != null) {
                     cursor.recordMatch(this, node);
                 }
                 return node;
@@ -1047,7 +1165,7 @@
                 const repeatedNode = this._pattern.parse(cursor);
                 if (cursor.hasError) {
                     const lastValidNode = this.getLastValidNode();
-                    if (lastValidNode) {
+                    if (lastValidNode != null) {
                         passed = true;
                     }
                     else {
@@ -1064,13 +1182,13 @@
                         break;
                     }
                     cursor.next();
-                    if (this._divider) {
+                    if (this._divider != null) {
                         const dividerNode = this._divider.parse(cursor);
                         if (cursor.hasError) {
                             passed = true;
                             break;
                         }
-                        else if (dividerNode) {
+                        else if (dividerNode != null) {
                             this._nodes.push(dividerNode);
                             if (!cursor.hasNext()) {
                                 passed = true;
@@ -1099,12 +1217,9 @@
                 }
             }
             const lastIndex = children[children.length - 1].lastIndex;
-            const value = cursor.getChars(this._firstIndex, lastIndex);
+            cursor.getChars(this._firstIndex, lastIndex);
             cursor.moveTo(lastIndex);
-            if (this._shouldReduceAst) {
-                children = [];
-            }
-            return new Node("repeat", this._name, this._firstIndex, lastIndex, children, this._shouldReduceAst ? value : undefined);
+            return new Node("repeat", this._name, this._firstIndex, lastIndex, children, undefined);
         }
         getLastValidNode() {
             const nodes = this._nodes.filter((node) => node !== null);
@@ -1113,51 +1228,64 @@
             }
             return nodes[nodes.length - 1];
         }
-        enableAstReduction() {
-            this._shouldReduceAst = true;
-        }
-        disableAstReduction() {
-            this._shouldReduceAst = false;
-        }
         getTokens() {
             return this._pattern.getTokens();
         }
-        getNextTokens(lastMatched) {
-            let index = -1;
+        getTokensAfter(childReference) {
+            const patterns = this.getPatternsAfter(childReference);
             const tokens = [];
+            patterns.forEach(p => tokens.push(...p.getTokens()));
+            return tokens;
+        }
+        getNextTokens() {
+            if (this.parent == null) {
+                return [];
+            }
+            return this.parent.getTokensAfter(this);
+        }
+        getPatterns() {
+            return this._pattern.getPatterns();
+        }
+        getPatternsAfter(childReference) {
+            let index = -1;
+            const patterns = [];
             for (let i = 0; i < this._children.length; i++) {
-                if (this._children[i] === lastMatched) {
+                if (this._children[i] === childReference) {
                     index = i;
                 }
             }
+            // If the last match isn't a child of this pattern.
             if (index === -1) {
                 return [];
             }
+            // If the last match was the repeated patterns, then suggest the divider.
             if (index === 0 && this._divider) {
-                tokens.push(...this._children[1].getTokens());
+                patterns.push(this._children[1]);
                 if (this._parent) {
-                    tokens.push(...this._parent.getNextTokens(this));
+                    patterns.push(...this._parent.getPatternsAfter(this));
                 }
             }
+            // Suggest the pattern because the divider was the last match.
             if (index === 1) {
-                tokens.push(...this._children[0].getTokens());
+                patterns.push(this._children[0]);
             }
             if (index === 0 && !this._divider && this._parent) {
-                tokens.push(...this._children[0].getTokens());
-                tokens.push(...this._parent.getNextTokens(this));
+                patterns.push(this._children[0]);
+                patterns.push(...this._parent.getPatternsAfter(this));
             }
-            return tokens;
+            return patterns;
         }
-        getNextPattern() {
-            return getNextPattern(this);
+        getNextPatterns() {
+            if (this.parent == null) {
+                return [];
+            }
+            return this.parent.getPatternsAfter(this);
         }
-        findPattern(isMatch) {
-            return findPattern(this, isMatch);
+        findPattern(predicate) {
+            return findPattern(this, predicate);
         }
         clone(name = this._name, isOptional = this._isOptional) {
-            const repeat = new Repeat(name, this._pattern, this._divider, isOptional);
-            repeat._shouldReduceAst = this._shouldReduceAst;
-            return repeat;
+            return new Repeat(name, this._pattern, this._divider, isOptional);
         }
     }
 
@@ -1168,9 +1296,6 @@
         get name() {
             return this._name;
         }
-        get isOptional() {
-            return this._isOptional;
-        }
         get parent() {
             return this._parent;
         }
@@ -1180,6 +1305,9 @@
         get children() {
             return this._children;
         }
+        get isOptional() {
+            return this._isOptional;
+        }
         constructor(name, isOptional = false) {
             this._type = "reference";
             this._name = name;
@@ -1188,35 +1316,22 @@
             this._pattern = null;
             this._children = [];
         }
-        parseText(text) {
+        test(text) {
+            const cursor = new Cursor(text);
+            const ast = this.parse(cursor);
+            return (ast === null || ast === void 0 ? void 0 : ast.value) === text;
+        }
+        exec(text) {
             const cursor = new Cursor(text);
             const ast = this.parse(cursor);
             return {
-                ast,
+                ast: (ast === null || ast === void 0 ? void 0 : ast.value) === text ? ast : null,
                 cursor
             };
         }
         parse(cursor) {
             return this._getPatternSafely().parse(cursor);
         }
-        clone(name = this._name, isOptional = this._isOptional) {
-            return new Reference(name, isOptional);
-        }
-        getTokens() {
-            return this._getPatternSafely().getTokens();
-        }
-        getNextTokens(_lastMatched) {
-            if (this.parent == null) {
-                return [];
-            }
-            return this.parent.getNextTokens(this);
-        }
-        getNextPattern() {
-            return getNextPattern(this);
-        }
-        findPattern(_isMatch) {
-            return null;
-        }
         _getPatternSafely() {
             if (this._pattern === null) {
                 const pattern = this._findPattern();
@@ -1249,10 +1364,210 @@
             }
             return node;
         }
+        getTokens() {
+            return this._getPatternSafely().getTokens();
+        }
+        getTokensAfter(_lastMatched) {
+            if (this._parent == null) {
+                return [];
+            }
+            return this._parent.getTokensAfter(this);
+        }
+        getNextTokens() {
+            if (this.parent == null) {
+                return [];
+            }
+            return this.parent.getTokensAfter(this);
+        }
+        getPatterns() {
+            return this._getPatternSafely().getPatterns();
+        }
+        getPatternsAfter(_childReference) {
+            if (this._parent == null) {
+                return [];
+            }
+            return this._parent.getPatternsAfter(this);
+        }
+        getNextPatterns() {
+            if (this.parent == null) {
+                return [];
+            }
+            return this.parent.getPatternsAfter(this);
+        }
+        findPattern(_predicate) {
+            return null;
+        }
+        clone(name = this._name, isOptional = this._isOptional) {
+            return new Reference(name, isOptional);
+        }
+    }
+
+    const defaultOptions = { greedyPatternNames: [], customTokens: {} };
+    class AutoComplete {
+        constructor(pattern, options = defaultOptions) {
+            this._pattern = pattern;
+            this._options = options;
+            this._text = "";
+        }
+        /**
+         * @deprecated Use suggestFor instead.
+         * @param text The text to suggest for.
+         */
+        suggest(text) {
+            return this.suggestFor(text);
+        }
+        suggestFor(text) {
+            if (text.length === 0) {
+                return {
+                    isComplete: false,
+                    options: this._createSuggestionsFromRoot(),
+                    errorAtIndex: 0,
+                    cursor: null,
+                    ast: null
+                };
+            }
+            this._text = text;
+            this._cursor = new Cursor(text);
+            const ast = this._pattern.parse(this._cursor);
+            const leafPattern = this._cursor.leafMatch.pattern;
+            const isComplete = (ast === null || ast === void 0 ? void 0 : ast.value) === text;
+            const options = this._createSuggestionsFromTokens();
+            [this._pattern];
+            let errorAtIndex = null;
+            if (leafPattern != null) {
+                leafPattern.getNextPatterns();
+            }
+            if (this._cursor.hasError && this._cursor.furthestError != null) {
+                errorAtIndex = this._cursor.furthestError.index;
+                errorAtIndex = options.reduce((errorAtIndex, option) => Math.max(errorAtIndex, option.startIndex), errorAtIndex);
+            }
+            return {
+                isComplete: isComplete,
+                options: options,
+                errorAtIndex,
+                cursor: this._cursor,
+                ast,
+            };
+        }
+        _createSuggestionsFromRoot() {
+            const suggestions = [];
+            const tokens = this._pattern.getTokens();
+            for (const token of tokens) {
+                suggestions.push(this._createSuggestion("", token));
+            }
+            return suggestions;
+        }
+        _createSuggestionsFromTokens() {
+            const leafMatch = this._cursor.leafMatch;
+            if (!leafMatch.pattern) {
+                return this._createSuggestions(-1, this._getTokensForPattern(this._pattern));
+            }
+            const leafPattern = leafMatch.pattern;
+            const parent = leafMatch.pattern.parent;
+            if (parent !== null && leafMatch.node != null) {
+                const patterns = leafPattern.getNextPatterns();
+                const tokens = patterns.reduce((acc, pattern) => {
+                    acc.push(...this._getTokensForPattern(pattern));
+                    return acc;
+                }, []);
+                return this._createSuggestions(leafMatch.node.lastIndex, tokens);
+            }
+            else {
+                return [];
+            }
+        }
+        _getTokensForPattern(pattern) {
+            const augmentedTokens = this._getAugmentedTokens(pattern);
+            if (this._options.greedyPatternNames != null && this._options.greedyPatternNames.includes(pattern.name)) {
+                const nextPatterns = pattern.getNextPatterns();
+                const tokens = [];
+                const nextPatternTokens = nextPatterns.reduce((acc, pattern) => {
+                    acc.push(...this._getTokensForPattern(pattern));
+                    return acc;
+                }, []);
+                for (let token of augmentedTokens) {
+                    for (let nextPatternToken of nextPatternTokens) {
+                        tokens.push(token + nextPatternToken);
+                    }
+                }
+                return tokens;
+            }
+            else {
+                return augmentedTokens;
+            }
+        }
+        _getAugmentedTokens(pattern) {
+            const customTokensMap = this._options.customTokens || {};
+            const leafPatterns = pattern.getPatterns();
+            const tokens = customTokensMap[pattern.name] || [];
+            leafPatterns.forEach(p => {
+                const augmentedTokens = customTokensMap[p.name] || [];
+                tokens.push(...p.getTokens(), ...augmentedTokens);
+            });
+            return tokens;
+        }
+        _createSuggestions(lastIndex, tokens) {
+            let substring = lastIndex === -1 ? "" : this._cursor.getChars(0, lastIndex);
+            const suggestionStrings = [];
+            const options = [];
+            for (const token of tokens) {
+                const suggestion = substring + token;
+                const startsWith = suggestion.startsWith(substring);
+                const alreadyExist = suggestionStrings.includes(suggestion);
+                const isSameAsText = suggestion === this._text;
+                if (startsWith && !alreadyExist && !isSameAsText) {
+                    suggestionStrings.push(suggestion);
+                    options.push(this._createSuggestion(this._cursor.text, suggestion));
+                }
+            }
+            const reducedOptions = getFurthestOptions(options);
+            reducedOptions.sort((a, b) => a.text.localeCompare(b.text));
+            return reducedOptions;
+        }
+        _createSuggestion(fullText, suggestion) {
+            const furthestMatch = findMatchIndex(suggestion, fullText);
+            const text = suggestion.slice(furthestMatch);
+            return {
+                text: text,
+                startIndex: furthestMatch,
+            };
+        }
+    }
+    function findMatchIndex(str1, str2) {
+        let matchCount = 0;
+        let minLength = str1.length;
+        if (str2.length < minLength) {
+            minLength = str2.length;
+        }
+        for (let i = 0; i < minLength; i++) {
+            if (str1[i] === str2[i]) {
+                matchCount++;
+            }
+            else {
+                break;
+            }
+        }
+        return matchCount;
+    }
+    function getFurthestOptions(options) {
+        let furthestOptions = [];
+        let furthestIndex = -1;
+        for (const option of options) {
+            if (option.startIndex > furthestIndex) {
+                furthestIndex = option.startIndex;
+                furthestOptions = [];
+            }
+            if (option.startIndex === furthestIndex) {
+                furthestOptions.push(option);
+            }
+        }
+        return furthestOptions;
     }
 
     exports.And = And;
+    exports.AutoComplete = AutoComplete;
     exports.Cursor = Cursor;
+    exports.CursorHistory = CursorHistory;
     exports.Literal = Literal;
     exports.Node = Node;
     exports.Not = Not;