clarity-pattern-parser 4.0.1 → 4.0.3

package/dist/index.esm.js

@@ -894,7 +894,8 @@ class Recursive extends Pattern {
             if (pattern == null) {
                 return false;
             }
-            return pattern.name === this.name;
+            return (pattern.type !== "recursive" &&
+                pattern.name === this.name);
         });
     }
     climb(pattern, isMatch) {
@@ -940,26 +941,15 @@ class Recursive extends Pattern {
         }
         return new Recursive(name, isOptional);
     }
-    getTokenValue() {
-        var _a;
-        return ((_a = this.getPattern()) === null || _a === void 0 ? void 0 : _a.getTokenValue()) || null;
-    }
     getTokens() {
         var _a;
-        if (!this.isRecursing) {
-            this.isRecursing = true;
-            const tokens = ((_a = this.getPattern()) === null || _a === void 0 ? void 0 : _a.getTokens()) || [];
-            this.isRecursing = false;
-            return tokens;
-        }
-        return [];
+        return ((_a = this.getPattern()) === null || _a === void 0 ? void 0 : _a.getTokens()) || [];
     }
 }
 
 class Reference extends Pattern {
     constructor(name, isOptional = false) {
         super("reference", name, [], isOptional);
-        this.isRecursing = false;
     }
     getRoot() {
         let node = this.parent;
@@ -1030,9 +1020,6 @@ class Reference extends Pattern {
         }
         return new Reference(name, isOptional);
     }
-    getTokenValue() {
-        return this.safelyGetPattern().getTokenValue();
-    }
     safelyGetPattern() {
         let pattern = this.children[0];
         const hasNoPattern = pattern == null;
@@ -1047,14 +1034,212 @@ class Reference extends Pattern {
         return pattern;
     }
     getTokens() {
-        if (!this.isRecursing) {
-            this.isRecursing = true;
-            let pattern = this.safelyGetPattern();
-            const tokens = pattern.getTokens();
-            this.isRecursing = false;
-            return tokens;
+        return this.safelyGetPattern().getTokens();
+    }
+}
+
+class Visitor {
+    constructor(root = null, selectedNodes = []) {
+        this.root = root;
+        this.selectedNodes = selectedNodes;
+    }
+    flatten() {
+        this.selectedNodes.forEach((node) => {
+            if (node.children.length > 0) {
+                const children = [];
+                Visitor.walkUp(node, (descendant) => {
+                    if (descendant.children.length === 0) {
+                        children.push(descendant);
+                    }
+                });
+                node.children = children;
+            }
+        });
+        return this;
+    }
+    remove() {
+        if (this.root == null) {
+            return this;
         }
-        return [];
+        this.recursiveRemove(this.root);
+        return this;
+    }
+    recursiveRemove(node) {
+        const nodesToRemove = this.selectedNodes;
+        for (let x = 0; x < node.children.length; x++) {
+            if (nodesToRemove.indexOf(node.children[x]) > -1) {
+                node.children.splice(x, 1);
+                x--;
+            }
+            else {
+                this.recursiveRemove(node.children[x]);
+            }
+        }
+    }
+    wrap(callback) {
+        const visitor = new Visitor(this.root);
+        visitor.selectRoot().transform((node) => {
+            if (this.selectedNodes.includes(node)) {
+                return callback(node);
+            }
+            return node;
+        });
+        return this;
+    }
+    unwrap() {
+        if (this.root == null) {
+            return this;
+        }
+        Visitor.walkDown(this.root, (node, stack) => {
+            if (this.selectedNodes.includes(node)) {
+                const parent = stack[stack.length - 1];
+                const grandParent = stack[stack.length - 2];
+                if (parent != null && grandParent != null) {
+                    const index = grandParent.children.indexOf(parent);
+                    if (index > -1) {
+                        grandParent.children.splice(index, 1, ...parent.children);
+                    }
+                }
+            }
+        });
+        return this;
+    }
+    prepend(callback) {
+        if (this.root == null) {
+            return this;
+        }
+        Visitor.walkUp(this.root, (node, stack) => {
+            if (this.selectedNodes.includes(node)) {
+                const parent = stack[stack.length - 1];
+                if (parent != null) {
+                    const index = parent.children.indexOf(node);
+                    if (index > -1) {
+                        parent.children.splice(index, 0, callback(node));
+                    }
+                }
+            }
+        });
+        return this;
+    }
+    append(callback) {
+        if (this.root == null) {
+            return this;
+        }
+        Visitor.walkDown(this.root, (node, stack) => {
+            if (this.selectedNodes.includes(node)) {
+                const parent = stack[stack.length - 1];
+                if (parent != null) {
+                    const index = parent.children.indexOf(node);
+                    if (index > -1) {
+                        parent.children.splice(index + 1, 0, callback(node));
+                    }
+                }
+            }
+        });
+        return this;
+    }
+    transform(callback) {
+        this.selectedNodes.forEach((node) => {
+            return this.recursiveTransform(node, callback);
+        });
+        return this;
+    }
+    recursiveTransform(node, callback) {
+        const length = node.children.length;
+        for (let x = 0; x < length; x++) {
+            node.children[x] = this.recursiveTransform(node.children[x], callback);
+        }
+        return callback(node);
+    }
+    selectAll() {
+        return this.select((n) => true);
+    }
+    selectNode(node) {
+        return new Visitor(this.root, [...this.selectedNodes, node]);
+    }
+    deselectNode(node) {
+        const visitor = new Visitor(this.root, this.selectedNodes.slice());
+        return visitor.filter((n) => n !== node);
+    }
+    select(callback) {
+        if (this.root == null) {
+            return this;
+        }
+        const node = this.root;
+        const selectedNodes = [];
+        if (node.children.length > 0) {
+            Visitor.walkDown(node, (descendant) => {
+                if (callback(descendant)) {
+                    selectedNodes.push(descendant);
+                }
+            });
+        }
+        return new Visitor(this.root, selectedNodes);
+    }
+    forEach(callback) {
+        this.selectedNodes.forEach(callback);
+        return this;
+    }
+    filter(callback) {
+        return new Visitor(this.root, this.selectedNodes.filter(callback));
+    }
+    map(callback) {
+        return new Visitor(this.root, this.selectedNodes.map(callback));
+    }
+    selectRoot() {
+        if (this.root == null) {
+            return this;
+        }
+        return new Visitor(this.root, [this.root]);
+    }
+    first() {
+        return this.get(0);
+    }
+    last() {
+        return this.get(this.selectedNodes.length - 1);
+    }
+    get(index) {
+        const node = this.selectedNodes[index];
+        if (node == null) {
+            throw new Error(`Couldn't find node at index: ${index}, out of ${this.selectedNodes.length}.`);
+        }
+        return new Visitor(node, []);
+    }
+    clear() {
+        this.selectedNodes = [];
+        return this;
+    }
+    setRoot(root) {
+        this.root = root;
+        return this;
+    }
+    static select(root, callback) {
+        if (callback != null) {
+            return new Visitor(root).select(callback);
+        }
+        else {
+            return new Visitor(root);
+        }
+    }
+    static walkUp(node, callback, ancestors = []) {
+        ancestors.push(node);
+        if (node.children.length > 0) {
+            const children = node.children.slice();
+            children.forEach((c) => this.walkUp(c, callback, ancestors));
+        }
+        ancestors.pop();
+        callback(node, ancestors);
+        return this;
+    }
+    static walkDown(node, callback, ancestors = []) {
+        callback(node, ancestors);
+        ancestors.push(node);
+        if (node.children.length > 0) {
+            const children = node.children.slice();
+            children.forEach((c) => this.walkDown(c, callback, ancestors));
+        }
+        ancestors.pop();
+        return this;
     }
 }
 
@@ -1201,7 +1386,7 @@ class TextSuggester {
         if (noMatch) {
             let options = (_d = this.rootPattern) === null || _d === void 0 ? void 0 : _d.getTokens();
             options = options === null || options === void 0 ? void 0 : options.filter((option) => {
-                return option.indexOf(this.text) > -1;
+                return option.indexOf(this.text) === 0;
             });
             if ((options === null || options === void 0 ? void 0 : options.length) === 0) {
                 this.tokens = null;
@@ -1302,210 +1487,5 @@ class TextSuggester {
     }
 }
 
-class Visitor {
-    constructor(root = null, selectedNodes = []) {
-        this.root = root;
-        this.selectedNodes = selectedNodes;
-    }
-    flatten() {
-        this.selectedNodes.forEach((node) => {
-            if (node.children.length > 0) {
-                const children = [];
-                Visitor.walkUp(node, (descendant) => {
-                    if (descendant.children.length === 0) {
-                        children.push(descendant);
-                    }
-                });
-                node.children = children;
-            }
-        });
-        return this;
-    }
-    remove() {
-        if (this.root == null) {
-            return this;
-        }
-        this.recursiveRemove(this.root);
-        return this;
-    }
-    recursiveRemove(node) {
-        const nodesToRemove = this.selectedNodes;
-        for (let x = 0; x < node.children.length; x++) {
-            if (nodesToRemove.indexOf(node.children[x]) > -1) {
-                node.children.splice(x, 1);
-                x--;
-            }
-            else {
-                this.recursiveRemove(node.children[x]);
-            }
-        }
-    }
-    wrap(callback) {
-        const visitor = new Visitor(this.root);
-        visitor.selectRoot().transform((node) => {
-            if (this.selectedNodes.includes(node)) {
-                return callback(node);
-            }
-            return node;
-        });
-        return this;
-    }
-    unwrap() {
-        if (this.root == null) {
-            return this;
-        }
-        Visitor.walkDown(this.root, (node, stack) => {
-            if (this.selectedNodes.includes(node)) {
-                const parent = stack[stack.length - 1];
-                const grandParent = stack[stack.length - 2];
-                if (parent != null && grandParent != null) {
-                    const index = grandParent.children.indexOf(parent);
-                    if (index > -1) {
-                        grandParent.children.splice(index, 1, ...parent.children);
-                    }
-                }
-            }
-        });
-        return this;
-    }
-    prepend(callback) {
-        if (this.root == null) {
-            return this;
-        }
-        Visitor.walkUp(this.root, (node, stack) => {
-            if (this.selectedNodes.includes(node)) {
-                const parent = stack[stack.length - 1];
-                if (parent != null) {
-                    const index = parent.children.indexOf(node);
-                    if (index > -1) {
-                        parent.children.splice(index, 0, callback(node));
-                    }
-                }
-            }
-        });
-        return this;
-    }
-    append(callback) {
-        if (this.root == null) {
-            return this;
-        }
-        Visitor.walkDown(this.root, (node, stack) => {
-            if (this.selectedNodes.includes(node)) {
-                const parent = stack[stack.length - 1];
-                if (parent != null) {
-                    const index = parent.children.indexOf(node);
-                    if (index > -1) {
-                        parent.children.splice(index + 1, 0, callback(node));
-                    }
-                }
-            }
-        });
-        return this;
-    }
-    transform(callback) {
-        this.selectedNodes.forEach((node) => {
-            return this.recursiveTransform(node, callback);
-        });
-        return this;
-    }
-    recursiveTransform(node, callback) {
-        const length = node.children.length;
-        for (let x = 0; x < length; x++) {
-            node.children[x] = this.recursiveTransform(node.children[x], callback);
-        }
-        return callback(node);
-    }
-    selectAll() {
-        return this.select((n) => true);
-    }
-    selectNode(node) {
-        return new Visitor(this.root, [...this.selectedNodes, node]);
-    }
-    deselectNode(node) {
-        const visitor = new Visitor(this.root, this.selectedNodes.slice());
-        return visitor.filter((n) => n !== node);
-    }
-    select(callback) {
-        if (this.root == null) {
-            return this;
-        }
-        const node = this.root;
-        const selectedNodes = [];
-        if (node.children.length > 0) {
-            Visitor.walkDown(node, (descendant) => {
-                if (callback(descendant)) {
-                    selectedNodes.push(descendant);
-                }
-            });
-        }
-        return new Visitor(this.root, selectedNodes);
-    }
-    forEach(callback) {
-        this.selectedNodes.forEach(callback);
-        return this;
-    }
-    filter(callback) {
-        return new Visitor(this.root, this.selectedNodes.filter(callback));
-    }
-    map(callback) {
-        return new Visitor(this.root, this.selectedNodes.map(callback));
-    }
-    selectRoot() {
-        if (this.root == null) {
-            return this;
-        }
-        return new Visitor(this.root, [this.root]);
-    }
-    first() {
-        return this.get(0);
-    }
-    last() {
-        return this.get(this.selectedNodes.length - 1);
-    }
-    get(index) {
-        const node = this.selectedNodes[index];
-        if (node == null) {
-            throw new Error(`Couldn't find node at index: ${index}, out of ${this.selectedNodes.length}.`);
-        }
-        return new Visitor(node, []);
-    }
-    clear() {
-        this.selectedNodes = [];
-        return this;
-    }
-    setRoot(root) {
-        this.root = root;
-        return this;
-    }
-    static select(root, callback) {
-        if (callback != null) {
-            return new Visitor(root).select(callback);
-        }
-        else {
-            return new Visitor(root);
-        }
-    }
-    static walkUp(node, callback, ancestors = []) {
-        ancestors.push(node);
-        if (node.children.length > 0) {
-            const children = node.children.slice();
-            children.forEach((c) => this.walkUp(c, callback, ancestors));
-        }
-        ancestors.pop();
-        callback(node, ancestors);
-        return this;
-    }
-    static walkDown(node, callback, ancestors = []) {
-        callback(node, ancestors);
-        ancestors.push(node);
-        if (node.children.length > 0) {
-            const children = node.children.slice();
-            children.forEach((c) => this.walkDown(c, callback, ancestors));
-        }
-        ancestors.pop();
-        return this;
-    }
-}
-
 export { And, Cursor, Literal, LookAhead, Node, Not, Or, ParseError, Pattern, Recursive, Reference, Regex, Repeat, TextSuggester, Visitor };
 //# sourceMappingURL=index.esm.js.map