clarity-pattern-parser 8.2.0 → 8.3.0

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) {
@@ -182,6 +182,36 @@
         }
     }
 
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
     class ParseError {
         constructor(startIndex, endIndex, pattern) {
             this.startIndex = startIndex;
@@ -285,12 +315,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 +357,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 +414,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 +432,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 +536,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 +554,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 +686,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 +704,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,20 +803,6 @@
     }
 
     class Or {
-        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;
-        }
         get type() {
             return this._type;
         }
@@ -805,6 +821,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;
@@ -827,6 +857,7 @@
             this._firstIndex = cursor.index;
             const node = this._tryToParse(cursor);
             if (node != null) {
+                cursor.moveTo(node.lastIndex);
                 cursor.resolveError();
                 return node;
             }
@@ -897,28 +928,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;
         }
@@ -943,6 +958,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 = [];
@@ -975,8 +1006,9 @@
                 }
             }
             if (matchCount < this._min) {
+                const lastIndex = cursor.index;
                 cursor.moveTo(startIndex);
-                cursor.recordErrorAt(startIndex, startIndex, this);
+                cursor.recordErrorAt(startIndex, lastIndex, this);
                 return null;
             }
             else if (nodes.length === 0) {
@@ -1067,28 +1099,6 @@
     }
 
     class InfiniteRepeat {
-        constructor(name, pattern, options = {}) {
-            const min = options.min != null ? options.min : 1;
-            const divider = options.divider;
-            let children;
-            if (divider != null) {
-                children = [pattern.clone(), divider.clone(divider.name, false)];
-            }
-            else {
-                children = [pattern.clone()];
-            }
-            this._assignChildrenToParent(children);
-            this._type = "infinite-repeat";
-            this._name = name;
-            this._min = min;
-            this._parent = null;
-            this._children = children;
-            this._pattern = children[0];
-            this._divider = children[1];
-            this._firstIndex = -1;
-            this._nodes = [];
-            this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
-        }
         get type() {
             return this._type;
         }
@@ -1110,6 +1120,28 @@
         get min() {
             return this._min;
         }
+        constructor(name, pattern, options = {}) {
+            const min = options.min != null ? options.min : 1;
+            const divider = options.divider;
+            let children;
+            if (divider != null) {
+                children = [pattern.clone(pattern.name, false), divider.clone(divider.name, false)];
+            }
+            else {
+                children = [pattern.clone(pattern.name, false)];
+            }
+            this._assignChildrenToParent(children);
+            this._type = "infinite-repeat";
+            this._name = name;
+            this._min = min;
+            this._parent = null;
+            this._children = children;
+            this._pattern = children[0];
+            this._divider = children[1];
+            this._firstIndex = -1;
+            this._nodes = [];
+            this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
+        }
         _assignChildrenToParent(children) {
             for (const child of children) {
                 child.parent = this;
@@ -1216,6 +1248,10 @@
                 const dividerNode = this._nodes.pop();
                 cursor.moveTo(dividerNode.firstIndex);
             }
+            // if (this._nodes.length === 0) {
+            //   cursor.moveTo(this._firstIndex);
+            //   return null;
+            // }
             const lastIndex = this._nodes[this._nodes.length - 1].lastIndex;
             cursor.moveTo(lastIndex);
             return new Node(this._type, this._name, this._firstIndex, lastIndex, this._nodes);
@@ -1303,19 +1339,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;
         }
@@ -1334,6 +1357,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);
         }
@@ -1403,20 +1439,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;
         }
@@ -1435,6 +1457,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;
@@ -1547,7 +1583,6 @@
         createNode(cursor) {
             const children = filterOutNull(this._nodes);
             const lastIndex = children[children.length - 1].lastIndex;
-            cursor.getChars(this._firstIndex, lastIndex);
             cursor.moveTo(lastIndex);
             return new Node("and", this._name, this._firstIndex, lastIndex, children);
         }
@@ -1589,9 +1624,6 @@
             let index = -1;
             for (let i = 0; i < this._children.length; i++) {
                 if (this._children[i] === childReference) {
-                    if (i + 1 < this._children.length) {
-                        this._children[i + 1];
-                    }
                     nextSiblingIndex = i + 1;
                     index = i;
                     break;
@@ -1633,11 +1665,11 @@
         }
     }
 
-    const name = new Regex("name", "[a-zA-Z_-]+[a-zA-Z0-9_-]*");
+    const name$1 = new Regex("name", "[a-zA-Z_-]+[a-zA-Z0-9_-]*");
 
     const optionalNot = new Literal("not", "!", true);
     const optionalIsOptional$1 = new Literal("is-optional", "?", true);
-    const patternName$1 = name.clone("pattern-name");
+    const patternName$1 = name$1.clone("pattern-name");
     const pattern$1 = new And("pattern", [
         optionalNot,
         patternName$1,
@@ -1650,44 +1682,44 @@
 
     const divider = new Regex("or-divider", "\\s*[|]\\s*");
     divider.setTokens([" | "]);
-    const orLiteral = new Repeat("or-literal", name.clone("pattern-name"), { divider, min: 2 });
+    const orLiteral = new Repeat("or-literal", name$1.clone("pattern-name"), { divider, min: 2 });
 
     const regexLiteral = new Regex("regex-literal", "/(\\\\/|[^/\\n\\r])*/");
 
-    const spaces = new Regex("spaces", "[ \\t]+");
-    spaces.setTokens([" "]);
+    const spaces$1 = new Regex("spaces", "[ \\t]+");
+    spaces$1.setTokens([" "]);
 
     const optionalIsOptional = new Literal("is-optional", "?", true);
-    const patternName = name.clone("pattern-name");
+    const patternName = name$1.clone("pattern-name");
     const pattern = new And("pattern", [
         patternName,
         optionalIsOptional,
     ]);
-    const optionalSpaces$1 = spaces.clone("optional-spaces", true);
-    const dividerPattern = name.clone("divider-pattern");
-    const openBracket = new Literal("open-bracket", "{");
-    const closeBracket = new Literal("close-bracket", "}");
+    const optionalSpaces$2 = spaces$1.clone("optional-spaces", true);
+    const dividerPattern = name$1.clone("divider-pattern");
+    const openBracket$1 = new Literal("open-bracket", "{");
+    const closeBracket$1 = new Literal("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"]);
     const optionalInteger = integer.clone("integer", true);
     const bounds = new And("bounds", [
-        openBracket,
-        optionalSpaces$1,
+        openBracket$1,
+        optionalSpaces$2,
         optionalInteger.clone("min"),
-        optionalSpaces$1,
+        optionalSpaces$2,
         comma,
-        optionalSpaces$1,
+        optionalSpaces$2,
         optionalInteger.clone("max"),
-        optionalSpaces$1,
-        closeBracket
+        optionalSpaces$2,
+        closeBracket$1
     ]);
     const exactCount = new And("exact-count", [
-        openBracket,
-        optionalSpaces$1,
+        openBracket$1,
+        optionalSpaces$2,
         integer,
-        optionalSpaces$1,
-        closeBracket,
+        optionalSpaces$2,
+        closeBracket$1,
     ]);
     const quantifierShorthand = new Regex("quantifier-shorthand", "\\*|\\+");
     quantifierShorthand.setTokens(["*", "+"]);
@@ -1704,19 +1736,19 @@
     dividerComma.setTokens([", "]);
     const repeatLiteral = new And("repeat-literal", [
         openParen,
-        optionalSpaces$1,
+        optionalSpaces$2,
         pattern,
         optional,
         new And("optional-divider-section", [dividerComma, dividerPattern], true),
-        optionalSpaces$1,
+        optionalSpaces$2,
         closeParen,
-        new And("quantifier-section", [optionalSpaces$1, quantifier]),
-        new And("optional-trim-divider-section", [spaces, trimDivider], true)
+        new And("quantifier-section", [optionalSpaces$2, quantifier]),
+        new And("optional-trim-divider-section", [spaces$1, trimDivider], true)
     ]);
 
     const literal = new Regex("literal", "\"(?:\\\\[\"\\\\]|[^\n\"\\\\])*\"");
 
-    const optionalSpaces = spaces.clone("optional-spaces", true);
+    const optionalSpaces$1 = spaces$1.clone("optional-spaces", true);
     const assignOperator = new Literal("assign-operator", "=");
     const optionalComment = comment.clone("inline-comment", true);
     const statements = new Or("statements", [
@@ -1725,39 +1757,57 @@
         orLiteral,
         andLiteral,
         repeatLiteral,
-        name.clone("alias-literal"),
+        name$1.clone("alias-literal"),
     ]);
     const statement = new And("statement", [
-        optionalSpaces,
-        name,
-        optionalSpaces,
+        optionalSpaces$1,
+        name$1,
+        optionalSpaces$1,
         assignOperator,
-        optionalSpaces,
+        optionalSpaces$1,
         statements,
-        optionalSpaces,
+        optionalSpaces$1,
         optionalComment,
+        optionalSpaces$1,
+    ]);
+
+    const spaces = new Regex("spaces", "\\s+", true);
+    const importNameDivider = new Regex("import-name-divider", "(\\s+)?,(\\s+)?");
+    const importKeyword = new Literal("import", "import");
+    const fromKeyword = new Literal("from", "from");
+    const openBracket = new Literal("open-bracket", "{");
+    const closeBracket = new Literal("close-bracket", "}");
+    const name = new Regex("import-name", "[^}\\s,]+");
+    const importedNames = new Repeat("imported-names", name, { divider: importNameDivider });
+    const optionalSpaces = spaces.clone("optional-spaces", true);
+    const importStatement = new And("import-statement", [
+        importKeyword,
+        optionalSpaces,
+        openBracket,
+        optionalSpaces,
+        importedNames,
         optionalSpaces,
+        closeBracket,
+        optionalSpaces,
+        fromKeyword,
+        spaces,
+        literal.clone("url"),
     ]);
 
-    const whitespace = new Regex("whitespace", "[ \\t]+");
+    const whitespace = new Regex("whitespace", "[ \\t]+((\\r?\\n)+)?");
     const newLine = new Regex("new-line", "(\\r?\\n)+");
     whitespace.setTokens([" "]);
     newLine.setTokens(["\n"]);
     const line = new Or("line", [
+        newLine,
+        whitespace,
         comment,
-        statement,
-        whitespace
-    ], true);
-    const grammar = new Repeat("grammar", line, { divider: newLine });
+        importStatement,
+        statement
+    ]);
+    const grammar = new Repeat("grammer", line);
 
     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;
         }
@@ -1776,6 +1826,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);
@@ -2045,10 +2102,16 @@
     class ParseContext {
         constructor() {
             this.patternsByName = new Map();
+            this.importedPatternsByName = new Map();
         }
     }
+    function defaultImportResolver(_path, _basePath) {
+        throw new Error("No import resolver supplied.");
+    }
     class Grammar {
-        constructor() {
+        constructor(options = {}) {
+            this._meta = options.meta == null ? null : options.meta;
+            this._resolveImport = options.resolveImport == null ? defaultImportResolver : options.resolveImport;
             this._parseContext = new ParseContext();
             this._autoComplete = new AutoComplete(grammar, {
                 greedyPatternNames: ["spaces", "optional-spaces", "whitespace", "new-line"],
@@ -2060,9 +2123,31 @@
                 }
             });
         }
+        import(path) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const grammarFile = yield this._resolveImport(path, null);
+                const grammar = new Grammar({ resolveImport: this._resolveImport, meta: { originPath: grammarFile.path } });
+                return grammar.parse(grammarFile.expression);
+            });
+        }
         parse(expression) {
+            return __awaiter(this, void 0, void 0, function* () {
+                this._parseContext = new ParseContext();
+                const ast = this._tryToParse(expression);
+                yield this._resolveImports(ast);
+                this._buildPatterns(ast);
+                this._cleanAst(ast);
+                return this._parseContext.patternsByName;
+            });
+        }
+        parseString(expression) {
             this._parseContext = new ParseContext();
-            this._tryToParse(expression);
+            const ast = this._tryToParse(expression);
+            if (this._hasImports(ast)) {
+                throw new Error("Cannot use imports on parseString, use parse instead.");
+            }
+            this._buildPatterns(ast);
+            this._cleanAst(ast);
             return this._parseContext.patternsByName;
         }
         _tryToParse(expression) {
@@ -2079,8 +2164,14 @@
                 throw new Error(message);
             }
             // If it is complete it will always have a node. So we have to cast it.
-            this._cleanAst(ast);
-            this._buildPatterns(ast);
+            return ast;
+        }
+        _hasImports(ast) {
+            const importBlock = ast.find(n => n.name === "import-block");
+            if (importBlock == null) {
+                return false;
+            }
+            return importBlock && importBlock.children.length > 0;
         }
         _cleanAst(ast) {
             ast.findAll(n => n.name === "spaces" ||
@@ -2121,6 +2212,36 @@
                 }
             });
         }
+        _resolveImports(ast) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const parseContext = this._parseContext;
+                const importStatements = ast.findAll(n => n.name === "import-statement");
+                for (const importStatement of importStatements) {
+                    const urlNode = importStatement.find(n => n.name === "url");
+                    const url = urlNode.value.slice(1, -1);
+                    const grammarFile = yield this._resolveImport(url, ((_a = this._meta) === null || _a === void 0 ? void 0 : _a.originPath) || null);
+                    const grammar = new Grammar({ resolveImport: this._resolveImport, meta: { originPath: grammarFile.path } });
+                    try {
+                        const patterns = yield grammar.parse(grammarFile.expression);
+                        const importNames = importStatement.findAll(n => n.name === "import-name").map(n => n.value);
+                        importNames.forEach((importName) => {
+                            if (parseContext.importedPatternsByName.has(importName)) {
+                                throw new Error(`'${importName}' was already used within another import.`);
+                            }
+                            const pattern = patterns.get(importName);
+                            if (pattern == null) {
+                                throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${url}.`);
+                            }
+                            parseContext.importedPatternsByName.set(importName, pattern);
+                        });
+                    }
+                    catch (e) {
+                        throw new Error(`Failed loading expression from: "${url}". Error details: "${e.message}"`);
+                    }
+                }
+            });
+        }
         _buildLiteral(statementNode) {
             const nameNode = statementNode.find(n => n.name === "name");
             const literalNode = statementNode.find(n => n.name === "literal");
@@ -2140,14 +2261,17 @@
         _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) {
-            const pattern = this._parseContext.patternsByName.get(name);
+            let pattern = this._parseContext.patternsByName.get(name);
+            if (pattern == null) {
+                pattern = this._parseContext.importedPatternsByName.get(name);
+            }
             if (pattern == null) {
                 return new Reference(name);
             }
@@ -2156,7 +2280,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");
@@ -2175,7 +2299,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");
@@ -2232,10 +2356,18 @@
             const alias = pattern.clone(name);
             this._parseContext.patternsByName.set(name, alias);
         }
-        static parse(expression) {
-            const grammar = new Grammar();
+        static parse(expression, options) {
+            const grammar = new Grammar(options);
             return grammar.parse(expression);
         }
+        static import(path, options) {
+            const grammar = new Grammar(options);
+            return grammar.import(path);
+        }
+        static parseString(expression) {
+            const grammar = new Grammar();
+            return grammar.parseString(expression);
+        }
     }
 
     exports.And = And;
@@ -2254,5 +2386,5 @@
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));
 //# sourceMappingURL=index.browser.js.map