clarity-pattern-parser 10.0.3 → 10.0.4

package/dist/index.browser.js

@@ -378,6 +378,13 @@
         }
     }
 
+    class CyclicalParseError extends Error {
+        constructor(patternId, patternName) {
+            super("Cyclical Parse Error");
+            this.patternId = patternId;
+            this.patternName = patternName;
+        }
+    }
     class Cursor {
         get text() {
             return this._text;
@@ -483,14 +490,13 @@
             this._history.stopRecording();
         }
         startParseWith(pattern) {
-            const patternName = pattern.name;
             const trace = {
                 pattern,
                 cursorIndex: this.index
             };
-            const hasCycle = this._stackTrace.find(t => t.pattern.id === pattern.id && this.index === t.cursorIndex);
+            const hasCycle = this._stackTrace.filter(t => t.pattern.id === pattern.id && this.index === t.cursorIndex).length > 1;
             if (hasCycle) {
-                throw new Error(`Cyclical Pattern: ${this._stackTrace.map(t => `${t.pattern.name}#${t.pattern.id}{${t.cursorIndex}}`).join(" -> ")} -> ${patternName}#${pattern.id}{${this.index}}.`);
+                throw new CyclicalParseError(pattern.id, pattern.name);
             }
             this._history.pushStackTrace(trace);
             this._stackTrace.push(trace);
@@ -998,7 +1004,19 @@
             const results = [];
             for (const pattern of this._children) {
                 cursor.moveTo(this._firstIndex);
-                const result = pattern.parse(cursor);
+                let result = null;
+                try {
+                    result = pattern.parse(cursor);
+                }
+                catch (error) {
+                    if (error.patternId === this._id) {
+                        continue;
+                    }
+                    else {
+                        cursor.endParse();
+                        throw error;
+                    }
+                }
                 if (this._isGreedy) {
                     results.push(result);
                 }
@@ -1994,8 +2012,8 @@
     ]);
 
     const optionalSpaces$3 = new Optional("optional-spaces", spaces$1);
-    const openBracket$1 = new Literal("open-bracket", "{");
-    const closeBracket$1 = new Literal("close-bracket", "}");
+    const openBracket$1 = new Literal("repeat-open-bracket", "{");
+    const closeBracket$1 = new Literal("repeat-close-bracket", "}");
     const comma = new Literal("comma", ",");
     const integer = new Regex("integer", "([1-9][0-9]*)|0");
     integer.setTokens(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]);
@@ -2032,15 +2050,15 @@
     const dividerComma = new Regex("divider-comma", "\\s*,\\s*");
     dividerComma.setTokens([", "]);
     const patternName$2 = name$1.clone("pattern-name");
-    const patterns$3 = new Options("or-patterns", [patternName$2, anonymousPattern]);
-    const dividerPattern = patterns$3.clone("divider-pattern");
-    const dividerSection = new Sequence("divider-section", [dividerComma, dividerPattern, trimFlag]);
-    const optionalDividerSection = new Optional("optional-divider-section", dividerSection);
+    const repeatPattern = new Options("repeat-pattern", [patternName$2, anonymousPattern]);
+    const repeatDividerPattern = repeatPattern.clone("repeat-divider-pattern");
+    const repeatDividerSection = new Sequence("repeat-divider-section", [dividerComma, repeatDividerPattern, trimFlag]);
+    const repeatOptionalDividerSection = new Optional("repeat-optional-divider-section", repeatDividerSection);
     const repeatLiteral = new Sequence("repeat-literal", [
         openParen,
         optionalSpaces$3,
-        patterns$3,
-        optionalDividerSection,
+        repeatPattern,
+        repeatOptionalDividerSection,
         optionalSpaces$3,
         closeParen,
         new Sequence("quantifier-section", [quantifier]),
@@ -2061,7 +2079,7 @@
 
     const patternName = name$1.clone("pattern-name");
     patternName.setTokens(["[PATTERN_NAME]"]);
-    const patterns$1 = new Options("or-patterns", [patternName, anonymousPattern]);
+    const patterns$1 = new Options("options-patterns", [patternName, anonymousPattern]);
     const defaultDivider = new Regex("default-divider", "\\s*[|]\\s*");
     defaultDivider.setTokens(["|"]);
     const greedyDivider = new Regex("greedy-divider", "\\s*[<][|][>]\\s*");
@@ -2108,7 +2126,7 @@
     const body = new Optional("optional-body", new Repeat("body", bodyLine, { divider: newLine$1 }));
 
     const optionalSpaces$1 = new Optional("optional-spaces", allSpaces);
-    const optionalLineSpaces$1 = new Optional("options-line-spaces", lineSpaces$1);
+    const optionalLineSpaces$1 = new Optional("optional-line-spaces", lineSpaces$1);
     const importNameDivider = new Regex("import-name-divider", "(\\s+)?,(\\s+)?");
     importNameDivider.setTokens([", "]);
     const name = new Regex("import-name", "[^}\\s,]+");
@@ -2748,7 +2766,7 @@
             const trimDivider = repeatNode.find(n => n.name === "trim-flag") != null;
             const patterNode = repeatNode.children[1].type === "spaces" ? repeatNode.children[2] : repeatNode.children[1];
             const pattern = this._buildPattern(patterNode);
-            const dividerSectionNode = repeatNode.find(n => n.name === "divider-section");
+            const dividerSectionNode = repeatNode.find(n => n.name === "repeat-divider-section");
             const options = {
                 min: 1,
                 max: Infinity