clarity-pattern-parser 8.2.0 → 8.3.0

package/dist/index.js

@@ -3,16 +3,6 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 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;
     }
@@ -43,6 +33,16 @@ class Node {
     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) {
@@ -180,6 +180,36 @@ class Node {
     }
 }
 
+/******************************************************************************
+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;
@@ -283,12 +313,6 @@ class CursorHistory {
 }
 
 class Cursor {
-    constructor(text) {
-        this._text = text;
-        this._index = 0;
-        this._length = text.length;
-        this._history = new CursorHistory();
-    }
     get text() {
         return this._text;
     }
@@ -331,6 +355,12 @@ class Cursor {
     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;
     }
@@ -382,20 +412,6 @@ class Cursor {
 }
 
 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;
     }
@@ -414,6 +430,20 @@ class Literal {
     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);
@@ -504,20 +534,6 @@ class Literal {
 }
 
 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;
     }
@@ -536,6 +552,20 @@ class Regex {
     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.");
@@ -654,14 +684,6 @@ function findPattern(pattern, predicate) {
 }
 
 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;
     }
@@ -680,6 +702,14 @@ class Reference {
     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);
@@ -771,20 +801,6 @@ function clonePatterns(patterns, isOptional) {
 }
 
 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;
     }
@@ -803,6 +819,20 @@ class Or {
     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;
@@ -825,6 +855,7 @@ class Or {
         this._firstIndex = cursor.index;
         const node = this._tryToParse(cursor);
         if (node != null) {
+            cursor.moveTo(node.lastIndex);
             cursor.resolveError();
             return node;
         }
@@ -895,28 +926,12 @@ class Or {
         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;
     }
@@ -941,6 +956,22 @@ class FiniteRepeat {
     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 = [];
@@ -973,8 +1004,9 @@ class FiniteRepeat {
             }
         }
         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) {
@@ -1065,28 +1097,6 @@ class FiniteRepeat {
 }
 
 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;
     }
@@ -1108,6 +1118,28 @@ class InfiniteRepeat {
     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;
@@ -1214,6 +1246,10 @@ class InfiniteRepeat {
             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);
@@ -1301,19 +1337,6 @@ class InfiniteRepeat {
 }
 
 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;
     }
@@ -1332,6 +1355,19 @@ class Repeat {
     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);
     }
@@ -1401,20 +1437,6 @@ function filterOutNull(nodes) {
 }
 
 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;
     }
@@ -1433,6 +1455,20 @@ class And {
     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;
@@ -1545,7 +1581,6 @@ class And {
     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);
     }
@@ -1587,9 +1622,6 @@ class And {
         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;
@@ -1631,11 +1663,11 @@ class And {
     }
 }
 
-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,
@@ -1648,44 +1680,44 @@ const andLiteral = new Repeat("and-literal", pattern$1, { divider: divider$1, mi
 
 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(["*", "+"]);
@@ -1702,19 +1734,19 @@ const dividerComma = new Regex("divider-comma", "\\s*,\\s*");
 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", [
@@ -1723,39 +1755,57 @@ const statements = new Or("statements", [
     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;
     }
@@ -1774,6 +1824,13 @@ class Not {
     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);
@@ -2043,10 +2100,16 @@ function getFurthestOptions(options) {
 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"],
@@ -2058,9 +2121,31 @@ class Grammar {
             }
         });
     }
+    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) {
@@ -2077,8 +2162,14 @@ class Grammar {
             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" ||
@@ -2119,6 +2210,36 @@ class Grammar {
             }
         });
     }
+    _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");
@@ -2138,14 +2259,17 @@ class Grammar {
     _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);
         }
@@ -2154,7 +2278,7 @@ class Grammar {
     _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");
@@ -2173,7 +2297,7 @@ class Grammar {
     _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");
@@ -2230,10 +2354,18 @@ class Grammar {
         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;