clarity-pattern-parser 5.0.0 → 6.0.2

package/dist/index.js

@@ -27,6 +27,9 @@ class Node {
     get children() {
         return this._children;
     }
+    get hasChildren() {
+        return this._children.length > 0;
+    }
     get value() {
         return this.toString();
     }
@@ -76,22 +79,54 @@ class Node {
     }
     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);
@@ -100,6 +135,20 @@ class Node {
         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);
     }
@@ -144,15 +193,18 @@ class CursorHistory {
         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;
     }
@@ -165,9 +217,6 @@ class CursorHistory {
     get patterns() {
         return this._patterns;
     }
-    get rootMatch() {
-        return this._rootMatch;
-    }
     recordMatch(pattern, node) {
         if (this._isRecording) {
             this._patterns.push(pattern);
@@ -210,17 +259,17 @@ class Cursor {
         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;
     }
@@ -251,14 +300,14 @@ class Cursor {
     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--;
@@ -273,7 +322,10 @@ class Cursor {
         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);
@@ -293,22 +345,6 @@ class Cursor {
     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 {
@@ -335,8 +371,6 @@ class Regex {
         this._cursor = null;
         this._substring = "";
         this._tokens = [];
-        this._hasContextualTokenAggregation = false;
-        this._isRetrievingContextualTokens = false;
         this._type = "regex";
         this._name = name;
         this._isOptional = isOptional;
@@ -356,11 +390,16 @@ class Regex {
             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
         };
     }
@@ -387,7 +426,7 @@ class Regex {
     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);
     }
@@ -400,47 +439,38 @@ class Regex {
     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) {
@@ -510,7 +540,6 @@ class And {
         this._parent = null;
         this._children = children;
         this._firstIndex = -1;
-        this._shouldReduceAst = false;
         this._nodes = [];
     }
     _assignChildrenToParent(children) {
@@ -518,11 +547,16 @@ class And {
             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
         };
     }
@@ -556,34 +590,43 @@ class And {
                 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;
             }
@@ -611,18 +654,9 @@ class And {
     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 = [];
@@ -634,13 +668,35 @@ class And {
         }
         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];
                 }
@@ -649,39 +705,44 @@ class And {
                 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);
     }
 }
 
@@ -716,14 +777,17 @@ class Literal {
         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
         };
     }
@@ -766,45 +830,38 @@ class Literal {
         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;
     }
 }
 
@@ -815,9 +872,6 @@ class Not {
     get name() {
         return this._name;
     }
-    get isOptional() {
-        return false;
-    }
     get parent() {
         return this._parent;
     }
@@ -827,6 +881,9 @@ class Not {
     get children() {
         return this._children;
     }
+    get isOptional() {
+        return false;
+    }
     constructor(name, pattern) {
         this._type = "not";
         this._name = name;
@@ -834,7 +891,12 @@ class Not {
         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 {
@@ -860,17 +922,44 @@ class Not {
         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;
     }
 }
 
@@ -904,7 +993,6 @@ class Or {
         this._parent = null;
         this._children = children;
         this._isOptional = isOptional;
-        this._node = null;
         this._firstIndex = 0;
     }
     _assignChildrenToParent(children) {
@@ -912,17 +1000,21 @@ class Or {
             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();
@@ -954,17 +1046,39 @@ class Or {
         }
         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);
@@ -1003,7 +1117,6 @@ class Repeat {
         this._pattern = children[0];
         this._divider = children[1];
         this._firstIndex = -1;
-        this._shouldReduceAst = false;
         this._nodes = [];
     }
     _assignChildrenToParent(children) {
@@ -1011,11 +1124,16 @@ class Repeat {
             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
         };
     }
@@ -1026,7 +1144,7 @@ class Repeat {
         if (passed) {
             cursor.resolveError();
             const node = this.createNode(cursor);
-            if (node) {
+            if (node != null) {
                 cursor.recordMatch(this, node);
             }
             return node;
@@ -1045,7 +1163,7 @@ class Repeat {
             const repeatedNode = this._pattern.parse(cursor);
             if (cursor.hasError) {
                 const lastValidNode = this.getLastValidNode();
-                if (lastValidNode) {
+                if (lastValidNode != null) {
                     passed = true;
                 }
                 else {
@@ -1062,13 +1180,13 @@ class Repeat {
                     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;
@@ -1097,12 +1215,9 @@ class Repeat {
             }
         }
         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);
@@ -1111,51 +1226,64 @@ class Repeat {
         }
         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);
     }
 }
 
@@ -1166,9 +1294,6 @@ class Reference {
     get name() {
         return this._name;
     }
-    get isOptional() {
-        return this._isOptional;
-    }
     get parent() {
         return this._parent;
     }
@@ -1178,6 +1303,9 @@ class Reference {
     get children() {
         return this._children;
     }
+    get isOptional() {
+        return this._isOptional;
+    }
     constructor(name, isOptional = false) {
         this._type = "reference";
         this._name = name;
@@ -1186,35 +1314,22 @@ class Reference {
         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();
@@ -1247,10 +1362,210 @@ class Reference {
         }
         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;