clarity-pattern-parser 8.1.7 → 8.2.1

package/dist/index.browser.js

@@ -2,19 +2,9 @@
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
     typeof define === 'function' && define.amd ? define(['exports'], factory) :
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.clarityPatternParser = {}));
-}(this, (function (exports) { 'use strict';
+})(this, (function (exports) { 'use strict';
 
     class Node {
-        constructor(type, name, firstIndex, lastIndex, children = [], value = "") {
-            this._type = type;
-            this._name = name;
-            this._firstIndex = firstIndex;
-            this._lastIndex = lastIndex;
-            this._parent = null;
-            this._children = children;
-            this._value = value;
-            this._children.forEach(c => c._parent = this);
-        }
         get type() {
             return this._type;
         }
@@ -45,6 +35,16 @@
         get value() {
             return this.toString();
         }
+        constructor(type, name, firstIndex, lastIndex, children = [], value = "") {
+            this._type = type;
+            this._name = name;
+            this._firstIndex = firstIndex;
+            this._lastIndex = lastIndex;
+            this._parent = null;
+            this._children = children;
+            this._value = value;
+            this._children.forEach(c => c._parent = this);
+        }
         removeChild(node) {
             const index = this._children.indexOf(node);
             if (index > -1) {
@@ -285,12 +285,6 @@
     }
 
     class Cursor {
-        constructor(text) {
-            this._text = text;
-            this._index = 0;
-            this._length = text.length;
-            this._history = new CursorHistory();
-        }
         get text() {
             return this._text;
         }
@@ -333,6 +327,12 @@
         get currentChar() {
             return this._text[this._index];
         }
+        constructor(text) {
+            this._text = text;
+            this._index = 0;
+            this._length = text.length;
+            this._history = new CursorHistory();
+        }
         hasNext() {
             return this._index + 1 < this._length;
         }
@@ -384,20 +384,6 @@
     }
 
     class Literal {
-        constructor(name, value, isOptional = false) {
-            if (value.length === 0) {
-                throw new Error("Value Cannot be empty.");
-            }
-            this._type = "literal";
-            this._name = name;
-            this._literal = value;
-            this._runes = Array.from(value);
-            this._isOptional = isOptional;
-            this._parent = null;
-            this._firstIndex = 0;
-            this._lastIndex = 0;
-            this._endIndex = 0;
-        }
         get type() {
             return this._type;
         }
@@ -416,6 +402,20 @@
         get isOptional() {
             return this._isOptional;
         }
+        constructor(name, value, isOptional = false) {
+            if (value.length === 0) {
+                throw new Error("Value Cannot be empty.");
+            }
+            this._type = "literal";
+            this._name = name;
+            this._literal = value;
+            this._runes = Array.from(value);
+            this._isOptional = isOptional;
+            this._parent = null;
+            this._firstIndex = 0;
+            this._lastIndex = 0;
+            this._endIndex = 0;
+        }
         test(text) {
             const cursor = new Cursor(text);
             const ast = this.parse(cursor);
@@ -506,20 +506,6 @@
     }
 
     class Regex {
-        constructor(name, regex, isOptional = false) {
-            this._node = null;
-            this._cursor = null;
-            this._firstIndex = -1;
-            this._substring = "";
-            this._tokens = [];
-            this._type = "regex";
-            this._name = name;
-            this._isOptional = isOptional;
-            this._parent = null;
-            this._originalRegexString = regex;
-            this._regex = new RegExp(`^${regex}`, "g");
-            this.assertArguments();
-        }
         get type() {
             return this._type;
         }
@@ -538,6 +524,20 @@
         get isOptional() {
             return this._isOptional;
         }
+        constructor(name, regex, isOptional = false) {
+            this._node = null;
+            this._cursor = null;
+            this._firstIndex = -1;
+            this._substring = "";
+            this._tokens = [];
+            this._type = "regex";
+            this._name = name;
+            this._isOptional = isOptional;
+            this._parent = null;
+            this._originalRegexString = regex;
+            this._regex = new RegExp(`^${regex}`, "g");
+            this.assertArguments();
+        }
         assertArguments() {
             if (this._originalRegexString.length < 1) {
                 throw new Error("Invalid Arguments: The regex string argument needs to be at least one character long.");
@@ -656,14 +656,6 @@
     }
 
     class Reference {
-        constructor(name, isOptional = false) {
-            this._type = "reference";
-            this._name = name;
-            this._parent = null;
-            this._isOptional = isOptional;
-            this._pattern = null;
-            this._children = [];
-        }
         get type() {
             return this._type;
         }
@@ -682,6 +674,14 @@
         get isOptional() {
             return this._isOptional;
         }
+        constructor(name, isOptional = false) {
+            this._type = "reference";
+            this._name = name;
+            this._parent = null;
+            this._isOptional = isOptional;
+            this._pattern = null;
+            this._children = [];
+        }
         test(text) {
             const cursor = new Cursor(text);
             const ast = this.parse(cursor);
@@ -773,19 +773,6 @@
     }
 
     class Or {
-        constructor(name, options, isOptional = false) {
-            if (options.length === 0) {
-                throw new Error("Need at least one pattern with an 'or' pattern.");
-            }
-            const children = clonePatterns(options, false);
-            this._assignChildrenToParent(children);
-            this._type = "or";
-            this._name = name;
-            this._parent = null;
-            this._children = children;
-            this._isOptional = isOptional;
-            this._firstIndex = 0;
-        }
         get type() {
             return this._type;
         }
@@ -804,6 +791,20 @@
         get isOptional() {
             return this._isOptional;
         }
+        constructor(name, options, isOptional = false, isGreedy = false) {
+            if (options.length === 0) {
+                throw new Error("Need at least one pattern with an 'or' pattern.");
+            }
+            const children = clonePatterns(options, false);
+            this._assignChildrenToParent(children);
+            this._type = "or";
+            this._name = name;
+            this._parent = null;
+            this._children = children;
+            this._isOptional = isOptional;
+            this._firstIndex = 0;
+            this._isGreedy = isGreedy;
+        }
         _assignChildrenToParent(children) {
             for (const child of children) {
                 child.parent = this;
@@ -826,6 +827,7 @@
             this._firstIndex = cursor.index;
             const node = this._tryToParse(cursor);
             if (node != null) {
+                cursor.moveTo(node.lastIndex);
                 cursor.resolveError();
                 return node;
             }
@@ -838,15 +840,21 @@
             return null;
         }
         _tryToParse(cursor) {
+            const results = [];
             for (const pattern of this._children) {
                 cursor.moveTo(this._firstIndex);
                 const result = pattern.parse(cursor);
-                if (!cursor.hasError) {
+                if (this._isGreedy) {
+                    results.push(result);
+                }
+                if (!cursor.hasError && !this._isGreedy) {
                     return result;
                 }
                 cursor.resolveError();
             }
-            return null;
+            const nonNullResults = results.filter(r => r != null);
+            nonNullResults.sort((a, b) => b.endIndex - a.endIndex);
+            return nonNullResults[0] || null;
         }
         getTokens() {
             const tokens = [];
@@ -890,28 +898,12 @@
             return findPattern(this, predicate);
         }
         clone(name = this._name, isOptional = this._isOptional) {
-            const or = new Or(name, this._children, isOptional);
+            const or = new Or(name, this._children, isOptional, this._isGreedy);
             return or;
         }
     }
 
     class FiniteRepeat {
-        constructor(name, pattern, repeatAmount, options = {}) {
-            this._type = "finite-repeat";
-            this._name = name;
-            this._parent = null;
-            this._children = [];
-            this._hasDivider = options.divider != null;
-            this._min = options.min != null ? options.min : 1;
-            this._max = repeatAmount;
-            this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
-            for (let i = 0; i < repeatAmount; i++) {
-                this._children.push(pattern.clone(pattern.name));
-                if (options.divider != null && (i < repeatAmount - 1 || !this._trimDivider)) {
-                    this._children.push(options.divider.clone(options.divider.name, false));
-                }
-            }
-        }
         get type() {
             return this._type;
         }
@@ -936,6 +928,22 @@
         get max() {
             return this._max;
         }
+        constructor(name, pattern, repeatAmount, options = {}) {
+            this._type = "finite-repeat";
+            this._name = name;
+            this._parent = null;
+            this._children = [];
+            this._hasDivider = options.divider != null;
+            this._min = options.min != null ? options.min : 1;
+            this._max = repeatAmount;
+            this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
+            for (let i = 0; i < repeatAmount; i++) {
+                this._children.push(pattern.clone(pattern.name));
+                if (options.divider != null && (i < repeatAmount - 1 || !this._trimDivider)) {
+                    this._children.push(options.divider.clone(options.divider.name, false));
+                }
+            }
+        }
         parse(cursor) {
             const startIndex = cursor.index;
             const nodes = [];
@@ -1060,6 +1068,27 @@
     }
 
     class InfiniteRepeat {
+        get type() {
+            return this._type;
+        }
+        get name() {
+            return this._name;
+        }
+        get parent() {
+            return this._parent;
+        }
+        set parent(pattern) {
+            this._parent = pattern;
+        }
+        get children() {
+            return this._children;
+        }
+        get isOptional() {
+            return this._min === 0;
+        }
+        get min() {
+            return this._min;
+        }
         constructor(name, pattern, options = {}) {
             const min = options.min != null ? options.min : 1;
             const divider = options.divider;
@@ -1082,27 +1111,6 @@
             this._nodes = [];
             this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
         }
-        get type() {
-            return this._type;
-        }
-        get name() {
-            return this._name;
-        }
-        get parent() {
-            return this._parent;
-        }
-        set parent(pattern) {
-            this._parent = pattern;
-        }
-        get children() {
-            return this._children;
-        }
-        get isOptional() {
-            return this._min === 0;
-        }
-        get min() {
-            return this._min;
-        }
         _assignChildrenToParent(children) {
             for (const child of children) {
                 child.parent = this;
@@ -1296,19 +1304,6 @@
     }
 
     class Repeat {
-        constructor(name, pattern, options = {}) {
-            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 });
-            if (this._options.max !== Infinity) {
-                this._repeatPattern = new FiniteRepeat(name, pattern, this._options.max, this._options);
-            }
-            else {
-                this._repeatPattern = new InfiniteRepeat(name, pattern, this._options);
-            }
-            this._children = [this._repeatPattern];
-            this._repeatPattern.parent = this;
-        }
         get type() {
             return this._repeatPattern.type;
         }
@@ -1327,6 +1322,19 @@
         get isOptional() {
             return this._repeatPattern.isOptional;
         }
+        constructor(name, pattern, options = {}) {
+            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 });
+            if (this._options.max !== Infinity) {
+                this._repeatPattern = new FiniteRepeat(name, pattern, this._options.max, this._options);
+            }
+            else {
+                this._repeatPattern = new InfiniteRepeat(name, pattern, this._options);
+            }
+            this._children = [this._repeatPattern];
+            this._repeatPattern.parent = this;
+        }
         parse(cursor) {
             return this._repeatPattern.parse(cursor);
         }
@@ -1396,20 +1404,6 @@
     }
 
     class And {
-        constructor(name, sequence, isOptional = false) {
-            if (sequence.length === 0) {
-                throw new Error("Need at least one pattern with an 'and' pattern.");
-            }
-            const children = clonePatterns(sequence);
-            this._assignChildrenToParent(children);
-            this._type = "and";
-            this._name = name;
-            this._isOptional = isOptional;
-            this._parent = null;
-            this._children = children;
-            this._firstIndex = -1;
-            this._nodes = [];
-        }
         get type() {
             return this._type;
         }
@@ -1428,6 +1422,20 @@
         get isOptional() {
             return this._isOptional;
         }
+        constructor(name, sequence, isOptional = false) {
+            if (sequence.length === 0) {
+                throw new Error("Need at least one pattern with an 'and' pattern.");
+            }
+            const children = clonePatterns(sequence);
+            this._assignChildrenToParent(children);
+            this._type = "and";
+            this._name = name;
+            this._isOptional = isOptional;
+            this._parent = null;
+            this._children = children;
+            this._firstIndex = -1;
+            this._nodes = [];
+        }
         _assignChildrenToParent(children) {
             for (const child of children) {
                 child.parent = this;
@@ -1744,13 +1752,6 @@
     const grammar = new Repeat("grammar", line, { divider: newLine });
 
     class Not {
-        constructor(name, pattern) {
-            this._type = "not";
-            this._name = name;
-            this._parent = null;
-            this._children = [pattern.clone(pattern.name, false)];
-            this._children[0].parent = this;
-        }
         get type() {
             return this._type;
         }
@@ -1769,6 +1770,13 @@
         get isOptional() {
             return false;
         }
+        constructor(name, pattern) {
+            this._type = "not";
+            this._name = name;
+            this._parent = null;
+            this._children = [pattern.clone(pattern.name, false)];
+            this._children[0].parent = this;
+        }
         test(text) {
             const cursor = new Cursor(text);
             this.parse(cursor);
@@ -2133,10 +2141,10 @@
         _buildOr(statementNode) {
             const nameNode = statementNode.find(n => n.name === "name");
             const orNode = statementNode.find(n => n.name === "or-literal");
-            const patternNodes = orNode.children.filter(n => n.name == "pattern-name");
+            const patternNodes = orNode.children.filter(n => n.name === "pattern-name");
             const name = nameNode.value;
             const patterns = patternNodes.map(n => this._getPattern(n.value));
-            const or = new Or(name, patterns);
+            const or = new Or(name, patterns, false, true);
             this._parseContext.patternsByName.set(name, or);
         }
         _getPattern(name) {
@@ -2149,7 +2157,7 @@
         _buildAnd(statementNode) {
             const nameNode = statementNode.find(n => n.name === "name");
             const andNode = statementNode.find(n => n.name === "and-literal");
-            const patternNodes = andNode.children.filter(n => n.name == "pattern");
+            const patternNodes = andNode.children.filter(n => n.name === "pattern");
             const name = nameNode.value;
             const patterns = patternNodes.map(n => {
                 const nameNode = n.find(n => n.name === "pattern-name");
@@ -2168,7 +2176,7 @@
         _buildRepeat(statementNode) {
             const nameNode = statementNode.find(n => n.name === "name");
             const repeatNode = statementNode.find(n => n.name === "repeat-literal");
-            const patternNode = repeatNode.find(n => n.name == "pattern");
+            const patternNode = repeatNode.find(n => n.name === "pattern");
             const patternNameNode = patternNode.find(n => n.name === "pattern-name");
             const dividerNode = repeatNode.find(n => n.name === "divider-pattern");
             const bounds = repeatNode.find(n => n.name === "bounds");
@@ -2247,5 +2255,5 @@
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));
 //# sourceMappingURL=index.browser.js.map