clarity-pattern-parser 11.2.0 → 11.2.1

package/dist/index.js

@@ -554,7 +554,7 @@ function testPattern(pattern, text, record = false) {
     return !result.cursor.hasError;
 }
 
-let idIndex$9 = 0;
+let idIndex$a = 0;
 class Literal {
     get id() {
         return this._id;
@@ -584,7 +584,7 @@ class Literal {
         if (value.length === 0) {
             throw new Error("Value Cannot be empty.");
         }
-        this._id = `literal-${idIndex$9++}`;
+        this._id = `literal-${idIndex$a++}`;
         this._type = "literal";
         this._name = name;
         this._token = value;
@@ -675,7 +675,7 @@ class Literal {
     }
 }
 
-let idIndex$8 = 0;
+let idIndex$9 = 0;
 class Regex {
     get id() {
         return this._id;
@@ -707,7 +707,7 @@ class Regex {
         this._firstIndex = 0;
         this._substring = "";
         this._tokens = [];
-        this._id = `regex-${idIndex$8++}`;
+        this._id = `regex-${idIndex$9++}`;
         this._type = "regex";
         this._name = name;
         this._parent = null;
@@ -827,7 +827,7 @@ function findPattern(pattern, predicate) {
     }
 }
 
-let idIndex$7 = 0;
+let idIndex$8 = 0;
 class Reference {
     get id() {
         return this._id;
@@ -851,7 +851,7 @@ class Reference {
         return this._firstIndex;
     }
     constructor(name, referencePatternName) {
-        this._id = `reference-${idIndex$7++}`;
+        this._id = `reference-${idIndex$8++}`;
         this._type = "reference";
         this._name = name;
         this._referencePatternName = referencePatternName || name;
@@ -1028,7 +1028,7 @@ function isRecursivePattern(pattern) {
     return false;
 }
 
-let idIndex$6 = 0;
+let idIndex$7 = 0;
 class Options {
     get id() {
         return this._id;
@@ -1057,7 +1057,7 @@ class Options {
         }
         const children = clonePatterns(options);
         this._assignChildrenToParent(children);
-        this._id = `options-${idIndex$6++}`;
+        this._id = `options-${idIndex$7++}`;
         this._type = "options";
         this._name = name;
         this._parent = null;
@@ -1162,7 +1162,7 @@ class Options {
     }
 }
 
-let idIndex$5 = 0;
+let idIndex$6 = 0;
 class FiniteRepeat {
     get id() {
         return this._id;
@@ -1192,7 +1192,7 @@ class FiniteRepeat {
         return this._firstIndex;
     }
     constructor(name, pattern, options = {}) {
-        this._id = `finite-repeat-${idIndex$5++}`;
+        this._id = `finite-repeat-${idIndex$6++}`;
         this._type = "finite-repeat";
         this._name = name;
         this._parent = null;
@@ -1334,7 +1334,7 @@ class FiniteRepeat {
     }
 }
 
-let idIndex$4 = 0;
+let idIndex$5 = 0;
 class InfiniteRepeat {
     get id() {
         return this._id;
@@ -1371,7 +1371,7 @@ class InfiniteRepeat {
             children = [pattern.clone()];
         }
         this._assignChildrenToParent(children);
-        this._id = `infinite-repeat-${idIndex$4++}`;
+        this._id = `infinite-repeat-${idIndex$5++}`;
         this._type = "infinite-repeat";
         this._name = name;
         this._min = min;
@@ -1589,7 +1589,7 @@ class InfiniteRepeat {
     }
 }
 
-let idIndex$3 = 0;
+let idIndex$4 = 0;
 class Repeat {
     get id() {
         return this._id;
@@ -1625,7 +1625,7 @@ class Repeat {
         return this._options;
     }
     constructor(name, pattern, options = {}) {
-        this._id = `repeat-${idIndex$3++}`;
+        this._id = `repeat-${idIndex$4++}`;
         this._pattern = pattern;
         this._parent = null;
         this._options = Object.assign(Object.assign({}, options), { min: options.min == null ? 1 : options.min, max: options.max == null ? Infinity : options.max });
@@ -1704,7 +1704,7 @@ function filterOutNull(nodes) {
     return filteredNodes;
 }
 
-let idIndex$2 = 0;
+let idIndex$3 = 0;
 class Sequence {
     get id() {
         return this._id;
@@ -1733,7 +1733,7 @@ class Sequence {
         }
         const children = clonePatterns(sequence);
         this._assignChildrenToParent(children);
-        this._id = `sequence-${idIndex$2++}`;
+        this._id = `sequence-${idIndex$3++}`;
         this._type = "sequence";
         this._name = name;
         this._parent = null;
@@ -1969,12 +1969,13 @@ const anonymousLiterals = new Options("anonymous-literals", [
     new Reference("repeat-literal"),
 ]);
 const anonymousWrappedLiterals = new Options("anonymous-wrapped-literals", [
+    new Reference("take-until-literal"),
     new Reference("options-literal"),
     new Reference("sequence-literal"),
     new Reference("complex-anonymous-pattern")
 ]);
 
-let idIndex$1 = 0;
+let idIndex$2 = 0;
 class Optional {
     get id() {
         return this._id;
@@ -1998,7 +1999,7 @@ class Optional {
         return this._children[0].startedOnIndex;
     }
     constructor(name, pattern) {
-        this._id = `optional-${idIndex$1++}`;
+        this._id = `optional-${idIndex$2++}`;
         this._type = "optional";
         this._name = name;
         this._parent = null;
@@ -2070,12 +2071,12 @@ class Optional {
 
 const inlinePatternOpenParen = new Literal("anonymous-pattern-open-paren", "(");
 const inlinePatternCloseParen = new Literal("anonymous-pattern-close-paren", ")");
-const optionalLineSpaces$3 = new Optional("optional-line-spaces", lineSpaces$1);
+const optionalLineSpaces$4 = new Optional("optional-line-spaces", lineSpaces$1);
 const complexAnonymousPattern = new Sequence("complex-anonymous-pattern", [
     inlinePatternOpenParen,
-    optionalLineSpaces$3,
+    optionalLineSpaces$4,
     anonymousWrappedLiterals,
-    optionalLineSpaces$3,
+    optionalLineSpaces$4,
     inlinePatternCloseParen,
 ]);
 const anonymousPattern = new Options("anonymous-pattern", [
@@ -2162,6 +2163,20 @@ greedyDivider.setTokens(["<|>"]);
 const divider = new Options("options-divider", [defaultDivider, greedyDivider]);
 const optionsLiteral = new Repeat("options-literal", patterns$1, { divider, min: 2, trimDivider: true });
 
+const anyChar = new Literal("any-char", "?");
+const upTo = new Literal("up-to", "->");
+const wall = new Literal("wall", "|");
+const optionalLineSpaces$3 = new Optional("optional-line-spaces", lineSpaces$1);
+const takeUntilLiteral = new Sequence("take-until-literal", [
+    anyChar,
+    optionalLineSpaces$3,
+    upTo,
+    optionalLineSpaces$3,
+    wall,
+    optionalLineSpaces$3,
+    new Reference("pattern")
+]);
+
 const aliasLiteral = name$1.clone("alias-literal");
 aliasLiteral.setTokens(["[ALIAS_LITERAL]"]);
 const optionalIsOptional = new Optional("optional-flag", new Literal("is-optional", "?"));
@@ -2170,6 +2185,7 @@ const pattern = new Options("pattern", [
     literal$1,
     regexLiteral,
     repeatLiteral,
+    takeUntilLiteral,
     aliasLiteral,
     optionsLiteral,
     sequenceLiteral,
@@ -2363,7 +2379,7 @@ const grammar = new Sequence("grammar", [
     optionalSpaces
 ]);
 
-let idIndex = 0;
+let idIndex$1 = 0;
 class Not {
     get id() {
         return this._id;
@@ -2387,7 +2403,7 @@ class Not {
         return this.children[0].startedOnIndex;
     }
     constructor(name, pattern) {
-        this._id = `not-${idIndex++}`;
+        this._id = `not-${idIndex$1++}`;
         this._type = "not";
         this._name = name;
         this._parent = null;
@@ -3156,6 +3172,126 @@ class Expression {
     }
 }
 
+let idIndex = 0;
+class TakeUntil {
+    get id() {
+        return this._id;
+    }
+    get type() {
+        return this._type;
+    }
+    get name() {
+        return this._name;
+    }
+    get children() {
+        return this._children;
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(pattern) {
+        this._parent = pattern;
+    }
+    get startedOnIndex() {
+        return this._startedOnIndex;
+    }
+    constructor(name, terminatingPattern) {
+        this._id = String(idIndex++);
+        this._type = "take-until";
+        this._name = name;
+        this._parent = null;
+        this._terminatingPattern = terminatingPattern;
+        this._children = [this._terminatingPattern];
+        this._tokens = [];
+        this._startedOnIndex = 0;
+    }
+    parse(cursor) {
+        let cursorIndex = cursor.index;
+        let foundMatch = false;
+        this._startedOnIndex = cursor.index;
+        let terminatingResult = this._terminatingPattern.parse(cursor);
+        if (terminatingResult == null) {
+            foundMatch = true;
+            cursor.moveTo(cursorIndex);
+            cursorIndex += 1;
+            cursor.hasNext() && cursor.next();
+            cursor.resolveError();
+        }
+        while (true) {
+            terminatingResult = this._terminatingPattern.parse(cursor);
+            if (terminatingResult == null) {
+                cursor.moveTo(cursorIndex);
+                cursorIndex += 1;
+                if (cursor.hasNext()) {
+                    cursor.next();
+                }
+                else {
+                    break;
+                }
+                cursor.resolveError();
+            }
+            else {
+                break;
+            }
+        }
+        if (foundMatch) {
+            cursor.moveTo(cursorIndex - 1);
+            const value = cursor.getChars(this.startedOnIndex, cursorIndex - 1);
+            return Node.createValueNode(this._type, this._name, value);
+        }
+        else {
+            cursor.resolveError();
+            cursor.moveTo(this.startedOnIndex);
+            cursor.recordErrorAt(this._startedOnIndex, this._startedOnIndex, this);
+            return null;
+        }
+    }
+    exec(text, record) {
+        return execPattern(this, text, record);
+    }
+    test(text, record) {
+        return testPattern(this, text, record);
+    }
+    clone(name = this.name) {
+        const clone = new TakeUntil(name, this._terminatingPattern);
+        clone._id = this._id;
+        return clone;
+    }
+    getTokens() {
+        return this._tokens;
+    }
+    getTokensAfter(_childReference) {
+        return [];
+    }
+    getNextTokens() {
+        if (this.parent == null) {
+            return [];
+        }
+        return this.parent.getTokensAfter(this);
+    }
+    getPatterns() {
+        return [this];
+    }
+    getPatternsAfter(_childReference) {
+        return [];
+    }
+    getNextPatterns() {
+        if (this.parent == null) {
+            return [];
+        }
+        return this.parent.getPatternsAfter(this);
+    }
+    find(_predicate) {
+        return null;
+    }
+    setTokens(tokens) {
+        this._tokens = tokens;
+    }
+    isEqual(pattern) {
+        return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+    }
+}
+
 let indexId = 0;
 class RightAssociated {
     get id() {
@@ -3286,6 +3422,7 @@ const patternNodes = {
     "sequence-literal": true,
     "repeat-literal": true,
     "alias-literal": true,
+    "take-until-literal": true,
     "configurable-anonymous-pattern": true
 };
 class ParseContext {
@@ -3396,6 +3533,10 @@ class Grammar {
                     this._saveAlias(n);
                     break;
                 }
+                case "take-until-literal": {
+                    this._saveTakeUntil(n);
+                    break;
+                }
                 case "configurable-anonymous-pattern": {
                     this._saveConfigurableAnonymous(n);
                     break;
@@ -3515,6 +3656,9 @@ class Grammar {
             case "sequence-literal": {
                 return this._buildSequence(name, node);
             }
+            case "take-until-literal": {
+                return this._buildTakeUntil(name, node);
+            }
             case "complex-anonymous-pattern": {
                 return this._buildComplexAnonymousPattern(node);
             }
@@ -3598,6 +3742,19 @@ class Grammar {
         }
         return isOptional ? new Optional(name, new Repeat(`inner-optional-${name}`, pattern, options)) : new Repeat(name, pattern, options);
     }
+    _saveTakeUntil(statementNode) {
+        const nameNode = statementNode.find(n => n.name === "name");
+        const name = nameNode.value;
+        const takeUntilNode = statementNode.find(n => n.name === "take-until-literal");
+        const takeUntil = this._buildTakeUntil(name, takeUntilNode);
+        this._applyDecorators(statementNode, takeUntil);
+        this._parseContext.patternsByName.set(name, takeUntil);
+    }
+    _buildTakeUntil(name, takeUntilNode) {
+        const patternNode = takeUntilNode.children[takeUntilNode.children.length - 1];
+        const untilPattern = this._buildPattern(patternNode);
+        return new TakeUntil(name, untilPattern);
+    }
     _saveConfigurableAnonymous(node) {
         const nameNode = node.find(n => n.name === "name");
         const name = nameNode.value;