clarity-pattern-parser 10.0.2 → 10.0.4

package/dist/ast/Node.d.ts

@@ -52,6 +52,7 @@ export declare class Node {
     toString(): string;
     toCycleFreeObject(): CycleFreeNode;
     toJson(space?: number): string;
+    isEqual(node: Node): boolean;
     static createValueNode(name: string, value: string): Node;
     static createNode(name: string, children: Node[]): Node;
 }

package/dist/index.browser.js

@@ -225,6 +225,9 @@
         toJson(space) {
             return JSON.stringify(this.toCycleFreeObject(), null, space);
         }
+        isEqual(node) {
+            return node.toJson(0) === this.toJson(0);
+        }
         static createValueNode(name, value) {
             return new Node("custom-value-node", name, 0, 0, [], value);
         }
@@ -375,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;
@@ -480,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);
@@ -995,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);
                 }
@@ -1107,7 +1128,6 @@
             }
         }
         parse(cursor) {
-            var _a;
             cursor.startParseWith(this);
             const startIndex = cursor.index;
             const nodes = [];
@@ -1137,7 +1157,7 @@
                 }
             }
             if (this._trimDivider && this._hasDivider) {
-                const isDividerLastMatch = ((_a = cursor.leafMatch.pattern) === null || _a === void 0 ? void 0 : _a.id) === this.children[1].id;
+                const isDividerLastMatch = this.children.length > 1 && nodes[nodes.length - 1].name === this.children[1].name;
                 if (isDividerLastMatch) {
                     const node = nodes.pop();
                     cursor.moveTo(node.firstIndex);
@@ -1408,10 +1428,11 @@
             return passed;
         }
         _createNode(cursor) {
+            var _a;
             const hasDivider = this._divider != null;
             if (hasDivider &&
                 this._trimDivider &&
-                cursor.leafMatch.pattern === this._divider) {
+                this._nodes[this._nodes.length - 1].name === ((_a = this._divider) === null || _a === void 0 ? void 0 : _a.name)) {
                 const dividerNode = this._nodes.pop();
                 cursor.moveTo(dividerNode.firstIndex);
             }
@@ -1523,10 +1544,10 @@
             return this._children;
         }
         get min() {
-            return this.children[0].min;
+            return this._options.min;
         }
         get max() {
-            return this.children[0].max || Infinity;
+            return this._options.max;
         }
         constructor(name, pattern, options = {}) {
             this._id = `repeat-${idIndex$3++}`;
@@ -1762,7 +1783,7 @@
             const tokens = [];
             for (const child of this._children) {
                 tokens.push(...child.getTokens());
-                if (child.type !== "optional") {
+                if (child.type !== "optional" && child.type !== "not") {
                     break;
                 }
             }
@@ -1784,7 +1805,7 @@
             const patterns = [];
             for (const child of this._children) {
                 patterns.push(...child.getPatterns());
-                if (child.type !== "optional") {
+                if (child.type !== "optional" && child.type !== "not") {
                     break;
                 }
             }
@@ -1991,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"]);
@@ -2029,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]),
@@ -2058,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*");
@@ -2105,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,]+");
@@ -2208,9 +2229,6 @@
         get children() {
             return this._children;
         }
-        get isOptional() {
-            return false;
-        }
         constructor(name, pattern) {
             this._id = `not-${idIndex++}`;
             this._type = "not";
@@ -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
@@ -2865,7 +2883,7 @@
                         .importedPatternsByName
                         .values());
                     const grammar = new Grammar({
-                        params: importedValues,
+                        params: [...importedValues, ...this._parseContext.paramsByName.values()],
                         originResource: this._originResource,
                         resolveImport: this._resolveImport
                     });