clarity-pattern-parser 11.4.1 → 11.5.0

package/dist/ast/Node.d.ts

@@ -40,13 +40,13 @@ export declare class Node {
     append(...nodes: Node[]): void;
     nextSibling(): Node | null;
     previousSibling(): Node | null;
-    find(predicate: (node: Node) => boolean): Node | null;
-    findAll(predicate: (node: Node) => boolean): Node[];
+    find(predicate: (node: Node) => boolean, breadthFirst?: boolean): Node | null;
+    findAll(predicate: (node: Node) => boolean, breadthFirst?: 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;
+    walkUp(callback: (node: Node) => boolean | void): boolean;
+    walkDown(callback: (node: Node) => boolean | void): boolean;
+    walkBreadthFirst(callback: (node: Node) => boolean | void): boolean;
     transform(visitors: Record<string, (node: Node) => Node>): Node;
     flatten(): Node[];
     compact(): void;

package/dist/index.browser.js

@@ -130,16 +130,42 @@
             }
             return null;
         }
-        find(predicate) {
-            return this.findAll(predicate)[0] || null;
+        find(predicate, breadthFirst = false) {
+            let match = null;
+            if (breadthFirst) {
+                this.walkBreadthFirst(n => {
+                    if (predicate(n)) {
+                        match = n;
+                        return false;
+                    }
+                });
+            }
+            else {
+                this.walkUp(n => {
+                    if (predicate(n)) {
+                        match = n;
+                        return false;
+                    }
+                });
+            }
+            return match;
         }
-        findAll(predicate) {
+        findAll(predicate, breadthFirst = false) {
             const matches = [];
-            this.walkUp(n => {
-                if (predicate(n)) {
-                    matches.push(n);
-                }
-            });
+            if (breadthFirst) {
+                this.walkBreadthFirst(n => {
+                    if (predicate(n)) {
+                        matches.push(n);
+                    }
+                });
+            }
+            else {
+                this.walkUp(n => {
+                    if (predicate(n)) {
+                        matches.push(n);
+                    }
+                });
+            }
             return matches;
         }
         findRoot() {
@@ -162,22 +188,26 @@
             return null;
         }
         walkUp(callback) {
+            var _a;
             const childrenCopy = this._children.slice();
-            childrenCopy.forEach(c => c.walkUp(callback));
-            callback(this);
+            const result = childrenCopy.every(c => c.walkUp(callback));
+            return ((_a = callback(this)) !== null && _a !== void 0 ? _a : true) && result;
         }
         walkDown(callback) {
+            var _a;
             const childrenCopy = this._children.slice();
-            callback(this);
-            childrenCopy.forEach(c => c.walkDown(callback));
+            return ((_a = callback(this)) !== null && _a !== void 0 ? _a : true) && childrenCopy.every(c => c.walkDown(callback));
         }
         walkBreadthFirst(callback) {
             const queue = [this];
             while (queue.length > 0) {
                 const current = queue.shift();
-                callback(current);
+                if (callback(current) === false) {
+                    return false;
+                }
                 queue.push(...current.children);
             }
+            return true;
         }
         transform(visitors) {
             const childrenCopy = this._children.slice();
@@ -433,9 +463,10 @@
         }
     }
 
+    const segmenter = new Intl.Segmenter("und", { granularity: "grapheme" });
     class Cursor {
         get text() {
-            return this._chars.join("");
+            return this._text;
         }
         get isOnFirst() {
             return this._index === 0;
@@ -483,33 +514,55 @@
             return this._history.error != null;
         }
         get currentChar() {
-            return this._chars[this._index];
+            const index = this.getCharStartIndex(this._index);
+            return this.text.slice(index, index + this._charSize[index]);
         }
         constructor(text) {
-            this._chars = [...text];
+            this._text = text;
+            this._length = text.length;
+            this._charSize = [];
+            this._charMap = [];
             this._index = 0;
-            this._length = this._chars.length;
             this._history = new CursorHistory();
+            let index = 0;
+            for (const segment of segmenter.segment(text)) {
+                const size = segment.segment.length;
+                for (let i = 0; i < size; i++) {
+                    this._charMap.push(index);
+                    this._charSize.push(size);
+                }
+                index += size;
+            }
         }
         hasNext() {
-            return this._index + 1 < this._length;
+            const index = this._charMap[this._index];
+            const charSize = this._charSize[index];
+            return index + charSize < this._length;
         }
         next() {
             if (this.hasNext()) {
-                this._index++;
+                const index = this._charMap[this._index];
+                const size = this._charSize[index];
+                this.moveTo(index + size);
             }
         }
         hasPrevious() {
-            return this._index - 1 >= 0;
+            var _a;
+            const index = this._charMap[this._index];
+            const previousIndex = (_a = this._charMap[index - 1]) !== null && _a !== void 0 ? _a : -1;
+            return previousIndex >= 0;
         }
         previous() {
+            var _a;
             if (this.hasPrevious()) {
-                this._index--;
+                const index = this._charMap[this._index];
+                const previousIndex = (_a = this._charMap[index - 1]) !== null && _a !== void 0 ? _a : -1;
+                this.moveTo(previousIndex);
             }
         }
         moveTo(position) {
             if (position >= 0 && position < this._length) {
-                this._index = position;
+                this._index = this._charMap[position];
             }
         }
         moveToFirstChar() {
@@ -521,8 +574,8 @@
         getLastIndex() {
             return this._length - 1;
         }
-        getChars(first, last) {
-            return this._chars.slice(first, last + 1).join("");
+        substring(first, last) {
+            return this._text.slice(first, last + 1);
         }
         recordMatch(pattern, node) {
             this._history.recordMatch(pattern, node);
@@ -539,6 +592,18 @@
         stopRecording() {
             this._history.stopRecording();
         }
+        getCharStartIndex(index) {
+            return this._charMap[index];
+        }
+        getCharEndIndex(index) {
+            var _a;
+            let startIndex = this.getCharStartIndex(index);
+            return (_a = startIndex + this._charSize[startIndex]) !== null && _a !== void 0 ? _a : 1;
+        }
+        getCharLastIndex(index) {
+            var _a;
+            return (_a = this.getCharEndIndex(index) - 1) !== null && _a !== void 0 ? _a : 0;
+        }
     }
 
     function execPattern(pattern, text, record = false) {
@@ -604,11 +669,9 @@
             this._type = "literal";
             this._name = name;
             this._token = value;
-            this._runes = Array.from(value);
             this._parent = null;
             this._firstIndex = 0;
             this._lastIndex = 0;
-            this._endIndex = 0;
         }
         test(text, record = false) {
             return testPattern(this, text, record);
@@ -618,6 +681,7 @@
         }
         parse(cursor) {
             this._firstIndex = cursor.index;
+            this._lastIndex = cursor.index;
             const passed = this._tryToParse(cursor);
             if (passed) {
                 cursor.resolveError();
@@ -625,31 +689,28 @@
                 cursor.recordMatch(this, node);
                 return node;
             }
-            cursor.recordErrorAt(this._firstIndex, this._endIndex, this);
+            cursor.recordErrorAt(this._firstIndex, this._lastIndex, this);
             return null;
         }
         _tryToParse(cursor) {
-            let passed = false;
-            const literalRuneLength = this._runes.length;
-            for (let i = 0; i < literalRuneLength; i++) {
-                const literalRune = this._runes[i];
-                const cursorRune = cursor.currentChar;
-                if (literalRune !== cursorRune) {
-                    this._endIndex = cursor.index;
-                    break;
-                }
-                if (i + 1 === literalRuneLength) {
-                    this._lastIndex = this._firstIndex + this._token.length - 1;
-                    passed = true;
-                    break;
-                }
-                if (!cursor.hasNext()) {
-                    this._endIndex = cursor.index + 1;
-                    break;
+            const token = this._token;
+            const compareToToken = cursor.text.slice(this._firstIndex, this._firstIndex + this._token.length);
+            const length = Math.min(token.length, compareToToken.length);
+            for (let i = 0; i < length; i++) {
+                if (token[i] !== compareToToken[i]) {
+                    this._lastIndex = this._firstIndex + i;
+                    cursor.moveTo(this._lastIndex);
+                    return false;
                 }
-                cursor.next();
             }
-            return passed;
+            if (token != compareToToken) {
+                this._lastIndex = this._firstIndex + compareToToken.length - 1;
+                cursor.moveTo(this._lastIndex);
+                return false;
+            }
+            this._lastIndex = this._firstIndex + this._token.length - 1;
+            cursor.moveTo(this._lastIndex);
+            return true;
         }
         _createNode() {
             return new Node("literal", this._name, this._firstIndex, this._lastIndex, undefined, this._token);
@@ -728,7 +789,7 @@
             this._name = name;
             this._parent = null;
             this._originalRegexString = regex;
-            this._regex = new RegExp(`^${regex}`, "g");
+            this._regex = new RegExp(`^${regex}`, "gu");
             this.assertArguments();
         }
         assertArguments() {
@@ -757,7 +818,7 @@
         resetState(cursor) {
             this._cursor = cursor;
             this._regex.lastIndex = 0;
-            this._substring = this._cursor.text.substr(this._cursor.index);
+            this._substring = this._cursor.text.slice(this._cursor.index);
             this._node = null;
         }
         tryToParse(cursor) {
@@ -772,10 +833,9 @@
         processResult(cursor, result) {
             const currentIndex = cursor.index;
             const match = result[0];
-            const matchLength = [...match].length;
-            const newIndex = currentIndex + matchLength - 1;
-            this._node = new Node("regex", this._name, currentIndex, newIndex, undefined, result[0]);
-            cursor.moveTo(newIndex);
+            const lastIndex = cursor.getCharLastIndex(currentIndex + match.length - 1);
+            this._node = new Node("regex", this._name, currentIndex, lastIndex, undefined, result[0]);
+            cursor.moveTo(lastIndex);
             cursor.recordMatch(this, this._node);
         }
         processError(cursor) {
@@ -3303,7 +3363,7 @@
             }
             if (foundMatch) {
                 cursor.moveTo(cursorIndex - 1);
-                const value = cursor.getChars(this.startedOnIndex, cursorIndex - 1);
+                const value = cursor.substring(this.startedOnIndex, cursorIndex - 1);
                 const node = Node.createValueNode(this._type, this._name, value);
                 cursor.recordMatch(this, node);
                 return node;
@@ -3455,7 +3515,7 @@
         }
         const lastPattern = furthestMatch.pattern;
         const suggestions = cleanSuggestions(lastPattern.getNextTokens());
-        const strUpToError = cursor.getChars(0, endIndex);
+        const strUpToError = cursor.substring(0, endIndex);
         const lines = strUpToError.split("\n");
         const lastLine = lines[lines.length - 1];
         const line = lines.length;
@@ -4193,9 +4253,9 @@
         }
         _createSuggestionOptionsFromErrors() {
             // These errored because the length of the string.
-            const errors = this._cursor.errors.filter(e => e.lastIndex === this._cursor.length);
+            const errors = this._cursor.errors.filter(e => e.lastIndex === this._cursor.length - 1);
             const errorSuggestionOptions = errors.map(parseError => {
-                const currentText = this._cursor.getChars(parseError.startIndex, parseError.lastIndex);
+                const currentText = this._cursor.substring(parseError.startIndex, parseError.lastIndex);
                 const compositeSuggestions = this._getCompositeSuggestionsForPattern(parseError.pattern);
                 const trimmedErrorCompositeSuggestions = this._trimSuggestionsByExistingText(currentText, compositeSuggestions);
                 return this._createSuggestions(parseError.lastIndex, trimmedErrorCompositeSuggestions);
@@ -4251,7 +4311,7 @@
        * ie. sequence pattern segments ≈ [{look}, {an example}, {phrase}]
        * fullText = "look an"
        * remove {look} segment as its already been completed by the existing text.
-     */
+      */
         _filterCompletedSubSegments(currentText, compositeSuggestion) {
             let elementsToRemove = [];
             let workingText = currentText;
@@ -4354,7 +4414,7 @@
             return unique;
         }
         _createSuggestions(lastIndex, compositeSuggestionList) {
-            let textToIndex = lastIndex === -1 ? "" : this._cursor.getChars(0, lastIndex);
+            let textToIndex = lastIndex === -1 ? "" : this._cursor.substring(0, lastIndex);
             const options = [];
             for (const compositeSuggestion of compositeSuggestionList) {
                 // concatenated for start index identification inside createSuggestion