{"version":3,"file":"index-DSVZPbzW.cjs","sources":["../node_modules/.pnpm/pcre-to-regexp@1.1.0/node_modules/pcre-to-regexp/dist/index.js"],"sourcesContent":["\"use strict\";\n/**\n * Returns a JavaScript RegExp instance from the given PCRE-compatible string.\n * Flags may be passed in after the final delimiter in the `format` string.\n *\n * An empty array may be passsed in as the second argument, which will be\n * populated with the \"named capture group\" names as Strings in the Array,\n * once the RegExp has been returned.\n *\n * @param {String} pattern - PCRE regexp string to compile to a JS RegExp\n * @param {Array} [namedCaptures] - optional empty array, which will be populated with the named captures extracted from the PCRE regexp\n * @return {RegExp} returns a JavaScript RegExp instance from the given `pattern` and optionally `flags`\n * @public\n */\nfunction createPCRE(pattern, namedCaptures) {\n    pattern = String(pattern || '').trim();\n    let originalPattern = pattern;\n    let delim;\n    let flags = '';\n    // A delimiter can be any non-alphanumeric, non-backslash,\n    // non-whitespace character.\n    let hasDelim = /^[^a-zA-Z\\\\\\s]/.test(pattern);\n    if (hasDelim) {\n        delim = pattern[0];\n        let lastDelimIndex = pattern.lastIndexOf(delim);\n        // pull out the flags in the pattern\n        flags += pattern.substring(lastDelimIndex + 1);\n        // strip the delims from the pattern\n        pattern = pattern.substring(1, lastDelimIndex);\n    }\n    // populate namedCaptures array and removed named captures from the `pattern`\n    let numGroups = 0;\n    pattern = replaceCaptureGroups(pattern, (group) => {\n        if (/^\\(\\?[P<']/.test(group)) {\n            // PCRE-style \"named capture\"\n            // It is possible to name a subpattern using the syntax (?P<name>pattern).\n            // This subpattern will then be indexed in the matches array by its normal\n            // numeric position and also by name. PHP 5.2.2 introduced two alternative\n            // syntaxes (?<name>pattern) and (?'name'pattern).\n            let match = /^\\(\\?P?[<']([^>']+)[>']/.exec(group);\n            if (!match) {\n                throw new Error(`Failed to extract named captures from ${JSON.stringify(group)}`);\n            }\n            let capture = group.substring(match[0].length, group.length - 1);\n            if (namedCaptures) {\n                namedCaptures[numGroups] = match[1];\n            }\n            numGroups++;\n            return `(${capture})`;\n        }\n        if (group.substring(0, 3) === '(?:') {\n            // non-capture group, leave untouched\n            return group;\n        }\n        // regular capture, leave untouched\n        numGroups++;\n        return group;\n    });\n    // replace \"character classes\" with their raw RegExp equivalent\n    pattern = pattern.replace(/\\[:([^:]+):\\]/g, (characterClass, name) => {\n        return createPCRE.characterClasses[name] || characterClass;\n    });\n    // TODO: convert PCRE-only flags to JS\n    // TODO: handle lots more stuff....\n    // http://www.php.net/manual/en/reference.pcre.pattern.syntax.php\n    return new createPCRE.PCRE(pattern, flags, originalPattern, flags, delim);\n}\n/**\n * Invokes `fn` for each \"capture group\" encountered in the PCRE `pattern`,\n * and inserts the returned value into the pattern instead of the capture\n * group itself.\n *\n * @private\n */\nfunction replaceCaptureGroups(pattern, fn) {\n    let start = 0;\n    let depth = 0;\n    let escaped = false;\n    for (let i = 0; i < pattern.length; i++) {\n        let cur = pattern[i];\n        if (escaped) {\n            // skip this letter, it's been escaped\n            escaped = false;\n            continue;\n        }\n        switch (cur) {\n            case '(':\n                // we're only interested in groups when the depth reaches 0\n                if (depth === 0) {\n                    start = i;\n                }\n                depth++;\n                break;\n            case ')':\n                if (depth > 0) {\n                    depth--;\n                    // we're only interested in groups when the depth reaches 0\n                    if (depth === 0) {\n                        let end = i + 1;\n                        let l = start === 0 ? '' : pattern.substring(0, start);\n                        let r = pattern.substring(end);\n                        let v = String(fn(pattern.substring(start, end)));\n                        pattern = l + v + r;\n                        i = start;\n                    }\n                }\n                break;\n            case '\\\\':\n                escaped = true;\n                break;\n            default:\n                // skip\n                break;\n        }\n    }\n    return pattern;\n}\n(function (createPCRE) {\n    class PCRE extends RegExp {\n        constructor(pattern, flags, pcrePattern, pcreFlags, delimiter) {\n            super(pattern, flags);\n            this.pcrePattern = pcrePattern;\n            this.pcreFlags = pcreFlags;\n            this.delimiter = delimiter;\n        }\n    }\n    createPCRE.PCRE = PCRE;\n    /**\n     * Mapping of \"character class\" names to their JS RegExp equivalent.\n     * So that /[:digit:]/ gets converted into /\\d/, etc.\n     *\n     * See: http://en.wikipedia.org/wiki/Regular_expression#Character_classes\n     */\n    createPCRE.characterClasses = {\n        alnum: '[A-Za-z0-9]',\n        word: '[A-Za-z0-9_]',\n        alpha: '[A-Za-z]',\n        blank: '[ \\\\t]',\n        cntrl: '[\\\\x00-\\\\x1F\\\\x7F]',\n        digit: '\\\\d',\n        graph: '[\\\\x21-\\\\x7E]',\n        lower: '[a-z]',\n        print: '[\\\\x20-\\\\x7E]',\n        punct: '[\\\\]\\\\[!\"#$%&\\'()*+,./:;<=>?@\\\\\\\\^_`{|}~-]',\n        space: '\\\\s',\n        upper: '[A-Z]',\n        xdigit: '[A-Fa-f0-9]'\n    };\n})(createPCRE || (createPCRE = {}));\ncreatePCRE.prototype = createPCRE.PCRE.prototype;\nmodule.exports = createPCRE;\n//# sourceMappingURL=index.js.map"],"names":["createPCRE","pattern","namedCaptures","originalPattern","delim","flags","lastDelimIndex","numGroups","replaceCaptureGroups","group","match","capture","characterClass","name","fn","start","depth","escaped","i","cur","end","l","r","v","PCRE","pcrePattern","pcreFlags","delimiter","dist"],"mappings":"iHAcA,SAASA,EAAWC,EAASC,EAAe,CACxCD,EAAU,OAAOA,GAAW,EAAE,EAAE,KAAI,EACpC,IAAIE,EAAkBF,EAClBG,EACAC,EAAQ,GAIZ,GADe,iBAAiB,KAAKJ,CAAO,EAC9B,CACVG,EAAQH,EAAQ,CAAC,EACjB,IAAIK,EAAiBL,EAAQ,YAAYG,CAAK,EAE9CC,GAASJ,EAAQ,UAAUK,EAAiB,CAAC,EAE7CL,EAAUA,EAAQ,UAAU,EAAGK,CAAc,CAChD,CAED,IAAIC,EAAY,EAChB,OAAAN,EAAUO,EAAqBP,EAAUQ,GAAU,CAC/C,GAAI,aAAa,KAAKA,CAAK,EAAG,CAM1B,IAAIC,EAAQ,0BAA0B,KAAKD,CAAK,EAChD,GAAI,CAACC,EACD,MAAM,IAAI,MAAM,yCAAyC,KAAK,UAAUD,CAAK,CAAC,EAAE,EAEpF,IAAIE,EAAUF,EAAM,UAAUC,EAAM,CAAC,EAAE,OAAQD,EAAM,OAAS,CAAC,EAC/D,OAAIP,IACAA,EAAcK,CAAS,EAAIG,EAAM,CAAC,GAEtCH,IACO,IAAII,CAAO,GACrB,CACD,OAAIF,EAAM,UAAU,EAAG,CAAC,IAAM,OAK9BF,IACOE,CACf,CAAK,EAEDR,EAAUA,EAAQ,QAAQ,iBAAkB,CAACW,EAAgBC,IAClDb,EAAW,iBAAiBa,CAAI,GAAKD,CAC/C,EAIM,IAAIZ,EAAW,KAAKC,EAASI,EAAOF,EAAiBE,EAAOD,CAAK,CAC5E,CAQA,SAASI,EAAqBP,EAASa,EAAI,CACvC,IAAIC,EAAQ,EACRC,EAAQ,EACRC,EAAU,GACd,QAASC,EAAI,EAAGA,EAAIjB,EAAQ,OAAQiB,IAAK,CACrC,IAAIC,EAAMlB,EAAQiB,CAAC,EACnB,GAAID,EAAS,CAETA,EAAU,GACV,QACH,CACD,OAAQE,EAAG,CACP,IAAK,IAEGH,IAAU,IACVD,EAAQG,GAEZF,IACA,MACJ,IAAK,IACD,GAAIA,EAAQ,IACRA,IAEIA,IAAU,GAAG,CACb,IAAII,EAAMF,EAAI,EACVG,EAAIN,IAAU,EAAI,GAAKd,EAAQ,UAAU,EAAGc,CAAK,EACjDO,EAAIrB,EAAQ,UAAUmB,CAAG,EACzBG,EAAI,OAAOT,EAAGb,EAAQ,UAAUc,EAAOK,CAAG,CAAC,CAAC,EAChDnB,EAAUoB,EAAIE,EAAID,EAClBJ,EAAIH,CACP,CAEL,MACJ,IAAK,KACDE,EAAU,GACV,KAIP,CACJ,CACD,OAAOhB,CACX,EACC,SAAUD,EAAY,CACnB,MAAMwB,UAAa,MAAO,CACtB,YAAYvB,EAASI,EAAOoB,EAAaC,EAAWC,EAAW,CAC3D,MAAM1B,EAASI,CAAK,EACpB,KAAK,YAAcoB,EACnB,KAAK,UAAYC,EACjB,KAAK,UAAYC,CACpB,CACJ,CACD3B,EAAW,KAAOwB,EAOlBxB,EAAW,iBAAmB,CAC1B,MAAO,cACP,KAAM,eACN,MAAO,WACP,MAAO,SACP,MAAO,qBACP,MAAO,MACP,MAAO,gBACP,MAAO,QACP,MAAO,gBACP,MAAO,6CACP,MAAO,MACP,MAAO,QACP,OAAQ,aAChB,CACA,GAAGA,IAAeA,EAAa,CAAE,EAAC,EAClCA,EAAW,UAAYA,EAAW,KAAK,cACvC4B,EAAiB5B","x_google_ignoreList":[0]}