{"version":3,"sources":["jsdelivr-header.js","/npm/regexp-to-ast@0.5.0/lib/regexp-to-ast.js"],"names":[],"mappings":"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","file":"/npm/regexp-to-ast@0.5.0/lib/regexp-to-ast.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.37.0.\n * Original file: /npm/regexp-to-ast@0.5.0/lib/regexp-to-ast.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n",";(function(root, factory) {\n    // istanbul ignore next\n    if (typeof define === \"function\" && define.amd) {\n        // istanbul ignore next\n        define([], factory)\n    } else if (typeof module === \"object\" && module.exports) {\n        module.exports = factory()\n    } else {\n        // istanbul ignore next\n        root.regexpToAst = factory()\n    }\n})(\n    typeof self !== \"undefined\"\n        ? // istanbul ignore next\n          self\n        : this,\n    function() {\n        // references\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\n        function RegExpParser() {}\n\n        RegExpParser.prototype.saveState = function() {\n            return {\n                idx: this.idx,\n                input: this.input,\n                groupIdx: this.groupIdx\n            }\n        }\n\n        RegExpParser.prototype.restoreState = function(newState) {\n            this.idx = newState.idx\n            this.input = newState.input\n            this.groupIdx = newState.groupIdx\n        }\n\n        RegExpParser.prototype.pattern = function(input) {\n            // parser state\n            this.idx = 0\n            this.input = input\n            this.groupIdx = 0\n\n            this.consumeChar(\"/\")\n            var value = this.disjunction()\n            this.consumeChar(\"/\")\n\n            var 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\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\n            if (this.idx !== this.input.length) {\n                throw Error(\n                    \"Redundant input: \" + this.input.substring(this.idx)\n                )\n            }\n            return {\n                type: \"Pattern\",\n                flags: flags,\n                value: value,\n                loc: this.loc(0)\n            }\n        }\n\n        RegExpParser.prototype.disjunction = function() {\n            var alts = []\n            var begin = this.idx\n\n            alts.push(this.alternative())\n\n            while (this.peekChar() === \"|\") {\n                this.consumeChar(\"|\")\n                alts.push(this.alternative())\n            }\n\n            return { type: \"Disjunction\", value: alts, loc: this.loc(begin) }\n        }\n\n        RegExpParser.prototype.alternative = function() {\n            var terms = []\n            var begin = this.idx\n\n            while (this.isTerm()) {\n                terms.push(this.term())\n            }\n\n            return { type: \"Alternative\", value: terms, loc: this.loc(begin) }\n        }\n\n        RegExpParser.prototype.term = function() {\n            if (this.isAssertion()) {\n                return this.assertion()\n            } else {\n                return this.atom()\n            }\n        }\n\n        RegExpParser.prototype.assertion = function() {\n            var 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                    // istanbul ignore next\n                    throw Error(\"Invalid Assertion Escape\")\n                // '(?=' or '(?!'\n                case \"(\":\n                    this.consumeChar(\"?\")\n\n                    var type\n                    switch (this.popChar()) {\n                        case \"=\":\n                            type = \"Lookahead\"\n                            break\n                        case \"!\":\n                            type = \"NegativeLookahead\"\n                            break\n                    }\n                    ASSERT_EXISTS(type)\n\n                    var disjunction = this.disjunction()\n\n                    this.consumeChar(\")\")\n\n                    return {\n                        type: type,\n                        value: disjunction,\n                        loc: this.loc(begin)\n                    }\n            }\n            // istanbul ignore next\n            ASSERT_NEVER_REACH_HERE()\n        }\n\n        RegExpParser.prototype.quantifier = function(isBacktracking) {\n            var range\n            var 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                    var atLeast = this.integerIncludingZero()\n                    switch (this.popChar()) {\n                        case \"}\":\n                            range = {\n                                atLeast: atLeast,\n                                atMost: atLeast\n                            }\n                            break\n                        case \",\":\n                            var atMost\n                            if (this.isDigit()) {\n                                atMost = this.integerIncludingZero()\n                                range = {\n                                    atLeast: atLeast,\n                                    atMost: atMost\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\n            // throwing exceptions from \"ASSERT_EXISTS\" during backtracking\n            // causes severe performance degradations\n            if (isBacktracking === true && range === undefined) {\n                return undefined\n            }\n\n            ASSERT_EXISTS(range)\n\n            if (this.peekChar(0) === \"?\") {\n                this.consumeChar(\"?\")\n                range.greedy = false\n            } else {\n                range.greedy = true\n            }\n\n            range.type = \"Quantifier\"\n            range.loc = this.loc(begin)\n            return range\n        }\n\n        RegExpParser.prototype.atom = function() {\n            var atom\n            var 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\n            if (atom === undefined && this.isPatternCharacter()) {\n                atom = this.patternCharacter()\n            }\n\n            ASSERT_EXISTS(atom)\n\n            atom.loc = this.loc(begin)\n\n            if (this.isQuantifier()) {\n                atom.quantifier = this.quantifier()\n            }\n\n            return atom\n        }\n\n        RegExpParser.prototype.dotAll = function() {\n            this.consumeChar(\".\")\n            return {\n                type: \"Set\",\n                complement: true,\n                value: [cc(\"\\n\"), cc(\"\\r\"), cc(\"\\u2028\"), cc(\"\\u2029\")]\n            }\n        }\n\n        RegExpParser.prototype.atomEscape = function() {\n            this.consumeChar(\"\\\\\")\n\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\n        RegExpParser.prototype.decimalEscapeAtom = function() {\n            var value = this.positiveInteger()\n\n            return { type: \"GroupBackReference\", value: value }\n        }\n\n        RegExpParser.prototype.characterClassEscape = function() {\n            var set\n            var 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\n            ASSERT_EXISTS(set)\n\n            return { type: \"Set\", value: set, complement: complement }\n        }\n\n        RegExpParser.prototype.controlEscapeAtom = function() {\n            var 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            ASSERT_EXISTS(escapeCode)\n\n            return { type: \"Character\", value: escapeCode }\n        }\n\n        RegExpParser.prototype.controlLetterEscapeAtom = function() {\n            this.consumeChar(\"c\")\n            var letter = this.popChar()\n            if (/[a-zA-Z]/.test(letter) === false) {\n                throw Error(\"Invalid \")\n            }\n\n            var letterCode = letter.toUpperCase().charCodeAt(0) - 64\n            return { type: \"Character\", value: letterCode }\n        }\n\n        RegExpParser.prototype.nulCharacterAtom = function() {\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\n        RegExpParser.prototype.hexEscapeSequenceAtom = function() {\n            this.consumeChar(\"x\")\n            return this.parseHexDigits(2)\n        }\n\n        RegExpParser.prototype.regExpUnicodeEscapeSequenceAtom = function() {\n            this.consumeChar(\"u\")\n            return this.parseHexDigits(4)\n        }\n\n        RegExpParser.prototype.identityEscapeAtom = function() {\n            // TODO: implement \"SourceCharacter but not UnicodeIDContinue\"\n            // // http://unicode.org/reports/tr31/#Specific_Character_Adjustments\n            var escapedChar = this.popChar()\n            return { type: \"Character\", value: cc(escapedChar) }\n        }\n\n        RegExpParser.prototype.classPatternCharacterAtom = function() {\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                    var nextChar = this.popChar()\n                    return { type: \"Character\", value: cc(nextChar) }\n            }\n        }\n\n        RegExpParser.prototype.characterClass = function() {\n            var set = []\n            var complement = false\n            this.consumeChar(\"[\")\n            if (this.peekChar(0) === \"^\") {\n                this.consumeChar(\"^\")\n                complement = true\n            }\n\n            while (this.isClassAtom()) {\n                var from = this.classAtom()\n                var isFromSingleChar = from.type === \"Character\"\n                if (isFromSingleChar && this.isRangeDash()) {\n                    this.consumeChar(\"-\")\n                    var to = this.classAtom()\n                    var isToSingleChar = to.type === \"Character\"\n\n                    // a range can only be used when both sides are single characters\n                    if (isToSingleChar) {\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                    } else {\n                        // literal dash\n                        insertToSet(from.value, set)\n                        set.push(cc(\"-\"))\n                        insertToSet(to.value, set)\n                    }\n                } else {\n                    insertToSet(from.value, set)\n                }\n            }\n\n            this.consumeChar(\"]\")\n\n            return { type: \"Set\", complement: complement, value: set }\n        }\n\n        RegExpParser.prototype.classAtom = function() {\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\n        RegExpParser.prototype.classEscape = function() {\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\n        RegExpParser.prototype.group = function() {\n            var 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            var value = this.disjunction()\n            this.consumeChar(\")\")\n\n            var groupAst = {\n                type: \"Group\",\n                capturing: capturing,\n                value: value\n            }\n\n            if (capturing) {\n                groupAst.idx = this.groupIdx\n            }\n\n            return groupAst\n        }\n\n        RegExpParser.prototype.positiveInteger = function() {\n            var number = this.popChar()\n\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\n            while (decimalPattern.test(this.peekChar(0))) {\n                number += this.popChar()\n            }\n\n            return parseInt(number, 10)\n        }\n\n        RegExpParser.prototype.integerIncludingZero = function() {\n            var number = this.popChar()\n            if (decimalPattern.test(number) === false) {\n                throw Error(\"Expecting an integer\")\n            }\n\n            while (decimalPattern.test(this.peekChar(0))) {\n                number += this.popChar()\n            }\n\n            return parseInt(number, 10)\n        }\n\n        RegExpParser.prototype.patternCharacter = function() {\n            var 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        RegExpParser.prototype.isRegExpFlag = function() {\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\n        RegExpParser.prototype.isRangeDash = function() {\n            return this.peekChar() === \"-\" && this.isClassAtom(1)\n        }\n\n        RegExpParser.prototype.isDigit = function() {\n            return decimalPattern.test(this.peekChar(0))\n        }\n\n        RegExpParser.prototype.isClassAtom = function(howMuch) {\n            if (howMuch === undefined) {\n                howMuch = 0\n            }\n\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\n        RegExpParser.prototype.isTerm = function() {\n            return this.isAtom() || this.isAssertion()\n        }\n\n        RegExpParser.prototype.isAtom = function() {\n            if (this.isPatternCharacter()) {\n                return true\n            }\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\n        RegExpParser.prototype.isAssertion = function() {\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 '(?!'\n                case \"(\":\n                    return (\n                        this.peekChar(1) === \"?\" &&\n                        (this.peekChar(2) === \"=\" || this.peekChar(2) === \"!\")\n                    )\n                default:\n                    return false\n            }\n        }\n\n        RegExpParser.prototype.isQuantifier = function() {\n            var prevState = this.saveState()\n            try {\n                return this.quantifier(true) !== undefined\n            } catch (e) {\n                return false\n            } finally {\n                this.restoreState(prevState)\n            }\n        }\n\n        RegExpParser.prototype.isPatternCharacter = function() {\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\n        RegExpParser.prototype.parseHexDigits = function(howMany) {\n            var hexString = \"\"\n            for (var i = 0; i < howMany; i++) {\n                var hexChar = this.popChar()\n                if (hexDigitPattern.test(hexChar) === false) {\n                    throw Error(\"Expecting a HexDecimal digits\")\n                }\n                hexString += hexChar\n            }\n            var charCode = parseInt(hexString, 16)\n            return { type: \"Character\", value: charCode }\n        }\n\n        RegExpParser.prototype.peekChar = function(howMuch) {\n            if (howMuch === undefined) {\n                howMuch = 0\n            }\n            return this.input[this.idx + howMuch]\n        }\n\n        RegExpParser.prototype.popChar = function() {\n            var nextChar = this.peekChar(0)\n            this.consumeChar()\n            return nextChar\n        }\n\n        RegExpParser.prototype.consumeChar = function(char) {\n            if (char !== undefined && this.input[this.idx] !== char) {\n                throw Error(\n                    \"Expected: '\" +\n                        char +\n                        \"' but found: '\" +\n                        this.input[this.idx] +\n                        \"' at offset: \" +\n                        this.idx\n                )\n            }\n\n            if (this.idx >= this.input.length) {\n                throw Error(\"Unexpected end of input\")\n            }\n            this.idx++\n        }\n\n        RegExpParser.prototype.loc = function(begin) {\n            return { begin: begin, end: this.idx }\n        }\n\n        // consts and utilities\n        var hexDigitPattern = /[0-9a-fA-F]/\n        var decimalPattern = /[0-9]/\n        var decimalPatternNoZero = /[1-9]/\n\n        function cc(char) {\n            return char.charCodeAt(0)\n        }\n\n        function insertToSet(item, set) {\n            if (item.length !== undefined) {\n                item.forEach(function(subItem) {\n                    set.push(subItem)\n                })\n            } else {\n                set.push(item)\n            }\n        }\n\n        function addFlag(flagObj, flagKey) {\n            if (flagObj[flagKey] === true) {\n                throw \"duplicate flag \" + flagKey\n            }\n\n            flagObj[flagKey] = true\n        }\n\n        function ASSERT_EXISTS(obj) {\n            // istanbul ignore next\n            if (obj === undefined) {\n                throw Error(\"Internal Error - Should never get here!\")\n            }\n        }\n\n        // istanbul ignore next\n        function ASSERT_NEVER_REACH_HERE() {\n            throw Error(\"Internal Error - Should never get here!\")\n        }\n\n        var i\n        var digitsCharCodes = []\n        for (i = cc(\"0\"); i <= cc(\"9\"); i++) {\n            digitsCharCodes.push(i)\n        }\n\n        var wordCharCodes = [cc(\"_\")].concat(digitsCharCodes)\n        for (i = cc(\"a\"); i <= cc(\"z\"); i++) {\n            wordCharCodes.push(i)\n        }\n\n        for (i = cc(\"A\"); i <= cc(\"Z\"); i++) {\n            wordCharCodes.push(i)\n        }\n\n        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#character-classes\n        var whitespaceCodes = [\n            cc(\" \"),\n            cc(\"\\f\"),\n            cc(\"\\n\"),\n            cc(\"\\r\"),\n            cc(\"\\t\"),\n            cc(\"\\v\"),\n            cc(\"\\t\"),\n            cc(\"\\u00a0\"),\n            cc(\"\\u1680\"),\n            cc(\"\\u2000\"),\n            cc(\"\\u2001\"),\n            cc(\"\\u2002\"),\n            cc(\"\\u2003\"),\n            cc(\"\\u2004\"),\n            cc(\"\\u2005\"),\n            cc(\"\\u2006\"),\n            cc(\"\\u2007\"),\n            cc(\"\\u2008\"),\n            cc(\"\\u2009\"),\n            cc(\"\\u200a\"),\n            cc(\"\\u2028\"),\n            cc(\"\\u2029\"),\n            cc(\"\\u202f\"),\n            cc(\"\\u205f\"),\n            cc(\"\\u3000\"),\n            cc(\"\\ufeff\")\n        ]\n\n        function BaseRegExpVisitor() {}\n\n        BaseRegExpVisitor.prototype.visitChildren = function(node) {\n            for (var key in node) {\n                var child = node[key]\n                /* istanbul ignore else */\n                if (node.hasOwnProperty(key)) {\n                    if (child.type !== undefined) {\n                        this.visit(child)\n                    } else if (Array.isArray(child)) {\n                        child.forEach(function(subChild) {\n                            this.visit(subChild)\n                        }, this)\n                    }\n                }\n            }\n        }\n\n        BaseRegExpVisitor.prototype.visit = function(node) {\n            switch (node.type) {\n                case \"Pattern\":\n                    this.visitPattern(node)\n                    break\n                case \"Flags\":\n                    this.visitFlags(node)\n                    break\n                case \"Disjunction\":\n                    this.visitDisjunction(node)\n                    break\n                case \"Alternative\":\n                    this.visitAlternative(node)\n                    break\n                case \"StartAnchor\":\n                    this.visitStartAnchor(node)\n                    break\n                case \"EndAnchor\":\n                    this.visitEndAnchor(node)\n                    break\n                case \"WordBoundary\":\n                    this.visitWordBoundary(node)\n                    break\n                case \"NonWordBoundary\":\n                    this.visitNonWordBoundary(node)\n                    break\n                case \"Lookahead\":\n                    this.visitLookahead(node)\n                    break\n                case \"NegativeLookahead\":\n                    this.visitNegativeLookahead(node)\n                    break\n                case \"Character\":\n                    this.visitCharacter(node)\n                    break\n                case \"Set\":\n                    this.visitSet(node)\n                    break\n                case \"Group\":\n                    this.visitGroup(node)\n                    break\n                case \"GroupBackReference\":\n                    this.visitGroupBackReference(node)\n                    break\n                case \"Quantifier\":\n                    this.visitQuantifier(node)\n                    break\n            }\n\n            this.visitChildren(node)\n        }\n\n        BaseRegExpVisitor.prototype.visitPattern = function(node) {}\n\n        BaseRegExpVisitor.prototype.visitFlags = function(node) {}\n\n        BaseRegExpVisitor.prototype.visitDisjunction = function(node) {}\n\n        BaseRegExpVisitor.prototype.visitAlternative = function(node) {}\n\n        // Assertion\n        BaseRegExpVisitor.prototype.visitStartAnchor = function(node) {}\n\n        BaseRegExpVisitor.prototype.visitEndAnchor = function(node) {}\n\n        BaseRegExpVisitor.prototype.visitWordBoundary = function(node) {}\n\n        BaseRegExpVisitor.prototype.visitNonWordBoundary = function(node) {}\n\n        BaseRegExpVisitor.prototype.visitLookahead = function(node) {}\n\n        BaseRegExpVisitor.prototype.visitNegativeLookahead = function(node) {}\n\n        // atoms\n        BaseRegExpVisitor.prototype.visitCharacter = function(node) {}\n\n        BaseRegExpVisitor.prototype.visitSet = function(node) {}\n\n        BaseRegExpVisitor.prototype.visitGroup = function(node) {}\n\n        BaseRegExpVisitor.prototype.visitGroupBackReference = function(node) {}\n\n        BaseRegExpVisitor.prototype.visitQuantifier = function(node) {}\n\n        return {\n            RegExpParser: RegExpParser,\n            BaseRegExpVisitor: BaseRegExpVisitor,\n            VERSION: \"0.5.0\"\n        }\n    }\n)\n"]}