@rspack/dev-server 2.0.2 → 2.0.3

package/dist/0~http-proxy-middleware.js

@@ -0,0 +1,3817 @@
+/*! LICENSE: 0~http-proxy-middleware.js.LICENSE.txt */
+import node_http from "node:http";
+import node_https from "node:https";
+import node_http2 from "node:http2";
+import { EventEmitter } from "node:events";
+import "node:net";
+import "node:stream";
+import { URL as external_node_url_URL } from "node:url";
+import { URL as external_url_URL } from "url";
+import "node:zlib";
+import "node:querystring";
+import { __webpack_require__ } from "./465.js";
+import "./0~debug.js";
+import "./465.js";
+__webpack_require__.add({
+    "./node_modules/.pnpm/braces@3.0.3/node_modules/braces/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const stringify = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js");
+        const compile = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/compile.js");
+        const expand = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/expand.js");
+        const parse = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/parse.js");
+        const braces = (input, options = {})=>{
+            let output = [];
+            if (Array.isArray(input)) for (const pattern of input){
+                const result = braces.create(pattern, options);
+                if (Array.isArray(result)) output.push(...result);
+                else output.push(result);
+            }
+            else output = [].concat(braces.create(input, options));
+            if (options && true === options.expand && true === options.nodupes) output = [
+                ...new Set(output)
+            ];
+            return output;
+        };
+        braces.parse = (input, options = {})=>parse(input, options);
+        braces.stringify = (input, options = {})=>{
+            if ('string' == typeof input) return stringify(braces.parse(input, options), options);
+            return stringify(input, options);
+        };
+        braces.compile = (input, options = {})=>{
+            if ('string' == typeof input) input = braces.parse(input, options);
+            return compile(input, options);
+        };
+        braces.expand = (input, options = {})=>{
+            if ('string' == typeof input) input = braces.parse(input, options);
+            let result = expand(input, options);
+            if (true === options.noempty) result = result.filter(Boolean);
+            if (true === options.nodupes) result = [
+                ...new Set(result)
+            ];
+            return result;
+        };
+        braces.create = (input, options = {})=>{
+            if ('' === input || input.length < 3) return [
+                input
+            ];
+            return true !== options.expand ? braces.compile(input, options) : braces.expand(input, options);
+        };
+        module.exports = braces;
+    },
+    "./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/compile.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const fill = __webpack_require__("./node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.js");
+        const utils = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js");
+        const compile = (ast, options = {})=>{
+            const walk = (node, parent = {})=>{
+                const invalidBlock = utils.isInvalidBrace(parent);
+                const invalidNode = true === node.invalid && true === options.escapeInvalid;
+                const invalid = true === invalidBlock || true === invalidNode;
+                const prefix = true === options.escapeInvalid ? '\\' : '';
+                let output = '';
+                if (true === node.isOpen) return prefix + node.value;
+                if (true === node.isClose) {
+                    console.log('node.isClose', prefix, node.value);
+                    return prefix + node.value;
+                }
+                if ('open' === node.type) return invalid ? prefix + node.value : '(';
+                if ('close' === node.type) return invalid ? prefix + node.value : ')';
+                if ('comma' === node.type) return 'comma' === node.prev.type ? '' : invalid ? node.value : '|';
+                if (node.value) return node.value;
+                if (node.nodes && node.ranges > 0) {
+                    const args = utils.reduce(node.nodes);
+                    const range = fill(...args, {
+                        ...options,
+                        wrap: false,
+                        toRegex: true,
+                        strictZeros: true
+                    });
+                    if (0 !== range.length) return args.length > 1 && range.length > 1 ? `(${range})` : range;
+                }
+                if (node.nodes) for (const child of node.nodes)output += walk(child, node);
+                return output;
+            };
+            return walk(ast);
+        };
+        module.exports = compile;
+    },
+    "./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/constants.js" (module) {
+        module.exports = {
+            MAX_LENGTH: 10000,
+            CHAR_0: '0',
+            CHAR_9: '9',
+            CHAR_UPPERCASE_A: 'A',
+            CHAR_LOWERCASE_A: 'a',
+            CHAR_UPPERCASE_Z: 'Z',
+            CHAR_LOWERCASE_Z: 'z',
+            CHAR_LEFT_PARENTHESES: '(',
+            CHAR_RIGHT_PARENTHESES: ')',
+            CHAR_ASTERISK: '*',
+            CHAR_AMPERSAND: '&',
+            CHAR_AT: '@',
+            CHAR_BACKSLASH: '\\',
+            CHAR_BACKTICK: '`',
+            CHAR_CARRIAGE_RETURN: '\r',
+            CHAR_CIRCUMFLEX_ACCENT: '^',
+            CHAR_COLON: ':',
+            CHAR_COMMA: ',',
+            CHAR_DOLLAR: '$',
+            CHAR_DOT: '.',
+            CHAR_DOUBLE_QUOTE: '"',
+            CHAR_EQUAL: '=',
+            CHAR_EXCLAMATION_MARK: '!',
+            CHAR_FORM_FEED: '\f',
+            CHAR_FORWARD_SLASH: '/',
+            CHAR_HASH: '#',
+            CHAR_HYPHEN_MINUS: '-',
+            CHAR_LEFT_ANGLE_BRACKET: '<',
+            CHAR_LEFT_CURLY_BRACE: '{',
+            CHAR_LEFT_SQUARE_BRACKET: '[',
+            CHAR_LINE_FEED: '\n',
+            CHAR_NO_BREAK_SPACE: '\u00A0',
+            CHAR_PERCENT: '%',
+            CHAR_PLUS: '+',
+            CHAR_QUESTION_MARK: '?',
+            CHAR_RIGHT_ANGLE_BRACKET: '>',
+            CHAR_RIGHT_CURLY_BRACE: '}',
+            CHAR_RIGHT_SQUARE_BRACKET: ']',
+            CHAR_SEMICOLON: ';',
+            CHAR_SINGLE_QUOTE: '\'',
+            CHAR_SPACE: ' ',
+            CHAR_TAB: '\t',
+            CHAR_UNDERSCORE: '_',
+            CHAR_VERTICAL_LINE: '|',
+            CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF'
+        };
+    },
+    "./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/expand.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const fill = __webpack_require__("./node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.js");
+        const stringify = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js");
+        const utils = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js");
+        const append = (queue = '', stash = '', enclose = false)=>{
+            const result = [];
+            queue = [].concat(queue);
+            stash = [].concat(stash);
+            if (!stash.length) return queue;
+            if (!queue.length) return enclose ? utils.flatten(stash).map((ele)=>`{${ele}}`) : stash;
+            for (const item of queue)if (Array.isArray(item)) for (const value of item)result.push(append(value, stash, enclose));
+            else for (let ele of stash){
+                if (true === enclose && 'string' == typeof ele) ele = `{${ele}}`;
+                result.push(Array.isArray(ele) ? append(item, ele, enclose) : item + ele);
+            }
+            return utils.flatten(result);
+        };
+        const expand = (ast, options = {})=>{
+            const rangeLimit = void 0 === options.rangeLimit ? 1000 : options.rangeLimit;
+            const walk = (node, parent = {})=>{
+                node.queue = [];
+                let p = parent;
+                let q = parent.queue;
+                while('brace' !== p.type && 'root' !== p.type && p.parent){
+                    p = p.parent;
+                    q = p.queue;
+                }
+                if (node.invalid || node.dollar) return void q.push(append(q.pop(), stringify(node, options)));
+                if ('brace' === node.type && true !== node.invalid && 2 === node.nodes.length) return void q.push(append(q.pop(), [
+                    '{}'
+                ]));
+                if (node.nodes && node.ranges > 0) {
+                    const args = utils.reduce(node.nodes);
+                    if (utils.exceedsLimit(...args, options.step, rangeLimit)) throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
+                    let range = fill(...args, options);
+                    if (0 === range.length) range = stringify(node, options);
+                    q.push(append(q.pop(), range));
+                    node.nodes = [];
+                    return;
+                }
+                const enclose = utils.encloseBrace(node);
+                let queue = node.queue;
+                let block = node;
+                while('brace' !== block.type && 'root' !== block.type && block.parent){
+                    block = block.parent;
+                    queue = block.queue;
+                }
+                for(let i = 0; i < node.nodes.length; i++){
+                    const child = node.nodes[i];
+                    if ('comma' === child.type && 'brace' === node.type) {
+                        if (1 === i) queue.push('');
+                        queue.push('');
+                        continue;
+                    }
+                    if ('close' === child.type) {
+                        q.push(append(q.pop(), queue, enclose));
+                        continue;
+                    }
+                    if (child.value && 'open' !== child.type) {
+                        queue.push(append(queue.pop(), child.value));
+                        continue;
+                    }
+                    if (child.nodes) walk(child, node);
+                }
+                return queue;
+            };
+            return utils.flatten(walk(ast));
+        };
+        module.exports = expand;
+    },
+    "./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/parse.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const stringify = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js");
+        const { MAX_LENGTH, CHAR_BACKSLASH, CHAR_BACKTICK, CHAR_COMMA, CHAR_DOT, CHAR_LEFT_PARENTHESES, CHAR_RIGHT_PARENTHESES, CHAR_LEFT_CURLY_BRACE, CHAR_RIGHT_CURLY_BRACE, CHAR_LEFT_SQUARE_BRACKET, CHAR_RIGHT_SQUARE_BRACKET, CHAR_DOUBLE_QUOTE, CHAR_SINGLE_QUOTE, CHAR_NO_BREAK_SPACE, CHAR_ZERO_WIDTH_NOBREAK_SPACE } = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/constants.js");
+        const parse = (input, options = {})=>{
+            if ('string' != typeof input) throw new TypeError('Expected a string');
+            const opts = options || {};
+            const max = 'number' == typeof opts.maxLength ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+            if (input.length > max) throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
+            const ast = {
+                type: 'root',
+                input,
+                nodes: []
+            };
+            const stack = [
+                ast
+            ];
+            let block = ast;
+            let prev = ast;
+            let brackets = 0;
+            const length = input.length;
+            let index = 0;
+            let depth = 0;
+            let value;
+            const advance = ()=>input[index++];
+            const push = (node)=>{
+                if ('text' === node.type && 'dot' === prev.type) prev.type = 'text';
+                if (prev && 'text' === prev.type && 'text' === node.type) {
+                    prev.value += node.value;
+                    return;
+                }
+                block.nodes.push(node);
+                node.parent = block;
+                node.prev = prev;
+                prev = node;
+                return node;
+            };
+            push({
+                type: 'bos'
+            });
+            while(index < length){
+                block = stack[stack.length - 1];
+                value = advance();
+                if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) continue;
+                if (value === CHAR_BACKSLASH) {
+                    push({
+                        type: 'text',
+                        value: (options.keepEscaping ? value : '') + advance()
+                    });
+                    continue;
+                }
+                if (value === CHAR_RIGHT_SQUARE_BRACKET) {
+                    push({
+                        type: 'text',
+                        value: '\\' + value
+                    });
+                    continue;
+                }
+                if (value === CHAR_LEFT_SQUARE_BRACKET) {
+                    brackets++;
+                    let next;
+                    while(index < length && (next = advance())){
+                        value += next;
+                        if (next === CHAR_LEFT_SQUARE_BRACKET) {
+                            brackets++;
+                            continue;
+                        }
+                        if (next === CHAR_BACKSLASH) {
+                            value += advance();
+                            continue;
+                        }
+                        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+                            brackets--;
+                            if (0 === brackets) break;
+                        }
+                    }
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (value === CHAR_LEFT_PARENTHESES) {
+                    block = push({
+                        type: 'paren',
+                        nodes: []
+                    });
+                    stack.push(block);
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (value === CHAR_RIGHT_PARENTHESES) {
+                    if ('paren' !== block.type) {
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                    block = stack.pop();
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    block = stack[stack.length - 1];
+                    continue;
+                }
+                if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
+                    const open = value;
+                    let next;
+                    if (true !== options.keepQuotes) value = '';
+                    while(index < length && (next = advance())){
+                        if (next === CHAR_BACKSLASH) {
+                            value += next + advance();
+                            continue;
+                        }
+                        if (next === open) {
+                            if (true === options.keepQuotes) value += next;
+                            break;
+                        }
+                        value += next;
+                    }
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (value === CHAR_LEFT_CURLY_BRACE) {
+                    depth++;
+                    const dollar = prev.value && '$' === prev.value.slice(-1) || true === block.dollar;
+                    const brace = {
+                        type: 'brace',
+                        open: true,
+                        close: false,
+                        dollar,
+                        depth,
+                        commas: 0,
+                        ranges: 0,
+                        nodes: []
+                    };
+                    block = push(brace);
+                    stack.push(block);
+                    push({
+                        type: 'open',
+                        value
+                    });
+                    continue;
+                }
+                if (value === CHAR_RIGHT_CURLY_BRACE) {
+                    if ('brace' !== block.type) {
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                    const type = 'close';
+                    block = stack.pop();
+                    block.close = true;
+                    push({
+                        type,
+                        value
+                    });
+                    depth--;
+                    block = stack[stack.length - 1];
+                    continue;
+                }
+                if (value === CHAR_COMMA && depth > 0) {
+                    if (block.ranges > 0) {
+                        block.ranges = 0;
+                        const open = block.nodes.shift();
+                        block.nodes = [
+                            open,
+                            {
+                                type: 'text',
+                                value: stringify(block)
+                            }
+                        ];
+                    }
+                    push({
+                        type: 'comma',
+                        value
+                    });
+                    block.commas++;
+                    continue;
+                }
+                if (value === CHAR_DOT && depth > 0 && 0 === block.commas) {
+                    const siblings = block.nodes;
+                    if (0 === depth || 0 === siblings.length) {
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                    if ('dot' === prev.type) {
+                        block.range = [];
+                        prev.value += value;
+                        prev.type = 'range';
+                        if (3 !== block.nodes.length && 5 !== block.nodes.length) {
+                            block.invalid = true;
+                            block.ranges = 0;
+                            prev.type = 'text';
+                            continue;
+                        }
+                        block.ranges++;
+                        block.args = [];
+                        continue;
+                    }
+                    if ('range' === prev.type) {
+                        siblings.pop();
+                        const before = siblings[siblings.length - 1];
+                        before.value += prev.value + value;
+                        prev = before;
+                        block.ranges--;
+                        continue;
+                    }
+                    push({
+                        type: 'dot',
+                        value
+                    });
+                    continue;
+                }
+                push({
+                    type: 'text',
+                    value
+                });
+            }
+            do {
+                block = stack.pop();
+                if ('root' !== block.type) {
+                    block.nodes.forEach((node)=>{
+                        if (!node.nodes) {
+                            if ('open' === node.type) node.isOpen = true;
+                            if ('close' === node.type) node.isClose = true;
+                            if (!node.nodes) node.type = 'text';
+                            node.invalid = true;
+                        }
+                    });
+                    const parent = stack[stack.length - 1];
+                    const index = parent.nodes.indexOf(block);
+                    parent.nodes.splice(index, 1, ...block.nodes);
+                }
+            }while (stack.length > 0);
+            push({
+                type: 'eos'
+            });
+            return ast;
+        };
+        module.exports = parse;
+    },
+    "./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const utils = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js");
+        module.exports = (ast, options = {})=>{
+            const stringify = (node, parent = {})=>{
+                const invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
+                const invalidNode = true === node.invalid && true === options.escapeInvalid;
+                let output = '';
+                if (node.value) {
+                    if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) return '\\' + node.value;
+                    return node.value;
+                }
+                if (node.value) return node.value;
+                if (node.nodes) for (const child of node.nodes)output += stringify(child);
+                return output;
+            };
+            return stringify(ast);
+        };
+    },
+    "./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js" (__unused_rspack_module, exports) {
+        exports.isInteger = (num)=>{
+            if ('number' == typeof num) return Number.isInteger(num);
+            if ('string' == typeof num && '' !== num.trim()) return Number.isInteger(Number(num));
+            return false;
+        };
+        exports.find = (node, type)=>node.nodes.find((node)=>node.type === type);
+        exports.exceedsLimit = (min, max, step = 1, limit)=>{
+            if (false === limit) return false;
+            if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
+            return (Number(max) - Number(min)) / Number(step) >= limit;
+        };
+        exports.escapeNode = (block, n = 0, type)=>{
+            const node = block.nodes[n];
+            if (!node) return;
+            if (type && node.type === type || 'open' === node.type || 'close' === node.type) {
+                if (true !== node.escaped) {
+                    node.value = '\\' + node.value;
+                    node.escaped = true;
+                }
+            }
+        };
+        exports.encloseBrace = (node)=>{
+            if ('brace' !== node.type) return false;
+            if (node.commas >> 0 + node.ranges === 0) {
+                node.invalid = true;
+                return true;
+            }
+            return false;
+        };
+        exports.isInvalidBrace = (block)=>{
+            if ('brace' !== block.type) return false;
+            if (true === block.invalid || block.dollar) return true;
+            if (block.commas >> 0 + block.ranges === 0) {
+                block.invalid = true;
+                return true;
+            }
+            if (true !== block.open || true !== block.close) {
+                block.invalid = true;
+                return true;
+            }
+            return false;
+        };
+        exports.isOpenOrClose = (node)=>{
+            if ('open' === node.type || 'close' === node.type) return true;
+            return true === node.open || true === node.close;
+        };
+        exports.reduce = (nodes)=>nodes.reduce((acc, node)=>{
+                if ('text' === node.type) acc.push(node.value);
+                if ('range' === node.type) node.type = 'text';
+                return acc;
+            }, []);
+        exports.flatten = (...args)=>{
+            const result = [];
+            const flat = (arr)=>{
+                for(let i = 0; i < arr.length; i++){
+                    const ele = arr[i];
+                    if (Array.isArray(ele)) {
+                        flat(ele);
+                        continue;
+                    }
+                    if (void 0 !== ele) result.push(ele);
+                }
+                return result;
+            };
+            flat(args);
+            return result;
+        };
+    },
+    "./node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        /*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */ const util = __webpack_require__("util");
+        const toRegexRange = __webpack_require__("./node_modules/.pnpm/to-regex-range@5.0.1/node_modules/to-regex-range/index.js");
+        const isObject = (val)=>null !== val && 'object' == typeof val && !Array.isArray(val);
+        const transform = (toNumber)=>(value)=>true === toNumber ? Number(value) : String(value);
+        const isValidValue = (value)=>'number' == typeof value || 'string' == typeof value && '' !== value;
+        const isNumber = (num)=>Number.isInteger(+num);
+        const zeros = (input)=>{
+            let value = `${input}`;
+            let index = -1;
+            if ('-' === value[0]) value = value.slice(1);
+            if ('0' === value) return false;
+            while('0' === value[++index]);
+            return index > 0;
+        };
+        const stringify = (start, end, options)=>{
+            if ('string' == typeof start || 'string' == typeof end) return true;
+            return true === options.stringify;
+        };
+        const pad = (input, maxLength, toNumber)=>{
+            if (maxLength > 0) {
+                let dash = '-' === input[0] ? '-' : '';
+                if (dash) input = input.slice(1);
+                input = dash + input.padStart(dash ? maxLength - 1 : maxLength, '0');
+            }
+            if (false === toNumber) return String(input);
+            return input;
+        };
+        const toMaxLen = (input, maxLength)=>{
+            let negative = '-' === input[0] ? '-' : '';
+            if (negative) {
+                input = input.slice(1);
+                maxLength--;
+            }
+            while(input.length < maxLength)input = '0' + input;
+            return negative ? '-' + input : input;
+        };
+        const toSequence = (parts, options, maxLen)=>{
+            parts.negatives.sort((a, b)=>a < b ? -1 : a > b ? 1 : 0);
+            parts.positives.sort((a, b)=>a < b ? -1 : a > b ? 1 : 0);
+            let prefix = options.capture ? '' : '?:';
+            let positives = '';
+            let negatives = '';
+            let result;
+            if (parts.positives.length) positives = parts.positives.map((v)=>toMaxLen(String(v), maxLen)).join('|');
+            if (parts.negatives.length) negatives = `-(${prefix}${parts.negatives.map((v)=>toMaxLen(String(v), maxLen)).join('|')})`;
+            result = positives && negatives ? `${positives}|${negatives}` : positives || negatives;
+            if (options.wrap) return `(${prefix}${result})`;
+            return result;
+        };
+        const toRange = (a, b, isNumbers, options)=>{
+            if (isNumbers) return toRegexRange(a, b, {
+                wrap: false,
+                ...options
+            });
+            let start = String.fromCharCode(a);
+            if (a === b) return start;
+            let stop = String.fromCharCode(b);
+            return `[${start}-${stop}]`;
+        };
+        const toRegex = (start, end, options)=>{
+            if (Array.isArray(start)) {
+                let wrap = true === options.wrap;
+                let prefix = options.capture ? '' : '?:';
+                return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
+            }
+            return toRegexRange(start, end, options);
+        };
+        const rangeError = (...args)=>new RangeError('Invalid range arguments: ' + util.inspect(...args));
+        const invalidRange = (start, end, options)=>{
+            if (true === options.strictRanges) throw rangeError([
+                start,
+                end
+            ]);
+            return [];
+        };
+        const invalidStep = (step, options)=>{
+            if (true === options.strictRanges) throw new TypeError(`Expected step "${step}" to be a number`);
+            return [];
+        };
+        const fillNumbers = (start, end, step = 1, options = {})=>{
+            let a = Number(start);
+            let b = Number(end);
+            if (!Number.isInteger(a) || !Number.isInteger(b)) {
+                if (true === options.strictRanges) throw rangeError([
+                    start,
+                    end
+                ]);
+                return [];
+            }
+            if (0 === a) a = 0;
+            if (0 === b) b = 0;
+            let descending = a > b;
+            let startString = String(start);
+            let endString = String(end);
+            let stepString = String(step);
+            step = Math.max(Math.abs(step), 1);
+            let padded = zeros(startString) || zeros(endString) || zeros(stepString);
+            let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
+            let toNumber = false === padded && false === stringify(start, end, options);
+            let format = options.transform || transform(toNumber);
+            if (options.toRegex && 1 === step) return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
+            let parts = {
+                negatives: [],
+                positives: []
+            };
+            let push = (num)=>parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));
+            let range = [];
+            let index = 0;
+            while(descending ? a >= b : a <= b){
+                if (true === options.toRegex && step > 1) push(a);
+                else range.push(pad(format(a, index), maxLen, toNumber));
+                a = descending ? a - step : a + step;
+                index++;
+            }
+            if (true === options.toRegex) return step > 1 ? toSequence(parts, options, maxLen) : toRegex(range, null, {
+                wrap: false,
+                ...options
+            });
+            return range;
+        };
+        const fillLetters = (start, end, step = 1, options = {})=>{
+            if (!isNumber(start) && start.length > 1 || !isNumber(end) && end.length > 1) return invalidRange(start, end, options);
+            let format = options.transform || ((val)=>String.fromCharCode(val));
+            let a = `${start}`.charCodeAt(0);
+            let b = `${end}`.charCodeAt(0);
+            let descending = a > b;
+            let min = Math.min(a, b);
+            let max = Math.max(a, b);
+            if (options.toRegex && 1 === step) return toRange(min, max, false, options);
+            let range = [];
+            let index = 0;
+            while(descending ? a >= b : a <= b){
+                range.push(format(a, index));
+                a = descending ? a - step : a + step;
+                index++;
+            }
+            if (true === options.toRegex) return toRegex(range, null, {
+                wrap: false,
+                options
+            });
+            return range;
+        };
+        const fill = (start, end, step, options = {})=>{
+            if (null == end && isValidValue(start)) return [
+                start
+            ];
+            if (!isValidValue(start) || !isValidValue(end)) return invalidRange(start, end, options);
+            if ('function' == typeof step) return fill(start, end, 1, {
+                transform: step
+            });
+            if (isObject(step)) return fill(start, end, 0, step);
+            let opts = {
+                ...options
+            };
+            if (true === opts.capture) opts.wrap = true;
+            step = step || opts.step || 1;
+            if (!isNumber(step)) {
+                if (null != step && !isObject(step)) return invalidStep(step, opts);
+                return fill(start, end, 1, step);
+            }
+            if (isNumber(start) && isNumber(end)) return fillNumbers(start, end, step, opts);
+            return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
+        };
+        module.exports = fill;
+    },
+    "./node_modules/.pnpm/is-extglob@2.1.1/node_modules/is-extglob/index.js" (module) {
+        /*!
+ * is-extglob <https://github.com/jonschlinkert/is-extglob>
+ *
+ * Copyright (c) 2014-2016, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */ module.exports = function(str) {
+            if ('string' != typeof str || '' === str) return false;
+            var match;
+            while(match = /(\\).|([@?!+*]\(.*\))/g.exec(str)){
+                if (match[2]) return true;
+                str = str.slice(match.index + match[0].length);
+            }
+            return false;
+        };
+    },
+    "./node_modules/.pnpm/is-glob@4.0.3/node_modules/is-glob/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        /*!
+ * is-glob <https://github.com/jonschlinkert/is-glob>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */ var isExtglob = __webpack_require__("./node_modules/.pnpm/is-extglob@2.1.1/node_modules/is-extglob/index.js");
+        var chars = {
+            '{': '}',
+            '(': ')',
+            '[': ']'
+        };
+        var strictCheck = function(str) {
+            if ('!' === str[0]) return true;
+            var index = 0;
+            var pipeIndex = -2;
+            var closeSquareIndex = -2;
+            var closeCurlyIndex = -2;
+            var closeParenIndex = -2;
+            var backSlashIndex = -2;
+            while(index < str.length){
+                if ('*' === str[index]) return true;
+                if ('?' === str[index + 1] && /[\].+)]/.test(str[index])) return true;
+                if (-1 !== closeSquareIndex && '[' === str[index] && ']' !== str[index + 1]) {
+                    if (closeSquareIndex < index) closeSquareIndex = str.indexOf(']', index);
+                    if (closeSquareIndex > index) {
+                        if (-1 === backSlashIndex || backSlashIndex > closeSquareIndex) return true;
+                        backSlashIndex = str.indexOf('\\', index);
+                        if (-1 === backSlashIndex || backSlashIndex > closeSquareIndex) return true;
+                    }
+                }
+                if (-1 !== closeCurlyIndex && '{' === str[index] && '}' !== str[index + 1]) {
+                    closeCurlyIndex = str.indexOf('}', index);
+                    if (closeCurlyIndex > index) {
+                        backSlashIndex = str.indexOf('\\', index);
+                        if (-1 === backSlashIndex || backSlashIndex > closeCurlyIndex) return true;
+                    }
+                }
+                if (-1 !== closeParenIndex && '(' === str[index] && '?' === str[index + 1] && /[:!=]/.test(str[index + 2]) && ')' !== str[index + 3]) {
+                    closeParenIndex = str.indexOf(')', index);
+                    if (closeParenIndex > index) {
+                        backSlashIndex = str.indexOf('\\', index);
+                        if (-1 === backSlashIndex || backSlashIndex > closeParenIndex) return true;
+                    }
+                }
+                if (-1 !== pipeIndex && '(' === str[index] && '|' !== str[index + 1]) {
+                    if (pipeIndex < index) pipeIndex = str.indexOf('|', index);
+                    if (-1 !== pipeIndex && ')' !== str[pipeIndex + 1]) {
+                        closeParenIndex = str.indexOf(')', pipeIndex);
+                        if (closeParenIndex > pipeIndex) {
+                            backSlashIndex = str.indexOf('\\', pipeIndex);
+                            if (-1 === backSlashIndex || backSlashIndex > closeParenIndex) return true;
+                        }
+                    }
+                }
+                if ('\\' === str[index]) {
+                    var open = str[index + 1];
+                    index += 2;
+                    var close = chars[open];
+                    if (close) {
+                        var n = str.indexOf(close, index);
+                        if (-1 !== n) index = n + 1;
+                    }
+                    if ('!' === str[index]) return true;
+                } else index++;
+            }
+            return false;
+        };
+        var relaxedCheck = function(str) {
+            if ('!' === str[0]) return true;
+            var index = 0;
+            while(index < str.length){
+                if (/[*?{}()[\]]/.test(str[index])) return true;
+                if ('\\' === str[index]) {
+                    var open = str[index + 1];
+                    index += 2;
+                    var close = chars[open];
+                    if (close) {
+                        var n = str.indexOf(close, index);
+                        if (-1 !== n) index = n + 1;
+                    }
+                    if ('!' === str[index]) return true;
+                } else index++;
+            }
+            return false;
+        };
+        module.exports = function(str, options) {
+            if ('string' != typeof str || '' === str) return false;
+            if (isExtglob(str)) return true;
+            var check = strictCheck;
+            if (options && false === options.strict) check = relaxedCheck;
+            return check(str);
+        };
+    },
+    "./node_modules/.pnpm/is-number@7.0.0/node_modules/is-number/index.js" (module) {
+        /*!
+ * is-number <https://github.com/jonschlinkert/is-number>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */ module.exports = function(num) {
+            if ('number' == typeof num) return num - num === 0;
+            if ('string' == typeof num && '' !== num.trim()) return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
+            return false;
+        };
+    },
+    "./node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const util = __webpack_require__("util");
+        const braces = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/index.js");
+        const picomatch = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/index.js");
+        const utils = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/utils.js");
+        const isEmptyString = (v)=>'' === v || './' === v;
+        const hasBraces = (v)=>{
+            const index = v.indexOf('{');
+            return index > -1 && v.indexOf('}', index) > -1;
+        };
+        const micromatch = (list, patterns, options)=>{
+            patterns = [].concat(patterns);
+            list = [].concat(list);
+            let omit = new Set();
+            let keep = new Set();
+            let items = new Set();
+            let negatives = 0;
+            let onResult = (state)=>{
+                items.add(state.output);
+                if (options && options.onResult) options.onResult(state);
+            };
+            for(let i = 0; i < patterns.length; i++){
+                let isMatch = picomatch(String(patterns[i]), {
+                    ...options,
+                    onResult
+                }, true);
+                let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
+                if (negated) negatives++;
+                for (let item of list){
+                    let matched = isMatch(item, true);
+                    let match = negated ? !matched.isMatch : matched.isMatch;
+                    if (match) if (negated) omit.add(matched.output);
+                    else {
+                        omit.delete(matched.output);
+                        keep.add(matched.output);
+                    }
+                }
+            }
+            let result = negatives === patterns.length ? [
+                ...items
+            ] : [
+                ...keep
+            ];
+            let matches = result.filter((item)=>!omit.has(item));
+            if (options && 0 === matches.length) {
+                if (true === options.failglob) throw new Error(`No matches found for "${patterns.join(', ')}"`);
+                if (true === options.nonull || true === options.nullglob) return options.unescape ? patterns.map((p)=>p.replace(/\\/g, '')) : patterns;
+            }
+            return matches;
+        };
+        micromatch.match = micromatch;
+        micromatch.matcher = (pattern, options)=>picomatch(pattern, options);
+        micromatch.isMatch = (str, patterns, options)=>picomatch(patterns, options)(str);
+        micromatch.any = micromatch.isMatch;
+        micromatch.not = (list, patterns, options = {})=>{
+            patterns = [].concat(patterns).map(String);
+            let result = new Set();
+            let items = [];
+            let onResult = (state)=>{
+                if (options.onResult) options.onResult(state);
+                items.push(state.output);
+            };
+            let matches = new Set(micromatch(list, patterns, {
+                ...options,
+                onResult
+            }));
+            for (let item of items)if (!matches.has(item)) result.add(item);
+            return [
+                ...result
+            ];
+        };
+        micromatch.contains = (str, pattern, options)=>{
+            if ('string' != typeof str) throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+            if (Array.isArray(pattern)) return pattern.some((p)=>micromatch.contains(str, p, options));
+            if ('string' == typeof pattern) {
+                if (isEmptyString(str) || isEmptyString(pattern)) return false;
+                if (str.includes(pattern) || str.startsWith('./') && str.slice(2).includes(pattern)) return true;
+            }
+            return micromatch.isMatch(str, pattern, {
+                ...options,
+                contains: true
+            });
+        };
+        micromatch.matchKeys = (obj, patterns, options)=>{
+            if (!utils.isObject(obj)) throw new TypeError('Expected the first argument to be an object');
+            let keys = micromatch(Object.keys(obj), patterns, options);
+            let res = {};
+            for (let key of keys)res[key] = obj[key];
+            return res;
+        };
+        micromatch.some = (list, patterns, options)=>{
+            let items = [].concat(list);
+            for (let pattern of [].concat(patterns)){
+                let isMatch = picomatch(String(pattern), options);
+                if (items.some((item)=>isMatch(item))) return true;
+            }
+            return false;
+        };
+        micromatch.every = (list, patterns, options)=>{
+            let items = [].concat(list);
+            for (let pattern of [].concat(patterns)){
+                let isMatch = picomatch(String(pattern), options);
+                if (!items.every((item)=>isMatch(item))) return false;
+            }
+            return true;
+        };
+        micromatch.all = (str, patterns, options)=>{
+            if ('string' != typeof str) throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+            return [].concat(patterns).every((p)=>picomatch(p, options)(str));
+        };
+        micromatch.capture = (glob, input, options)=>{
+            let posix = utils.isWindows(options);
+            let regex = picomatch.makeRe(String(glob), {
+                ...options,
+                capture: true
+            });
+            let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
+            if (match) return match.slice(1).map((v)=>void 0 === v ? '' : v);
+        };
+        micromatch.makeRe = (...args)=>picomatch.makeRe(...args);
+        micromatch.scan = (...args)=>picomatch.scan(...args);
+        micromatch.parse = (patterns, options)=>{
+            let res = [];
+            for (let pattern of [].concat(patterns || []))for (let str of braces(String(pattern), options))res.push(picomatch.parse(str, options));
+            return res;
+        };
+        micromatch.braces = (pattern, options)=>{
+            if ('string' != typeof pattern) throw new TypeError('Expected a string');
+            if (options && true === options.nobrace || !hasBraces(pattern)) return [
+                pattern
+            ];
+            return braces(pattern, options);
+        };
+        micromatch.braceExpand = (pattern, options)=>{
+            if ('string' != typeof pattern) throw new TypeError('Expected a string');
+            return micromatch.braces(pattern, {
+                ...options,
+                expand: true
+            });
+        };
+        micromatch.hasBraces = hasBraces;
+        module.exports = micromatch;
+    },
+    "./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        module.exports = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/picomatch.js");
+    },
+    "./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/constants.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const path = __webpack_require__("path");
+        const WIN_SLASH = '\\\\/';
+        const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+        const DEFAULT_MAX_EXTGLOB_RECURSION = 0;
+        const DOT_LITERAL = '\\.';
+        const PLUS_LITERAL = '\\+';
+        const QMARK_LITERAL = '\\?';
+        const SLASH_LITERAL = '\\/';
+        const ONE_CHAR = '(?=.)';
+        const QMARK = '[^/]';
+        const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+        const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+        const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+        const NO_DOT = `(?!${DOT_LITERAL})`;
+        const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+        const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+        const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+        const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+        const STAR = `${QMARK}*?`;
+        const POSIX_CHARS = {
+            DOT_LITERAL,
+            PLUS_LITERAL,
+            QMARK_LITERAL,
+            SLASH_LITERAL,
+            ONE_CHAR,
+            QMARK,
+            END_ANCHOR,
+            DOTS_SLASH,
+            NO_DOT,
+            NO_DOTS,
+            NO_DOT_SLASH,
+            NO_DOTS_SLASH,
+            QMARK_NO_DOT,
+            STAR,
+            START_ANCHOR
+        };
+        const WINDOWS_CHARS = {
+            ...POSIX_CHARS,
+            SLASH_LITERAL: `[${WIN_SLASH}]`,
+            QMARK: WIN_NO_SLASH,
+            STAR: `${WIN_NO_SLASH}*?`,
+            DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+            NO_DOT: `(?!${DOT_LITERAL})`,
+            NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+            NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+            NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+            QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+            START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+            END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+        };
+        const POSIX_REGEX_SOURCE = {
+            __proto__: null,
+            alnum: 'a-zA-Z0-9',
+            alpha: 'a-zA-Z',
+            ascii: '\\x00-\\x7F',
+            blank: ' \\t',
+            cntrl: '\\x00-\\x1F\\x7F',
+            digit: '0-9',
+            graph: '\\x21-\\x7E',
+            lower: 'a-z',
+            print: '\\x20-\\x7E ',
+            punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+            space: ' \\t\\r\\n\\v\\f',
+            upper: 'A-Z',
+            word: 'A-Za-z0-9_',
+            xdigit: 'A-Fa-f0-9'
+        };
+        module.exports = {
+            DEFAULT_MAX_EXTGLOB_RECURSION,
+            MAX_LENGTH: 65536,
+            POSIX_REGEX_SOURCE,
+            REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+            REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+            REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+            REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+            REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+            REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+            REPLACEMENTS: {
+                __proto__: null,
+                '***': '*',
+                '**/**': '**',
+                '**/**/**': '**'
+            },
+            CHAR_0: 48,
+            CHAR_9: 57,
+            CHAR_UPPERCASE_A: 65,
+            CHAR_LOWERCASE_A: 97,
+            CHAR_UPPERCASE_Z: 90,
+            CHAR_LOWERCASE_Z: 122,
+            CHAR_LEFT_PARENTHESES: 40,
+            CHAR_RIGHT_PARENTHESES: 41,
+            CHAR_ASTERISK: 42,
+            CHAR_AMPERSAND: 38,
+            CHAR_AT: 64,
+            CHAR_BACKWARD_SLASH: 92,
+            CHAR_CARRIAGE_RETURN: 13,
+            CHAR_CIRCUMFLEX_ACCENT: 94,
+            CHAR_COLON: 58,
+            CHAR_COMMA: 44,
+            CHAR_DOT: 46,
+            CHAR_DOUBLE_QUOTE: 34,
+            CHAR_EQUAL: 61,
+            CHAR_EXCLAMATION_MARK: 33,
+            CHAR_FORM_FEED: 12,
+            CHAR_FORWARD_SLASH: 47,
+            CHAR_GRAVE_ACCENT: 96,
+            CHAR_HASH: 35,
+            CHAR_HYPHEN_MINUS: 45,
+            CHAR_LEFT_ANGLE_BRACKET: 60,
+            CHAR_LEFT_CURLY_BRACE: 123,
+            CHAR_LEFT_SQUARE_BRACKET: 91,
+            CHAR_LINE_FEED: 10,
+            CHAR_NO_BREAK_SPACE: 160,
+            CHAR_PERCENT: 37,
+            CHAR_PLUS: 43,
+            CHAR_QUESTION_MARK: 63,
+            CHAR_RIGHT_ANGLE_BRACKET: 62,
+            CHAR_RIGHT_CURLY_BRACE: 125,
+            CHAR_RIGHT_SQUARE_BRACKET: 93,
+            CHAR_SEMICOLON: 59,
+            CHAR_SINGLE_QUOTE: 39,
+            CHAR_SPACE: 32,
+            CHAR_TAB: 9,
+            CHAR_UNDERSCORE: 95,
+            CHAR_VERTICAL_LINE: 124,
+            CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+            SEP: path.sep,
+            extglobChars (chars) {
+                return {
+                    '!': {
+                        type: 'negate',
+                        open: '(?:(?!(?:',
+                        close: `))${chars.STAR})`
+                    },
+                    '?': {
+                        type: 'qmark',
+                        open: '(?:',
+                        close: ')?'
+                    },
+                    '+': {
+                        type: 'plus',
+                        open: '(?:',
+                        close: ')+'
+                    },
+                    '*': {
+                        type: 'star',
+                        open: '(?:',
+                        close: ')*'
+                    },
+                    '@': {
+                        type: 'at',
+                        open: '(?:',
+                        close: ')'
+                    }
+                };
+            },
+            globChars (win32) {
+                return true === win32 ? WINDOWS_CHARS : POSIX_CHARS;
+            }
+        };
+    },
+    "./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/parse.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const constants = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/constants.js");
+        const utils = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/utils.js");
+        const { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants;
+        const expandRange = (args, options)=>{
+            if ('function' == typeof options.expandRange) return options.expandRange(...args, options);
+            args.sort();
+            const value = `[${args.join('-')}]`;
+            try {
+                new RegExp(value);
+            } catch (ex) {
+                return args.map((v)=>utils.escapeRegex(v)).join('..');
+            }
+            return value;
+        };
+        const syntaxError = (type, char)=>`Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+        const splitTopLevel = (input)=>{
+            const parts = [];
+            let bracket = 0;
+            let paren = 0;
+            let quote = 0;
+            let value = '';
+            let escaped = false;
+            for (const ch of input){
+                if (true === escaped) {
+                    value += ch;
+                    escaped = false;
+                    continue;
+                }
+                if ('\\' === ch) {
+                    value += ch;
+                    escaped = true;
+                    continue;
+                }
+                if ('"' === ch) {
+                    quote = 1 === quote ? 0 : 1;
+                    value += ch;
+                    continue;
+                }
+                if (0 === quote) {
+                    if ('[' === ch) bracket++;
+                    else if (']' === ch && bracket > 0) bracket--;
+                    else if (0 === bracket) {
+                        if ('(' === ch) paren++;
+                        else if (')' === ch && paren > 0) paren--;
+                        else if ('|' === ch && 0 === paren) {
+                            parts.push(value);
+                            value = '';
+                            continue;
+                        }
+                    }
+                }
+                value += ch;
+            }
+            parts.push(value);
+            return parts;
+        };
+        const isPlainBranch = (branch)=>{
+            let escaped = false;
+            for (const ch of branch){
+                if (true === escaped) {
+                    escaped = false;
+                    continue;
+                }
+                if ('\\' === ch) {
+                    escaped = true;
+                    continue;
+                }
+                if (/[?*+@!()[\]{}]/.test(ch)) return false;
+            }
+            return true;
+        };
+        const normalizeSimpleBranch = (branch)=>{
+            let value = branch.trim();
+            let changed = true;
+            while(true === changed){
+                changed = false;
+                if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
+                    value = value.slice(2, -1);
+                    changed = true;
+                }
+            }
+            if (!isPlainBranch(value)) return;
+            return value.replace(/\\(.)/g, '$1');
+        };
+        const hasRepeatedCharPrefixOverlap = (branches)=>{
+            const values = branches.map(normalizeSimpleBranch).filter(Boolean);
+            for(let i = 0; i < values.length; i++)for(let j = i + 1; j < values.length; j++){
+                const a = values[i];
+                const b = values[j];
+                const char = a[0];
+                if (char && a === char.repeat(a.length) && b === char.repeat(b.length)) {
+                    if (a === b || a.startsWith(b) || b.startsWith(a)) return true;
+                }
+            }
+            return false;
+        };
+        const parseRepeatedExtglob = (pattern, requireEnd = true)=>{
+            if ('+' !== pattern[0] && '*' !== pattern[0] || '(' !== pattern[1]) return;
+            let bracket = 0;
+            let paren = 0;
+            let quote = 0;
+            let escaped = false;
+            for(let i = 1; i < pattern.length; i++){
+                const ch = pattern[i];
+                if (true === escaped) {
+                    escaped = false;
+                    continue;
+                }
+                if ('\\' === ch) {
+                    escaped = true;
+                    continue;
+                }
+                if ('"' === ch) {
+                    quote = 1 === quote ? 0 : 1;
+                    continue;
+                }
+                if (1 !== quote) {
+                    if ('[' === ch) {
+                        bracket++;
+                        continue;
+                    }
+                    if (']' === ch && bracket > 0) {
+                        bracket--;
+                        continue;
+                    }
+                    if (!(bracket > 0)) {
+                        if ('(' === ch) {
+                            paren++;
+                            continue;
+                        }
+                        if (')' === ch) {
+                            paren--;
+                            if (0 === paren) {
+                                if (true === requireEnd && i !== pattern.length - 1) return;
+                                return {
+                                    type: pattern[0],
+                                    body: pattern.slice(2, i),
+                                    end: i
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        const getStarExtglobSequenceOutput = (pattern)=>{
+            let index = 0;
+            const chars = [];
+            while(index < pattern.length){
+                const match = parseRepeatedExtglob(pattern.slice(index), false);
+                if (!match || '*' !== match.type) return;
+                const branches = splitTopLevel(match.body).map((branch)=>branch.trim());
+                if (1 !== branches.length) return;
+                const branch = normalizeSimpleBranch(branches[0]);
+                if (!branch || 1 !== branch.length) return;
+                chars.push(branch);
+                index += match.end + 1;
+            }
+            if (chars.length < 1) return;
+            const source = 1 === chars.length ? utils.escapeRegex(chars[0]) : `[${chars.map((ch)=>utils.escapeRegex(ch)).join('')}]`;
+            return `${source}*`;
+        };
+        const repeatedExtglobRecursion = (pattern)=>{
+            let depth = 0;
+            let value = pattern.trim();
+            let match = parseRepeatedExtglob(value);
+            while(match){
+                depth++;
+                value = match.body.trim();
+                match = parseRepeatedExtglob(value);
+            }
+            return depth;
+        };
+        const analyzeRepeatedExtglob = (body, options)=>{
+            if (false === options.maxExtglobRecursion) return {
+                risky: false
+            };
+            const max = 'number' == typeof options.maxExtglobRecursion ? options.maxExtglobRecursion : constants.DEFAULT_MAX_EXTGLOB_RECURSION;
+            const branches = splitTopLevel(body).map((branch)=>branch.trim());
+            if (branches.length > 1) {
+                if (branches.some((branch)=>'' === branch) || branches.some((branch)=>/^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)) return {
+                    risky: true
+                };
+            }
+            for (const branch of branches){
+                const safeOutput = getStarExtglobSequenceOutput(branch);
+                if (safeOutput) return {
+                    risky: true,
+                    safeOutput
+                };
+                if (repeatedExtglobRecursion(branch) > max) return {
+                    risky: true
+                };
+            }
+            return {
+                risky: false
+            };
+        };
+        const parse = (input, options)=>{
+            if ('string' != typeof input) throw new TypeError('Expected a string');
+            input = REPLACEMENTS[input] || input;
+            const opts = {
+                ...options
+            };
+            const max = 'number' == typeof opts.maxLength ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+            let len = input.length;
+            if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+            const bos = {
+                type: 'bos',
+                value: '',
+                output: opts.prepend || ''
+            };
+            const tokens = [
+                bos
+            ];
+            const capture = opts.capture ? '' : '?:';
+            const win32 = utils.isWindows(options);
+            const PLATFORM_CHARS = constants.globChars(win32);
+            const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+            const { DOT_LITERAL, PLUS_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK, QMARK_NO_DOT, STAR, START_ANCHOR } = PLATFORM_CHARS;
+            const globstar = (opts)=>`(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+            const nodot = opts.dot ? '' : NO_DOT;
+            const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+            let star = true === opts.bash ? globstar(opts) : STAR;
+            if (opts.capture) star = `(${star})`;
+            if ('boolean' == typeof opts.noext) opts.noextglob = opts.noext;
+            const state = {
+                input,
+                index: -1,
+                start: 0,
+                dot: true === opts.dot,
+                consumed: '',
+                output: '',
+                prefix: '',
+                backtrack: false,
+                negated: false,
+                brackets: 0,
+                braces: 0,
+                parens: 0,
+                quotes: 0,
+                globstar: false,
+                tokens
+            };
+            input = utils.removePrefix(input, state);
+            len = input.length;
+            const extglobs = [];
+            const braces = [];
+            const stack = [];
+            let prev = bos;
+            let value;
+            const eos = ()=>state.index === len - 1;
+            const peek = state.peek = (n = 1)=>input[state.index + n];
+            const advance = state.advance = ()=>input[++state.index] || '';
+            const remaining = ()=>input.slice(state.index + 1);
+            const consume = (value = '', num = 0)=>{
+                state.consumed += value;
+                state.index += num;
+            };
+            const append = (token)=>{
+                state.output += null != token.output ? token.output : token.value;
+                consume(token.value);
+            };
+            const negate = ()=>{
+                let count = 1;
+                while('!' === peek() && ('(' !== peek(2) || '?' === peek(3))){
+                    advance();
+                    state.start++;
+                    count++;
+                }
+                if (count % 2 === 0) return false;
+                state.negated = true;
+                state.start++;
+                return true;
+            };
+            const increment = (type)=>{
+                state[type]++;
+                stack.push(type);
+            };
+            const decrement = (type)=>{
+                state[type]--;
+                stack.pop();
+            };
+            const push = (tok)=>{
+                if ('globstar' === prev.type) {
+                    const isBrace = state.braces > 0 && ('comma' === tok.type || 'brace' === tok.type);
+                    const isExtglob = true === tok.extglob || extglobs.length && ('pipe' === tok.type || 'paren' === tok.type);
+                    if ('slash' !== tok.type && 'paren' !== tok.type && !isBrace && !isExtglob) {
+                        state.output = state.output.slice(0, -prev.output.length);
+                        prev.type = 'star';
+                        prev.value = '*';
+                        prev.output = star;
+                        state.output += prev.output;
+                    }
+                }
+                if (extglobs.length && 'paren' !== tok.type) extglobs[extglobs.length - 1].inner += tok.value;
+                if (tok.value || tok.output) append(tok);
+                if (prev && 'text' === prev.type && 'text' === tok.type) {
+                    prev.value += tok.value;
+                    prev.output = (prev.output || '') + tok.value;
+                    return;
+                }
+                tok.prev = prev;
+                tokens.push(tok);
+                prev = tok;
+            };
+            const extglobOpen = (type, value)=>{
+                const token = {
+                    ...EXTGLOB_CHARS[value],
+                    conditions: 1,
+                    inner: ''
+                };
+                token.prev = prev;
+                token.parens = state.parens;
+                token.output = state.output;
+                token.startIndex = state.index;
+                token.tokensIndex = tokens.length;
+                const output = (opts.capture ? '(' : '') + token.open;
+                increment('parens');
+                push({
+                    type,
+                    value,
+                    output: state.output ? '' : ONE_CHAR
+                });
+                push({
+                    type: 'paren',
+                    extglob: true,
+                    value: advance(),
+                    output
+                });
+                extglobs.push(token);
+            };
+            const extglobClose = (token)=>{
+                const literal = input.slice(token.startIndex, state.index + 1);
+                const body = input.slice(token.startIndex + 2, state.index);
+                const analysis = analyzeRepeatedExtglob(body, opts);
+                if (('plus' === token.type || 'star' === token.type) && analysis.risky) {
+                    const safeOutput = analysis.safeOutput ? (token.output ? '' : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : void 0;
+                    const open = tokens[token.tokensIndex];
+                    open.type = 'text';
+                    open.value = literal;
+                    open.output = safeOutput || utils.escapeRegex(literal);
+                    for(let i = token.tokensIndex + 1; i < tokens.length; i++){
+                        tokens[i].value = '';
+                        tokens[i].output = '';
+                        delete tokens[i].suffix;
+                    }
+                    state.output = token.output + open.output;
+                    state.backtrack = true;
+                    push({
+                        type: 'paren',
+                        extglob: true,
+                        value,
+                        output: ''
+                    });
+                    decrement('parens');
+                    return;
+                }
+                let output = token.close + (opts.capture ? ')' : '');
+                let rest;
+                if ('negate' === token.type) {
+                    let extglobStar = star;
+                    if (token.inner && token.inner.length > 1 && token.inner.includes('/')) extglobStar = globstar(opts);
+                    if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) output = token.close = `)$))${extglobStar}`;
+                    if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+                        const expression = parse(rest, {
+                            ...options,
+                            fastpaths: false
+                        }).output;
+                        output = token.close = `)${expression})${extglobStar})`;
+                    }
+                    if ('bos' === token.prev.type) state.negatedExtglob = true;
+                }
+                push({
+                    type: 'paren',
+                    extglob: true,
+                    value,
+                    output
+                });
+                decrement('parens');
+            };
+            if (false !== opts.fastpaths && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+                let backslashes = false;
+                let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index)=>{
+                    if ('\\' === first) {
+                        backslashes = true;
+                        return m;
+                    }
+                    if ('?' === first) {
+                        if (esc) return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+                        if (0 === index) return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+                        return QMARK.repeat(chars.length);
+                    }
+                    if ('.' === first) return DOT_LITERAL.repeat(chars.length);
+                    if ('*' === first) {
+                        if (esc) return esc + first + (rest ? star : '');
+                        return star;
+                    }
+                    return esc ? m : `\\${m}`;
+                });
+                if (true === backslashes) output = true === opts.unescape ? output.replace(/\\/g, '') : output.replace(/\\+/g, (m)=>m.length % 2 === 0 ? '\\\\' : m ? '\\' : '');
+                if (output === input && true === opts.contains) {
+                    state.output = input;
+                    return state;
+                }
+                state.output = utils.wrapOutput(output, state, options);
+                return state;
+            }
+            while(!eos()){
+                value = advance();
+                if ('\u0000' === value) continue;
+                if ('\\' === value) {
+                    const next = peek();
+                    if ('/' === next && true !== opts.bash) continue;
+                    if ('.' === next || ';' === next) continue;
+                    if (!next) {
+                        value += '\\';
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                    const match = /^\\+/.exec(remaining());
+                    let slashes = 0;
+                    if (match && match[0].length > 2) {
+                        slashes = match[0].length;
+                        state.index += slashes;
+                        if (slashes % 2 !== 0) value += '\\';
+                    }
+                    if (true === opts.unescape) value = advance();
+                    else value += advance();
+                    if (0 === state.brackets) {
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                }
+                if (state.brackets > 0 && (']' !== value || '[' === prev.value || '[^' === prev.value)) {
+                    if (false !== opts.posix && ':' === value) {
+                        const inner = prev.value.slice(1);
+                        if (inner.includes('[')) {
+                            prev.posix = true;
+                            if (inner.includes(':')) {
+                                const idx = prev.value.lastIndexOf('[');
+                                const pre = prev.value.slice(0, idx);
+                                const rest = prev.value.slice(idx + 2);
+                                const posix = POSIX_REGEX_SOURCE[rest];
+                                if (posix) {
+                                    prev.value = pre + posix;
+                                    state.backtrack = true;
+                                    advance();
+                                    if (!bos.output && 1 === tokens.indexOf(prev)) bos.output = ONE_CHAR;
+                                    continue;
+                                }
+                            }
+                        }
+                    }
+                    if ('[' === value && ':' !== peek() || '-' === value && ']' === peek()) value = `\\${value}`;
+                    if (']' === value && ('[' === prev.value || '[^' === prev.value)) value = `\\${value}`;
+                    if (true === opts.posix && '!' === value && '[' === prev.value) value = '^';
+                    prev.value += value;
+                    append({
+                        value
+                    });
+                    continue;
+                }
+                if (1 === state.quotes && '"' !== value) {
+                    value = utils.escapeRegex(value);
+                    prev.value += value;
+                    append({
+                        value
+                    });
+                    continue;
+                }
+                if ('"' === value) {
+                    state.quotes = 1 === state.quotes ? 0 : 1;
+                    if (true === opts.keepQuotes) push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if ('(' === value) {
+                    increment('parens');
+                    push({
+                        type: 'paren',
+                        value
+                    });
+                    continue;
+                }
+                if (')' === value) {
+                    if (0 === state.parens && true === opts.strictBrackets) throw new SyntaxError(syntaxError('opening', '('));
+                    const extglob = extglobs[extglobs.length - 1];
+                    if (extglob && state.parens === extglob.parens + 1) {
+                        extglobClose(extglobs.pop());
+                        continue;
+                    }
+                    push({
+                        type: 'paren',
+                        value,
+                        output: state.parens ? ')' : '\\)'
+                    });
+                    decrement('parens');
+                    continue;
+                }
+                if ('[' === value) {
+                    if (true !== opts.nobracket && remaining().includes(']')) increment('brackets');
+                    else {
+                        if (true !== opts.nobracket && true === opts.strictBrackets) throw new SyntaxError(syntaxError('closing', ']'));
+                        value = `\\${value}`;
+                    }
+                    push({
+                        type: 'bracket',
+                        value
+                    });
+                    continue;
+                }
+                if (']' === value) {
+                    if (true === opts.nobracket || prev && 'bracket' === prev.type && 1 === prev.value.length) {
+                        push({
+                            type: 'text',
+                            value,
+                            output: `\\${value}`
+                        });
+                        continue;
+                    }
+                    if (0 === state.brackets) {
+                        if (true === opts.strictBrackets) throw new SyntaxError(syntaxError('opening', '['));
+                        push({
+                            type: 'text',
+                            value,
+                            output: `\\${value}`
+                        });
+                        continue;
+                    }
+                    decrement('brackets');
+                    const prevValue = prev.value.slice(1);
+                    if (true !== prev.posix && '^' === prevValue[0] && !prevValue.includes('/')) value = `/${value}`;
+                    prev.value += value;
+                    append({
+                        value
+                    });
+                    if (false === opts.literalBrackets || utils.hasRegexChars(prevValue)) continue;
+                    const escaped = utils.escapeRegex(prev.value);
+                    state.output = state.output.slice(0, -prev.value.length);
+                    if (true === opts.literalBrackets) {
+                        state.output += escaped;
+                        prev.value = escaped;
+                        continue;
+                    }
+                    prev.value = `(${capture}${escaped}|${prev.value})`;
+                    state.output += prev.value;
+                    continue;
+                }
+                if ('{' === value && true !== opts.nobrace) {
+                    increment('braces');
+                    const open = {
+                        type: 'brace',
+                        value,
+                        output: '(',
+                        outputIndex: state.output.length,
+                        tokensIndex: state.tokens.length
+                    };
+                    braces.push(open);
+                    push(open);
+                    continue;
+                }
+                if ('}' === value) {
+                    const brace = braces[braces.length - 1];
+                    if (true === opts.nobrace || !brace) {
+                        push({
+                            type: 'text',
+                            value,
+                            output: value
+                        });
+                        continue;
+                    }
+                    let output = ')';
+                    if (true === brace.dots) {
+                        const arr = tokens.slice();
+                        const range = [];
+                        for(let i = arr.length - 1; i >= 0; i--){
+                            tokens.pop();
+                            if ('brace' === arr[i].type) break;
+                            if ('dots' !== arr[i].type) range.unshift(arr[i].value);
+                        }
+                        output = expandRange(range, opts);
+                        state.backtrack = true;
+                    }
+                    if (true !== brace.comma && true !== brace.dots) {
+                        const out = state.output.slice(0, brace.outputIndex);
+                        const toks = state.tokens.slice(brace.tokensIndex);
+                        brace.value = brace.output = '\\{';
+                        value = output = '\\}';
+                        state.output = out;
+                        for (const t of toks)state.output += t.output || t.value;
+                    }
+                    push({
+                        type: 'brace',
+                        value,
+                        output
+                    });
+                    decrement('braces');
+                    braces.pop();
+                    continue;
+                }
+                if ('|' === value) {
+                    if (extglobs.length > 0) extglobs[extglobs.length - 1].conditions++;
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (',' === value) {
+                    let output = value;
+                    const brace = braces[braces.length - 1];
+                    if (brace && 'braces' === stack[stack.length - 1]) {
+                        brace.comma = true;
+                        output = '|';
+                    }
+                    push({
+                        type: 'comma',
+                        value,
+                        output
+                    });
+                    continue;
+                }
+                if ('/' === value) {
+                    if ('dot' === prev.type && state.index === state.start + 1) {
+                        state.start = state.index + 1;
+                        state.consumed = '';
+                        state.output = '';
+                        tokens.pop();
+                        prev = bos;
+                        continue;
+                    }
+                    push({
+                        type: 'slash',
+                        value,
+                        output: SLASH_LITERAL
+                    });
+                    continue;
+                }
+                if ('.' === value) {
+                    if (state.braces > 0 && 'dot' === prev.type) {
+                        if ('.' === prev.value) prev.output = DOT_LITERAL;
+                        const brace = braces[braces.length - 1];
+                        prev.type = 'dots';
+                        prev.output += value;
+                        prev.value += value;
+                        brace.dots = true;
+                        continue;
+                    }
+                    if (state.braces + state.parens === 0 && 'bos' !== prev.type && 'slash' !== prev.type) {
+                        push({
+                            type: 'text',
+                            value,
+                            output: DOT_LITERAL
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'dot',
+                        value,
+                        output: DOT_LITERAL
+                    });
+                    continue;
+                }
+                if ('?' === value) {
+                    const isGroup = prev && '(' === prev.value;
+                    if (!isGroup && true !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        extglobOpen('qmark', value);
+                        continue;
+                    }
+                    if (prev && 'paren' === prev.type) {
+                        const next = peek();
+                        let output = value;
+                        if ('<' === next && !utils.supportsLookbehinds()) throw new Error('Node.js v10 or higher is required for regex lookbehinds');
+                        if ('(' === prev.value && !/[!=<:]/.test(next) || '<' === next && !/<([!=]|\w+>)/.test(remaining())) output = `\\${value}`;
+                        push({
+                            type: 'text',
+                            value,
+                            output
+                        });
+                        continue;
+                    }
+                    if (true !== opts.dot && ('slash' === prev.type || 'bos' === prev.type)) {
+                        push({
+                            type: 'qmark',
+                            value,
+                            output: QMARK_NO_DOT
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'qmark',
+                        value,
+                        output: QMARK
+                    });
+                    continue;
+                }
+                if ('!' === value) {
+                    if (true !== opts.noextglob && '(' === peek()) {
+                        if ('?' !== peek(2) || !/[!=<:]/.test(peek(3))) {
+                            extglobOpen('negate', value);
+                            continue;
+                        }
+                    }
+                    if (true !== opts.nonegate && 0 === state.index) {
+                        negate();
+                        continue;
+                    }
+                }
+                if ('+' === value) {
+                    if (true !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        extglobOpen('plus', value);
+                        continue;
+                    }
+                    if (prev && '(' === prev.value || false === opts.regex) {
+                        push({
+                            type: 'plus',
+                            value,
+                            output: PLUS_LITERAL
+                        });
+                        continue;
+                    }
+                    if (prev && ('bracket' === prev.type || 'paren' === prev.type || 'brace' === prev.type) || state.parens > 0) {
+                        push({
+                            type: 'plus',
+                            value
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'plus',
+                        value: PLUS_LITERAL
+                    });
+                    continue;
+                }
+                if ('@' === value) {
+                    if (true !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        push({
+                            type: 'at',
+                            extglob: true,
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if ('*' !== value) {
+                    if ('$' === value || '^' === value) value = `\\${value}`;
+                    const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+                    if (match) {
+                        value += match[0];
+                        state.index += match[0].length;
+                    }
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (prev && ('globstar' === prev.type || true === prev.star)) {
+                    prev.type = 'star';
+                    prev.star = true;
+                    prev.value += value;
+                    prev.output = star;
+                    state.backtrack = true;
+                    state.globstar = true;
+                    consume(value);
+                    continue;
+                }
+                let rest = remaining();
+                if (true !== opts.noextglob && /^\([^?]/.test(rest)) {
+                    extglobOpen('star', value);
+                    continue;
+                }
+                if ('star' === prev.type) {
+                    if (true === opts.noglobstar) {
+                        consume(value);
+                        continue;
+                    }
+                    const prior = prev.prev;
+                    const before = prior.prev;
+                    const isStart = 'slash' === prior.type || 'bos' === prior.type;
+                    const afterStar = before && ('star' === before.type || 'globstar' === before.type);
+                    if (true === opts.bash && (!isStart || rest[0] && '/' !== rest[0])) {
+                        push({
+                            type: 'star',
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    const isBrace = state.braces > 0 && ('comma' === prior.type || 'brace' === prior.type);
+                    const isExtglob = extglobs.length && ('pipe' === prior.type || 'paren' === prior.type);
+                    if (!isStart && 'paren' !== prior.type && !isBrace && !isExtglob) {
+                        push({
+                            type: 'star',
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    while('/**' === rest.slice(0, 3)){
+                        const after = input[state.index + 4];
+                        if (after && '/' !== after) break;
+                        rest = rest.slice(3);
+                        consume('/**', 3);
+                    }
+                    if ('bos' === prior.type && eos()) {
+                        prev.type = 'globstar';
+                        prev.value += value;
+                        prev.output = globstar(opts);
+                        state.output = prev.output;
+                        state.globstar = true;
+                        consume(value);
+                        continue;
+                    }
+                    if ('slash' === prior.type && 'bos' !== prior.prev.type && !afterStar && eos()) {
+                        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+                        prior.output = `(?:${prior.output}`;
+                        prev.type = 'globstar';
+                        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
+                        prev.value += value;
+                        state.globstar = true;
+                        state.output += prior.output + prev.output;
+                        consume(value);
+                        continue;
+                    }
+                    if ('slash' === prior.type && 'bos' !== prior.prev.type && '/' === rest[0]) {
+                        const end = void 0 !== rest[1] ? '|$' : '';
+                        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+                        prior.output = `(?:${prior.output}`;
+                        prev.type = 'globstar';
+                        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+                        prev.value += value;
+                        state.output += prior.output + prev.output;
+                        state.globstar = true;
+                        consume(value + advance());
+                        push({
+                            type: 'slash',
+                            value: '/',
+                            output: ''
+                        });
+                        continue;
+                    }
+                    if ('bos' === prior.type && '/' === rest[0]) {
+                        prev.type = 'globstar';
+                        prev.value += value;
+                        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+                        state.output = prev.output;
+                        state.globstar = true;
+                        consume(value + advance());
+                        push({
+                            type: 'slash',
+                            value: '/',
+                            output: ''
+                        });
+                        continue;
+                    }
+                    state.output = state.output.slice(0, -prev.output.length);
+                    prev.type = 'globstar';
+                    prev.output = globstar(opts);
+                    prev.value += value;
+                    state.output += prev.output;
+                    state.globstar = true;
+                    consume(value);
+                    continue;
+                }
+                const token = {
+                    type: 'star',
+                    value,
+                    output: star
+                };
+                if (true === opts.bash) {
+                    token.output = '.*?';
+                    if ('bos' === prev.type || 'slash' === prev.type) token.output = nodot + token.output;
+                    push(token);
+                    continue;
+                }
+                if (prev && ('bracket' === prev.type || 'paren' === prev.type) && true === opts.regex) {
+                    token.output = value;
+                    push(token);
+                    continue;
+                }
+                if (state.index === state.start || 'slash' === prev.type || 'dot' === prev.type) {
+                    if ('dot' === prev.type) {
+                        state.output += NO_DOT_SLASH;
+                        prev.output += NO_DOT_SLASH;
+                    } else if (true === opts.dot) {
+                        state.output += NO_DOTS_SLASH;
+                        prev.output += NO_DOTS_SLASH;
+                    } else {
+                        state.output += nodot;
+                        prev.output += nodot;
+                    }
+                    if ('*' !== peek()) {
+                        state.output += ONE_CHAR;
+                        prev.output += ONE_CHAR;
+                    }
+                }
+                push(token);
+            }
+            while(state.brackets > 0){
+                if (true === opts.strictBrackets) throw new SyntaxError(syntaxError('closing', ']'));
+                state.output = utils.escapeLast(state.output, '[');
+                decrement('brackets');
+            }
+            while(state.parens > 0){
+                if (true === opts.strictBrackets) throw new SyntaxError(syntaxError('closing', ')'));
+                state.output = utils.escapeLast(state.output, '(');
+                decrement('parens');
+            }
+            while(state.braces > 0){
+                if (true === opts.strictBrackets) throw new SyntaxError(syntaxError('closing', '}'));
+                state.output = utils.escapeLast(state.output, '{');
+                decrement('braces');
+            }
+            if (true !== opts.strictSlashes && ('star' === prev.type || 'bracket' === prev.type)) push({
+                type: 'maybe_slash',
+                value: '',
+                output: `${SLASH_LITERAL}?`
+            });
+            if (true === state.backtrack) {
+                state.output = '';
+                for (const token of state.tokens){
+                    state.output += null != token.output ? token.output : token.value;
+                    if (token.suffix) state.output += token.suffix;
+                }
+            }
+            return state;
+        };
+        parse.fastpaths = (input, options)=>{
+            const opts = {
+                ...options
+            };
+            const max = 'number' == typeof opts.maxLength ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+            const len = input.length;
+            if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+            input = REPLACEMENTS[input] || input;
+            const win32 = utils.isWindows(options);
+            const { DOT_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants.globChars(win32);
+            const nodot = opts.dot ? NO_DOTS : NO_DOT;
+            const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+            const capture = opts.capture ? '' : '?:';
+            const state = {
+                negated: false,
+                prefix: ''
+            };
+            let star = true === opts.bash ? '.*?' : STAR;
+            if (opts.capture) star = `(${star})`;
+            const globstar = (opts)=>{
+                if (true === opts.noglobstar) return star;
+                return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+            };
+            const create = (str)=>{
+                switch(str){
+                    case '*':
+                        return `${nodot}${ONE_CHAR}${star}`;
+                    case '.*':
+                        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+                    case '*.*':
+                        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+                    case '*/*':
+                        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+                    case '**':
+                        return nodot + globstar(opts);
+                    case '**/*':
+                        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+                    case '**/*.*':
+                        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+                    case '**/.*':
+                        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+                    default:
+                        {
+                            const match = /^(.*?)\.(\w+)$/.exec(str);
+                            if (!match) return;
+                            const source = create(match[1]);
+                            if (!source) return;
+                            return source + DOT_LITERAL + match[2];
+                        }
+                }
+            };
+            const output = utils.removePrefix(input, state);
+            let source = create(output);
+            if (source && true !== opts.strictSlashes) source += `${SLASH_LITERAL}?`;
+            return source;
+        };
+        module.exports = parse;
+    },
+    "./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/picomatch.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const path = __webpack_require__("path");
+        const scan = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/scan.js");
+        const parse = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/parse.js");
+        const utils = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/utils.js");
+        const constants = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/constants.js");
+        const isObject = (val)=>val && 'object' == typeof val && !Array.isArray(val);
+        const picomatch = (glob, options, returnState = false)=>{
+            if (Array.isArray(glob)) {
+                const fns = glob.map((input)=>picomatch(input, options, returnState));
+                const arrayMatcher = (str)=>{
+                    for (const isMatch of fns){
+                        const state = isMatch(str);
+                        if (state) return state;
+                    }
+                    return false;
+                };
+                return arrayMatcher;
+            }
+            const isState = isObject(glob) && glob.tokens && glob.input;
+            if ('' === glob || 'string' != typeof glob && !isState) throw new TypeError('Expected pattern to be a non-empty string');
+            const opts = options || {};
+            const posix = utils.isWindows(options);
+            const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
+            const state = regex.state;
+            delete regex.state;
+            let isIgnored = ()=>false;
+            if (opts.ignore) {
+                const ignoreOpts = {
+                    ...options,
+                    ignore: null,
+                    onMatch: null,
+                    onResult: null
+                };
+                isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+            }
+            const matcher = (input, returnObject = false)=>{
+                const { isMatch, match, output } = picomatch.test(input, regex, options, {
+                    glob,
+                    posix
+                });
+                const result = {
+                    glob,
+                    state,
+                    regex,
+                    posix,
+                    input,
+                    output,
+                    match,
+                    isMatch
+                };
+                if ('function' == typeof opts.onResult) opts.onResult(result);
+                if (false === isMatch) {
+                    result.isMatch = false;
+                    return returnObject ? result : false;
+                }
+                if (isIgnored(input)) {
+                    if ('function' == typeof opts.onIgnore) opts.onIgnore(result);
+                    result.isMatch = false;
+                    return returnObject ? result : false;
+                }
+                if ('function' == typeof opts.onMatch) opts.onMatch(result);
+                return returnObject ? result : true;
+            };
+            if (returnState) matcher.state = state;
+            return matcher;
+        };
+        picomatch.test = (input, regex, options, { glob, posix } = {})=>{
+            if ('string' != typeof input) throw new TypeError('Expected input to be a string');
+            if ('' === input) return {
+                isMatch: false,
+                output: ''
+            };
+            const opts = options || {};
+            const format = opts.format || (posix ? utils.toPosixSlashes : null);
+            let match = input === glob;
+            let output = match && format ? format(input) : input;
+            if (false === match) {
+                output = format ? format(input) : input;
+                match = output === glob;
+            }
+            if (false === match || true === opts.capture) match = true === opts.matchBase || true === opts.basename ? picomatch.matchBase(input, regex, options, posix) : regex.exec(output);
+            return {
+                isMatch: Boolean(match),
+                match,
+                output
+            };
+        };
+        picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options))=>{
+            const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+            return regex.test(path.basename(input));
+        };
+        picomatch.isMatch = (str, patterns, options)=>picomatch(patterns, options)(str);
+        picomatch.parse = (pattern, options)=>{
+            if (Array.isArray(pattern)) return pattern.map((p)=>picomatch.parse(p, options));
+            return parse(pattern, {
+                ...options,
+                fastpaths: false
+            });
+        };
+        picomatch.scan = (input, options)=>scan(input, options);
+        picomatch.compileRe = (state, options, returnOutput = false, returnState = false)=>{
+            if (true === returnOutput) return state.output;
+            const opts = options || {};
+            const prepend = opts.contains ? '' : '^';
+            const append = opts.contains ? '' : '$';
+            let source = `${prepend}(?:${state.output})${append}`;
+            if (state && true === state.negated) source = `^(?!${source}).*$`;
+            const regex = picomatch.toRegex(source, options);
+            if (true === returnState) regex.state = state;
+            return regex;
+        };
+        picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false)=>{
+            if (!input || 'string' != typeof input) throw new TypeError('Expected a non-empty string');
+            let parsed = {
+                negated: false,
+                fastpaths: true
+            };
+            if (false !== options.fastpaths && ('.' === input[0] || '*' === input[0])) parsed.output = parse.fastpaths(input, options);
+            if (!parsed.output) parsed = parse(input, options);
+            return picomatch.compileRe(parsed, options, returnOutput, returnState);
+        };
+        picomatch.toRegex = (source, options)=>{
+            try {
+                const opts = options || {};
+                return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+            } catch (err) {
+                if (options && true === options.debug) throw err;
+                return /$^/;
+            }
+        };
+        picomatch.constants = constants;
+        module.exports = picomatch;
+    },
+    "./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/scan.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const utils = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/utils.js");
+        const { CHAR_ASTERISK, CHAR_AT, CHAR_BACKWARD_SLASH, CHAR_COMMA, CHAR_DOT, CHAR_EXCLAMATION_MARK, CHAR_FORWARD_SLASH, CHAR_LEFT_CURLY_BRACE, CHAR_LEFT_PARENTHESES, CHAR_LEFT_SQUARE_BRACKET, CHAR_PLUS, CHAR_QUESTION_MARK, CHAR_RIGHT_CURLY_BRACE, CHAR_RIGHT_PARENTHESES, CHAR_RIGHT_SQUARE_BRACKET } = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/constants.js");
+        const isPathSeparator = (code)=>code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+        const depth = (token)=>{
+            if (true !== token.isPrefix) token.depth = token.isGlobstar ? 1 / 0 : 1;
+        };
+        const scan = (input, options)=>{
+            const opts = options || {};
+            const length = input.length - 1;
+            const scanToEnd = true === opts.parts || true === opts.scanToEnd;
+            const slashes = [];
+            const tokens = [];
+            const parts = [];
+            let str = input;
+            let index = -1;
+            let start = 0;
+            let lastIndex = 0;
+            let isBrace = false;
+            let isBracket = false;
+            let isGlob = false;
+            let isExtglob = false;
+            let isGlobstar = false;
+            let braceEscaped = false;
+            let backslashes = false;
+            let negated = false;
+            let negatedExtglob = false;
+            let finished = false;
+            let braces = 0;
+            let prev;
+            let code;
+            let token = {
+                value: '',
+                depth: 0,
+                isGlob: false
+            };
+            const eos = ()=>index >= length;
+            const peek = ()=>str.charCodeAt(index + 1);
+            const advance = ()=>{
+                prev = code;
+                return str.charCodeAt(++index);
+            };
+            while(index < length){
+                code = advance();
+                let next;
+                if (code === CHAR_BACKWARD_SLASH) {
+                    backslashes = token.backslashes = true;
+                    code = advance();
+                    if (code === CHAR_LEFT_CURLY_BRACE) braceEscaped = true;
+                    continue;
+                }
+                if (true === braceEscaped || code === CHAR_LEFT_CURLY_BRACE) {
+                    braces++;
+                    while(true !== eos() && (code = advance())){
+                        if (code === CHAR_BACKWARD_SLASH) {
+                            backslashes = token.backslashes = true;
+                            advance();
+                            continue;
+                        }
+                        if (code === CHAR_LEFT_CURLY_BRACE) {
+                            braces++;
+                            continue;
+                        }
+                        if (true !== braceEscaped && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+                            isBrace = token.isBrace = true;
+                            isGlob = token.isGlob = true;
+                            finished = true;
+                            if (true === scanToEnd) continue;
+                            break;
+                        }
+                        if (true !== braceEscaped && code === CHAR_COMMA) {
+                            isBrace = token.isBrace = true;
+                            isGlob = token.isGlob = true;
+                            finished = true;
+                            if (true === scanToEnd) continue;
+                            break;
+                        }
+                        if (code === CHAR_RIGHT_CURLY_BRACE) {
+                            braces--;
+                            if (0 === braces) {
+                                braceEscaped = false;
+                                isBrace = token.isBrace = true;
+                                finished = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_FORWARD_SLASH) {
+                    slashes.push(index);
+                    tokens.push(token);
+                    token = {
+                        value: '',
+                        depth: 0,
+                        isGlob: false
+                    };
+                    if (true === finished) continue;
+                    if (prev === CHAR_DOT && index === start + 1) {
+                        start += 2;
+                        continue;
+                    }
+                    lastIndex = index + 1;
+                    continue;
+                }
+                if (true !== opts.noext) {
+                    const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
+                    if (true === isExtglobChar && peek() === CHAR_LEFT_PARENTHESES) {
+                        isGlob = token.isGlob = true;
+                        isExtglob = token.isExtglob = true;
+                        finished = true;
+                        if (code === CHAR_EXCLAMATION_MARK && index === start) negatedExtglob = true;
+                        if (true === scanToEnd) {
+                            while(true !== eos() && (code = advance())){
+                                if (code === CHAR_BACKWARD_SLASH) {
+                                    backslashes = token.backslashes = true;
+                                    code = advance();
+                                    continue;
+                                }
+                                if (code === CHAR_RIGHT_PARENTHESES) {
+                                    isGlob = token.isGlob = true;
+                                    finished = true;
+                                    break;
+                                }
+                            }
+                            continue;
+                        }
+                        break;
+                    }
+                }
+                if (code === CHAR_ASTERISK) {
+                    if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+                    isGlob = token.isGlob = true;
+                    finished = true;
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_QUESTION_MARK) {
+                    isGlob = token.isGlob = true;
+                    finished = true;
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_LEFT_SQUARE_BRACKET) {
+                    while(true !== eos() && (next = advance())){
+                        if (next === CHAR_BACKWARD_SLASH) {
+                            backslashes = token.backslashes = true;
+                            advance();
+                            continue;
+                        }
+                        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+                            isBracket = token.isBracket = true;
+                            isGlob = token.isGlob = true;
+                            finished = true;
+                            break;
+                        }
+                    }
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+                if (true !== opts.nonegate && code === CHAR_EXCLAMATION_MARK && index === start) {
+                    negated = token.negated = true;
+                    start++;
+                    continue;
+                }
+                if (true !== opts.noparen && code === CHAR_LEFT_PARENTHESES) {
+                    isGlob = token.isGlob = true;
+                    if (true === scanToEnd) {
+                        while(true !== eos() && (code = advance())){
+                            if (code === CHAR_LEFT_PARENTHESES) {
+                                backslashes = token.backslashes = true;
+                                code = advance();
+                                continue;
+                            }
+                            if (code === CHAR_RIGHT_PARENTHESES) {
+                                finished = true;
+                                break;
+                            }
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                if (true === isGlob) {
+                    finished = true;
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+            }
+            if (true === opts.noext) {
+                isExtglob = false;
+                isGlob = false;
+            }
+            let base = str;
+            let prefix = '';
+            let glob = '';
+            if (start > 0) {
+                prefix = str.slice(0, start);
+                str = str.slice(start);
+                lastIndex -= start;
+            }
+            if (base && true === isGlob && lastIndex > 0) {
+                base = str.slice(0, lastIndex);
+                glob = str.slice(lastIndex);
+            } else if (true === isGlob) {
+                base = '';
+                glob = str;
+            } else base = str;
+            if (base && '' !== base && '/' !== base && base !== str) {
+                if (isPathSeparator(base.charCodeAt(base.length - 1))) base = base.slice(0, -1);
+            }
+            if (true === opts.unescape) {
+                if (glob) glob = utils.removeBackslashes(glob);
+                if (base && true === backslashes) base = utils.removeBackslashes(base);
+            }
+            const state = {
+                prefix,
+                input,
+                start,
+                base,
+                glob,
+                isBrace,
+                isBracket,
+                isGlob,
+                isExtglob,
+                isGlobstar,
+                negated,
+                negatedExtglob
+            };
+            if (true === opts.tokens) {
+                state.maxDepth = 0;
+                if (!isPathSeparator(code)) tokens.push(token);
+                state.tokens = tokens;
+            }
+            if (true === opts.parts || true === opts.tokens) {
+                let prevIndex;
+                for(let idx = 0; idx < slashes.length; idx++){
+                    const n = prevIndex ? prevIndex + 1 : start;
+                    const i = slashes[idx];
+                    const value = input.slice(n, i);
+                    if (opts.tokens) {
+                        if (0 === idx && 0 !== start) {
+                            tokens[idx].isPrefix = true;
+                            tokens[idx].value = prefix;
+                        } else tokens[idx].value = value;
+                        depth(tokens[idx]);
+                        state.maxDepth += tokens[idx].depth;
+                    }
+                    if (0 !== idx || '' !== value) parts.push(value);
+                    prevIndex = i;
+                }
+                if (prevIndex && prevIndex + 1 < input.length) {
+                    const value = input.slice(prevIndex + 1);
+                    parts.push(value);
+                    if (opts.tokens) {
+                        tokens[tokens.length - 1].value = value;
+                        depth(tokens[tokens.length - 1]);
+                        state.maxDepth += tokens[tokens.length - 1].depth;
+                    }
+                }
+                state.slashes = slashes;
+                state.parts = parts;
+            }
+            return state;
+        };
+        module.exports = scan;
+    },
+    "./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/utils.js" (__unused_rspack_module, exports, __webpack_require__) {
+        const path = __webpack_require__("path");
+        const win32 = 'win32' === process.platform;
+        const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/constants.js");
+        exports.isObject = (val)=>null !== val && 'object' == typeof val && !Array.isArray(val);
+        exports.hasRegexChars = (str)=>REGEX_SPECIAL_CHARS.test(str);
+        exports.isRegexChar = (str)=>1 === str.length && exports.hasRegexChars(str);
+        exports.escapeRegex = (str)=>str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+        exports.toPosixSlashes = (str)=>str.replace(REGEX_BACKSLASH, '/');
+        exports.removeBackslashes = (str)=>str.replace(REGEX_REMOVE_BACKSLASH, (match)=>'\\' === match ? '' : match);
+        exports.supportsLookbehinds = ()=>{
+            const segs = process.version.slice(1).split('.').map(Number);
+            if (3 === segs.length && segs[0] >= 9 || 8 === segs[0] && segs[1] >= 10) return true;
+            return false;
+        };
+        exports.isWindows = (options)=>{
+            if (options && 'boolean' == typeof options.windows) return options.windows;
+            return true === win32 || '\\' === path.sep;
+        };
+        exports.escapeLast = (input, char, lastIdx)=>{
+            const idx = input.lastIndexOf(char, lastIdx);
+            if (-1 === idx) return input;
+            if ('\\' === input[idx - 1]) return exports.escapeLast(input, char, idx - 1);
+            return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+        };
+        exports.removePrefix = (input, state = {})=>{
+            let output = input;
+            if (output.startsWith('./')) {
+                output = output.slice(2);
+                state.prefix = './';
+            }
+            return output;
+        };
+        exports.wrapOutput = (input, state = {}, options = {})=>{
+            const prepend = options.contains ? '' : '^';
+            const append = options.contains ? '' : '$';
+            let output = `${prepend}(?:${input})${append}`;
+            if (true === state.negated) output = `(?:^(?!${output}).*$)`;
+            return output;
+        };
+    },
+    "./node_modules/.pnpm/to-regex-range@5.0.1/node_modules/to-regex-range/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        /*!
+ * to-regex-range <https://github.com/micromatch/to-regex-range>
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */ const isNumber = __webpack_require__("./node_modules/.pnpm/is-number@7.0.0/node_modules/is-number/index.js");
+        const toRegexRange = (min, max, options)=>{
+            if (false === isNumber(min)) throw new TypeError('toRegexRange: expected the first argument to be a number');
+            if (void 0 === max || min === max) return String(min);
+            if (false === isNumber(max)) throw new TypeError('toRegexRange: expected the second argument to be a number.');
+            let opts = {
+                relaxZeros: true,
+                ...options
+            };
+            if ('boolean' == typeof opts.strictZeros) opts.relaxZeros = false === opts.strictZeros;
+            let relax = String(opts.relaxZeros);
+            let shorthand = String(opts.shorthand);
+            let capture = String(opts.capture);
+            let wrap = String(opts.wrap);
+            let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;
+            if (toRegexRange.cache.hasOwnProperty(cacheKey)) return toRegexRange.cache[cacheKey].result;
+            let a = Math.min(min, max);
+            let b = Math.max(min, max);
+            if (1 === Math.abs(a - b)) {
+                let result = min + '|' + max;
+                if (opts.capture) return `(${result})`;
+                if (false === opts.wrap) return result;
+                return `(?:${result})`;
+            }
+            let isPadded = hasPadding(min) || hasPadding(max);
+            let state = {
+                min,
+                max,
+                a,
+                b
+            };
+            let positives = [];
+            let negatives = [];
+            if (isPadded) {
+                state.isPadded = isPadded;
+                state.maxLen = String(state.max).length;
+            }
+            if (a < 0) {
+                let newMin = b < 0 ? Math.abs(b) : 1;
+                negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
+                a = state.a = 0;
+            }
+            if (b >= 0) positives = splitToPatterns(a, b, state, opts);
+            state.negatives = negatives;
+            state.positives = positives;
+            state.result = collatePatterns(negatives, positives, opts);
+            if (true === opts.capture) state.result = `(${state.result})`;
+            else if (false !== opts.wrap && positives.length + negatives.length > 1) state.result = `(?:${state.result})`;
+            toRegexRange.cache[cacheKey] = state;
+            return state.result;
+        };
+        function collatePatterns(neg, pos, options) {
+            let onlyNegative = filterPatterns(neg, pos, '-', false, options) || [];
+            let onlyPositive = filterPatterns(pos, neg, '', false, options) || [];
+            let intersected = filterPatterns(neg, pos, '-?', true, options) || [];
+            let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
+            return subpatterns.join('|');
+        }
+        function splitToRanges(min, max) {
+            let nines = 1;
+            let zeros = 1;
+            let stop = countNines(min, nines);
+            let stops = new Set([
+                max
+            ]);
+            while(min <= stop && stop <= max){
+                stops.add(stop);
+                nines += 1;
+                stop = countNines(min, nines);
+            }
+            stop = countZeros(max + 1, zeros) - 1;
+            while(min < stop && stop <= max){
+                stops.add(stop);
+                zeros += 1;
+                stop = countZeros(max + 1, zeros) - 1;
+            }
+            stops = [
+                ...stops
+            ];
+            stops.sort(compare);
+            return stops;
+        }
+        function rangeToPattern(start, stop, options) {
+            if (start === stop) return {
+                pattern: start,
+                count: [],
+                digits: 0
+            };
+            let zipped = zip(start, stop);
+            let digits = zipped.length;
+            let pattern = '';
+            let count = 0;
+            for(let i = 0; i < digits; i++){
+                let [startDigit, stopDigit] = zipped[i];
+                if (startDigit === stopDigit) pattern += startDigit;
+                else if ('0' !== startDigit || '9' !== stopDigit) pattern += toCharacterClass(startDigit, stopDigit, options);
+                else count++;
+            }
+            if (count) pattern += true === options.shorthand ? '\\d' : '[0-9]';
+            return {
+                pattern,
+                count: [
+                    count
+                ],
+                digits
+            };
+        }
+        function splitToPatterns(min, max, tok, options) {
+            let ranges = splitToRanges(min, max);
+            let tokens = [];
+            let start = min;
+            let prev;
+            for(let i = 0; i < ranges.length; i++){
+                let max = ranges[i];
+                let obj = rangeToPattern(String(start), String(max), options);
+                let zeros = '';
+                if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+                    if (prev.count.length > 1) prev.count.pop();
+                    prev.count.push(obj.count[0]);
+                    prev.string = prev.pattern + toQuantifier(prev.count);
+                    start = max + 1;
+                    continue;
+                }
+                if (tok.isPadded) zeros = padZeros(max, tok, options);
+                obj.string = zeros + obj.pattern + toQuantifier(obj.count);
+                tokens.push(obj);
+                start = max + 1;
+                prev = obj;
+            }
+            return tokens;
+        }
+        function filterPatterns(arr, comparison, prefix, intersection, options) {
+            let result = [];
+            for (let ele of arr){
+                let { string } = ele;
+                if (!intersection && !contains(comparison, 'string', string)) result.push(prefix + string);
+                if (intersection && contains(comparison, 'string', string)) result.push(prefix + string);
+            }
+            return result;
+        }
+        function zip(a, b) {
+            let arr = [];
+            for(let i = 0; i < a.length; i++)arr.push([
+                a[i],
+                b[i]
+            ]);
+            return arr;
+        }
+        function compare(a, b) {
+            return a > b ? 1 : b > a ? -1 : 0;
+        }
+        function contains(arr, key, val) {
+            return arr.some((ele)=>ele[key] === val);
+        }
+        function countNines(min, len) {
+            return Number(String(min).slice(0, -len) + '9'.repeat(len));
+        }
+        function countZeros(integer, zeros) {
+            return integer - integer % Math.pow(10, zeros);
+        }
+        function toQuantifier(digits) {
+            let [start = 0, stop = ''] = digits;
+            if (stop || start > 1) return `{${start + (stop ? ',' + stop : '')}}`;
+            return '';
+        }
+        function toCharacterClass(a, b, options) {
+            return `[${a}${b - a === 1 ? '' : '-'}${b}]`;
+        }
+        function hasPadding(str) {
+            return /^-?(0+)\d/.test(str);
+        }
+        function padZeros(value, tok, options) {
+            if (!tok.isPadded) return value;
+            let diff = Math.abs(tok.maxLen - String(value).length);
+            let relax = false !== options.relaxZeros;
+            switch(diff){
+                case 0:
+                    return '';
+                case 1:
+                    return relax ? '0?' : '0';
+                case 2:
+                    return relax ? '0{0,2}' : '00';
+                default:
+                    return relax ? `0{0,${diff}}` : `0{${diff}}`;
+            }
+        }
+        toRegexRange.cache = {};
+        toRegexRange.clearCache = ()=>toRegexRange.cache = {};
+        module.exports = toRegexRange;
+    }
+});
+const upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i;
+const defaultAgents = {
+    http: new node_http.Agent({
+        keepAlive: true,
+        maxSockets: 256,
+        maxFreeSockets: 64
+    }),
+    https: new node_https.Agent({
+        keepAlive: true,
+        maxSockets: 256,
+        maxFreeSockets: 64
+    })
+};
+const isSSL = /^https|wss/;
+const HTTP2_HEADER_BLACKLIST = [
+    ":method",
+    ":path",
+    ":scheme",
+    ":authority"
+];
+function setupOutgoing(outgoing, options, req, forward) {
+    outgoing.port = options[forward || "target"].port || (isSSL.test(options[forward || "target"].protocol ?? "http") ? 443 : 80);
+    for (const e of [
+        "host",
+        "hostname",
+        "socketPath",
+        "pfx",
+        "key",
+        "passphrase",
+        "cert",
+        "ca",
+        "ciphers",
+        "secureProtocol"
+    ]){
+        const value = options[forward || "target"][e];
+        if (void 0 !== value) outgoing[e] = value;
+    }
+    outgoing.method = options.method || req.method;
+    outgoing.headers = {
+        ...req.headers
+    };
+    if (req.headers?.[":authority"]) outgoing.headers.host = req.headers[":authority"];
+    if (options.headers) for (const key of Object.keys(options.headers))outgoing.headers[key] = options.headers[key];
+    if (req.httpVersionMajor > 1) for (const header of HTTP2_HEADER_BLACKLIST)delete outgoing.headers[header];
+    if (options.auth) outgoing.auth = options.auth;
+    if (options.ca) outgoing.ca = options.ca;
+    if (isSSL.test(options[forward || "target"].protocol ?? "http")) outgoing.rejectUnauthorized = void 0 === options.secure ? true : options.secure;
+    if (void 0 !== options.agent) outgoing.agent = options.agent || false;
+    else if (req.httpVersionMajor > 1 || upgradeHeader.test(req.headers.connection || "")) outgoing.agent = false;
+    else {
+        const targetProto = options[forward || "target"].protocol ?? "http";
+        outgoing.agent = isSSL.test(targetProto) ? defaultAgents.https : defaultAgents.http;
+    }
+    outgoing.localAddress = options.localAddress;
+    if (!outgoing.agent) {
+        outgoing.headers = outgoing.headers || {};
+        if ("string" != typeof outgoing.headers.connection || !upgradeHeader.test(outgoing.headers.connection)) outgoing.headers.connection = "close";
+    }
+    const target = options[forward || "target"];
+    const targetPath = target && false !== options.prependPath ? target.pathname || "" : "";
+    const targetSearch = target instanceof URL && false !== options.prependPath ? target.search || "" : "";
+    const reqUrl = req.url || "";
+    const qIdx = reqUrl.indexOf("?");
+    const reqPath = -1 === qIdx ? reqUrl : reqUrl.slice(0, qIdx);
+    const reqSearch = -1 === qIdx ? "" : reqUrl.slice(qIdx);
+    const normalizedPath = reqPath ? "/" === reqPath[0] ? reqPath : "/" + reqPath : "/";
+    let outgoingPath = options.toProxy ? "/" + reqUrl : normalizedPath + reqSearch;
+    outgoingPath = options.ignorePath ? "" : outgoingPath;
+    let fullPath = joinURL(targetPath, outgoingPath);
+    if (targetSearch) fullPath = fullPath.includes("?") ? fullPath.replace("?", targetSearch + "&") : fullPath + targetSearch;
+    outgoing.path = fullPath;
+    if (options.changeOrigin) outgoing.headers.host = requiresPort(outgoing.port, options[forward || "target"].protocol) && !hasPort(outgoing.host) ? outgoing.host + ":" + outgoing.port : outgoing.host ?? void 0;
+    return outgoing;
+}
+function joinURL(base, path) {
+    if (!base || "/" === base) return path || "/";
+    if (!path || "/" === path) return base || "/";
+    const baseHasTrailing = "/" === base[base.length - 1];
+    const pathHasLeading = "/" === path[0];
+    if (baseHasTrailing && pathHasLeading) return base + path.slice(1);
+    if (!baseHasTrailing && !pathHasLeading) return base + "/" + path;
+    return base + path;
+}
+function setupSocket(socket) {
+    socket.setTimeout(0);
+    socket.setNoDelay(true);
+    socket.setKeepAlive(true, 0);
+    return socket;
+}
+function getPort(req) {
+    const hostHeader = req.headers[":authority"] || req.headers.host;
+    const res = hostHeader ? hostHeader.match(/:(\d+)/) : "";
+    if (res) return res[1];
+    return hasEncryptedConnection(req) ? "443" : "80";
+}
+function hasEncryptedConnection(req) {
+    const socket = req.socket;
+    return !!socket && "encrypted" in socket && socket.encrypted;
+}
+function rewriteCookieProperty(header, config, property) {
+    if (Array.isArray(header)) return header.map(function(headerElement) {
+        return rewriteCookieProperty(headerElement, config, property);
+    });
+    return header.replace(new RegExp(String.raw`(;\s*` + property + "=)([^;]+)", "i"), function(match, prefix, previousValue) {
+        let newValue;
+        if (previousValue in config) newValue = config[previousValue];
+        else {
+            if (!("*" in config)) return match;
+            newValue = config["*"];
+        }
+        return newValue ? prefix + newValue : "";
+    });
+}
+function hasPort(host) {
+    return host ? !!~host.indexOf(":") : false;
+}
+function requiresPort(_port, _protocol) {
+    const protocol = _protocol?.split(":")[0];
+    const port = +_port;
+    if (!port) return false;
+    switch(protocol){
+        case "http":
+        case "ws":
+            return 80 !== port;
+        case "https":
+        case "wss":
+            return 443 !== port;
+        case "ftp":
+            return 21 !== port;
+        case "gopher":
+            return 70 !== port;
+        case "file":
+            return false;
+    }
+    return 0 !== port;
+}
+function defineProxyMiddleware(m) {
+    return m;
+}
+function defineProxyOutgoingMiddleware(m) {
+    return m;
+}
+const redirectRegex = /^201|30([12378])$/;
+const webOutgoingMiddleware = [
+    defineProxyOutgoingMiddleware((req, res, proxyRes)=>{
+        if ("1.0" === req.httpVersion || req.httpVersionMajor >= 2 || 204 === proxyRes.statusCode || 304 === proxyRes.statusCode) delete proxyRes.headers["transfer-encoding"];
+    }),
+    defineProxyOutgoingMiddleware((req, res, proxyRes)=>{
+        if ("1.0" === req.httpVersion) proxyRes.headers.connection = req.headers.connection || "close";
+        else if (req.httpVersionMajor < 2 && !proxyRes.headers.connection) proxyRes.headers.connection = req.headers.connection || "keep-alive";
+        else if (req.httpVersionMajor >= 2) delete proxyRes.headers.connection;
+    }),
+    defineProxyOutgoingMiddleware((req, res, proxyRes, options)=>{
+        if ((options.hostRewrite || options.autoRewrite || options.protocolRewrite) && proxyRes.headers.location && redirectRegex.test(String(proxyRes.statusCode))) {
+            const target = _toURL(options.target);
+            const u = new URL(proxyRes.headers.location, target);
+            if (target.host !== u.host) return;
+            if (options.hostRewrite) u.host = options.hostRewrite;
+            else if (options.autoRewrite) {
+                if (req.headers[":authority"]) u.host = req.headers[":authority"];
+                else if (req.headers.host) u.host = req.headers.host;
+            }
+            if (options.protocolRewrite) u.protocol = options.protocolRewrite;
+            proxyRes.headers.location = u.toString();
+        }
+    }),
+    defineProxyOutgoingMiddleware((req, res, proxyRes, options)=>{
+        const rewriteCookieDomainConfig = "string" == typeof options.cookieDomainRewrite ? {
+            "*": options.cookieDomainRewrite
+        } : options.cookieDomainRewrite;
+        const rewriteCookiePathConfig = "string" == typeof options.cookiePathRewrite ? {
+            "*": options.cookiePathRewrite
+        } : options.cookiePathRewrite;
+        const preserveHeaderKeyCase = options.preserveHeaderKeyCase;
+        let rawHeaderKeyMap;
+        const setHeader = function(key, header) {
+            if (void 0 === header || !String(key).trim()) return;
+            if (rewriteCookieDomainConfig && "set-cookie" === key.toLowerCase()) header = rewriteCookieProperty(header, rewriteCookieDomainConfig, "domain");
+            if (rewriteCookiePathConfig && "set-cookie" === key.toLowerCase()) header = rewriteCookieProperty(header, rewriteCookiePathConfig, "path");
+            try {
+                res.setHeader(String(key).trim(), header);
+            } catch  {}
+        };
+        if (preserveHeaderKeyCase && void 0 !== proxyRes.rawHeaders) {
+            rawHeaderKeyMap = {};
+            for(let i = 0; i < proxyRes.rawHeaders.length; i += 2){
+                const key = proxyRes.rawHeaders[i];
+                rawHeaderKeyMap[key.toLowerCase()] = key;
+            }
+        }
+        for (let key of Object.keys(proxyRes.headers)){
+            const header = proxyRes.headers[key];
+            if (preserveHeaderKeyCase && rawHeaderKeyMap) key = rawHeaderKeyMap[key] || key;
+            setHeader(key, header);
+        }
+    }),
+    defineProxyOutgoingMiddleware((req, res, proxyRes)=>{
+        res.statusCode = proxyRes.statusCode;
+        if (proxyRes.statusMessage && req.httpVersionMajor < 2) res.statusMessage = proxyRes.statusMessage;
+    })
+];
+function _toURL(target) {
+    if (target instanceof URL) return target;
+    if ("string" == typeof target) return new URL(target);
+    const protocol = target.protocol || "http:";
+    const host = target.host || target.hostname || "localhost";
+    const port = target.port;
+    return new URL(`${protocol}//${host}${port ? ":" + port : ""}`);
+}
+const nativeAgents = {
+    http: node_http,
+    https: node_https
+};
+const redirectStatuses = new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+]);
+const webIncomingMiddleware = [
+    defineProxyMiddleware((req)=>{
+        if (("DELETE" === req.method || "OPTIONS" === req.method) && !req.headers["content-length"]) {
+            req.headers["content-length"] = "0";
+            delete req.headers["transfer-encoding"];
+        }
+    }),
+    defineProxyMiddleware((req, res, options)=>{
+        if (options.timeout) req.socket.setTimeout(options.timeout, ()=>{
+            req.socket.destroy();
+        });
+    }),
+    defineProxyMiddleware((req, res, options)=>{
+        if (!options.xfwd) return;
+        const encrypted = req.isSpdy || hasEncryptedConnection(req);
+        const values = {
+            for: req.connection.remoteAddress || req.socket.remoteAddress,
+            port: getPort(req),
+            proto: encrypted ? "https" : "http"
+        };
+        for (const header of [
+            "for",
+            "port",
+            "proto"
+        ]){
+            const key = "x-forwarded-" + header;
+            if (!req.headers[key] && void 0 !== values[header]) req.headers[key] = values[header];
+        }
+        req.headers["x-forwarded-host"] = req.headers["x-forwarded-host"] || req.headers[":authority"] || req.headers.host || "";
+    }),
+    defineProxyMiddleware((req, res, options, server, head, callback)=>{
+        server.emit("start", req, res, options.target || options.forward);
+        const http = nativeAgents.http;
+        const https = nativeAgents.https;
+        const maxRedirects = "number" == typeof options.followRedirects ? options.followRedirects : options.followRedirects ? 5 : 0;
+        if (options.forward) {
+            const forwardReq = (isSSL.test(options.forward.protocol || "http") ? https : http).request(setupOutgoing(options.ssl || {}, options, req, "forward"));
+            const forwardError = createErrorHandler(forwardReq, options.forward);
+            req.on("error", forwardError);
+            forwardReq.on("error", forwardError);
+            (options.buffer || req).pipe(forwardReq);
+            if (!options.target) return void res.end();
+        }
+        const proxyReq = (isSSL.test(options.target.protocol || "http") ? https : http).request(setupOutgoing(options.ssl || {}, options, req));
+        proxyReq.on("socket", (_socket)=>{
+            if (server && !proxyReq.getHeader("expect")) server.emit("proxyReq", proxyReq, req, res, options);
+        });
+        if (options.proxyTimeout) proxyReq.setTimeout(options.proxyTimeout, function() {
+            proxyReq.destroy();
+        });
+        res.on("close", function() {
+            if (!res.writableFinished) proxyReq.destroy();
+        });
+        const proxyError = createErrorHandler(proxyReq, options.target);
+        req.on("error", proxyError);
+        proxyReq.on("error", proxyError);
+        function createErrorHandler(proxyReq, url) {
+            return function(err) {
+                if (!req.socket?.writable && "ECONNRESET" === err.code) {
+                    server.emit("econnreset", err, req, res, url);
+                    return proxyReq.destroy();
+                }
+                if (callback) callback(err, req, res, url);
+                else server.emit("error", err, req, res, url);
+            };
+        }
+        let bodyBuffer;
+        if (maxRedirects > 0) {
+            const chunks = [];
+            const source = options.buffer || req;
+            source.on("data", (chunk)=>{
+                chunks.push("string" == typeof chunk ? Buffer.from(chunk) : chunk);
+                proxyReq.write(chunk);
+            });
+            source.on("end", ()=>{
+                bodyBuffer = Buffer.concat(chunks);
+                proxyReq.end();
+            });
+            source.on("error", (err)=>{
+                proxyReq.destroy(err);
+            });
+        } else proxyReq.on("socket", (socket)=>{
+            if (socket.pending) socket.on("connect", ()=>(options.buffer || req).pipe(proxyReq));
+            else (options.buffer || req).pipe(proxyReq);
+        });
+        function handleResponse(proxyRes, redirectCount, currentUrl) {
+            const statusCode = proxyRes.statusCode;
+            if (maxRedirects > 0 && redirectStatuses.has(statusCode) && redirectCount < maxRedirects && proxyRes.headers.location) {
+                proxyRes.resume();
+                const location = new URL(proxyRes.headers.location, currentUrl);
+                const preserveMethod = 307 === statusCode || 308 === statusCode;
+                const redirectMethod = preserveMethod ? req.method || "GET" : "GET";
+                const isHTTPS = isSSL.test(location.protocol);
+                const agent = isHTTPS ? https : http;
+                const redirectHeaders = {
+                    ...req.headers
+                };
+                if (options.headers) Object.assign(redirectHeaders, options.headers);
+                redirectHeaders.host = location.host;
+                if (location.host !== currentUrl.host) {
+                    delete redirectHeaders.authorization;
+                    delete redirectHeaders.cookie;
+                }
+                if (!preserveMethod) {
+                    delete redirectHeaders["content-length"];
+                    delete redirectHeaders["content-type"];
+                    delete redirectHeaders["transfer-encoding"];
+                }
+                const redirectOpts = {
+                    hostname: location.hostname,
+                    port: location.port || (isHTTPS ? 443 : 80),
+                    path: location.pathname + location.search,
+                    method: redirectMethod,
+                    headers: redirectHeaders,
+                    agent: options.agent || false
+                };
+                if (isHTTPS) redirectOpts.rejectUnauthorized = void 0 === options.secure ? true : options.secure;
+                const redirectReq = agent.request(redirectOpts);
+                if (server && !redirectReq.getHeader("expect")) server.emit("proxyReq", redirectReq, req, res, options);
+                if (options.proxyTimeout) redirectReq.setTimeout(options.proxyTimeout, ()=>{
+                    redirectReq.destroy();
+                });
+                const redirectError = createErrorHandler(redirectReq, location);
+                redirectReq.on("error", redirectError);
+                redirectReq.on("response", (nextRes)=>{
+                    handleResponse(nextRes, redirectCount + 1, location);
+                });
+                if (preserveMethod && bodyBuffer && bodyBuffer.length > 0) redirectReq.end(bodyBuffer);
+                else redirectReq.end();
+                return;
+            }
+            if (server) server.emit("proxyRes", proxyRes, req, res);
+            if (!res.headersSent && !options.selfHandleResponse) {
+                for (const pass of webOutgoingMiddleware)if (pass(req, res, proxyRes, options)) break;
+            }
+            if (res.finished) {
+                if (server) server.emit("end", req, res, proxyRes);
+            } else {
+                res.on("close", function() {
+                    proxyRes.destroy();
+                });
+                proxyRes.on("close", function() {
+                    if (!proxyRes.complete && !res.destroyed) res.destroy();
+                });
+                proxyRes.on("error", function(err) {
+                    if (!res.destroyed) res.destroy(err);
+                    if (server.listenerCount("error") > 0) server.emit("error", err, req, res, currentUrl);
+                });
+                proxyRes.on("end", function() {
+                    if (server) server.emit("end", req, res, proxyRes);
+                });
+                if (!options.selfHandleResponse) proxyRes.pipe(res);
+            }
+        }
+        proxyReq.on("response", function(proxyRes) {
+            handleResponse(proxyRes, 0, options.target);
+        });
+    })
+];
+const websocketIncomingMiddleware = [
+    defineProxyMiddleware((req, socket)=>{
+        if ("GET" !== req.method || !req.headers.upgrade) {
+            socket.destroy();
+            return true;
+        }
+        if ("websocket" !== req.headers.upgrade.toLowerCase()) {
+            socket.destroy();
+            return true;
+        }
+    }),
+    defineProxyMiddleware((req, socket, options)=>{
+        if (!options.xfwd) return;
+        const values = {
+            for: req.connection.remoteAddress || req.socket.remoteAddress,
+            port: getPort(req),
+            proto: hasEncryptedConnection(req) ? "wss" : "ws"
+        };
+        for (const header of [
+            "for",
+            "port",
+            "proto"
+        ]){
+            const key = "x-forwarded-" + header;
+            if (!req.headers[key] && void 0 !== values[header]) req.headers[key] = values[header];
+        }
+    }),
+    defineProxyMiddleware((req, socket, options, server, head, callback)=>{
+        const createHttpHeader = function(line, headers) {
+            return Object.keys(headers).reduce(function(head, key) {
+                const value = headers[key];
+                if (!Array.isArray(value)) {
+                    head.push(key + ": " + value);
+                    return head;
+                }
+                for (const element of value)head.push(key + ": " + element);
+                return head;
+            }, [
+                line
+            ]).join("\r\n") + "\r\n\r\n";
+        };
+        setupSocket(socket);
+        if (head && head.length > 0) socket.unshift(head);
+        socket.on("error", onSocketError);
+        const proxyReq = (isSSL.test(options.target.protocol || "http") ? node_https : node_http).request(setupOutgoing(options.ssl || {}, options, req));
+        if (server) server.emit("proxyReqWs", proxyReq, req, socket, options, head);
+        proxyReq.on("error", onOutgoingError);
+        proxyReq.on("response", function(res) {
+            if (!res.upgrade) if (!socket.destroyed && socket.writable) {
+                socket.write(createHttpHeader("HTTP/" + res.httpVersion + " " + res.statusCode + " " + res.statusMessage, res.headers));
+                res.on("error", onOutgoingError);
+                res.pipe(socket);
+            } else res.resume();
+        });
+        proxyReq.on("upgrade", function(proxyRes, proxySocket, proxyHead) {
+            proxySocket.on("error", onOutgoingError);
+            proxySocket.on("end", function() {
+                server.emit("close", proxyRes, proxySocket, proxyHead);
+            });
+            socket.removeListener("error", onSocketError);
+            socket.on("error", function() {
+                proxySocket.end();
+            });
+            setupSocket(proxySocket);
+            if (proxyHead && proxyHead.length > 0) proxySocket.unshift(proxyHead);
+            socket.write(createHttpHeader("HTTP/1.1 101 Switching Protocols", proxyRes.headers));
+            proxySocket.pipe(socket).pipe(proxySocket);
+            server.emit("open", proxySocket);
+            server.emit("proxySocket", proxySocket);
+        });
+        proxyReq.end();
+        function onSocketError(err) {
+            if (callback) callback(err, req, socket);
+            else server.emit("error", err, req, socket);
+            proxyReq.destroy();
+        }
+        function onOutgoingError(err) {
+            if (callback) callback(err, req, socket);
+            else server.emit("error", err, req, socket);
+            socket.end();
+        }
+    })
+];
+var ProxyServer = class extends EventEmitter {
+    _server;
+    _webPasses = [
+        ...webIncomingMiddleware
+    ];
+    _wsPasses = [
+        ...websocketIncomingMiddleware
+    ];
+    options;
+    web;
+    ws;
+    constructor(options = {}){
+        super();
+        this.options = options || {};
+        this.options.prependPath = false !== options.prependPath;
+        this.web = _createProxyFn("web", this);
+        this.ws = _createProxyFn("ws", this);
+    }
+    listen(port, hostname, listeningListener) {
+        const closure = (req, res)=>this.web(req, res);
+        if (this.options.http2) {
+            if (!this.options.ssl) throw new Error("HTTP/2 requires ssl option");
+            this._server = node_http2.createSecureServer({
+                ...this.options.ssl,
+                allowHTTP1: true
+            }, closure);
+        } else if (this.options.ssl) this._server = node_https.createServer(this.options.ssl, closure);
+        else this._server = node_http.createServer(closure);
+        if (this.options.ws) this._server.on("upgrade", (req, socket, head)=>{
+            this.ws(req, socket, this.options, head).catch(()=>{});
+        });
+        this._server.listen(port, hostname, listeningListener);
+        return this;
+    }
+    close(callback) {
+        if (this._server) this._server.close((...args)=>{
+            this._server = void 0;
+            if (callback) Reflect.apply(callback, void 0, args);
+        });
+    }
+    before(type, passName, pass) {
+        if ("ws" !== type && "web" !== type) throw new Error("type must be `web` or `ws`");
+        const passes = this._getPasses(type);
+        let i = false;
+        for (const [idx, v] of passes.entries())if (v.name === passName) i = idx;
+        if (false === i) throw new Error("No such pass");
+        passes.splice(i, 0, pass);
+    }
+    after(type, passName, pass) {
+        if ("ws" !== type && "web" !== type) throw new Error("type must be `web` or `ws`");
+        const passes = this._getPasses(type);
+        let i = false;
+        for (const [idx, v] of passes.entries())if (v.name === passName) i = idx;
+        if (false === i) throw new Error("No such pass");
+        passes.splice(i++, 0, pass);
+    }
+    _getPasses(type) {
+        return "ws" === type ? this._wsPasses : this._webPasses;
+    }
+};
+function createProxyServer(options = {}) {
+    return new ProxyServer(options);
+}
+function _createProxyFn(type, server) {
+    return function(req, res, opts, head) {
+        const requestOptions = {
+            ...opts,
+            ...server.options
+        };
+        for (const key of [
+            "target",
+            "forward"
+        ])if ("string" == typeof requestOptions[key]) requestOptions[key] = new URL(requestOptions[key]);
+        if (!requestOptions.target && !requestOptions.forward) {
+            this.emit("error", /* @__PURE__ */ new Error("Must provide a proper URL as target"));
+            return Promise.resolve();
+        }
+        let _resolve;
+        let _reject;
+        const callbackPromise = new Promise((resolve, reject)=>{
+            _resolve = resolve;
+            _reject = reject;
+        });
+        res.on("close", ()=>{
+            _resolve();
+        });
+        res.on("error", (error)=>{
+            _reject(error);
+        });
+        for (const pass of server._getPasses(type)){
+            let stop;
+            try {
+                stop = pass(req, res, requestOptions, server, head, (error)=>{
+                    if (server.listenerCount("error") > 0) {
+                        server.emit("error", error, req, res);
+                        _resolve();
+                    } else _reject(error);
+                });
+            } catch (error) {
+                if (server.listenerCount("error") > 0) {
+                    server.emit("error", error, req, res);
+                    _resolve();
+                } else _reject(error);
+                break;
+            }
+            if (stop) {
+                _resolve();
+                break;
+            }
+        }
+        return callbackPromise;
+    };
+}
+new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+]);
+var errors_ERRORS;
+(function(ERRORS) {
+    ERRORS["ERR_CONFIG_FACTORY_TARGET_MISSING"] = "[HPM] Missing \"target\" option. Example: {target: \"http://www.example.org\"}";
+    ERRORS["ERR_CONTEXT_MATCHER_GENERIC"] = "[HPM] Invalid pathFilter. Expecting something like: \"/api\" or [\"/api\", \"/ajax\"]";
+    ERRORS["ERR_CONTEXT_MATCHER_INVALID_ARRAY"] = "[HPM] Invalid pathFilter. Plain paths (e.g. \"/api\") can not be mixed with globs (e.g. \"/api/**\"). Expecting something like: [\"/api\", \"/ajax\"] or [\"/api/**\", \"!**.html\"].";
+    ERRORS["ERR_PATH_REWRITER_CONFIG"] = "[HPM] Invalid pathRewrite config. Expecting object with pathRewrite config or a rewrite function";
+})(errors_ERRORS || (errors_ERRORS = {}));
+function verifyConfig(options) {
+    if (!options.target && !options.router) throw new Error(errors_ERRORS.ERR_CONFIG_FACTORY_TARGET_MISSING);
+}
+const src = __webpack_require__("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js");
+const Debug = src('http-proxy-middleware');
+const debug = Debug.extend('debug-proxy-errors-plugin');
+const debugProxyErrorsPlugin = (proxyServer)=>{
+    proxyServer.on('error', (error, req, res, target)=>{
+        debug(`httpxy error event: \n%O`, error);
+    });
+    proxyServer.on('proxyReq', (proxyReq, req, socket)=>{
+        socket.on('error', (error)=>{
+            debug('Socket error in proxyReq event: \n%O', error);
+        });
+    });
+    proxyServer.on('proxyRes', (proxyRes, req, res)=>{
+        res.on('close', ()=>{
+            if (!res.writableEnded) {
+                debug('Destroying proxyRes in proxyRes close event');
+                proxyRes.destroy();
+            }
+        });
+    });
+    proxyServer.on('proxyReqWs', (proxyReq, req, socket)=>{
+        socket.on('error', (error)=>{
+            debug('Socket error in proxyReqWs event: \n%O', error);
+        });
+    });
+    proxyServer.on('open', (proxySocket)=>{
+        proxySocket.on('error', (error)=>{
+            debug('Socket error in open event: \n%O', error);
+        });
+    });
+    proxyServer.on('close', (req, socket, head)=>{
+        socket.on('error', (error)=>{
+            debug('Socket error in close event: \n%O', error);
+        });
+    });
+    proxyServer.on('econnreset', (error, req, res, target)=>{
+        debug(`httpxy econnreset event: \n%O`, error);
+    });
+};
+function getStatusCode(errorCode) {
+    let statusCode;
+    if (/HPE_INVALID/.test(errorCode)) statusCode = 502;
+    else switch(errorCode){
+        case 'ECONNRESET':
+        case 'ENOTFOUND':
+        case 'ECONNREFUSED':
+        case 'ETIMEDOUT':
+            statusCode = 504;
+            break;
+        default:
+            statusCode = 500;
+            break;
+    }
+    return statusCode;
+}
+function sanitize(input) {
+    return input?.replace(/[<>]/g, (i)=>encodeURIComponent(i)) ?? '';
+}
+function isResponseLike(obj) {
+    return obj && 'function' == typeof obj.writeHead;
+}
+function isSocketLike(obj) {
+    return obj && 'function' == typeof obj.write && !('writeHead' in obj);
+}
+const errorResponsePlugin = (proxyServer, options)=>{
+    proxyServer.on('error', (err, req, res, target)=>{
+        if (!req || !res) throw err;
+        if (isResponseLike(res)) {
+            if (!res.headersSent) {
+                const statusCode = getStatusCode(err.code);
+                res.writeHead(statusCode);
+            }
+            const host = req.headers && req.headers.host;
+            res.end(`Error occurred while trying to proxy: ${sanitize(host)}${sanitize(req.url)}`);
+        } else if (isSocketLike(res)) res.destroy();
+    });
+};
+const noopLogger = {
+    info: ()=>{},
+    warn: ()=>{},
+    error: ()=>{}
+};
+function getLogger(options) {
+    return options.logger || noopLogger;
+}
+function createUrl({ protocol, host, port, path }) {
+    const ipv6Host = host?.includes(':') ? `[${host}]` : host;
+    const base = `${protocol || 'undefined:'}//${ipv6Host || '[::]'}`;
+    const url = new external_url_URL(base);
+    if (port) url.port = port;
+    if (path) url.pathname = path;
+    return url;
+}
+function logger_plugin_getPort(sockets) {
+    return Object.keys(sockets || {})?.[0]?.split(':')[1];
+}
+const loggerPlugin = (proxyServer, options)=>{
+    const logger = getLogger(options);
+    proxyServer.on('error', (err, req, res, target)=>{
+        const hostname = req?.headers?.host;
+        const requestHref = `${hostname}${req?.url}`;
+        const targetHref = `${target?.href}`;
+        const errorMessage = '[HPM] Error occurred while proxying request %s to %s [%s] (%s)';
+        const errReference = 'https://nodejs.org/api/errors.html#errors_common_system_errors';
+        logger.error(errorMessage, requestHref, targetHref, err.code || err, errReference);
+    });
+    proxyServer.on('proxyRes', (proxyRes, req, res)=>{
+        const originalUrl = req.originalUrl ?? `${req.baseUrl || ''}${req.url}`;
+        let target;
+        try {
+            const port = logger_plugin_getPort(proxyRes.req?.agent?.sockets);
+            const { protocol, host, path } = proxyRes.req;
+            target = createUrl({
+                protocol,
+                host,
+                port,
+                path
+            });
+        } catch (err) {
+            console.error('[HPM] Unexpected error while creating target URL', err);
+            target = new external_node_url_URL(options.target);
+            target.pathname = proxyRes.req.path;
+        }
+        const targetUrl = target.toString();
+        const exchange = `[HPM] ${req.method} ${originalUrl} -> ${targetUrl} [${proxyRes.statusCode}]`;
+        logger.info(exchange);
+    });
+    proxyServer.on('open', (socket)=>{
+        logger.info('[HPM] Client connected: %o', socket.address());
+    });
+    proxyServer.on('close', (req, proxySocket, proxyHead)=>{
+        logger.info('[HPM] Client disconnected: %o', proxySocket.address());
+    });
+};
+function function_getFunctionName(fn) {
+    return fn.name || '[anonymous Function]';
+}
+const proxy_events_debug = Debug.extend('proxy-events-plugin');
+const proxyEventsPlugin = (proxyServer, options)=>{
+    if (!options.on) return;
+    let eventName;
+    for(eventName in options.on)if (Object.prototype.hasOwnProperty.call(options.on, eventName)) {
+        const handler = options.on[eventName];
+        if (!handler) continue;
+        proxy_events_debug(`register event handler: "${eventName}" -> "${function_getFunctionName(handler)}"`);
+        proxyServer.on(eventName, handler);
+    }
+};
+function getPlugins(options) {
+    const maybeErrorResponsePlugin = options.on?.error ? [] : [
+        errorResponsePlugin
+    ];
+    const defaultPlugins = options.ejectPlugins ? [] : [
+        debugProxyErrorsPlugin,
+        proxyEventsPlugin,
+        loggerPlugin,
+        ...maybeErrorResponsePlugin
+    ];
+    const userPlugins = options.plugins ?? [];
+    return [
+        ...defaultPlugins,
+        ...userPlugins
+    ];
+}
+const is_glob = __webpack_require__("./node_modules/.pnpm/is-glob@4.0.3/node_modules/is-glob/index.js");
+const micromatch = __webpack_require__("./node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js");
+function matchPathFilter(pathFilter = '/', uri, req) {
+    if (isStringPath(pathFilter)) return matchSingleStringPath(pathFilter, uri);
+    if (isGlobPath(pathFilter)) return matchSingleGlobPath(pathFilter, uri);
+    if (Array.isArray(pathFilter)) {
+        if (pathFilter.every(isStringPath)) return matchMultiPath(pathFilter, uri);
+        if (pathFilter.every(isGlobPath)) return matchMultiGlobPath(pathFilter, uri);
+        throw new Error(errors_ERRORS.ERR_CONTEXT_MATCHER_INVALID_ARRAY);
+    }
+    if ('function' == typeof pathFilter) {
+        const pathname = getUrlPathName(uri);
+        return pathFilter(pathname, req);
+    }
+    throw new Error(errors_ERRORS.ERR_CONTEXT_MATCHER_GENERIC);
+}
+function matchSingleStringPath(pathFilter, uri) {
+    const pathname = getUrlPathName(uri);
+    return pathname?.indexOf(pathFilter) === 0;
+}
+function matchSingleGlobPath(pattern, uri) {
+    const pathname = getUrlPathName(uri);
+    const matches = micromatch([
+        pathname
+    ], pattern);
+    return matches && matches.length > 0;
+}
+function matchMultiGlobPath(patternList, uri) {
+    return matchSingleGlobPath(patternList, uri);
+}
+function matchMultiPath(pathFilterList, uri) {
+    let isMultiPath = false;
+    for (const context of pathFilterList)if (matchSingleStringPath(context, uri)) {
+        isMultiPath = true;
+        break;
+    }
+    return isMultiPath;
+}
+function getUrlPathName(uri) {
+    return uri && new URL(uri, 'http://0.0.0.0').pathname;
+}
+function isStringPath(pathFilter) {
+    return 'string' == typeof pathFilter && !is_glob(pathFilter);
+}
+function isGlobPath(pathFilter) {
+    return is_glob(pathFilter);
+}
+function isPlainObject(value) {
+    if ('object' != typeof value || null === value) return false;
+    const prototype = Object.getPrototypeOf(value);
+    return (null === prototype || prototype === Object.prototype || null === Object.getPrototypeOf(prototype)) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+const path_rewriter_debug = Debug.extend('path-rewriter');
+function createPathRewriter(rewriteConfig) {
+    let rulesCache;
+    if (!isValidRewriteConfig(rewriteConfig)) return;
+    if ('function' == typeof rewriteConfig) {
+        const customRewriteFn = rewriteConfig;
+        return customRewriteFn;
+    }
+    rulesCache = parsePathRewriteRules(rewriteConfig);
+    return rewritePath;
+    function rewritePath(path) {
+        let result = path;
+        for (const rule of rulesCache)if (rule.regex.test(path)) {
+            result = result.replace(rule.regex, rule.value);
+            path_rewriter_debug('rewriting path from "%s" to "%s"', path, result);
+            break;
+        }
+        return result;
+    }
+}
+function isValidRewriteConfig(rewriteConfig) {
+    if ('function' == typeof rewriteConfig) return true;
+    if (isPlainObject(rewriteConfig)) return 0 !== Object.keys(rewriteConfig).length;
+    if (null == rewriteConfig) return false;
+    throw new Error(errors_ERRORS.ERR_PATH_REWRITER_CONFIG);
+}
+function parsePathRewriteRules(rewriteConfig) {
+    const rules = [];
+    if (isPlainObject(rewriteConfig)) for (const [key, value] of Object.entries(rewriteConfig)){
+        rules.push({
+            regex: new RegExp(key),
+            value: value
+        });
+        path_rewriter_debug('rewrite rule created: "%s" ~> "%s"', key, value);
+    }
+    return rules;
+}
+const router_debug = Debug.extend('router');
+async function getTarget(req, config) {
+    let newTarget;
+    const router = config.router;
+    if (isPlainObject(router)) newTarget = getTargetFromProxyTable(req, router);
+    else if ('function' == typeof router) newTarget = await router(req);
+    return newTarget;
+}
+function getTargetFromProxyTable(req, table) {
+    let result;
+    const host = req.headers.host ?? '';
+    const path = req.url ?? '';
+    const hostAndPath = host + path;
+    for (const [key, value] of Object.entries(table))if (containsPath(key)) {
+        if (hostAndPath.indexOf(key) > -1) {
+            result = value;
+            router_debug('match: "%s" -> "%s"', key, result);
+            break;
+        }
+    } else if (key === host) {
+        result = value;
+        router_debug('match: "%s" -> "%s"', host, result);
+        break;
+    }
+    return result;
+}
+function containsPath(v) {
+    return v.indexOf('/') > -1;
+}
+const ipv6_debug = Debug.extend('ipv6');
+function normalizeIPv6LiteralTargets(options) {
+    options.target = normalizeIPv6ProxyTarget(options.target, 'target');
+    options.forward = normalizeIPv6ProxyTarget(options.forward, 'forward');
+}
+function normalizeIPv6ProxyTarget(target, optionName) {
+    const targetUrl = toTargetUrl(target);
+    if (targetUrl && isBracketedIPv6Hostname(targetUrl.hostname)) {
+        ipv6_debug('normalized IPv6 "%s" %s', optionName, target);
+        return {
+            hostname: stripBrackets(targetUrl.hostname),
+            pathname: targetUrl.pathname,
+            port: targetUrl.port,
+            protocol: targetUrl.protocol,
+            search: targetUrl.search
+        };
+    }
+    return target;
+}
+function toTargetUrl(target) {
+    if ('string' == typeof target) return new URL(target);
+    if (target instanceof URL) return target;
+}
+function isBracketedIPv6Hostname(hostname) {
+    return hostname.startsWith('[') && hostname.endsWith(']');
+}
+function stripBrackets(hostname) {
+    return hostname.replace(/^\[|\]$/g, '');
+}
+class HttpProxyMiddleware {
+    wsInternalSubscribed = false;
+    serverOnCloseSubscribed = false;
+    proxyOptions;
+    proxy;
+    pathRewriter;
+    logger;
+    constructor(options){
+        verifyConfig(options);
+        this.proxyOptions = options;
+        this.logger = getLogger(options);
+        Debug("create proxy server");
+        this.proxy = createProxyServer({});
+        this.registerPlugins(this.proxy, this.proxyOptions);
+        this.pathRewriter = createPathRewriter(this.proxyOptions.pathRewrite);
+        this.middleware.upgrade = (req, socket, head)=>{
+            if (!this.wsInternalSubscribed) this.handleUpgrade(req, socket, head);
+        };
+    }
+    middleware = async (req, res, next)=>{
+        if (this.shouldProxy(this.proxyOptions.pathFilter, req)) {
+            let activeProxyOptions;
+            try {
+                activeProxyOptions = await this.prepareProxyRequest(req);
+                if (!activeProxyOptions.target && !activeProxyOptions.forward) throw new Error('Must provide a proper URL as target');
+            } catch (err) {
+                next?.(err);
+                return;
+            }
+            try {
+                Debug("proxy request to target: %O", activeProxyOptions.target);
+                await this.proxy.web(req, res, activeProxyOptions);
+            } catch (err) {
+                this.proxy.emit('error', err, req, res, activeProxyOptions.target);
+                next?.(err);
+            }
+        } else next?.();
+        const server = req.socket?.server;
+        if (server && !this.serverOnCloseSubscribed) {
+            server.on('close', ()=>{
+                Debug('server close signal received: closing proxy server');
+                this.proxy.close(()=>{
+                    Debug('proxy server closed');
+                });
+            });
+            this.serverOnCloseSubscribed = true;
+        }
+        if (true === this.proxyOptions.ws && server) this.catchUpgradeRequest(server);
+    };
+    registerPlugins(proxy, options) {
+        const plugins = getPlugins(options);
+        plugins.forEach((plugin)=>{
+            Debug(`register plugin: "${function_getFunctionName(plugin)}"`);
+            plugin(proxy, options);
+        });
+    }
+    catchUpgradeRequest = (server)=>{
+        if (!this.wsInternalSubscribed) {
+            Debug('subscribing to server upgrade event');
+            server.on('upgrade', this.handleUpgrade);
+            this.wsInternalSubscribed = true;
+        }
+    };
+    handleUpgrade = async (req, socket, head)=>{
+        try {
+            if (this.shouldProxy(this.proxyOptions.pathFilter, req)) {
+                const proxiedReq = req;
+                const activeProxyOptions = await this.prepareProxyRequest(proxiedReq);
+                await this.proxy.ws(proxiedReq, socket, activeProxyOptions, head);
+                Debug('server upgrade event received. Proxying WebSocket');
+            }
+        } catch (err) {
+            this.proxy.emit('error', err, req, socket);
+        }
+    };
+    shouldProxy = (pathFilter, req)=>{
+        try {
+            return matchPathFilter(pathFilter, req.url, req);
+        } catch (err) {
+            Debug('Error: matchPathFilter() called with request url: ', `"${req.url}"`);
+            this.logger.error(err);
+            return false;
+        }
+    };
+    prepareProxyRequest = async (req)=>{
+        const newProxyOptions = Object.assign({}, this.proxyOptions);
+        await this.applyRouter(req, newProxyOptions);
+        normalizeIPv6LiteralTargets(newProxyOptions);
+        await this.applyPathRewrite(req, this.pathRewriter);
+        return newProxyOptions;
+    };
+    applyRouter = async (req, options)=>{
+        let newTarget;
+        if (options.router) {
+            newTarget = await getTarget(req, options);
+            if (newTarget) {
+                Debug('router new target: "%s"', newTarget);
+                options.target = newTarget;
+            }
+        }
+    };
+    applyPathRewrite = async (req, pathRewriter)=>{
+        if (req.url && pathRewriter) {
+            const path = await pathRewriter(req.url, req);
+            if ('string' == typeof path) {
+                Debug('pathRewrite new path: %s', path);
+                req.url = path;
+            } else Debug('pathRewrite: no rewritten path found: %s', req.url);
+        }
+    };
+}
+function createProxyMiddleware(options) {
+    const { middleware } = new HttpProxyMiddleware(options);
+    return middleware;
+}
+Debug.extend('response-interceptor');
+export { createProxyMiddleware };