clarity-pattern-parser 10.3.1 → 10.3.3

package/dist/index.esm.js

@@ -528,6 +528,9 @@ class Literal {
     get children() {
         return [];
     }
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
     constructor(name, value) {
         this.shouldCompactAst = false;
         if (value.length === 0) {
@@ -657,10 +660,13 @@ class Regex {
     get children() {
         return [];
     }
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
     constructor(name, regex) {
         this._node = null;
         this._cursor = null;
-        this._firstIndex = -1;
+        this._firstIndex = 0;
         this._substring = "";
         this._tokens = [];
         this.shouldCompactAst = false;
@@ -813,6 +819,9 @@ class Reference {
     get children() {
         return this._children;
     }
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
     constructor(name) {
         this.shouldCompactAst = false;
         this._id = `reference-${idIndex$7++}`;
@@ -822,6 +831,7 @@ class Reference {
         this._pattern = null;
         this._cachedPattern = null;
         this._children = [];
+        this._firstIndex = 0;
     }
     test(text) {
         const cursor = new Cursor(text);
@@ -838,6 +848,7 @@ class Reference {
         };
     }
     parse(cursor) {
+        this._firstIndex = cursor.index;
         return this.getReferencePatternSafely().parse(cursor);
     }
     getReferencePatternSafely() {
@@ -951,29 +962,6 @@ function clonePatterns(patterns) {
     return patterns.map(p => p.clone());
 }
 
-class DepthCache {
-    constructor() {
-        this._depthMap = {};
-    }
-    getDepth(name, cursorIndex) {
-        if (this._depthMap[name] == null) {
-            this._depthMap[name] = {};
-        }
-        if (this._depthMap[name][cursorIndex] == null) {
-            this._depthMap[name][cursorIndex] = 0;
-        }
-        return this._depthMap[name][cursorIndex];
-    }
-    incrementDepth(name, cursorIndex) {
-        const depth = this.getDepth(name, cursorIndex);
-        this._depthMap[name][cursorIndex] = depth + 1;
-    }
-    decrementDepth(name, cursorIndex) {
-        const depth = this.getDepth(name, cursorIndex);
-        this._depthMap[name][cursorIndex] = depth - 1;
-    }
-}
-
 function isRecursivePattern(pattern) {
     let onPattern = pattern.parent;
     let depth = 0;
@@ -989,10 +977,6 @@ function isRecursivePattern(pattern) {
     return false;
 }
 
-/*
-  The following is created to reduce the overhead of recursion check.
-*/
-const depthCache$2 = new DepthCache();
 let idIndex$6 = 0;
 class Options {
     get id() {
@@ -1013,6 +997,9 @@ class Options {
     get children() {
         return this._children;
     }
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
     constructor(name, options, isGreedy = false) {
         this.shouldCompactAst = false;
         if (options.length === 0) {
@@ -1048,12 +1035,8 @@ class Options {
         };
     }
     parse(cursor) {
-        // This is a cache to help with speed
-        this._firstIndex = cursor.index;
-        depthCache$2.incrementDepth(this._id, this._firstIndex);
         this._firstIndex = cursor.index;
         const node = this._tryToParse(cursor);
-        depthCache$2.decrementDepth(this._id, this._firstIndex);
         if (node != null) {
             cursor.moveTo(node.lastIndex);
             cursor.resolveError();
@@ -1066,7 +1049,7 @@ class Options {
         return null;
     }
     _tryToParse(cursor) {
-        if (depthCache$2.getDepth(this._id, this._firstIndex) > 2) {
+        if (this._isBeyondRecursiveAllowance()) {
             return null;
         }
         const results = [];
@@ -1086,6 +1069,20 @@ class Options {
         nonNullResults.sort((a, b) => b.endIndex - a.endIndex);
         return nonNullResults[0] || null;
     }
+    _isBeyondRecursiveAllowance() {
+        let depth = 0;
+        let pattern = this;
+        while (pattern != null) {
+            if (pattern.id === this.id && pattern.startedOnIndex === this.startedOnIndex) {
+                depth++;
+            }
+            if (depth > 2) {
+                return true;
+            }
+            pattern = pattern.parent;
+        }
+        return false;
+    }
     getTokens() {
         const tokens = [];
         for (const pattern of this._children) {
@@ -1170,6 +1167,9 @@ class FiniteRepeat {
     get max() {
         return this._max;
     }
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
     constructor(name, pattern, options = {}) {
         this.shouldCompactAst = false;
         this._id = `finite-repeat-${idIndex$5++}`;
@@ -1181,6 +1181,7 @@ class FiniteRepeat {
         this._min = options.min != null ? Math.max(options.min, 1) : 1;
         this._max = Math.max(this.min, options.max || this.min);
         this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
+        this._firstIndex = 0;
         for (let i = 0; i < this._max; i++) {
             const child = pattern.clone();
             child.parent = this;
@@ -1193,6 +1194,7 @@ class FiniteRepeat {
         }
     }
     parse(cursor) {
+        this._firstIndex = cursor.index;
         const startIndex = cursor.index;
         const nodes = [];
         const modulo = this._hasDivider ? 2 : 1;
@@ -1348,6 +1350,9 @@ class InfiniteRepeat {
     get min() {
         return this._min;
     }
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
     constructor(name, pattern, options = {}) {
         this.shouldCompactAst = false;
         const min = options.min != null ? Math.max(options.min, 1) : 1;
@@ -1623,6 +1628,9 @@ class Repeat {
     get max() {
         return this._options.max;
     }
+    get startedOnIndex() {
+        return this._repeatPattern.startedOnIndex;
+    }
     constructor(name, pattern, options = {}) {
         this._id = `repeat-${idIndex$3++}`;
         this._pattern = pattern;
@@ -1705,7 +1713,6 @@ function filterOutNull(nodes) {
     return filteredNodes;
 }
 
-const depthCache$1 = new DepthCache();
 let idIndex$2 = 0;
 class Sequence {
     get id() {
@@ -1726,6 +1733,9 @@ class Sequence {
     get children() {
         return this._children;
     }
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
     constructor(name, sequence) {
         this.shouldCompactAst = false;
         if (sequence.length === 0) {
@@ -1761,12 +1771,9 @@ class Sequence {
         };
     }
     parse(cursor) {
-        // This is a cache to help with speed
         this._firstIndex = cursor.index;
-        depthCache$1.incrementDepth(this._id, this._firstIndex);
         this._nodes = [];
         const passed = this.tryToParse(cursor);
-        depthCache$1.decrementDepth(this._id, this._firstIndex);
         if (passed) {
             const node = this.createNode(cursor);
             if (node !== null) {
@@ -1780,7 +1787,7 @@ class Sequence {
         return null;
     }
     tryToParse(cursor) {
-        if (depthCache$1.getDepth(this._id, this._firstIndex) > 1) {
+        if (this._isBeyondRecursiveAllowance()) {
             cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
             return false;
         }
@@ -1847,6 +1854,20 @@ class Sequence {
         }
         return nodes[nodes.length - 1];
     }
+    _isBeyondRecursiveAllowance() {
+        let depth = 0;
+        let pattern = this;
+        while (pattern != null) {
+            if (pattern.id === this.id && pattern.startedOnIndex === this.startedOnIndex) {
+                depth++;
+            }
+            if (depth > 1) {
+                return true;
+            }
+            pattern = pattern.parent;
+        }
+        return false;
+    }
     areRemainingPatternsOptional(fromIndex) {
         const startOnIndex = fromIndex + 1;
         const length = this._children.length;
@@ -2006,6 +2027,9 @@ class Optional {
     get children() {
         return this._children;
     }
+    get startedOnIndex() {
+        return this._children[0].startedOnIndex;
+    }
     constructor(name, pattern) {
         this.shouldCompactAst = false;
         this._id = `optional-${idIndex$1++}`;
@@ -2327,6 +2351,9 @@ class Not {
     get children() {
         return this._children;
     }
+    get startedOnIndex() {
+        return this.children[0].startedOnIndex;
+    }
     constructor(name, pattern) {
         this.shouldCompactAst = false;
         this._id = `not-${idIndex++}`;
@@ -2666,6 +2693,9 @@ class Context {
     get children() {
         return this._children;
     }
+    get startedOnIndex() {
+        return this.children[0].startedOnIndex;
+    }
     getPatternWithinContext(name) {
         return this._patterns[name] || null;
     }
@@ -2739,7 +2769,6 @@ class Context {
 }
 
 let indexId = 0;
-const depthCache = new DepthCache();
 function createNode(name, children) {
     return new Node("expression", name, 0, 0, children, "");
 }
@@ -2768,7 +2797,7 @@ class ExpressionPattern {
         return this._patterns;
     }
     get unaryPatterns() {
-        return this._unaryPatterns;
+        return this._atomPatterns;
     }
     get binaryPatterns() {
         return this._binaryPatterns;
@@ -2776,6 +2805,9 @@ class ExpressionPattern {
     get recursivePatterns() {
         return this._recursivePatterns;
     }
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
     constructor(name, patterns) {
         this.shouldCompactAst = false;
         if (patterns.length === 0) {
@@ -2786,7 +2818,9 @@ class ExpressionPattern {
         this._name = name;
         this._parent = null;
         this._firstIndex = -1;
-        this._unaryPatterns = [];
+        this._atomPatterns = [];
+        this._unaryPrefixPatterns = [];
+        this._unaryPrefixNames = [];
         this._binaryPatterns = [];
         this._recursivePatterns = [];
         this._recursiveNames = [];
@@ -2797,7 +2831,7 @@ class ExpressionPattern {
         this._originalPatterns = patterns;
         this._shouldCompactPatternsMap = {};
         this._patterns = this._organizePatterns(patterns);
-        if (this._unaryPatterns.length === 0) {
+        if (this._atomPatterns.length === 0) {
             throw new Error("Need at least one operand pattern with an 'expression' pattern.");
         }
     }
@@ -2805,7 +2839,13 @@ class ExpressionPattern {
         const finalPatterns = [];
         patterns.forEach((pattern) => {
             this._shouldCompactPatternsMap[pattern.name] = pattern.shouldCompactAst;
-            if (this._isBinary(pattern)) {
+            if (this._isUnary(pattern)) {
+                const unaryPrefix = this._extractUnaryPrefixPattern(pattern).clone();
+                this._unaryPrefixPatterns.push(pattern);
+                this._unaryPrefixNames.push(pattern.name);
+                finalPatterns.push(unaryPrefix);
+            }
+            else if (this._isBinary(pattern)) {
                 const binaryName = this._extractName(pattern);
                 const clone = this._extractDelimiter(pattern).clone();
                 clone.parent = this;
@@ -2832,7 +2872,7 @@ class ExpressionPattern {
             else {
                 const clone = pattern.clone();
                 clone.parent = this;
-                this._unaryPatterns.push(clone);
+                this._atomPatterns.push(clone);
                 finalPatterns.push(clone);
             }
         });
@@ -2864,6 +2904,26 @@ class ExpressionPattern {
         }
         return pattern.name;
     }
+    _isUnary(pattern) {
+        if (pattern.type === "right-associated" && this._isUnaryPattern(pattern.children[0])) {
+            return true;
+        }
+        return this._isUnaryPattern(pattern);
+    }
+    _isUnaryPattern(pattern) {
+        return pattern.type === "sequence" &&
+            pattern.children[0].type !== "reference" &&
+            pattern.children[0].name !== this.name &&
+            pattern.children[1].type === "reference" &&
+            pattern.children[1].name === this.name &&
+            pattern.children.length === 2;
+    }
+    _extractUnaryPrefixPattern(pattern) {
+        if (pattern.type === "right-associated") {
+            return pattern.children[0].children[0];
+        }
+        return pattern.children[0];
+    }
     _isRecursive(pattern) {
         if (pattern.type === "right-associated" && this._isRecursivePattern(pattern.children[0])) {
             return true;
@@ -2874,7 +2934,7 @@ class ExpressionPattern {
         return pattern.type === "sequence" &&
             pattern.children[0].type === "reference" &&
             pattern.children[0].name === this.name &&
-            pattern.children.length > 1;
+            pattern.children.length > 2;
     }
     _extractRecursiveTail(pattern) {
         if (pattern.type === "right-associated") {
@@ -2893,11 +2953,8 @@ class ExpressionPattern {
             lastChild.name === this.name;
     }
     parse(cursor) {
-        this._firstIndex = cursor.index;
-        depthCache.incrementDepth(this._id, this._firstIndex);
         this._firstIndex = cursor.index;
         const node = this._tryToParse(cursor);
-        depthCache.decrementDepth(this._id, this._firstIndex);
         if (node != null) {
             cursor.moveTo(node.lastIndex);
             cursor.resolveError();
@@ -2927,38 +2984,63 @@ class ExpressionPattern {
         }
     }
     _tryToParse(cursor) {
-        if (depthCache.getDepth(this._id, this._firstIndex) > 2) {
+        if (this._isBeyondRecursiveAllowance()) {
             cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
             return null;
         }
-        let lastUnaryNode = null;
+        let lastAtomNode = null;
         let lastBinaryNode = null;
         let onIndex = cursor.index;
         outer: while (true) {
             cursor.resolveError();
             onIndex = cursor.index;
-            for (let i = 0; i < this._unaryPatterns.length; i++) {
+            let prefix = null;
+            let prefixName = "";
+            for (let i = 0; i < this._unaryPrefixPatterns.length; i++) {
+                cursor.moveTo(onIndex);
+                const pattern = this._unaryPrefixPatterns[i];
+                const node = pattern.parse(cursor);
+                if (node != null) {
+                    prefix = node;
+                    prefixName = this._unaryPrefixNames[i];
+                    if (cursor.hasNext()) {
+                        cursor.next();
+                    }
+                    else {
+                        break outer;
+                    }
+                    break;
+                }
+                else {
+                    cursor.resolveError();
+                }
+            }
+            onIndex = cursor.index;
+            for (let i = 0; i < this._atomPatterns.length; i++) {
                 cursor.moveTo(onIndex);
-                const pattern = this._unaryPatterns[i];
+                const pattern = this._atomPatterns[i];
                 const node = pattern.parse(cursor);
                 if (node != null) {
-                    lastUnaryNode = node;
+                    lastAtomNode = node;
                     break;
                 }
                 else {
-                    lastUnaryNode = null;
+                    lastAtomNode = null;
                     cursor.resolveError();
                 }
             }
-            if (lastUnaryNode == null) {
+            if (lastAtomNode == null) {
                 break;
             }
             if (cursor.hasNext()) {
                 cursor.next();
             }
             else {
-                if (lastBinaryNode != null && lastUnaryNode != null) {
-                    lastBinaryNode.appendChild(lastUnaryNode);
+                if (lastBinaryNode != null && lastAtomNode != null) {
+                    if (prefix != null) {
+                        lastAtomNode = createNode(prefixName, [prefix, lastAtomNode]);
+                    }
+                    lastBinaryNode.appendChild(lastAtomNode);
                 }
                 break;
             }
@@ -2969,24 +3051,30 @@ class ExpressionPattern {
                 if (node != null) {
                     const name = this._recursiveNames[i];
                     if (this._endsInRecursion[i]) {
-                        if (lastBinaryNode != null && lastUnaryNode != null) {
-                            lastBinaryNode.appendChild(lastUnaryNode);
+                        if (lastBinaryNode != null && lastAtomNode != null) {
+                            if (prefix != null) {
+                                lastAtomNode = createNode(prefixName, [prefix, lastAtomNode]);
+                            }
+                            lastBinaryNode.appendChild(lastAtomNode);
                         }
-                        const frontExpression = lastBinaryNode == null ? lastUnaryNode : lastBinaryNode.findRoot();
+                        const frontExpression = lastBinaryNode == null ? lastAtomNode : lastBinaryNode.findRoot();
                         const recursiveNode = createNode(name, [frontExpression, ...node.children]);
                         recursiveNode.normalize(this._firstIndex);
                         return recursiveNode;
                     }
                     else {
-                        const recursiveNode = createNode(name, [lastUnaryNode, ...node.children]);
-                        recursiveNode.normalize(lastUnaryNode.startIndex);
-                        lastUnaryNode = recursiveNode;
+                        if (prefix != null) {
+                            lastAtomNode = createNode(prefixName, [prefix, lastAtomNode]);
+                        }
+                        const recursiveNode = createNode(name, [lastAtomNode, ...node.children]);
+                        recursiveNode.normalize(lastAtomNode.startIndex);
+                        lastAtomNode = recursiveNode;
                         if (cursor.hasNext()) {
                             cursor.next();
                         }
                         else {
-                            if (lastBinaryNode != null) {
-                                lastBinaryNode.appendChild(lastUnaryNode);
+                            if (lastBinaryNode != null && lastAtomNode != null) {
+                                lastBinaryNode.appendChild(lastAtomNode);
                             }
                             break outer;
                         }
@@ -3008,31 +3096,31 @@ class ExpressionPattern {
                 if (delimiterNode == null) {
                     if (i === this._binaryPatterns.length - 1) {
                         if (lastBinaryNode == null) {
-                            return lastUnaryNode;
+                            return lastAtomNode;
                         }
-                        else if (lastUnaryNode != null) {
-                            lastBinaryNode.appendChild(lastUnaryNode);
+                        else if (lastAtomNode != null) {
+                            lastBinaryNode.appendChild(lastAtomNode);
                         }
                     }
                     continue;
                 }
-                if (lastBinaryNode == null && lastUnaryNode != null && delimiterNode != null) {
-                    const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                if (lastBinaryNode == null && lastAtomNode != null && delimiterNode != null) {
+                    const node = createNode(name, [lastAtomNode, delimiterNode]);
                     lastBinaryNode = node;
                 }
-                else if (lastBinaryNode != null && lastUnaryNode != null && delimiterNode != null) {
+                else if (lastBinaryNode != null && lastAtomNode != null && delimiterNode != null) {
                     const precedence = this._precedenceMap[name];
                     const lastPrecendece = lastBinaryNode == null ? 0 : this._precedenceMap[lastBinaryNode.name] == null ? -1 : this._precedenceMap[lastBinaryNode.name];
                     const association = this._binaryAssociation[i];
                     if (precedence === lastPrecendece && association === Association.right) {
-                        const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                        const node = createNode(name, [lastAtomNode, delimiterNode]);
                         lastBinaryNode.appendChild(node);
                         lastBinaryNode = node;
                     }
                     else if (precedence === lastPrecendece) {
                         const node = createNode(name, []);
                         lastBinaryNode.replaceWith(node);
-                        lastBinaryNode.appendChild(lastUnaryNode);
+                        lastBinaryNode.appendChild(lastAtomNode);
                         node.append(lastBinaryNode, delimiterNode);
                         lastBinaryNode = node;
                     }
@@ -3047,7 +3135,7 @@ class ExpressionPattern {
                             root = ancestor;
                             ancestor = ancestor.parent;
                         }
-                        lastBinaryNode.appendChild(lastUnaryNode);
+                        lastBinaryNode.appendChild(lastAtomNode);
                         if (root != null) {
                             const node = createNode(name, []);
                             root.replaceWith(node);
@@ -3055,12 +3143,12 @@ class ExpressionPattern {
                             lastBinaryNode = node;
                         }
                         else {
-                            const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                            const node = createNode(name, [lastAtomNode, delimiterNode]);
                             lastBinaryNode = node;
                         }
                     }
                     else {
-                        const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                        const node = createNode(name, [lastAtomNode, delimiterNode]);
                         lastBinaryNode.appendChild(node);
                         lastBinaryNode = node;
                     }
@@ -3078,20 +3166,34 @@ class ExpressionPattern {
             }
         }
         if (lastBinaryNode == null) {
-            return lastUnaryNode;
+            return lastAtomNode;
         }
         else {
             const root = lastBinaryNode.findAncestor(n => n.parent == null) || lastBinaryNode;
             if (lastBinaryNode.children.length < 3) {
                 lastBinaryNode.remove();
                 if (lastBinaryNode === root) {
-                    return lastUnaryNode;
+                    return lastAtomNode;
                 }
             }
             root.normalize(this._firstIndex);
             return root;
         }
     }
+    _isBeyondRecursiveAllowance() {
+        let depth = 0;
+        let pattern = this;
+        while (pattern != null) {
+            if (pattern.id === this.id && pattern.startedOnIndex === this.startedOnIndex) {
+                depth++;
+            }
+            if (depth > 2) {
+                return true;
+            }
+            pattern = pattern.parent;
+        }
+        return false;
+    }
     test(text) {
         const cursor = new Cursor(text);
         const ast = this.parse(cursor);
@@ -3119,7 +3221,7 @@ class ExpressionPattern {
             return this._binaryPatterns.map(p => p.getTokens()).flat();
         }
         if (this.binaryPatterns.indexOf(childReference)) {
-            const unaryTokens = this._unaryPatterns.map(p => p.getTokens()).flat();
+            const unaryTokens = this._atomPatterns.map(p => p.getTokens()).flat();
             if (this._parent != null) {
                 const nextTokens = this._parent.getTokensAfter(this);
                 return [...unaryTokens, ...nextTokens];
@@ -3147,7 +3249,7 @@ class ExpressionPattern {
             return this._binaryPatterns.map(p => p.getPatterns()).flat();
         }
         if (this.binaryPatterns.indexOf(childReference)) {
-            const unaryPatterns = this._unaryPatterns.map(p => p.getPatterns()).flat();
+            const unaryPatterns = this._atomPatterns.map(p => p.getPatterns()).flat();
             if (this._parent != null) {
                 const nextPatterns = this._parent.getPatternsAfter(this);
                 return [...unaryPatterns, ...nextPatterns];