clarity-pattern-parser 4.0.1 → 4.0.3

package/dist/index.browser.js

@@ -900,7 +900,8 @@
               if (pattern == null) {
                   return false;
               }
-              return pattern.name === this.name;
+              return (pattern.type !== "recursive" &&
+                  pattern.name === this.name);
           });
       }
       climb(pattern, isMatch) {
@@ -946,26 +947,15 @@
           }
           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;
@@ -1036,9 +1026,6 @@
           }
           return new Reference(name, isOptional);
       }
-      getTokenValue() {
-          return this.safelyGetPattern().getTokenValue();
-      }
       safelyGetPattern() {
           let pattern = this.children[0];
           const hasNoPattern = pattern == null;
@@ -1053,14 +1040,212 @@
           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;
       }
   }
 
@@ -1207,7 +1392,7 @@
           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;
@@ -1308,211 +1493,6 @@
       }
   }
 
-  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;
-      }
-  }
-
   exports.And = And;
   exports.Cursor = Cursor;
   exports.Literal = Literal;