@plumile/ui 0.1.113 → 0.1.115

package/lib/esm/node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.js

@@ -1,600 +0,0 @@
-import { ASSERT_EXISTS as e, ASSERT_NEVER_REACH_HERE as t, addFlag as n, cc as r, insertToSet as i, isCharacter as a } from "./utils.js";
-import { digitsCharCodes as o, whitespaceCodes as s, wordCharCodes as c } from "./character-classes.js";
-//#region ../../node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.js
-var l = /[0-9a-fA-F]/, u = /[0-9]/, d = /[1-9]/, f = class {
-	constructor() {
-		this.idx = 0, this.input = "", this.groupIdx = 0;
-	}
-	saveState() {
-		return {
-			idx: this.idx,
-			input: this.input,
-			groupIdx: this.groupIdx
-		};
-	}
-	restoreState(e) {
-		this.idx = e.idx, this.input = e.input, this.groupIdx = e.groupIdx;
-	}
-	pattern(e) {
-		this.idx = 0, this.input = e, this.groupIdx = 0, this.consumeChar("/");
-		let t = this.disjunction();
-		this.consumeChar("/");
-		let r = {
-			type: "Flags",
-			loc: {
-				begin: this.idx,
-				end: e.length
-			},
-			global: !1,
-			ignoreCase: !1,
-			multiLine: !1,
-			unicode: !1,
-			sticky: !1
-		};
-		for (; this.isRegExpFlag();) switch (this.popChar()) {
-			case "g":
-				n(r, "global");
-				break;
-			case "i":
-				n(r, "ignoreCase");
-				break;
-			case "m":
-				n(r, "multiLine");
-				break;
-			case "u":
-				n(r, "unicode");
-				break;
-			case "y":
-				n(r, "sticky");
-				break;
-		}
-		if (this.idx !== this.input.length) throw Error("Redundant input: " + this.input.substring(this.idx));
-		return {
-			type: "Pattern",
-			flags: r,
-			value: t,
-			loc: this.loc(0)
-		};
-	}
-	disjunction() {
-		let e = [], t = this.idx;
-		for (e.push(this.alternative()); this.peekChar() === "|";) this.consumeChar("|"), e.push(this.alternative());
-		return {
-			type: "Disjunction",
-			value: e,
-			loc: this.loc(t)
-		};
-	}
-	alternative() {
-		let e = [], t = this.idx;
-		for (; this.isTerm();) e.push(this.term());
-		return {
-			type: "Alternative",
-			value: e,
-			loc: this.loc(t)
-		};
-	}
-	term() {
-		return this.isAssertion() ? this.assertion() : this.atom();
-	}
-	assertion() {
-		let n = this.idx;
-		switch (this.popChar()) {
-			case "^": return {
-				type: "StartAnchor",
-				loc: this.loc(n)
-			};
-			case "$": return {
-				type: "EndAnchor",
-				loc: this.loc(n)
-			};
-			case "\\":
-				switch (this.popChar()) {
-					case "b": return {
-						type: "WordBoundary",
-						loc: this.loc(n)
-					};
-					case "B": return {
-						type: "NonWordBoundary",
-						loc: this.loc(n)
-					};
-				}
-				/* c8 ignore next */
-				throw Error("Invalid Assertion Escape");
-			case "(":
-				this.consumeChar("?");
-				let t;
-				switch (this.popChar()) {
-					case "=":
-						t = "Lookahead";
-						break;
-					case "!":
-						t = "NegativeLookahead";
-						break;
-					case "<":
-						switch (this.popChar()) {
-							case "=":
-								t = "Lookbehind";
-								break;
-							case "!": t = "NegativeLookbehind";
-						}
-						break;
-				}
-				e(t);
-				let r = this.disjunction();
-				return this.consumeChar(")"), {
-					type: t,
-					value: r,
-					loc: this.loc(n)
-				};
-		}
-		// istanbul ignore next
-		return t();
-	}
-	quantifier(t = !1) {
-		let n, r = this.idx;
-		switch (this.popChar()) {
-			case "*":
-				n = {
-					atLeast: 0,
-					atMost: Infinity
-				};
-				break;
-			case "+":
-				n = {
-					atLeast: 1,
-					atMost: Infinity
-				};
-				break;
-			case "?":
-				n = {
-					atLeast: 0,
-					atMost: 1
-				};
-				break;
-			case "{":
-				let r = this.integerIncludingZero();
-				switch (this.popChar()) {
-					case "}":
-						n = {
-							atLeast: r,
-							atMost: r
-						};
-						break;
-					case ",":
-						let e;
-						this.isDigit() ? (e = this.integerIncludingZero(), n = {
-							atLeast: r,
-							atMost: e
-						}) : n = {
-							atLeast: r,
-							atMost: Infinity
-						}, this.consumeChar("}");
-						break;
-				}
-				if (t === !0 && n === void 0) return;
-				e(n);
-				break;
-		}
-		if (!(t === !0 && n === void 0) && e(n)) return this.peekChar(0) === "?" ? (this.consumeChar("?"), n.greedy = !1) : n.greedy = !0, n.type = "Quantifier", n.loc = this.loc(r), n;
-	}
-	atom() {
-		let n, r = this.idx;
-		switch (this.peekChar()) {
-			case ".":
-				n = this.dotAll();
-				break;
-			case "\\":
-				n = this.atomEscape();
-				break;
-			case "[":
-				n = this.characterClass();
-				break;
-			case "(":
-				n = this.group();
-				break;
-		}
-		// istanbul ignore next
-		return n === void 0 && this.isPatternCharacter() && (n = this.patternCharacter()), e(n) ? (n.loc = this.loc(r), this.isQuantifier() && (n.quantifier = this.quantifier()), n) : t();
-	}
-	dotAll() {
-		return this.consumeChar("."), {
-			type: "Set",
-			complement: !0,
-			value: [
-				r("\n"),
-				r("\r"),
-				r("\u2028"),
-				r("\u2029")
-			]
-		};
-	}
-	atomEscape() {
-		switch (this.consumeChar("\\"), this.peekChar()) {
-			case "1":
-			case "2":
-			case "3":
-			case "4":
-			case "5":
-			case "6":
-			case "7":
-			case "8":
-			case "9": return this.decimalEscapeAtom();
-			case "d":
-			case "D":
-			case "s":
-			case "S":
-			case "w":
-			case "W": return this.characterClassEscape();
-			case "f":
-			case "n":
-			case "r":
-			case "t":
-			case "v": return this.controlEscapeAtom();
-			case "c": return this.controlLetterEscapeAtom();
-			case "0": return this.nulCharacterAtom();
-			case "x": return this.hexEscapeSequenceAtom();
-			case "u": return this.regExpUnicodeEscapeSequenceAtom();
-			default: return this.identityEscapeAtom();
-		}
-	}
-	decimalEscapeAtom() {
-		return {
-			type: "GroupBackReference",
-			value: this.positiveInteger()
-		};
-	}
-	characterClassEscape() {
-		let n, r = !1;
-		switch (this.popChar()) {
-			case "d":
-				n = o;
-				break;
-			case "D":
-				n = o, r = !0;
-				break;
-			case "s":
-				n = s;
-				break;
-			case "S":
-				n = s, r = !0;
-				break;
-			case "w":
-				n = c;
-				break;
-			case "W":
-				n = c, r = !0;
-				break;
-		}
-		// istanbul ignore next
-		return e(n) ? {
-			type: "Set",
-			value: n,
-			complement: r
-		} : t();
-	}
-	controlEscapeAtom() {
-		let n;
-		switch (this.popChar()) {
-			case "f":
-				n = r("\f");
-				break;
-			case "n":
-				n = r("\n");
-				break;
-			case "r":
-				n = r("\r");
-				break;
-			case "t":
-				n = r("	");
-				break;
-			case "v":
-				n = r("\v");
-				break;
-		}
-		// istanbul ignore next
-		return e(n) ? {
-			type: "Character",
-			value: n
-		} : t();
-	}
-	controlLetterEscapeAtom() {
-		this.consumeChar("c");
-		let e = this.popChar();
-		if (/[a-zA-Z]/.test(e) === !1) throw Error("Invalid ");
-		return {
-			type: "Character",
-			value: e.toUpperCase().charCodeAt(0) - 64
-		};
-	}
-	nulCharacterAtom() {
-		return this.consumeChar("0"), {
-			type: "Character",
-			value: r("\0")
-		};
-	}
-	hexEscapeSequenceAtom() {
-		return this.consumeChar("x"), this.parseHexDigits(2);
-	}
-	regExpUnicodeEscapeSequenceAtom() {
-		return this.consumeChar("u"), this.parseHexDigits(4);
-	}
-	identityEscapeAtom() {
-		return {
-			type: "Character",
-			value: r(this.popChar())
-		};
-	}
-	classPatternCharacterAtom() {
-		switch (this.peekChar()) {
-			// istanbul ignore next
-			case "\n":
-			// istanbul ignore next
-			case "\r":
-			// istanbul ignore next
-			case "\u2028":
-			// istanbul ignore next
-			case "\u2029":
-			// istanbul ignore next
-			case "\\":
-			// istanbul ignore next
-			case "]": throw Error("TBD");
-			default: return {
-				type: "Character",
-				value: r(this.popChar())
-			};
-		}
-	}
-	characterClass() {
-		let e = [], t = !1;
-		for (this.consumeChar("["), this.peekChar(0) === "^" && (this.consumeChar("^"), t = !0); this.isClassAtom();) {
-			let t = this.classAtom();
-			if (t.type, a(t) && this.isRangeDash()) {
-				this.consumeChar("-");
-				let n = this.classAtom();
-				if (n.type, a(n)) {
-					if (n.value < t.value) throw Error("Range out of order in character class");
-					e.push({
-						from: t.value,
-						to: n.value
-					});
-				} else i(t.value, e), e.push(r("-")), i(n.value, e);
-			} else i(t.value, e);
-		}
-		return this.consumeChar("]"), {
-			type: "Set",
-			complement: t,
-			value: e
-		};
-	}
-	classAtom() {
-		switch (this.peekChar()) {
-			// istanbul ignore next
-			case "]":
-			// istanbul ignore next
-			case "\n":
-			// istanbul ignore next
-			case "\r":
-			// istanbul ignore next
-			case "\u2028":
-			// istanbul ignore next
-			case "\u2029": throw Error("TBD");
-			case "\\": return this.classEscape();
-			default: return this.classPatternCharacterAtom();
-		}
-	}
-	classEscape() {
-		switch (this.consumeChar("\\"), this.peekChar()) {
-			case "b": return this.consumeChar("b"), {
-				type: "Character",
-				value: r("\b")
-			};
-			case "d":
-			case "D":
-			case "s":
-			case "S":
-			case "w":
-			case "W": return this.characterClassEscape();
-			case "f":
-			case "n":
-			case "r":
-			case "t":
-			case "v": return this.controlEscapeAtom();
-			case "c": return this.controlLetterEscapeAtom();
-			case "0": return this.nulCharacterAtom();
-			case "x": return this.hexEscapeSequenceAtom();
-			case "u": return this.regExpUnicodeEscapeSequenceAtom();
-			default: return this.identityEscapeAtom();
-		}
-	}
-	group() {
-		let e = !0;
-		switch (this.consumeChar("("), this.peekChar(0)) {
-			case "?":
-				this.consumeChar("?"), this.consumeChar(":"), e = !1;
-				break;
-			default:
-				this.groupIdx++;
-				break;
-		}
-		let t = this.disjunction();
-		this.consumeChar(")");
-		let n = {
-			type: "Group",
-			capturing: e,
-			value: t
-		};
-		return e && (n.idx = this.groupIdx), n;
-	}
-	positiveInteger() {
-		let e = this.popChar();
-		// istanbul ignore next - can't ever get here due to previous lookahead checks
-		if (d.test(e) === !1) throw Error("Expecting a positive integer");
-		for (; u.test(this.peekChar(0));) e += this.popChar();
-		return parseInt(e, 10);
-	}
-	integerIncludingZero() {
-		let e = this.popChar();
-		if (u.test(e) === !1) throw Error("Expecting an integer");
-		for (; u.test(this.peekChar(0));) e += this.popChar();
-		return parseInt(e, 10);
-	}
-	patternCharacter() {
-		let e = this.popChar();
-		switch (e) {
-			// istanbul ignore next
-			case "\n":
-			// istanbul ignore next
-			case "\r":
-			// istanbul ignore next
-			case "\u2028":
-			// istanbul ignore next
-			case "\u2029":
-			// istanbul ignore next
-			case "^":
-			// istanbul ignore next
-			case "$":
-			// istanbul ignore next
-			case "\\":
-			// istanbul ignore next
-			case ".":
-			// istanbul ignore next
-			case "*":
-			// istanbul ignore next
-			case "+":
-			// istanbul ignore next
-			case "?":
-			// istanbul ignore next
-			case "(":
-			// istanbul ignore next
-			case ")":
-			// istanbul ignore next
-			case "[":
-			// istanbul ignore next
-			case "|":
- // istanbul ignore next
-			throw Error("TBD");
-			default: return {
-				type: "Character",
-				value: r(e)
-			};
-		}
-	}
-	isRegExpFlag() {
-		switch (this.peekChar(0)) {
-			case "g":
-			case "i":
-			case "m":
-			case "u":
-			case "y": return !0;
-			default: return !1;
-		}
-	}
-	isRangeDash() {
-		return this.peekChar() === "-" && this.isClassAtom(1);
-	}
-	isDigit() {
-		return u.test(this.peekChar(0));
-	}
-	isClassAtom(e = 0) {
-		switch (this.peekChar(e)) {
-			case "]":
-			case "\n":
-			case "\r":
-			case "\u2028":
-			case "\u2029": return !1;
-			default: return !0;
-		}
-	}
-	isTerm() {
-		return this.isAtom() || this.isAssertion();
-	}
-	isAtom() {
-		if (this.isPatternCharacter()) return !0;
-		switch (this.peekChar(0)) {
-			case ".":
-			case "\\":
-			case "[":
-			case "(": return !0;
-			default: return !1;
-		}
-	}
-	isAssertion() {
-		switch (this.peekChar(0)) {
-			case "^":
-			case "$": return !0;
-			case "\\": switch (this.peekChar(1)) {
-				case "b":
-				case "B": return !0;
-				default: return !1;
-			}
-			case "(": return this.peekChar(1) === "?" && (this.peekChar(2) === "=" || this.peekChar(2) === "!" || this.peekChar(2) === "<" && (this.peekChar(3) === "=" || this.peekChar(3) === "!"));
-			default: return !1;
-		}
-	}
-	isQuantifier() {
-		let e = this.saveState();
-		try {
-			return this.quantifier(!0) !== void 0;
-		} catch {
-			return !1;
-		} finally {
-			this.restoreState(e);
-		}
-	}
-	isPatternCharacter() {
-		switch (this.peekChar()) {
-			case "^":
-			case "$":
-			case "\\":
-			case ".":
-			case "*":
-			case "+":
-			case "?":
-			case "(":
-			case ")":
-			case "[":
-			case "|":
-			case "/":
-			case "\n":
-			case "\r":
-			case "\u2028":
-			case "\u2029": return !1;
-			default: return !0;
-		}
-	}
-	parseHexDigits(e) {
-		let t = "";
-		for (let n = 0; n < e; n++) {
-			let e = this.popChar();
-			if (l.test(e) === !1) throw Error("Expecting a HexDecimal digits");
-			t += e;
-		}
-		return {
-			type: "Character",
-			value: parseInt(t, 16)
-		};
-	}
-	peekChar(e = 0) {
-		return this.input[this.idx + e];
-	}
-	popChar() {
-		let e = this.peekChar(0);
-		return this.consumeChar(void 0), e;
-	}
-	consumeChar(e) {
-		if (e !== void 0 && this.input[this.idx] !== e) throw Error("Expected: '" + e + "' but found: '" + this.input[this.idx] + "' at offset: " + this.idx);
-		if (this.idx >= this.input.length) throw Error("Unexpected end of input");
-		this.idx++;
-	}
-	loc(e) {
-		return {
-			begin: e,
-			end: this.idx
-		};
-	}
-};
-//#endregion
-export { f as RegExpParser };
-
-//# sourceMappingURL=regexp-parser.js.map

package/lib/esm/node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"regexp-parser.js","names":[],"sources":["../../../../../../../../../node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.js"],"sourcesContent":["import { addFlag, ASSERT_EXISTS, ASSERT_NEVER_REACH_HERE, cc, insertToSet, isCharacter, } from \"./utils.js\";\nimport { digitsCharCodes, whitespaceCodes, wordCharCodes, } from \"./character-classes.js\";\n// consts and utilities\nconst hexDigitPattern = /[0-9a-fA-F]/;\nconst decimalPattern = /[0-9]/;\nconst decimalPatternNoZero = /[1-9]/;\n// https://hackernoon.com/the-madness-of-parsing-real-world-javascript-regexps-d9ee336df983\n// https://www.ecma-international.org/ecma-262/8.0/index.html#prod-Pattern\nexport class RegExpParser {\n    constructor() {\n        this.idx = 0;\n        this.input = \"\";\n        this.groupIdx = 0;\n    }\n    saveState() {\n        return {\n            idx: this.idx,\n            input: this.input,\n            groupIdx: this.groupIdx,\n        };\n    }\n    restoreState(newState) {\n        this.idx = newState.idx;\n        this.input = newState.input;\n        this.groupIdx = newState.groupIdx;\n    }\n    pattern(input) {\n        // parser state\n        this.idx = 0;\n        this.input = input;\n        this.groupIdx = 0;\n        this.consumeChar(\"/\");\n        const value = this.disjunction();\n        this.consumeChar(\"/\");\n        const flags = {\n            type: \"Flags\",\n            loc: { begin: this.idx, end: input.length },\n            global: false,\n            ignoreCase: false,\n            multiLine: false,\n            unicode: false,\n            sticky: false,\n        };\n        while (this.isRegExpFlag()) {\n            switch (this.popChar()) {\n                case \"g\":\n                    addFlag(flags, \"global\");\n                    break;\n                case \"i\":\n                    addFlag(flags, \"ignoreCase\");\n                    break;\n                case \"m\":\n                    addFlag(flags, \"multiLine\");\n                    break;\n                case \"u\":\n                    addFlag(flags, \"unicode\");\n                    break;\n                case \"y\":\n                    addFlag(flags, \"sticky\");\n                    break;\n            }\n        }\n        if (this.idx !== this.input.length) {\n            throw Error(\"Redundant input: \" + this.input.substring(this.idx));\n        }\n        return {\n            type: \"Pattern\",\n            flags: flags,\n            value: value,\n            loc: this.loc(0),\n        };\n    }\n    disjunction() {\n        const alts = [];\n        const begin = this.idx;\n        alts.push(this.alternative());\n        while (this.peekChar() === \"|\") {\n            this.consumeChar(\"|\");\n            alts.push(this.alternative());\n        }\n        return { type: \"Disjunction\", value: alts, loc: this.loc(begin) };\n    }\n    alternative() {\n        const terms = [];\n        const begin = this.idx;\n        while (this.isTerm()) {\n            terms.push(this.term());\n        }\n        return { type: \"Alternative\", value: terms, loc: this.loc(begin) };\n    }\n    term() {\n        if (this.isAssertion()) {\n            return this.assertion();\n        }\n        else {\n            return this.atom();\n        }\n    }\n    assertion() {\n        const begin = this.idx;\n        switch (this.popChar()) {\n            case \"^\":\n                return {\n                    type: \"StartAnchor\",\n                    loc: this.loc(begin),\n                };\n            case \"$\":\n                return { type: \"EndAnchor\", loc: this.loc(begin) };\n            // '\\b' or '\\B'\n            case \"\\\\\":\n                switch (this.popChar()) {\n                    case \"b\":\n                        return {\n                            type: \"WordBoundary\",\n                            loc: this.loc(begin),\n                        };\n                    case \"B\":\n                        return {\n                            type: \"NonWordBoundary\",\n                            loc: this.loc(begin),\n                        };\n                }\n                /* c8 ignore next */\n                throw Error(\"Invalid Assertion Escape\");\n            // '(?=' or '(?!'\n            case \"(\":\n                this.consumeChar(\"?\");\n                let type;\n                switch (this.popChar()) {\n                    case \"=\":\n                        type = \"Lookahead\";\n                        break;\n                    case \"!\":\n                        type = \"NegativeLookahead\";\n                        break;\n                    case \"<\": {\n                        switch (this.popChar()) {\n                            case \"=\":\n                                type = \"Lookbehind\";\n                                break;\n                            case \"!\":\n                                type = \"NegativeLookbehind\";\n                        }\n                        break;\n                    }\n                }\n                ASSERT_EXISTS(type);\n                const disjunction = this.disjunction();\n                this.consumeChar(\")\");\n                return {\n                    type: type,\n                    value: disjunction,\n                    loc: this.loc(begin),\n                };\n        }\n        // istanbul ignore next\n        return ASSERT_NEVER_REACH_HERE();\n    }\n    quantifier(isBacktracking = false) {\n        let range = undefined;\n        const begin = this.idx;\n        switch (this.popChar()) {\n            case \"*\":\n                range = {\n                    atLeast: 0,\n                    atMost: Infinity,\n                };\n                break;\n            case \"+\":\n                range = {\n                    atLeast: 1,\n                    atMost: Infinity,\n                };\n                break;\n            case \"?\":\n                range = {\n                    atLeast: 0,\n                    atMost: 1,\n                };\n                break;\n            case \"{\":\n                const atLeast = this.integerIncludingZero();\n                switch (this.popChar()) {\n                    case \"}\":\n                        range = {\n                            atLeast: atLeast,\n                            atMost: atLeast,\n                        };\n                        break;\n                    case \",\":\n                        let atMost;\n                        if (this.isDigit()) {\n                            atMost = this.integerIncludingZero();\n                            range = {\n                                atLeast: atLeast,\n                                atMost: atMost,\n                            };\n                        }\n                        else {\n                            range = {\n                                atLeast: atLeast,\n                                atMost: Infinity,\n                            };\n                        }\n                        this.consumeChar(\"}\");\n                        break;\n                }\n                // throwing exceptions from \"ASSERT_EXISTS\" during backtracking\n                // causes severe performance degradations\n                if (isBacktracking === true && range === undefined) {\n                    return undefined;\n                }\n                ASSERT_EXISTS(range);\n                break;\n        }\n        // throwing exceptions from \"ASSERT_EXISTS\" during backtracking\n        // causes severe performance degradations\n        if (isBacktracking === true && range === undefined) {\n            return undefined;\n        }\n        // istanbul ignore else\n        if (ASSERT_EXISTS(range)) {\n            if (this.peekChar(0) === \"?\") {\n                this.consumeChar(\"?\");\n                range.greedy = false;\n            }\n            else {\n                range.greedy = true;\n            }\n            range.type = \"Quantifier\";\n            range.loc = this.loc(begin);\n            return range;\n        }\n    }\n    atom() {\n        let atom;\n        const begin = this.idx;\n        switch (this.peekChar()) {\n            case \".\":\n                atom = this.dotAll();\n                break;\n            case \"\\\\\":\n                atom = this.atomEscape();\n                break;\n            case \"[\":\n                atom = this.characterClass();\n                break;\n            case \"(\":\n                atom = this.group();\n                break;\n        }\n        if (atom === undefined && this.isPatternCharacter()) {\n            atom = this.patternCharacter();\n        }\n        // istanbul ignore else\n        if (ASSERT_EXISTS(atom)) {\n            atom.loc = this.loc(begin);\n            if (this.isQuantifier()) {\n                atom.quantifier = this.quantifier();\n            }\n            return atom;\n        }\n        // istanbul ignore next\n        return ASSERT_NEVER_REACH_HERE();\n    }\n    dotAll() {\n        this.consumeChar(\".\");\n        return {\n            type: \"Set\",\n            complement: true,\n            value: [cc(\"\\n\"), cc(\"\\r\"), cc(\"\\u2028\"), cc(\"\\u2029\")],\n        };\n    }\n    atomEscape() {\n        this.consumeChar(\"\\\\\");\n        switch (this.peekChar()) {\n            case \"1\":\n            case \"2\":\n            case \"3\":\n            case \"4\":\n            case \"5\":\n            case \"6\":\n            case \"7\":\n            case \"8\":\n            case \"9\":\n                return this.decimalEscapeAtom();\n            case \"d\":\n            case \"D\":\n            case \"s\":\n            case \"S\":\n            case \"w\":\n            case \"W\":\n                return this.characterClassEscape();\n            case \"f\":\n            case \"n\":\n            case \"r\":\n            case \"t\":\n            case \"v\":\n                return this.controlEscapeAtom();\n            case \"c\":\n                return this.controlLetterEscapeAtom();\n            case \"0\":\n                return this.nulCharacterAtom();\n            case \"x\":\n                return this.hexEscapeSequenceAtom();\n            case \"u\":\n                return this.regExpUnicodeEscapeSequenceAtom();\n            default:\n                return this.identityEscapeAtom();\n        }\n    }\n    decimalEscapeAtom() {\n        const value = this.positiveInteger();\n        return { type: \"GroupBackReference\", value: value };\n    }\n    characterClassEscape() {\n        let set;\n        let complement = false;\n        switch (this.popChar()) {\n            case \"d\":\n                set = digitsCharCodes;\n                break;\n            case \"D\":\n                set = digitsCharCodes;\n                complement = true;\n                break;\n            case \"s\":\n                set = whitespaceCodes;\n                break;\n            case \"S\":\n                set = whitespaceCodes;\n                complement = true;\n                break;\n            case \"w\":\n                set = wordCharCodes;\n                break;\n            case \"W\":\n                set = wordCharCodes;\n                complement = true;\n                break;\n        }\n        // istanbul ignore else\n        if (ASSERT_EXISTS(set)) {\n            return { type: \"Set\", value: set, complement: complement };\n        }\n        // istanbul ignore next\n        return ASSERT_NEVER_REACH_HERE();\n    }\n    controlEscapeAtom() {\n        let escapeCode;\n        switch (this.popChar()) {\n            case \"f\":\n                escapeCode = cc(\"\\f\");\n                break;\n            case \"n\":\n                escapeCode = cc(\"\\n\");\n                break;\n            case \"r\":\n                escapeCode = cc(\"\\r\");\n                break;\n            case \"t\":\n                escapeCode = cc(\"\\t\");\n                break;\n            case \"v\":\n                escapeCode = cc(\"\\v\");\n                break;\n        }\n        // istanbul ignore else\n        if (ASSERT_EXISTS(escapeCode)) {\n            return { type: \"Character\", value: escapeCode };\n        }\n        // istanbul ignore next\n        return ASSERT_NEVER_REACH_HERE();\n    }\n    controlLetterEscapeAtom() {\n        this.consumeChar(\"c\");\n        const letter = this.popChar();\n        if (/[a-zA-Z]/.test(letter) === false) {\n            throw Error(\"Invalid \");\n        }\n        const letterCode = letter.toUpperCase().charCodeAt(0) - 64;\n        return { type: \"Character\", value: letterCode };\n    }\n    nulCharacterAtom() {\n        // TODO implement '[lookahead ∉ DecimalDigit]'\n        // TODO: for the deprecated octal escape sequence\n        this.consumeChar(\"0\");\n        return { type: \"Character\", value: cc(\"\\0\") };\n    }\n    hexEscapeSequenceAtom() {\n        this.consumeChar(\"x\");\n        return this.parseHexDigits(2);\n    }\n    regExpUnicodeEscapeSequenceAtom() {\n        this.consumeChar(\"u\");\n        return this.parseHexDigits(4);\n    }\n    identityEscapeAtom() {\n        // TODO: implement \"SourceCharacter but not UnicodeIDContinue\"\n        // // http://unicode.org/reports/tr31/#Specific_Character_Adjustments\n        const escapedChar = this.popChar();\n        return { type: \"Character\", value: cc(escapedChar) };\n    }\n    classPatternCharacterAtom() {\n        switch (this.peekChar()) {\n            // istanbul ignore next\n            case \"\\n\":\n            // istanbul ignore next\n            case \"\\r\":\n            // istanbul ignore next\n            case \"\\u2028\":\n            // istanbul ignore next\n            case \"\\u2029\":\n            // istanbul ignore next\n            case \"\\\\\":\n            // istanbul ignore next\n            case \"]\":\n                throw Error(\"TBD\");\n            default:\n                const nextChar = this.popChar();\n                return { type: \"Character\", value: cc(nextChar) };\n        }\n    }\n    characterClass() {\n        const set = [];\n        let complement = false;\n        this.consumeChar(\"[\");\n        if (this.peekChar(0) === \"^\") {\n            this.consumeChar(\"^\");\n            complement = true;\n        }\n        while (this.isClassAtom()) {\n            const from = this.classAtom();\n            const isFromSingleChar = from.type === \"Character\";\n            if (isCharacter(from) && this.isRangeDash()) {\n                this.consumeChar(\"-\");\n                const to = this.classAtom();\n                const isToSingleChar = to.type === \"Character\";\n                // a range can only be used when both sides are single characters\n                if (isCharacter(to)) {\n                    if (to.value < from.value) {\n                        throw Error(\"Range out of order in character class\");\n                    }\n                    set.push({ from: from.value, to: to.value });\n                }\n                else {\n                    // literal dash\n                    insertToSet(from.value, set);\n                    set.push(cc(\"-\"));\n                    insertToSet(to.value, set);\n                }\n            }\n            else {\n                insertToSet(from.value, set);\n            }\n        }\n        this.consumeChar(\"]\");\n        return { type: \"Set\", complement: complement, value: set };\n    }\n    classAtom() {\n        switch (this.peekChar()) {\n            // istanbul ignore next\n            case \"]\":\n            // istanbul ignore next\n            case \"\\n\":\n            // istanbul ignore next\n            case \"\\r\":\n            // istanbul ignore next\n            case \"\\u2028\":\n            // istanbul ignore next\n            case \"\\u2029\":\n                throw Error(\"TBD\");\n            case \"\\\\\":\n                return this.classEscape();\n            default:\n                return this.classPatternCharacterAtom();\n        }\n    }\n    classEscape() {\n        this.consumeChar(\"\\\\\");\n        switch (this.peekChar()) {\n            // Matches a backspace.\n            // (Not to be confused with \\b word boundary outside characterClass)\n            case \"b\":\n                this.consumeChar(\"b\");\n                return { type: \"Character\", value: cc(\"\\u0008\") };\n            case \"d\":\n            case \"D\":\n            case \"s\":\n            case \"S\":\n            case \"w\":\n            case \"W\":\n                return this.characterClassEscape();\n            case \"f\":\n            case \"n\":\n            case \"r\":\n            case \"t\":\n            case \"v\":\n                return this.controlEscapeAtom();\n            case \"c\":\n                return this.controlLetterEscapeAtom();\n            case \"0\":\n                return this.nulCharacterAtom();\n            case \"x\":\n                return this.hexEscapeSequenceAtom();\n            case \"u\":\n                return this.regExpUnicodeEscapeSequenceAtom();\n            default:\n                return this.identityEscapeAtom();\n        }\n    }\n    group() {\n        let capturing = true;\n        this.consumeChar(\"(\");\n        switch (this.peekChar(0)) {\n            case \"?\":\n                this.consumeChar(\"?\");\n                this.consumeChar(\":\");\n                capturing = false;\n                break;\n            default:\n                this.groupIdx++;\n                break;\n        }\n        const value = this.disjunction();\n        this.consumeChar(\")\");\n        const groupAst = {\n            type: \"Group\",\n            capturing: capturing,\n            value: value,\n        };\n        if (capturing) {\n            groupAst[\"idx\"] = this.groupIdx;\n        }\n        return groupAst;\n    }\n    positiveInteger() {\n        let number = this.popChar();\n        // istanbul ignore next - can't ever get here due to previous lookahead checks\n        // still implementing this error checking in case this ever changes.\n        if (decimalPatternNoZero.test(number) === false) {\n            throw Error(\"Expecting a positive integer\");\n        }\n        while (decimalPattern.test(this.peekChar(0))) {\n            number += this.popChar();\n        }\n        return parseInt(number, 10);\n    }\n    integerIncludingZero() {\n        let number = this.popChar();\n        if (decimalPattern.test(number) === false) {\n            throw Error(\"Expecting an integer\");\n        }\n        while (decimalPattern.test(this.peekChar(0))) {\n            number += this.popChar();\n        }\n        return parseInt(number, 10);\n    }\n    patternCharacter() {\n        const nextChar = this.popChar();\n        switch (nextChar) {\n            // istanbul ignore next\n            case \"\\n\":\n            // istanbul ignore next\n            case \"\\r\":\n            // istanbul ignore next\n            case \"\\u2028\":\n            // istanbul ignore next\n            case \"\\u2029\":\n            // istanbul ignore next\n            case \"^\":\n            // istanbul ignore next\n            case \"$\":\n            // istanbul ignore next\n            case \"\\\\\":\n            // istanbul ignore next\n            case \".\":\n            // istanbul ignore next\n            case \"*\":\n            // istanbul ignore next\n            case \"+\":\n            // istanbul ignore next\n            case \"?\":\n            // istanbul ignore next\n            case \"(\":\n            // istanbul ignore next\n            case \")\":\n            // istanbul ignore next\n            case \"[\":\n            // istanbul ignore next\n            case \"|\":\n                // istanbul ignore next\n                throw Error(\"TBD\");\n            default:\n                return { type: \"Character\", value: cc(nextChar) };\n        }\n    }\n    isRegExpFlag() {\n        switch (this.peekChar(0)) {\n            case \"g\":\n            case \"i\":\n            case \"m\":\n            case \"u\":\n            case \"y\":\n                return true;\n            default:\n                return false;\n        }\n    }\n    isRangeDash() {\n        return this.peekChar() === \"-\" && this.isClassAtom(1);\n    }\n    isDigit() {\n        return decimalPattern.test(this.peekChar(0));\n    }\n    isClassAtom(howMuch = 0) {\n        switch (this.peekChar(howMuch)) {\n            case \"]\":\n            case \"\\n\":\n            case \"\\r\":\n            case \"\\u2028\":\n            case \"\\u2029\":\n                return false;\n            default:\n                return true;\n        }\n    }\n    isTerm() {\n        return this.isAtom() || this.isAssertion();\n    }\n    isAtom() {\n        if (this.isPatternCharacter()) {\n            return true;\n        }\n        switch (this.peekChar(0)) {\n            case \".\":\n            case \"\\\\\": // atomEscape\n            case \"[\": // characterClass\n            // TODO: isAtom must be called before isAssertion - disambiguate\n            case \"(\": // group\n                return true;\n            default:\n                return false;\n        }\n    }\n    isAssertion() {\n        switch (this.peekChar(0)) {\n            case \"^\":\n            case \"$\":\n                return true;\n            // '\\b' or '\\B'\n            case \"\\\\\":\n                switch (this.peekChar(1)) {\n                    case \"b\":\n                    case \"B\":\n                        return true;\n                    default:\n                        return false;\n                }\n            // '(?=' or '(?!' or `(?<=` or `(?<!`\n            case \"(\":\n                return (this.peekChar(1) === \"?\" &&\n                    (this.peekChar(2) === \"=\" ||\n                        this.peekChar(2) === \"!\" ||\n                        (this.peekChar(2) === \"<\" &&\n                            (this.peekChar(3) === \"=\" || this.peekChar(3) === \"!\"))));\n            default:\n                return false;\n        }\n    }\n    isQuantifier() {\n        const prevState = this.saveState();\n        try {\n            return this.quantifier(true) !== undefined;\n        }\n        catch (e) {\n            return false;\n        }\n        finally {\n            this.restoreState(prevState);\n        }\n    }\n    isPatternCharacter() {\n        switch (this.peekChar()) {\n            case \"^\":\n            case \"$\":\n            case \"\\\\\":\n            case \".\":\n            case \"*\":\n            case \"+\":\n            case \"?\":\n            case \"(\":\n            case \")\":\n            case \"[\":\n            case \"|\":\n            case \"/\":\n            case \"\\n\":\n            case \"\\r\":\n            case \"\\u2028\":\n            case \"\\u2029\":\n                return false;\n            default:\n                return true;\n        }\n    }\n    parseHexDigits(howMany) {\n        let hexString = \"\";\n        for (let i = 0; i < howMany; i++) {\n            const hexChar = this.popChar();\n            if (hexDigitPattern.test(hexChar) === false) {\n                throw Error(\"Expecting a HexDecimal digits\");\n            }\n            hexString += hexChar;\n        }\n        const charCode = parseInt(hexString, 16);\n        return { type: \"Character\", value: charCode };\n    }\n    peekChar(howMuch = 0) {\n        return this.input[this.idx + howMuch];\n    }\n    popChar() {\n        const nextChar = this.peekChar(0);\n        this.consumeChar(undefined);\n        return nextChar;\n    }\n    consumeChar(char) {\n        if (char !== undefined && this.input[this.idx] !== char) {\n            throw Error(\"Expected: '\" +\n                char +\n                \"' but found: '\" +\n                this.input[this.idx] +\n                \"' at offset: \" +\n                this.idx);\n        }\n        if (this.idx >= this.input.length) {\n            throw Error(\"Unexpected end of input\");\n        }\n        this.idx++;\n    }\n    loc(begin) {\n        return { begin: begin, end: this.idx };\n    }\n}\n//# sourceMappingURL=regexp-parser.js.map"],"x_google_ignoreList":[0],"mappings":"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"}