@rsbuild/core 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/http-proxy-middleware.js

@@ -0,0 +1,2947 @@
+/*! LICENSE: http-proxy-middleware.js.LICENSE.txt */
+import { __webpack_require__ } from "./1~rslib-runtime.js";
+import "./552.js";
+import "./debug.js";
+__webpack_require__.add({
+    "../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let stringify = __webpack_require__("../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js"), compile = __webpack_require__("../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/compile.js"), expand = __webpack_require__("../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/expand.js"), parse = __webpack_require__("../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/parse.js"), braces = (input, options = {})=>{
+            let output = [];
+            if (Array.isArray(input)) for (let pattern of input){
+                let result = braces.create(pattern, options);
+                Array.isArray(result) ? output.push(...result) : output.push(result);
+            }
+            else output = [].concat(braces.create(input, options));
+            return options && !0 === options.expand && !0 === options.nodupes && (output = [
+                ...new Set(output)
+            ]), output;
+        };
+        braces.parse = (input, options = {})=>parse(input, options), braces.stringify = (input, options = {})=>'string' == typeof input ? stringify(braces.parse(input, options), options) : stringify(input, options), braces.compile = (input, options = {})=>('string' == typeof input && (input = braces.parse(input, options)), compile(input, options)), braces.expand = (input, options = {})=>{
+            'string' == typeof input && (input = braces.parse(input, options));
+            let result = expand(input, options);
+            return !0 === options.noempty && (result = result.filter(Boolean)), !0 === options.nodupes && (result = [
+                ...new Set(result)
+            ]), result;
+        }, braces.create = (input, options = {})=>'' === input || input.length < 3 ? [
+                input
+            ] : !0 !== 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__) {
+        let fill = __webpack_require__("../../node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.js"), utils = __webpack_require__("../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js");
+        module.exports = (ast, options = {})=>{
+            let walk = (node, parent = {})=>{
+                let invalidBlock = utils.isInvalidBrace(parent), invalidNode = !0 === node.invalid && !0 === options.escapeInvalid, invalid = !0 === invalidBlock || !0 === invalidNode, prefix = !0 === options.escapeInvalid ? '\\' : '', output = '';
+                if (!0 === node.isOpen) return prefix + node.value;
+                if (!0 === node.isClose) return console.log('node.isClose', prefix, node.value), 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) {
+                    let args = utils.reduce(node.nodes), range = fill(...args, {
+                        ...options,
+                        wrap: !1,
+                        toRegex: !0,
+                        strictZeros: !0
+                    });
+                    if (0 !== range.length) return args.length > 1 && range.length > 1 ? `(${range})` : range;
+                }
+                if (node.nodes) for (let child of node.nodes)output += walk(child, node);
+                return output;
+            };
+            return walk(ast);
+        };
+    },
+    "../../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__) {
+        let fill = __webpack_require__("../../node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.js"), stringify = __webpack_require__("../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js"), utils = __webpack_require__("../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js"), append = (queue = '', stash = '', enclose = !1)=>{
+            let result = [];
+            if (queue = [].concat(queue), !(stash = [].concat(stash)).length) return queue;
+            if (!queue.length) return enclose ? utils.flatten(stash).map((ele)=>`{${ele}}`) : stash;
+            for (let item of queue)if (Array.isArray(item)) for (let value of item)result.push(append(value, stash, enclose));
+            else for (let ele of stash)!0 === enclose && 'string' == typeof ele && (ele = `{${ele}}`), result.push(Array.isArray(ele) ? append(item, ele, enclose) : item + ele);
+            return utils.flatten(result);
+        };
+        module.exports = (ast, options = {})=>{
+            let rangeLimit = void 0 === options.rangeLimit ? 1000 : options.rangeLimit, walk = (node, parent = {})=>{
+                node.queue = [];
+                let p = parent, q = parent.queue;
+                for(; 'brace' !== p.type && 'root' !== p.type && p.parent;)q = (p = p.parent).queue;
+                if (node.invalid || node.dollar) return void q.push(append(q.pop(), stringify(node, options)));
+                if ('brace' === node.type && !0 !== node.invalid && 2 === node.nodes.length) return void q.push(append(q.pop(), [
+                    '{}'
+                ]));
+                if (node.nodes && node.ranges > 0) {
+                    let args = utils.reduce(node.nodes);
+                    if (utils.exceedsLimit(...args, options.step, rangeLimit)) throw RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
+                    let range = fill(...args, options);
+                    0 === range.length && (range = stringify(node, options)), q.push(append(q.pop(), range)), node.nodes = [];
+                    return;
+                }
+                let enclose = utils.encloseBrace(node), queue = node.queue, block = node;
+                for(; 'brace' !== block.type && 'root' !== block.type && block.parent;)queue = (block = block.parent).queue;
+                for(let i = 0; i < node.nodes.length; i++){
+                    let child = node.nodes[i];
+                    if ('comma' === child.type && 'brace' === node.type) {
+                        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;
+                    }
+                    child.nodes && walk(child, node);
+                }
+                return queue;
+            };
+            return utils.flatten(walk(ast));
+        };
+    },
+    "../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/parse.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let stringify = __webpack_require__("../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js"), { 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");
+        module.exports = (input, options = {})=>{
+            let value;
+            if ('string' != typeof input) throw TypeError('Expected a string');
+            let opts = options || {}, max = 'number' == typeof opts.maxLength ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+            if (input.length > max) throw SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
+            let ast = {
+                type: 'root',
+                input,
+                nodes: []
+            }, stack = [
+                ast
+            ], block = ast, prev = ast, brackets = 0, length = input.length, index = 0, depth = 0, advance = ()=>input[index++], push = (node)=>{
+                if ('text' === node.type && 'dot' === prev.type && (prev.type = 'text'), prev && 'text' === prev.type && 'text' === node.type) {
+                    prev.value += node.value;
+                    return;
+                }
+                return block.nodes.push(node), node.parent = block, node.prev = prev, prev = node, node;
+            };
+            for(push({
+                type: 'bos'
+            }); index < length;)if (block = stack[stack.length - 1], (value = advance()) !== CHAR_ZERO_WIDTH_NOBREAK_SPACE && value !== CHAR_NO_BREAK_SPACE) {
+                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) {
+                    let next;
+                    for(brackets++; index < length && (next = advance());){
+                        if (value += next, next === CHAR_LEFT_SQUARE_BRACKET) {
+                            brackets++;
+                            continue;
+                        }
+                        if (next === CHAR_BACKSLASH) {
+                            value += advance();
+                            continue;
+                        }
+                        if (next === CHAR_RIGHT_SQUARE_BRACKET && 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) {
+                    let next, open = value;
+                    for(!0 !== options.keepQuotes && (value = ''); index < length && (next = advance());){
+                        if (next === CHAR_BACKSLASH) {
+                            value += next + advance();
+                            continue;
+                        }
+                        if (next === open) {
+                            !0 === options.keepQuotes && (value += next);
+                            break;
+                        }
+                        value += next;
+                    }
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (value === CHAR_LEFT_CURLY_BRACE) {
+                    depth++, block = push({
+                        type: 'brace',
+                        open: !0,
+                        close: !1,
+                        dollar: prev.value && '$' === prev.value.slice(-1) || !0 === block.dollar,
+                        depth,
+                        commas: 0,
+                        ranges: 0,
+                        nodes: []
+                    }), stack.push(block), push({
+                        type: 'open',
+                        value
+                    });
+                    continue;
+                }
+                if (value === CHAR_RIGHT_CURLY_BRACE) {
+                    if ('brace' !== block.type) {
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                    (block = stack.pop()).close = !0, push({
+                        type: 'close',
+                        value
+                    }), depth--, block = stack[stack.length - 1];
+                    continue;
+                }
+                if (value === CHAR_COMMA && depth > 0) {
+                    if (block.ranges > 0) {
+                        block.ranges = 0;
+                        let 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) {
+                    let siblings = block.nodes;
+                    if (0 === depth || 0 === siblings.length) {
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                    if ('dot' === prev.type) {
+                        if (block.range = [], prev.value += value, prev.type = 'range', 3 !== block.nodes.length && 5 !== block.nodes.length) {
+                            block.invalid = !0, block.ranges = 0, prev.type = 'text';
+                            continue;
+                        }
+                        block.ranges++, block.args = [];
+                        continue;
+                    }
+                    if ('range' === prev.type) {
+                        siblings.pop();
+                        let 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 if ('root' !== (block = stack.pop()).type) {
+                block.nodes.forEach((node)=>{
+                    node.nodes || ('open' === node.type && (node.isOpen = !0), 'close' === node.type && (node.isClose = !0), node.nodes || (node.type = 'text'), node.invalid = !0);
+                });
+                let parent = stack[stack.length - 1], index = parent.nodes.indexOf(block);
+                parent.nodes.splice(index, 1, ...block.nodes);
+            }
+            while (stack.length > 0);
+            return push({
+                type: 'eos'
+            }), ast;
+        };
+    },
+    "../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let utils = __webpack_require__("../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js");
+        module.exports = (ast, options = {})=>{
+            let stringify = (node, parent = {})=>{
+                let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent), invalidNode = !0 === node.invalid && !0 === options.escapeInvalid, output = '';
+                if (node.value) return (invalidBlock || invalidNode) && utils.isOpenOrClose(node) ? '\\' + node.value : node.value;
+                if (node.value) return node.value;
+                if (node.nodes) for (let 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)=>'number' == typeof num ? Number.isInteger(num) : 'string' == typeof num && '' !== num.trim() && Number.isInteger(Number(num)), exports.find = (node, type)=>node.nodes.find((node)=>node.type === type), exports.exceedsLimit = (min, max, step = 1, limit)=>!1 !== limit && !!exports.isInteger(min) && !!exports.isInteger(max) && (Number(max) - Number(min)) / Number(step) >= limit, exports.escapeNode = (block, n = 0, type)=>{
+            let node = block.nodes[n];
+            node && (type && node.type === type || 'open' === node.type || 'close' === node.type) && !0 !== node.escaped && (node.value = '\\' + node.value, node.escaped = !0);
+        }, exports.encloseBrace = (node)=>'brace' === node.type && node.commas >> 0 + node.ranges == 0 && (node.invalid = !0, !0), exports.isInvalidBrace = (block)=>'brace' === block.type && (!0 === block.invalid || !!block.dollar || (block.commas >> 0 + block.ranges == 0 || !0 !== block.open || !0 !== block.close) && (block.invalid = !0, !0)), exports.isOpenOrClose = (node)=>'open' === node.type || 'close' === node.type || !0 === node.open || !0 === node.close, exports.reduce = (nodes)=>nodes.reduce((acc, node)=>('text' === node.type && acc.push(node.value), 'range' === node.type && (node.type = 'text'), acc), []), exports.flatten = (...args)=>{
+            let result = [], flat = (arr)=>{
+                for(let i = 0; i < arr.length; i++){
+                    let ele = arr[i];
+                    if (Array.isArray(ele)) {
+                        flat(ele);
+                        continue;
+                    }
+                    void 0 !== ele && result.push(ele);
+                }
+                return result;
+            };
+            return flat(args), result;
+        };
+    },
+    "../../node_modules/.pnpm/eventemitter3@4.0.7/node_modules/eventemitter3/index.js" (module) {
+        var has = Object.prototype.hasOwnProperty, prefix = '~';
+        function Events() {}
+        function EE(fn, context, once) {
+            this.fn = fn, this.context = context, this.once = once || !1;
+        }
+        function addListener(emitter, event, fn, context, once) {
+            if ('function' != typeof fn) throw TypeError('The listener must be a function');
+            var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+            return emitter._events[evt] ? emitter._events[evt].fn ? emitter._events[evt] = [
+                emitter._events[evt],
+                listener
+            ] : emitter._events[evt].push(listener) : (emitter._events[evt] = listener, emitter._eventsCount++), emitter;
+        }
+        function clearEvent(emitter, evt) {
+            0 == --emitter._eventsCount ? emitter._events = new Events() : delete emitter._events[evt];
+        }
+        function EventEmitter() {
+            this._events = new Events(), this._eventsCount = 0;
+        }
+        Object.create && (Events.prototype = Object.create(null), new Events().__proto__ || (prefix = !1)), EventEmitter.prototype.eventNames = function eventNames() {
+            var events, name, names = [];
+            if (0 === this._eventsCount) return names;
+            for(name in events = this._events)has.call(events, name) && names.push(prefix ? name.slice(1) : name);
+            return Object.getOwnPropertySymbols ? names.concat(Object.getOwnPropertySymbols(events)) : names;
+        }, EventEmitter.prototype.listeners = function listeners(event) {
+            var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+            if (!handlers) return [];
+            if (handlers.fn) return [
+                handlers.fn
+            ];
+            for(var i = 0, l = handlers.length, ee = Array(l); i < l; i++)ee[i] = handlers[i].fn;
+            return ee;
+        }, EventEmitter.prototype.listenerCount = function listenerCount(event) {
+            var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+            return listeners ? listeners.fn ? 1 : listeners.length : 0;
+        }, EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+            var evt = prefix ? prefix + event : event;
+            if (!this._events[evt]) return !1;
+            var args, i, listeners = this._events[evt], len = arguments.length;
+            if (listeners.fn) {
+                switch(listeners.once && this.removeListener(event, listeners.fn, void 0, !0), len){
+                    case 1:
+                        return listeners.fn.call(listeners.context), !0;
+                    case 2:
+                        return listeners.fn.call(listeners.context, a1), !0;
+                    case 3:
+                        return listeners.fn.call(listeners.context, a1, a2), !0;
+                    case 4:
+                        return listeners.fn.call(listeners.context, a1, a2, a3), !0;
+                    case 5:
+                        return listeners.fn.call(listeners.context, a1, a2, a3, a4), !0;
+                    case 6:
+                        return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), !0;
+                }
+                for(i = 1, args = Array(len - 1); i < len; i++)args[i - 1] = arguments[i];
+                listeners.fn.apply(listeners.context, args);
+            } else {
+                var j, length = listeners.length;
+                for(i = 0; i < length; i++)switch(listeners[i].once && this.removeListener(event, listeners[i].fn, void 0, !0), len){
+                    case 1:
+                        listeners[i].fn.call(listeners[i].context);
+                        break;
+                    case 2:
+                        listeners[i].fn.call(listeners[i].context, a1);
+                        break;
+                    case 3:
+                        listeners[i].fn.call(listeners[i].context, a1, a2);
+                        break;
+                    case 4:
+                        listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+                        break;
+                    default:
+                        if (!args) for(j = 1, args = Array(len - 1); j < len; j++)args[j - 1] = arguments[j];
+                        listeners[i].fn.apply(listeners[i].context, args);
+                }
+            }
+            return !0;
+        }, EventEmitter.prototype.on = function on(event, fn, context) {
+            return addListener(this, event, fn, context, !1);
+        }, EventEmitter.prototype.once = function once(event, fn, context) {
+            return addListener(this, event, fn, context, !0);
+        }, EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+            var evt = prefix ? prefix + event : event;
+            if (!this._events[evt]) return this;
+            if (!fn) return clearEvent(this, evt), this;
+            var listeners = this._events[evt];
+            if (listeners.fn) listeners.fn !== fn || once && !listeners.once || context && listeners.context !== context || clearEvent(this, evt);
+            else {
+                for(var i = 0, events = [], length = listeners.length; i < length; i++)(listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) && events.push(listeners[i]);
+                events.length ? this._events[evt] = 1 === events.length ? events[0] : events : clearEvent(this, evt);
+            }
+            return this;
+        }, EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+            var evt;
+            return event ? (evt = prefix ? prefix + event : event, this._events[evt] && clearEvent(this, evt)) : (this._events = new Events(), this._eventsCount = 0), this;
+        }, EventEmitter.prototype.off = EventEmitter.prototype.removeListener, EventEmitter.prototype.addListener = EventEmitter.prototype.on, EventEmitter.prefixed = prefix, EventEmitter.EventEmitter = EventEmitter, module.exports = EventEmitter;
+    },
+    "../../node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let util = __webpack_require__("util"), toRegexRange = __webpack_require__("../../node_modules/.pnpm/to-regex-range@5.0.1/node_modules/to-regex-range/index.js"), isObject = (val)=>null !== val && 'object' == typeof val && !Array.isArray(val), isValidValue = (value)=>'number' == typeof value || 'string' == typeof value && '' !== value, zeros = (input)=>{
+            let value = `${input}`, index = -1;
+            if ('-' === value[0] && (value = value.slice(1)), '0' === value) return !1;
+            for(; '0' === value[++index];);
+            return index > 0;
+        }, pad = (input, maxLength, toNumber)=>{
+            if (maxLength > 0) {
+                let dash = '-' === input[0] ? '-' : '';
+                dash && (input = input.slice(1)), input = dash + input.padStart(dash ? maxLength - 1 : maxLength, '0');
+            }
+            return !1 === toNumber ? String(input) : input;
+        }, toMaxLen = (input, maxLength)=>{
+            let negative = '-' === input[0] ? '-' : '';
+            for(negative && (input = input.slice(1), maxLength--); input.length < maxLength;)input = '0' + input;
+            return negative ? '-' + input : input;
+        }, toRange = (a, b, isNumbers, options)=>{
+            if (isNumbers) return toRegexRange(a, b, {
+                wrap: !1,
+                ...options
+            });
+            let start = String.fromCharCode(a);
+            if (a === b) return start;
+            let stop = String.fromCharCode(b);
+            return `[${start}-${stop}]`;
+        }, toRegex = (start, end, options)=>{
+            if (Array.isArray(start)) {
+                let wrap = !0 === options.wrap, prefix = options.capture ? '' : '?:';
+                return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
+            }
+            return toRegexRange(start, end, options);
+        }, rangeError = (...args)=>RangeError('Invalid range arguments: ' + util.inspect(...args)), invalidRange = (start, end, options)=>{
+            if (!0 === options.strictRanges) throw rangeError([
+                start,
+                end
+            ]);
+            return [];
+        }, 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 (!0 === opts.capture && (opts.wrap = !0), !Number.isInteger(+(step = step || opts.step || 1))) {
+                if (null != step && !isObject(step)) {
+                    var step1 = step;
+                    if (!0 === opts.strictRanges) throw TypeError(`Expected step "${step1}" to be a number`);
+                    return [];
+                }
+                return fill(start, end, 1, step);
+            }
+            return Number.isInteger(+start) && Number.isInteger(+end) ? ((start, end, step = 1, options = {})=>{
+                let a = Number(start), b = Number(end);
+                if (!Number.isInteger(a) || !Number.isInteger(b)) {
+                    if (!0 === options.strictRanges) throw rangeError([
+                        start,
+                        end
+                    ]);
+                    return [];
+                }
+                0 === a && (a = 0), 0 === b && (b = 0);
+                let descending = a > b, startString = String(start), endString = String(end), stepString = String(step);
+                step = Math.max(Math.abs(step), 1);
+                let padded = zeros(startString) || zeros(endString) || zeros(stepString), maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0, toNumber = !1 === padded && !1 == ('string' == typeof start || 'string' == typeof end || !0 === options.stringify), format = options.transform || ((value)=>!0 === toNumber ? Number(value) : String(value));
+                if (options.toRegex && 1 === step) return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), !0, options);
+                let parts = {
+                    negatives: [],
+                    positives: []
+                }, push = (num)=>parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num)), range = [], index = 0;
+                for(; descending ? a >= b : a <= b;)!0 === options.toRegex && step > 1 ? push(a) : range.push(pad(format(a, index), maxLen, toNumber)), a = descending ? a - step : a + step, index++;
+                if (!0 === options.toRegex) {
+                    let result, prefix, positives, negatives;
+                    return step > 1 ? (parts.negatives.sort((a, b)=>a < b ? -1 : +(a > b)), parts.positives.sort((a, b)=>a < b ? -1 : +(a > b)), prefix = options.capture ? '' : '?:', positives = '', negatives = '', (parts.positives.length && (positives = parts.positives.map((v)=>toMaxLen(String(v), maxLen)).join('|')), parts.negatives.length && (negatives = `-(${prefix}${parts.negatives.map((v)=>toMaxLen(String(v), maxLen)).join('|')})`), result = positives && negatives ? `${positives}|${negatives}` : positives || negatives, options.wrap) ? `(${prefix}${result})` : result) : toRegex(range, null, {
+                        wrap: !1,
+                        ...options
+                    });
+                }
+                return range;
+            })(start, end, step, opts) : ((start, end, step = 1, options = {})=>{
+                if (!Number.isInteger(+start) && start.length > 1 || !Number.isInteger(+end) && end.length > 1) return invalidRange(start, end, options);
+                let format = options.transform || ((val)=>String.fromCharCode(val)), a = `${start}`.charCodeAt(0), b = `${end}`.charCodeAt(0), descending = a > b, min = Math.min(a, b), max = Math.max(a, b);
+                if (options.toRegex && 1 === step) return toRange(min, max, !1, options);
+                let range = [], index = 0;
+                for(; descending ? a >= b : a <= b;)range.push(format(a, index)), a = descending ? a - step : a + step, index++;
+                return !0 === options.toRegex ? toRegex(range, null, {
+                    wrap: !1,
+                    options
+                }) : range;
+            })(start, end, Math.max(Math.abs(step), 1), opts);
+        };
+        module.exports = fill;
+    },
+    "../../node_modules/.pnpm/follow-redirects@1.15.11_debug@4.4.3_supports-color@10.2.2_/node_modules/follow-redirects/debug.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var debug;
+        module.exports = function() {
+            if (!debug) {
+                try {
+                    debug = __webpack_require__("../../node_modules/.pnpm/debug@4.4.3_supports-color@10.2.2/node_modules/debug/src/index.js")("follow-redirects");
+                } catch (error) {}
+                "function" != typeof debug && (debug = function() {});
+            }
+            debug.apply(null, arguments);
+        };
+    },
+    "../../node_modules/.pnpm/follow-redirects@1.15.11_debug@4.4.3_supports-color@10.2.2_/node_modules/follow-redirects/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var looksLikeNode, looksLikeBrowser, looksLikeV8, url = __webpack_require__("url?5f07"), URL = url.URL, http = __webpack_require__("http"), https = __webpack_require__("https"), Writable = __webpack_require__("stream").Writable, assert = __webpack_require__("assert"), debug = __webpack_require__("../../node_modules/.pnpm/follow-redirects@1.15.11_debug@4.4.3_supports-color@10.2.2_/node_modules/follow-redirects/debug.js");
+        looksLikeNode = "u" > typeof process, looksLikeBrowser = "u" > typeof window && "u" > typeof document, looksLikeV8 = isFunction(Error.captureStackTrace), looksLikeNode || !looksLikeBrowser && looksLikeV8 || console.warn("The follow-redirects package should be excluded from browser builds.");
+        var useNativeURL = !1;
+        try {
+            assert(new URL(""));
+        } catch (error) {
+            useNativeURL = "ERR_INVALID_URL" === error.code;
+        }
+        var preservedUrlFields = [
+            "auth",
+            "host",
+            "hostname",
+            "href",
+            "path",
+            "pathname",
+            "port",
+            "protocol",
+            "query",
+            "search",
+            "hash"
+        ], events = [
+            "abort",
+            "aborted",
+            "connect",
+            "error",
+            "socket",
+            "timeout"
+        ], eventHandlers = Object.create(null);
+        events.forEach(function(event) {
+            eventHandlers[event] = function(arg1, arg2, arg3) {
+                this._redirectable.emit(event, arg1, arg2, arg3);
+            };
+        });
+        var InvalidUrlError = createErrorType("ERR_INVALID_URL", "Invalid URL", TypeError), RedirectionError = createErrorType("ERR_FR_REDIRECTION_FAILURE", "Redirected request failed"), TooManyRedirectsError = createErrorType("ERR_FR_TOO_MANY_REDIRECTS", "Maximum number of redirects exceeded", RedirectionError), MaxBodyLengthExceededError = createErrorType("ERR_FR_MAX_BODY_LENGTH_EXCEEDED", "Request body larger than maxBodyLength limit"), WriteAfterEndError = createErrorType("ERR_STREAM_WRITE_AFTER_END", "write after end"), destroy = Writable.prototype.destroy || noop;
+        function RedirectableRequest(options, responseCallback) {
+            Writable.call(this), this._sanitizeOptions(options), this._options = options, this._ended = !1, this._ending = !1, this._redirectCount = 0, this._redirects = [], this._requestBodyLength = 0, this._requestBodyBuffers = [], responseCallback && this.on("response", responseCallback);
+            var self = this;
+            this._onNativeResponse = function(response) {
+                try {
+                    self._processResponse(response);
+                } catch (cause) {
+                    self.emit("error", cause instanceof RedirectionError ? cause : new RedirectionError({
+                        cause: cause
+                    }));
+                }
+            }, this._performRequest();
+        }
+        function wrap(protocols) {
+            var exports = {
+                maxRedirects: 21,
+                maxBodyLength: 10485760
+            }, nativeProtocols = {};
+            return Object.keys(protocols).forEach(function(scheme) {
+                var protocol = scheme + ":", nativeProtocol = nativeProtocols[protocol] = protocols[scheme], wrappedProtocol = exports[scheme] = Object.create(nativeProtocol);
+                function get(input, options, callback) {
+                    var wrappedRequest = wrappedProtocol.request(input, options, callback);
+                    return wrappedRequest.end(), wrappedRequest;
+                }
+                Object.defineProperties(wrappedProtocol, {
+                    request: {
+                        value: function request(input, options, callback) {
+                            return isURL(input) ? input = spreadUrlObject(input) : isString(input) ? input = spreadUrlObject(parseUrl(input)) : (callback = options, options = validateUrl(input), input = {
+                                protocol: protocol
+                            }), isFunction(options) && (callback = options, options = null), (options = Object.assign({
+                                maxRedirects: exports.maxRedirects,
+                                maxBodyLength: exports.maxBodyLength
+                            }, input, options)).nativeProtocols = nativeProtocols, isString(options.host) || isString(options.hostname) || (options.hostname = "::1"), assert.equal(options.protocol, protocol, "protocol mismatch"), debug("options", options), new RedirectableRequest(options, callback);
+                        },
+                        configurable: !0,
+                        enumerable: !0,
+                        writable: !0
+                    },
+                    get: {
+                        value: get,
+                        configurable: !0,
+                        enumerable: !0,
+                        writable: !0
+                    }
+                });
+            }), exports;
+        }
+        function noop() {}
+        function parseUrl(input) {
+            var parsed;
+            if (useNativeURL) parsed = new URL(input);
+            else if (!isString((parsed = validateUrl(url.parse(input))).protocol)) throw new InvalidUrlError({
+                input
+            });
+            return parsed;
+        }
+        function resolveUrl(relative, base) {
+            return useNativeURL ? new URL(relative, base) : parseUrl(url.resolve(base, relative));
+        }
+        function validateUrl(input) {
+            if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname) || /^\[/.test(input.host) && !/^\[[:0-9a-f]+\](:\d+)?$/i.test(input.host)) throw new InvalidUrlError({
+                input: input.href || input
+            });
+            return input;
+        }
+        function spreadUrlObject(urlObject, target) {
+            var spread = target || {};
+            for (var key of preservedUrlFields)spread[key] = urlObject[key];
+            return spread.hostname.startsWith("[") && (spread.hostname = spread.hostname.slice(1, -1)), "" !== spread.port && (spread.port = Number(spread.port)), spread.path = spread.search ? spread.pathname + spread.search : spread.pathname, spread;
+        }
+        function removeMatchingHeaders(regex, headers) {
+            var lastValue;
+            for(var header in headers)regex.test(header) && (lastValue = headers[header], delete headers[header]);
+            return null == lastValue ? void 0 : String(lastValue).trim();
+        }
+        function createErrorType(code, message, baseClass) {
+            function CustomError(properties) {
+                isFunction(Error.captureStackTrace) && Error.captureStackTrace(this, this.constructor), Object.assign(this, properties || {}), this.code = code, this.message = this.cause ? message + ": " + this.cause.message : message;
+            }
+            return CustomError.prototype = new (baseClass || Error)(), Object.defineProperties(CustomError.prototype, {
+                constructor: {
+                    value: CustomError,
+                    enumerable: !1
+                },
+                name: {
+                    value: "Error [" + code + "]",
+                    enumerable: !1
+                }
+            }), CustomError;
+        }
+        function destroyRequest(request, error) {
+            for (var event of events)request.removeListener(event, eventHandlers[event]);
+            request.on("error", noop), request.destroy(error);
+        }
+        function isSubdomain(subdomain, domain) {
+            assert(isString(subdomain) && isString(domain));
+            var dot = subdomain.length - domain.length - 1;
+            return dot > 0 && "." === subdomain[dot] && subdomain.endsWith(domain);
+        }
+        function isString(value) {
+            return "string" == typeof value || value instanceof String;
+        }
+        function isFunction(value) {
+            return "function" == typeof value;
+        }
+        function isBuffer(value) {
+            return "object" == typeof value && "length" in value;
+        }
+        function isURL(value) {
+            return URL && value instanceof URL;
+        }
+        RedirectableRequest.prototype = Object.create(Writable.prototype), RedirectableRequest.prototype.abort = function() {
+            destroyRequest(this._currentRequest), this._currentRequest.abort(), this.emit("abort");
+        }, RedirectableRequest.prototype.destroy = function(error) {
+            return destroyRequest(this._currentRequest, error), destroy.call(this, error), this;
+        }, RedirectableRequest.prototype.write = function(data, encoding, callback) {
+            if (this._ending) throw new WriteAfterEndError();
+            if (!isString(data) && !isBuffer(data)) throw TypeError("data should be a string, Buffer or Uint8Array");
+            if (isFunction(encoding) && (callback = encoding, encoding = null), 0 === data.length) {
+                callback && callback();
+                return;
+            }
+            this._requestBodyLength + data.length <= this._options.maxBodyLength ? (this._requestBodyLength += data.length, this._requestBodyBuffers.push({
+                data: data,
+                encoding: encoding
+            }), this._currentRequest.write(data, encoding, callback)) : (this.emit("error", new MaxBodyLengthExceededError()), this.abort());
+        }, RedirectableRequest.prototype.end = function(data, encoding, callback) {
+            if (isFunction(data) ? (callback = data, data = encoding = null) : isFunction(encoding) && (callback = encoding, encoding = null), data) {
+                var self = this, currentRequest = this._currentRequest;
+                this.write(data, encoding, function() {
+                    self._ended = !0, currentRequest.end(null, null, callback);
+                }), this._ending = !0;
+            } else this._ended = this._ending = !0, this._currentRequest.end(null, null, callback);
+        }, RedirectableRequest.prototype.setHeader = function(name, value) {
+            this._options.headers[name] = value, this._currentRequest.setHeader(name, value);
+        }, RedirectableRequest.prototype.removeHeader = function(name) {
+            delete this._options.headers[name], this._currentRequest.removeHeader(name);
+        }, RedirectableRequest.prototype.setTimeout = function(msecs, callback) {
+            var self = this;
+            function destroyOnTimeout(socket) {
+                socket.setTimeout(msecs), socket.removeListener("timeout", socket.destroy), socket.addListener("timeout", socket.destroy);
+            }
+            function startTimer(socket) {
+                self._timeout && clearTimeout(self._timeout), self._timeout = setTimeout(function() {
+                    self.emit("timeout"), clearTimer();
+                }, msecs), destroyOnTimeout(socket);
+            }
+            function clearTimer() {
+                self._timeout && (clearTimeout(self._timeout), self._timeout = null), self.removeListener("abort", clearTimer), self.removeListener("error", clearTimer), self.removeListener("response", clearTimer), self.removeListener("close", clearTimer), callback && self.removeListener("timeout", callback), self.socket || self._currentRequest.removeListener("socket", startTimer);
+            }
+            return callback && this.on("timeout", callback), this.socket ? startTimer(this.socket) : this._currentRequest.once("socket", startTimer), this.on("socket", destroyOnTimeout), this.on("abort", clearTimer), this.on("error", clearTimer), this.on("response", clearTimer), this.on("close", clearTimer), this;
+        }, [
+            "flushHeaders",
+            "getHeader",
+            "setNoDelay",
+            "setSocketKeepAlive"
+        ].forEach(function(method) {
+            RedirectableRequest.prototype[method] = function(a, b) {
+                return this._currentRequest[method](a, b);
+            };
+        }), [
+            "aborted",
+            "connection",
+            "socket"
+        ].forEach(function(property) {
+            Object.defineProperty(RedirectableRequest.prototype, property, {
+                get: function() {
+                    return this._currentRequest[property];
+                }
+            });
+        }), RedirectableRequest.prototype._sanitizeOptions = function(options) {
+            if (options.headers || (options.headers = {}), options.host && (options.hostname || (options.hostname = options.host), delete options.host), !options.pathname && options.path) {
+                var searchPos = options.path.indexOf("?");
+                searchPos < 0 ? options.pathname = options.path : (options.pathname = options.path.substring(0, searchPos), options.search = options.path.substring(searchPos));
+            }
+        }, RedirectableRequest.prototype._performRequest = function() {
+            var protocol = this._options.protocol, nativeProtocol = this._options.nativeProtocols[protocol];
+            if (!nativeProtocol) throw TypeError("Unsupported protocol " + protocol);
+            if (this._options.agents) {
+                var scheme = protocol.slice(0, -1);
+                this._options.agent = this._options.agents[scheme];
+            }
+            var request = this._currentRequest = nativeProtocol.request(this._options, this._onNativeResponse);
+            for (var event of (request._redirectable = this, events))request.on(event, eventHandlers[event]);
+            if (this._currentUrl = /^\//.test(this._options.path) ? url.format(this._options) : this._options.path, this._isRedirect) {
+                var i = 0, self = this, buffers = this._requestBodyBuffers;
+                !function writeNext(error) {
+                    if (request === self._currentRequest) if (error) self.emit("error", error);
+                    else if (i < buffers.length) {
+                        var buffer = buffers[i++];
+                        request.finished || request.write(buffer.data, buffer.encoding, writeNext);
+                    } else self._ended && request.end();
+                }();
+            }
+        }, RedirectableRequest.prototype._processResponse = function(response) {
+            var requestHeaders, statusCode = response.statusCode;
+            this._options.trackRedirects && this._redirects.push({
+                url: this._currentUrl,
+                headers: response.headers,
+                statusCode: statusCode
+            });
+            var location = response.headers.location;
+            if (!location || !1 === this._options.followRedirects || statusCode < 300 || statusCode >= 400) {
+                response.responseUrl = this._currentUrl, response.redirects = this._redirects, this.emit("response", response), this._requestBodyBuffers = [];
+                return;
+            }
+            if (destroyRequest(this._currentRequest), response.destroy(), ++this._redirectCount > this._options.maxRedirects) throw new TooManyRedirectsError();
+            var beforeRedirect = this._options.beforeRedirect;
+            beforeRedirect && (requestHeaders = Object.assign({
+                Host: response.req.getHeader("host")
+            }, this._options.headers));
+            var method = this._options.method;
+            (301 !== statusCode && 302 !== statusCode || "POST" !== this._options.method) && (303 !== statusCode || /^(?:GET|HEAD)$/.test(this._options.method)) || (this._options.method = "GET", this._requestBodyBuffers = [], removeMatchingHeaders(/^content-/i, this._options.headers));
+            var currentHostHeader = removeMatchingHeaders(/^host$/i, this._options.headers), currentUrlParts = parseUrl(this._currentUrl), currentHost = currentHostHeader || currentUrlParts.host, currentUrl = /^\w+:/.test(location) ? this._currentUrl : url.format(Object.assign(currentUrlParts, {
+                host: currentHost
+            })), redirectUrl = resolveUrl(location, currentUrl);
+            if (debug("redirecting to", redirectUrl.href), this._isRedirect = !0, spreadUrlObject(redirectUrl, this._options), (redirectUrl.protocol === currentUrlParts.protocol || "https:" === redirectUrl.protocol) && (redirectUrl.host === currentHost || isSubdomain(redirectUrl.host, currentHost)) || removeMatchingHeaders(/^(?:(?:proxy-)?authorization|cookie)$/i, this._options.headers), isFunction(beforeRedirect)) {
+                var responseDetails = {
+                    headers: response.headers,
+                    statusCode: statusCode
+                }, requestDetails = {
+                    url: currentUrl,
+                    method: method,
+                    headers: requestHeaders
+                };
+                beforeRedirect(this._options, responseDetails, requestDetails), this._sanitizeOptions(this._options);
+            }
+            this._performRequest();
+        }, module.exports = wrap({
+            http: http,
+            https: https
+        }), module.exports.wrap = wrap;
+    },
+    "../../node_modules/.pnpm/http-proxy@1.18.1_patch_hash=424b689da454f1f336d635615733f30568882789c1173f861c30f95ba8_7c4b684cae90eb7d05b3dfae37f0ceb4/node_modules/http-proxy/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        module.exports = __webpack_require__("../../node_modules/.pnpm/http-proxy@1.18.1_patch_hash=424b689da454f1f336d635615733f30568882789c1173f861c30f95ba8_7c4b684cae90eb7d05b3dfae37f0ceb4/node_modules/http-proxy/lib/http-proxy.js");
+    },
+    "../../node_modules/.pnpm/http-proxy@1.18.1_patch_hash=424b689da454f1f336d635615733f30568882789c1173f861c30f95ba8_7c4b684cae90eb7d05b3dfae37f0ceb4/node_modules/http-proxy/lib/http-proxy.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var ProxyServer = __webpack_require__("../../node_modules/.pnpm/http-proxy@1.18.1_patch_hash=424b689da454f1f336d635615733f30568882789c1173f861c30f95ba8_7c4b684cae90eb7d05b3dfae37f0ceb4/node_modules/http-proxy/lib/http-proxy/index.js").Server;
+        function createProxyServer(options) {
+            return new ProxyServer(options);
+        }
+        ProxyServer.createProxyServer = createProxyServer, ProxyServer.createServer = createProxyServer, ProxyServer.createProxy = createProxyServer, module.exports = ProxyServer;
+    },
+    "../../node_modules/.pnpm/http-proxy@1.18.1_patch_hash=424b689da454f1f336d635615733f30568882789c1173f861c30f95ba8_7c4b684cae90eb7d05b3dfae37f0ceb4/node_modules/http-proxy/lib/http-proxy/common.js" (__unused_rspack_module, exports, __webpack_require__) {
+        var url = __webpack_require__("url?5f07"), required = __webpack_require__("../../node_modules/.pnpm/requires-port@1.0.0/node_modules/requires-port/index.js"), upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i, isSSL = /^https|wss/;
+        function hasPort(host) {
+            return !!~host.indexOf(':');
+        }
+        exports.isSSL = isSSL, exports.setupOutgoing = function(outgoing, options, req, forward) {
+            outgoing.port = options[forward || 'target'].port || (isSSL.test(options[forward || 'target'].protocol) ? 443 : 80), [
+                'host',
+                'hostname',
+                'socketPath',
+                'pfx',
+                'key',
+                'passphrase',
+                'cert',
+                'ca',
+                'ciphers',
+                'secureProtocol'
+            ].forEach(function(e) {
+                outgoing[e] = options[forward || 'target'][e];
+            }), outgoing.method = options.method || req.method, outgoing.headers = Object.assign({}, req.headers), options.headers && Object.assign(outgoing.headers, options.headers), options.auth && (outgoing.auth = options.auth), options.ca && (outgoing.ca = options.ca), isSSL.test(options[forward || 'target'].protocol) && (outgoing.rejectUnauthorized = void 0 === options.secure || options.secure), outgoing.agent = options.agent || !1, outgoing.localAddress = options.localAddress, !outgoing.agent && (outgoing.headers = outgoing.headers || {}, 'string' == typeof outgoing.headers.connection && upgradeHeader.test(outgoing.headers.connection) || (outgoing.headers.connection = 'close'));
+            var target = options[forward || 'target'], targetPath = target && !1 !== options.prependPath && target.path || '', outgoingPath = options.toProxy ? req.url : url.parse(req.url).path || '';
+            return outgoingPath = options.ignorePath ? '' : outgoingPath, outgoing.path = exports.urlJoin(targetPath, outgoingPath), options.changeOrigin && (outgoing.headers.host = required(outgoing.port, options[forward || 'target'].protocol) && !hasPort(outgoing.host) ? outgoing.host + ':' + outgoing.port : outgoing.host), outgoing;
+        }, exports.setupSocket = function(socket) {
+            return socket.setTimeout(0), socket.setNoDelay(!0), socket.setKeepAlive(!0, 0), socket;
+        }, exports.getPort = function(req) {
+            var res = req.headers.host ? req.headers.host.match(/:(\d+)/) : '';
+            return res ? res[1] : exports.hasEncryptedConnection(req) ? '443' : '80';
+        }, exports.hasEncryptedConnection = function(req) {
+            return !!(req.connection.encrypted || req.connection.pair);
+        }, exports.urlJoin = function() {
+            var retSegs, args = Array.prototype.slice.call(arguments), lastIndex = args.length - 1, lastSegs = args[lastIndex].split('?');
+            return args[lastIndex] = lastSegs.shift(), (retSegs = [
+                args.filter(Boolean).join('/').replace(/\/+/g, '/').replace('http:/', 'http://').replace('https:/', 'https://')
+            ]).push.apply(retSegs, lastSegs), retSegs.join('?');
+        }, exports.rewriteCookieProperty = function rewriteCookieProperty(header, config, property) {
+            return Array.isArray(header) ? header.map(function(headerElement) {
+                return rewriteCookieProperty(headerElement, config, property);
+            }) : header.replace(RegExp("(;\\s*" + property + "=)([^;]+)", 'i'), function(match, prefix, previousValue) {
+                var newValue;
+                if (previousValue in config) newValue = config[previousValue];
+                else {
+                    if (!('*' in config)) return match;
+                    newValue = config['*'];
+                }
+                return newValue ? prefix + newValue : '';
+            });
+        };
+    },
+    "../../node_modules/.pnpm/http-proxy@1.18.1_patch_hash=424b689da454f1f336d635615733f30568882789c1173f861c30f95ba8_7c4b684cae90eb7d05b3dfae37f0ceb4/node_modules/http-proxy/lib/http-proxy/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var httpProxy = module.exports, parse_url = __webpack_require__("url?5f07").parse, EE3 = __webpack_require__("../../node_modules/.pnpm/eventemitter3@4.0.7/node_modules/eventemitter3/index.js"), http = __webpack_require__("http"), https = __webpack_require__("https"), web = __webpack_require__("../../node_modules/.pnpm/http-proxy@1.18.1_patch_hash=424b689da454f1f336d635615733f30568882789c1173f861c30f95ba8_7c4b684cae90eb7d05b3dfae37f0ceb4/node_modules/http-proxy/lib/http-proxy/passes/web-incoming.js"), ws = __webpack_require__("../../node_modules/.pnpm/http-proxy@1.18.1_patch_hash=424b689da454f1f336d635615733f30568882789c1173f861c30f95ba8_7c4b684cae90eb7d05b3dfae37f0ceb4/node_modules/http-proxy/lib/http-proxy/passes/ws-incoming.js");
+        function createRightProxy(type) {
+            return function(options) {
+                return function(req, res) {
+                    var head, cbl, passes = 'ws' === type ? this.wsPasses : this.webPasses, args = [].slice.call(arguments), cntr = args.length - 1;
+                    'function' == typeof args[cntr] && (cbl = args[cntr], cntr--);
+                    var requestOptions = options;
+                    if (!(args[cntr] instanceof Buffer) && args[cntr] !== res && (Object.assign(requestOptions = Object.assign({}, options), args[cntr]), cntr--), args[cntr] instanceof Buffer && (head = args[cntr]), [
+                        'target',
+                        'forward'
+                    ].forEach(function(e) {
+                        'string' == typeof requestOptions[e] && (requestOptions[e] = parse_url(requestOptions[e]));
+                    }), !requestOptions.target && !requestOptions.forward) return this.emit('error', Error('Must provide a proper URL as target'));
+                    for(var i = 0; i < passes.length && !passes[i](req, res, requestOptions, head, this, cbl); i++);
+                };
+            };
+        }
+        function ProxyServer(options) {
+            EE3.call(this), (options = options || {}).prependPath = !1 !== options.prependPath, this.web = this.proxyRequest = createRightProxy('web')(options), this.ws = this.proxyWebsocketRequest = createRightProxy('ws')(options), this.options = options, this.webPasses = Object.keys(web).map(function(pass) {
+                return web[pass];
+            }), this.wsPasses = Object.keys(ws).map(function(pass) {
+                return ws[pass];
+            }), this.on('error', this.onError, this);
+        }
+        httpProxy.Server = ProxyServer, httpProxy.createRightProxy = createRightProxy, __webpack_require__("util").inherits(ProxyServer, EE3), ProxyServer.prototype.onError = function(err) {
+            if (1 === this.listeners('error').length) throw err;
+        }, ProxyServer.prototype.listen = function(port, hostname) {
+            var self = this, closure = function(req, res) {
+                self.web(req, res);
+            };
+            return this._server = this.options.ssl ? https.createServer(this.options.ssl, closure) : http.createServer(closure), this.options.ws && this._server.on('upgrade', function(req, socket, head) {
+                self.ws(req, socket, head);
+            }), this._server.listen(port, hostname), this;
+        }, ProxyServer.prototype.close = function(callback) {
+            var self = this;
+            function done() {
+                self._server = null, callback && callback.apply(null, arguments);
+            }
+            this._server && this._server.close(done);
+        }, ProxyServer.prototype.before = function(type, passName, callback) {
+            if ('ws' !== type && 'web' !== type) throw Error('type must be `web` or `ws`');
+            var passes = 'ws' === type ? this.wsPasses : this.webPasses, i = !1;
+            if (passes.forEach(function(v, idx) {
+                v.name === passName && (i = idx);
+            }), !1 === i) throw Error('No such pass');
+            passes.splice(i, 0, callback);
+        }, ProxyServer.prototype.after = function(type, passName, callback) {
+            if ('ws' !== type && 'web' !== type) throw Error('type must be `web` or `ws`');
+            var passes = 'ws' === type ? this.wsPasses : this.webPasses, i = !1;
+            if (passes.forEach(function(v, idx) {
+                v.name === passName && (i = idx);
+            }), !1 === i) throw Error('No such pass');
+            passes.splice(i++, 0, callback);
+        };
+    },
+    "../../node_modules/.pnpm/http-proxy@1.18.1_patch_hash=424b689da454f1f336d635615733f30568882789c1173f861c30f95ba8_7c4b684cae90eb7d05b3dfae37f0ceb4/node_modules/http-proxy/lib/http-proxy/passes/web-incoming.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var httpNative = __webpack_require__("http"), httpsNative = __webpack_require__("https"), web_o = __webpack_require__("../../node_modules/.pnpm/http-proxy@1.18.1_patch_hash=424b689da454f1f336d635615733f30568882789c1173f861c30f95ba8_7c4b684cae90eb7d05b3dfae37f0ceb4/node_modules/http-proxy/lib/http-proxy/passes/web-outgoing.js"), common = __webpack_require__("../../node_modules/.pnpm/http-proxy@1.18.1_patch_hash=424b689da454f1f336d635615733f30568882789c1173f861c30f95ba8_7c4b684cae90eb7d05b3dfae37f0ceb4/node_modules/http-proxy/lib/http-proxy/common.js"), followRedirects = __webpack_require__("../../node_modules/.pnpm/follow-redirects@1.15.11_debug@4.4.3_supports-color@10.2.2_/node_modules/follow-redirects/index.js");
+        web_o = Object.keys(web_o).map(function(pass) {
+            return web_o[pass];
+        });
+        var nativeAgents = {
+            http: httpNative,
+            https: httpsNative
+        };
+        module.exports = {
+            deleteLength: function deleteLength(req, res, options) {
+                'DELETE' !== req.method && 'OPTIONS' !== req.method || req.headers['content-length'] || (req.headers['content-length'] = '0', delete req.headers['transfer-encoding']);
+            },
+            timeout: function timeout(req, res, options) {
+                options.timeout && req.socket.setTimeout(options.timeout);
+            },
+            XHeaders: function XHeaders(req, res, options) {
+                if (options.xfwd) {
+                    var encrypted = req.isSpdy || common.hasEncryptedConnection(req), values = {
+                        for: req.connection.remoteAddress || req.socket.remoteAddress,
+                        port: common.getPort(req),
+                        proto: encrypted ? 'https' : 'http'
+                    };
+                    [
+                        'for',
+                        'port',
+                        'proto'
+                    ].forEach(function(header) {
+                        req.headers['x-forwarded-' + header] = (req.headers['x-forwarded-' + header] || '') + (req.headers['x-forwarded-' + header] ? ',' : '') + values[header];
+                    }), req.headers['x-forwarded-host'] = req.headers['x-forwarded-host'] || req.headers.host || '';
+                }
+            },
+            stream: function stream(req, res, options, _, server, clb) {
+                server.emit('start', req, res, options.target || options.forward);
+                var agents = options.followRedirects ? followRedirects : nativeAgents, http = agents.http, https = agents.https;
+                if (options.forward) {
+                    var forwardReq = ('https:' === options.forward.protocol ? https : http).request(common.setupOutgoing(options.ssl || {}, options, req, 'forward')), forwardError = createErrorHandler(forwardReq, options.forward);
+                    if (req.on('error', forwardError), forwardReq.on('error', forwardError), (options.buffer || req).pipe(forwardReq), !options.target) return res.end();
+                }
+                var proxyReq = ('https:' === options.target.protocol ? https : http).request(common.setupOutgoing(options.ssl || {}, options, req));
+                proxyReq.on('socket', function(socket) {
+                    server && !proxyReq.getHeader('expect') && server.emit('proxyReq', proxyReq, req, res, options);
+                }), options.proxyTimeout && proxyReq.setTimeout(options.proxyTimeout, function() {
+                    proxyReq.abort();
+                }), req.on('aborted', function() {
+                    proxyReq.abort();
+                });
+                var proxyError = createErrorHandler(proxyReq, options.target);
+                function createErrorHandler(proxyReq, url) {
+                    return function proxyError(err) {
+                        if (req.socket.destroyed && 'ECONNRESET' === err.code) return server.emit('econnreset', err, req, res, url), proxyReq.abort();
+                        clb ? clb(err, req, res, url) : server.emit('error', err, req, res, url);
+                    };
+                }
+                req.on('error', proxyError), proxyReq.on('error', proxyError), (options.buffer || req).pipe(proxyReq), proxyReq.on('response', function(proxyRes) {
+                    if (server && server.emit('proxyRes', proxyRes, req, res), !res.headersSent && !options.selfHandleResponse) for(var i = 0; i < web_o.length && !web_o[i](req, res, proxyRes, options); i++);
+                    res.finished ? server && server.emit('end', req, res, proxyRes) : (proxyRes.on('end', function() {
+                        server && server.emit('end', req, res, proxyRes);
+                    }), options.selfHandleResponse || proxyRes.pipe(res));
+                });
+            }
+        };
+    },
+    "../../node_modules/.pnpm/http-proxy@1.18.1_patch_hash=424b689da454f1f336d635615733f30568882789c1173f861c30f95ba8_7c4b684cae90eb7d05b3dfae37f0ceb4/node_modules/http-proxy/lib/http-proxy/passes/web-outgoing.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var url = __webpack_require__("url?5f07"), common = __webpack_require__("../../node_modules/.pnpm/http-proxy@1.18.1_patch_hash=424b689da454f1f336d635615733f30568882789c1173f861c30f95ba8_7c4b684cae90eb7d05b3dfae37f0ceb4/node_modules/http-proxy/lib/http-proxy/common.js"), redirectRegex = /^201|30(1|2|7|8)$/;
+        module.exports = {
+            removeChunked: function removeChunked(req, res, proxyRes) {
+                '1.0' === req.httpVersion && delete proxyRes.headers['transfer-encoding'];
+            },
+            setConnection: function setConnection(req, res, proxyRes) {
+                '1.0' === req.httpVersion ? proxyRes.headers.connection = req.headers.connection || 'close' : '2.0' === req.httpVersion || proxyRes.headers.connection || (proxyRes.headers.connection = req.headers.connection || 'keep-alive');
+            },
+            setRedirectHostRewrite: function setRedirectHostRewrite(req, res, proxyRes, options) {
+                if ((options.hostRewrite || options.autoRewrite || options.protocolRewrite) && proxyRes.headers.location && redirectRegex.test(proxyRes.statusCode)) {
+                    var target = url.parse(options.target), u = url.parse(proxyRes.headers.location);
+                    target.host == u.host && (options.hostRewrite ? u.host = options.hostRewrite : options.autoRewrite && (u.host = req.headers.host), options.protocolRewrite && (u.protocol = options.protocolRewrite), proxyRes.headers.location = u.format());
+                }
+            },
+            writeHeaders: function writeHeaders(req, res, proxyRes, options) {
+                var rawHeaderKeyMap, rewriteCookieDomainConfig = options.cookieDomainRewrite, rewriteCookiePathConfig = options.cookiePathRewrite, preserveHeaderKeyCase = options.preserveHeaderKeyCase, setHeader = function(key, header) {
+                    void 0 != header && (rewriteCookieDomainConfig && 'set-cookie' === key.toLowerCase() && (header = common.rewriteCookieProperty(header, rewriteCookieDomainConfig, 'domain')), rewriteCookiePathConfig && 'set-cookie' === key.toLowerCase() && (header = common.rewriteCookieProperty(header, rewriteCookiePathConfig, 'path')), res.setHeader(String(key).trim(), header));
+                };
+                if ('string' == typeof rewriteCookieDomainConfig && (rewriteCookieDomainConfig = {
+                    '*': rewriteCookieDomainConfig
+                }), 'string' == typeof rewriteCookiePathConfig && (rewriteCookiePathConfig = {
+                    '*': rewriteCookiePathConfig
+                }), preserveHeaderKeyCase && void 0 != proxyRes.rawHeaders) {
+                    rawHeaderKeyMap = {};
+                    for(var i = 0; i < proxyRes.rawHeaders.length; i += 2){
+                        var key = proxyRes.rawHeaders[i];
+                        rawHeaderKeyMap[key.toLowerCase()] = key;
+                    }
+                }
+                Object.keys(proxyRes.headers).forEach(function(key) {
+                    var header = proxyRes.headers[key];
+                    preserveHeaderKeyCase && rawHeaderKeyMap && (key = rawHeaderKeyMap[key] || key), setHeader(key, header);
+                });
+            },
+            writeStatusCode: function writeStatusCode(req, res, proxyRes) {
+                proxyRes.statusMessage ? (res.statusCode = proxyRes.statusCode, res.statusMessage = proxyRes.statusMessage) : res.statusCode = proxyRes.statusCode;
+            }
+        };
+    },
+    "../../node_modules/.pnpm/http-proxy@1.18.1_patch_hash=424b689da454f1f336d635615733f30568882789c1173f861c30f95ba8_7c4b684cae90eb7d05b3dfae37f0ceb4/node_modules/http-proxy/lib/http-proxy/passes/ws-incoming.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var http = __webpack_require__("http"), https = __webpack_require__("https"), common = __webpack_require__("../../node_modules/.pnpm/http-proxy@1.18.1_patch_hash=424b689da454f1f336d635615733f30568882789c1173f861c30f95ba8_7c4b684cae90eb7d05b3dfae37f0ceb4/node_modules/http-proxy/lib/http-proxy/common.js");
+        module.exports = {
+            checkMethodAndHeader: function checkMethodAndHeader(req, socket) {
+                if ('GET' !== req.method || !req.headers.upgrade || 'websocket' !== req.headers.upgrade.toLowerCase()) return socket.destroy(), !0;
+            },
+            XHeaders: function XHeaders(req, socket, options) {
+                if (options.xfwd) {
+                    var values = {
+                        for: req.connection.remoteAddress || req.socket.remoteAddress,
+                        port: common.getPort(req),
+                        proto: common.hasEncryptedConnection(req) ? 'wss' : 'ws'
+                    };
+                    [
+                        'for',
+                        'port',
+                        'proto'
+                    ].forEach(function(header) {
+                        req.headers['x-forwarded-' + header] = (req.headers['x-forwarded-' + header] || '') + (req.headers['x-forwarded-' + header] ? ',' : '') + values[header];
+                    });
+                }
+            },
+            stream: function stream(req, socket, options, head, server, clb) {
+                var createHttpHeader = function(line, headers) {
+                    return Object.keys(headers).reduce(function(head, key) {
+                        var value = headers[key];
+                        if (!Array.isArray(value)) return head.push(key + ': ' + value), head;
+                        for(var i = 0; i < value.length; i++)head.push(key + ': ' + value[i]);
+                        return head;
+                    }, [
+                        line
+                    ]).join('\r\n') + '\r\n\r\n';
+                };
+                common.setupSocket(socket), head && head.length && socket.unshift(head);
+                var proxyReq = (common.isSSL.test(options.target.protocol) ? https : http).request(common.setupOutgoing(options.ssl || {}, options, req));
+                return server && server.emit('proxyReqWs', proxyReq, req, socket, options, head), proxyReq.on('error', onOutgoingError), proxyReq.on('response', function(res) {
+                    res.upgrade || (socket.write(createHttpHeader('HTTP/' + res.httpVersion + ' ' + res.statusCode + ' ' + res.statusMessage, res.headers)), res.pipe(socket));
+                }), proxyReq.on('upgrade', function(proxyRes, proxySocket, proxyHead) {
+                    proxySocket.on('error', onOutgoingError), proxySocket.on('end', function() {
+                        server.emit('close', proxyRes, proxySocket, proxyHead);
+                    }), socket.on('error', function() {
+                        proxySocket.end();
+                    }), common.setupSocket(proxySocket), proxyHead && proxyHead.length && 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 onOutgoingError(err) {
+                    clb ? clb(err, req, socket) : server.emit('error', err, req, socket), socket.end();
+                }
+            }
+        };
+    },
+    "../../node_modules/.pnpm/is-extglob@2.1.1/node_modules/is-extglob/index.js" (module) {
+        module.exports = function isExtglob(str) {
+            var match;
+            if ('string' != typeof str || '' === str) return !1;
+            for(; match = /(\\).|([@?!+*]\(.*\))/g.exec(str);){
+                if (match[2]) return !0;
+                str = str.slice(match.index + match[0].length);
+            }
+            return !1;
+        };
+    },
+    "../../node_modules/.pnpm/is-glob@4.0.3/node_modules/is-glob/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var isExtglob = __webpack_require__("../../node_modules/.pnpm/is-extglob@2.1.1/node_modules/is-extglob/index.js"), chars = {
+            '{': '}',
+            '(': ')',
+            '[': ']'
+        }, strictCheck = function(str) {
+            if ('!' === str[0]) return !0;
+            for(var index = 0, pipeIndex = -2, closeSquareIndex = -2, closeCurlyIndex = -2, closeParenIndex = -2, backSlashIndex = -2; index < str.length;){
+                if ('*' === str[index] || '?' === str[index + 1] && /[\].+)]/.test(str[index]) || -1 !== closeSquareIndex && '[' === str[index] && ']' !== str[index + 1] && (closeSquareIndex < index && (closeSquareIndex = str.indexOf(']', index)), closeSquareIndex > index) && (-1 === backSlashIndex || backSlashIndex > closeSquareIndex || -1 === (backSlashIndex = str.indexOf('\\', index)) || backSlashIndex > closeSquareIndex) || -1 !== closeCurlyIndex && '{' === str[index] && '}' !== str[index + 1] && (closeCurlyIndex = str.indexOf('}', index)) > index && (-1 === (backSlashIndex = str.indexOf('\\', index)) || backSlashIndex > closeCurlyIndex) || -1 !== closeParenIndex && '(' === str[index] && '?' === str[index + 1] && /[:!=]/.test(str[index + 2]) && ')' !== str[index + 3] && (closeParenIndex = str.indexOf(')', index)) > index && (-1 === (backSlashIndex = str.indexOf('\\', index)) || backSlashIndex > closeParenIndex) || -1 !== pipeIndex && '(' === str[index] && '|' !== str[index + 1] && (pipeIndex < index && (pipeIndex = str.indexOf('|', index)), -1 !== pipeIndex && ')' !== str[pipeIndex + 1] && (closeParenIndex = str.indexOf(')', pipeIndex)) > pipeIndex) && (-1 === (backSlashIndex = str.indexOf('\\', pipeIndex)) || backSlashIndex > closeParenIndex)) return !0;
+                if ('\\' === str[index]) {
+                    var open = str[index + 1];
+                    index += 2;
+                    var close = chars[open];
+                    if (close) {
+                        var n = str.indexOf(close, index);
+                        -1 !== n && (index = n + 1);
+                    }
+                    if ('!' === str[index]) return !0;
+                } else index++;
+            }
+            return !1;
+        }, relaxedCheck = function(str) {
+            if ('!' === str[0]) return !0;
+            for(var index = 0; index < str.length;){
+                if (/[*?{}()[\]]/.test(str[index])) return !0;
+                if ('\\' === str[index]) {
+                    var open = str[index + 1];
+                    index += 2;
+                    var close = chars[open];
+                    if (close) {
+                        var n = str.indexOf(close, index);
+                        -1 !== n && (index = n + 1);
+                    }
+                    if ('!' === str[index]) return !0;
+                } else index++;
+            }
+            return !1;
+        };
+        module.exports = function isGlob(str, options) {
+            if ('string' != typeof str || '' === str) return !1;
+            if (isExtglob(str)) return !0;
+            var check = strictCheck;
+            return options && !1 === options.strict && (check = relaxedCheck), check(str);
+        };
+    },
+    "../../node_modules/.pnpm/is-number@7.0.0/node_modules/is-number/index.js" (module) {
+        module.exports = function(num) {
+            return 'number' == typeof num ? num - num == 0 : 'string' == typeof num && '' !== num.trim() && (Number.isFinite ? Number.isFinite(+num) : isFinite(+num));
+        };
+    },
+    "../../node_modules/.pnpm/is-plain-object@5.0.0/node_modules/is-plain-object/dist/is-plain-object.js" (__unused_rspack_module, exports) {
+        function isObject(o) {
+            return '[object Object]' === Object.prototype.toString.call(o);
+        }
+        exports.isPlainObject = function isPlainObject(o) {
+            var ctor, prot;
+            return !1 !== isObject(o) && (void 0 === (ctor = o.constructor) || !1 !== isObject(prot = ctor.prototype) && !1 !== prot.hasOwnProperty('isPrototypeOf'));
+        };
+    },
+    "../../node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let util = __webpack_require__("util"), braces = __webpack_require__("../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/index.js"), picomatch = __webpack_require__("../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/index.js"), utils = __webpack_require__("../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js"), isEmptyString = (v)=>'' === v || './' === v, hasBraces = (v)=>{
+            let index = v.indexOf('{');
+            return index > -1 && v.indexOf('}', index) > -1;
+        }, micromatch = (list, patterns, options)=>{
+            patterns = [].concat(patterns), list = [].concat(list);
+            let omit = new Set(), keep = new Set(), items = new Set(), negatives = 0, onResult = (state)=>{
+                items.add(state.output), options && options.onResult && options.onResult(state);
+            };
+            for(let i = 0; i < patterns.length; i++){
+                let isMatch = picomatch(String(patterns[i]), {
+                    ...options,
+                    onResult
+                }, !0), negated = isMatch.state.negated || isMatch.state.negatedExtglob;
+                for (let item of (negated && negatives++, list)){
+                    let matched = isMatch(item, !0);
+                    (negated ? !matched.isMatch : matched.isMatch) && (negated ? omit.add(matched.output) : (omit.delete(matched.output), keep.add(matched.output)));
+                }
+            }
+            let matches = (negatives === patterns.length ? [
+                ...items
+            ] : [
+                ...keep
+            ]).filter((item)=>!omit.has(item));
+            if (options && 0 === matches.length) {
+                if (!0 === options.failglob) throw Error(`No matches found for "${patterns.join(', ')}"`);
+                if (!0 === options.nonull || !0 === 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(), items = [], matches = new Set(micromatch(list, patterns, {
+                ...options,
+                onResult: (state)=>{
+                    options.onResult && options.onResult(state), items.push(state.output);
+                }
+            }));
+            for (let item of items)matches.has(item) || result.add(item);
+            return [
+                ...result
+            ];
+        }, micromatch.contains = (str, pattern, options)=>{
+            if ('string' != typeof str) throw 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 !1;
+                if (str.includes(pattern) || str.startsWith('./') && str.slice(2).includes(pattern)) return !0;
+            }
+            return micromatch.isMatch(str, pattern, {
+                ...options,
+                contains: !0
+            });
+        }, micromatch.matchKeys = (obj, patterns, options)=>{
+            if (!utils.isObject(obj)) throw TypeError('Expected the first argument to be an object');
+            let keys = micromatch(Object.keys(obj), patterns, options), 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 !0;
+            }
+            return !1;
+        }, 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 !1;
+            }
+            return !0;
+        }, micromatch.all = (str, patterns, options)=>{
+            if ('string' != typeof str) throw 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), match = picomatch.makeRe(String(glob), {
+                ...options,
+                capture: !0
+            }).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 TypeError('Expected a string');
+            return options && !0 === options.nobrace || !hasBraces(pattern) ? [
+                pattern
+            ] : braces(pattern, options);
+        }, micromatch.braceExpand = (pattern, options)=>{
+            if ('string' != typeof pattern) throw TypeError('Expected a string');
+            return micromatch.braces(pattern, {
+                ...options,
+                expand: !0
+            });
+        }, micromatch.hasBraces = hasBraces, module.exports = micromatch;
+    },
+    "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        module.exports = __webpack_require__("../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.js");
+    },
+    "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let path = __webpack_require__("path?37f5"), WIN_NO_SLASH = "[^\\\\/]", QMARK = '[^/]', END_ANCHOR = "(?:\\/|$)", START_ANCHOR = "(?:^|\\/)", DOTS_SLASH = `\\.{1,2}${END_ANCHOR}`, NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`, NO_DOT_SLASH = `(?!\\.{0,1}${END_ANCHOR})`, NO_DOTS_SLASH = `(?!${DOTS_SLASH})`, STAR = `${QMARK}*?`, 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
+        }, WINDOWS_CHARS = {
+            ...POSIX_CHARS,
+            SLASH_LITERAL: "[\\\\/]",
+            QMARK: WIN_NO_SLASH,
+            STAR: `${WIN_NO_SLASH}*?`,
+            DOTS_SLASH: "\\.{1,2}(?:[\\\\/]|$)",
+            NO_DOT: "(?!\\.)",
+            NO_DOTS: "(?!(?:^|[\\\\/])\\.{1,2}(?:[\\\\/]|$))",
+            NO_DOT_SLASH: "(?!\\.{0,1}(?:[\\\\/]|$))",
+            NO_DOTS_SLASH: "(?!\\.{1,2}(?:[\\\\/]|$))",
+            QMARK_NO_DOT: "[^.\\\\/]",
+            START_ANCHOR: "(?:^|[\\\\/])",
+            END_ANCHOR: "(?:[\\\\/]|$)"
+        };
+        module.exports = {
+            MAX_LENGTH: 65536,
+            POSIX_REGEX_SOURCE: {
+                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'
+            },
+            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: {
+                '***': '*',
+                '**/**': '**',
+                '**/**/**': '**'
+            },
+            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)=>({
+                    '!': {
+                        type: 'negate',
+                        open: '(?:(?!(?:',
+                        close: `))${chars.STAR})`
+                    },
+                    '?': {
+                        type: 'qmark',
+                        open: '(?:',
+                        close: ')?'
+                    },
+                    '+': {
+                        type: 'plus',
+                        open: '(?:',
+                        close: ')+'
+                    },
+                    '*': {
+                        type: 'star',
+                        open: '(?:',
+                        close: ')*'
+                    },
+                    '@': {
+                        type: 'at',
+                        open: '(?:',
+                        close: ')'
+                    }
+                }),
+            globChars: (win32)=>!0 === win32 ? WINDOWS_CHARS : POSIX_CHARS
+        };
+    },
+    "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/parse.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let constants = __webpack_require__("../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js"), utils = __webpack_require__("../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js"), { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants, expandRange = (args, options)=>{
+            if ('function' == typeof options.expandRange) return options.expandRange(...args, options);
+            args.sort();
+            let value = `[${args.join('-')}]`;
+            try {
+                new RegExp(value);
+            } catch (ex) {
+                return args.map((v)=>utils.escapeRegex(v)).join('..');
+            }
+            return value;
+        }, syntaxError = (type, char)=>`Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`, parse = (input, options)=>{
+            let value;
+            if ('string' != typeof input) throw TypeError('Expected a string');
+            input = REPLACEMENTS[input] || input;
+            let opts = {
+                ...options
+            }, max = 'number' == typeof opts.maxLength ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH, len = input.length;
+            if (len > max) throw SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+            let bos = {
+                type: 'bos',
+                value: '',
+                output: opts.prepend || ''
+            }, tokens = [
+                bos
+            ], capture = opts.capture ? '' : '?:', win32 = utils.isWindows(options), PLATFORM_CHARS = constants.globChars(win32), EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS), { 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, globstar = (opts)=>`(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`, nodot = opts.dot ? '' : NO_DOT, qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT, star = !0 === opts.bash ? globstar(opts) : STAR;
+            opts.capture && (star = `(${star})`), 'boolean' == typeof opts.noext && (opts.noextglob = opts.noext);
+            let state = {
+                input,
+                index: -1,
+                start: 0,
+                dot: !0 === opts.dot,
+                consumed: '',
+                output: '',
+                prefix: '',
+                backtrack: !1,
+                negated: !1,
+                brackets: 0,
+                braces: 0,
+                parens: 0,
+                quotes: 0,
+                globstar: !1,
+                tokens
+            };
+            len = (input = utils.removePrefix(input, state)).length;
+            let extglobs = [], braces = [], stack = [], prev = bos, eos = ()=>state.index === len - 1, peek = state.peek = (n = 1)=>input[state.index + n], advance = state.advance = ()=>input[++state.index] || '', remaining = ()=>input.slice(state.index + 1), consume = (value = '', num = 0)=>{
+                state.consumed += value, state.index += num;
+            }, append = (token)=>{
+                state.output += null != token.output ? token.output : token.value, consume(token.value);
+            }, negate = ()=>{
+                let count = 1;
+                for(; '!' === peek() && ('(' !== peek(2) || '?' === peek(3));)advance(), state.start++, count++;
+                return count % 2 != 0 && (state.negated = !0, state.start++, !0);
+            }, increment = (type)=>{
+                state[type]++, stack.push(type);
+            }, decrement = (type)=>{
+                state[type]--, stack.pop();
+            }, push = (tok)=>{
+                if ('globstar' === prev.type) {
+                    let isBrace = state.braces > 0 && ('comma' === tok.type || 'brace' === tok.type), isExtglob = !0 === tok.extglob || extglobs.length && ('pipe' === tok.type || 'paren' === tok.type);
+                    '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), (tok.value || tok.output) && append(tok), 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;
+            }, extglobOpen = (type, value)=>{
+                let token = {
+                    ...EXTGLOB_CHARS[value],
+                    conditions: 1,
+                    inner: ''
+                };
+                token.prev = prev, token.parens = state.parens, token.output = state.output;
+                let output = (opts.capture ? '(' : '') + token.open;
+                increment('parens'), push({
+                    type,
+                    value,
+                    output: state.output ? '' : ONE_CHAR
+                }), push({
+                    type: 'paren',
+                    extglob: !0,
+                    value: advance(),
+                    output
+                }), extglobs.push(token);
+            }, extglobClose = (token)=>{
+                let rest, output = token.close + (opts.capture ? ')' : '');
+                if ('negate' === token.type) {
+                    let extglobStar = star;
+                    if (token.inner && token.inner.length > 1 && token.inner.includes('/') && (extglobStar = globstar(opts)), (extglobStar !== star || eos() || /^\)+$/.test(remaining())) && (output = token.close = `)$))${extglobStar}`), token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+                        let expression = parse(rest, {
+                            ...options,
+                            fastpaths: !1
+                        }).output;
+                        output = token.close = `)${expression})${extglobStar})`;
+                    }
+                    'bos' === token.prev.type && (state.negatedExtglob = !0);
+                }
+                push({
+                    type: 'paren',
+                    extglob: !0,
+                    value,
+                    output
+                }), decrement('parens');
+            };
+            if (!1 !== opts.fastpaths && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+                let backslashes = !1, output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index)=>'\\' === first ? (backslashes = !0, m) : '?' === first ? esc ? esc + first + (rest ? QMARK.repeat(rest.length) : '') : 0 === index ? qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '') : QMARK.repeat(chars.length) : '.' === first ? DOT_LITERAL.repeat(chars.length) : '*' === first ? esc ? esc + first + (rest ? star : '') : star : esc ? m : `\\${m}`);
+                return (!0 === backslashes && (output = !0 === opts.unescape ? output.replace(/\\/g, '') : output.replace(/\\+/g, (m)=>m.length % 2 == 0 ? '\\\\' : m ? '\\' : '')), output === input && !0 === opts.contains) ? state.output = input : state.output = utils.wrapOutput(output, state, options), state;
+            }
+            for(; !eos();){
+                if ('\u0000' === (value = advance())) continue;
+                if ('\\' === value) {
+                    let next = peek();
+                    if ('/' === next && !0 !== opts.bash || '.' === next || ';' === next) continue;
+                    if (!next) {
+                        push({
+                            type: 'text',
+                            value: value += '\\'
+                        });
+                        continue;
+                    }
+                    let match = /^\\+/.exec(remaining()), slashes = 0;
+                    if (match && match[0].length > 2 && (slashes = match[0].length, state.index += slashes, slashes % 2 != 0 && (value += '\\')), !0 === opts.unescape ? value = advance() : value += advance(), 0 === state.brackets) {
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                }
+                if (state.brackets > 0 && (']' !== value || '[' === prev.value || '[^' === prev.value)) {
+                    if (!1 !== opts.posix && ':' === value) {
+                        let inner = prev.value.slice(1);
+                        if (inner.includes('[') && (prev.posix = !0, inner.includes(':'))) {
+                            let idx = prev.value.lastIndexOf('['), pre = prev.value.slice(0, idx), posix = POSIX_REGEX_SOURCE[prev.value.slice(idx + 2)];
+                            if (posix) {
+                                prev.value = pre + posix, state.backtrack = !0, advance(), bos.output || 1 !== tokens.indexOf(prev) || (bos.output = ONE_CHAR);
+                                continue;
+                            }
+                        }
+                    }
+                    ('[' === value && ':' !== peek() || '-' === value && ']' === peek()) && (value = `\\${value}`), ']' === value && ('[' === prev.value || '[^' === prev.value) && (value = `\\${value}`), !0 === 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 === opts.keepQuotes && push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if ('(' === value) {
+                    increment('parens'), push({
+                        type: 'paren',
+                        value
+                    });
+                    continue;
+                }
+                if (')' === value) {
+                    if (0 === state.parens && !0 === opts.strictBrackets) throw SyntaxError(syntaxError('opening', '('));
+                    let 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 (!0 !== opts.nobracket && remaining().includes(']')) increment('brackets');
+                    else {
+                        if (!0 !== opts.nobracket && !0 === opts.strictBrackets) throw SyntaxError(syntaxError('closing', ']'));
+                        value = `\\${value}`;
+                    }
+                    push({
+                        type: 'bracket',
+                        value
+                    });
+                    continue;
+                }
+                if (']' === value) {
+                    if (!0 === opts.nobracket || prev && 'bracket' === prev.type && 1 === prev.value.length) {
+                        push({
+                            type: 'text',
+                            value,
+                            output: `\\${value}`
+                        });
+                        continue;
+                    }
+                    if (0 === state.brackets) {
+                        if (!0 === opts.strictBrackets) throw SyntaxError(syntaxError('opening', '['));
+                        push({
+                            type: 'text',
+                            value,
+                            output: `\\${value}`
+                        });
+                        continue;
+                    }
+                    decrement('brackets');
+                    let prevValue = prev.value.slice(1);
+                    if (!0 === prev.posix || '^' !== prevValue[0] || prevValue.includes('/') || (value = `/${value}`), prev.value += value, append({
+                        value
+                    }), !1 === opts.literalBrackets || utils.hasRegexChars(prevValue)) continue;
+                    let escaped = utils.escapeRegex(prev.value);
+                    if (state.output = state.output.slice(0, -prev.value.length), !0 === opts.literalBrackets) {
+                        state.output += escaped, prev.value = escaped;
+                        continue;
+                    }
+                    prev.value = `(${capture}${escaped}|${prev.value})`, state.output += prev.value;
+                    continue;
+                }
+                if ('{' === value && !0 !== opts.nobrace) {
+                    increment('braces');
+                    let open = {
+                        type: 'brace',
+                        value,
+                        output: '(',
+                        outputIndex: state.output.length,
+                        tokensIndex: state.tokens.length
+                    };
+                    braces.push(open), push(open);
+                    continue;
+                }
+                if ('}' === value) {
+                    let brace = braces[braces.length - 1];
+                    if (!0 === opts.nobrace || !brace) {
+                        push({
+                            type: 'text',
+                            value,
+                            output: value
+                        });
+                        continue;
+                    }
+                    let output = ')';
+                    if (!0 === brace.dots) {
+                        let arr = tokens.slice(), range = [];
+                        for(let i = arr.length - 1; i >= 0 && (tokens.pop(), 'brace' !== arr[i].type); i--)'dots' !== arr[i].type && range.unshift(arr[i].value);
+                        output = expandRange(range, opts), state.backtrack = !0;
+                    }
+                    if (!0 !== brace.comma && !0 !== brace.dots) {
+                        let out = state.output.slice(0, brace.outputIndex), toks = state.tokens.slice(brace.tokensIndex);
+                        for (let t of (brace.value = brace.output = '\\{', value = output = '\\}', state.output = out, toks))state.output += t.output || t.value;
+                    }
+                    push({
+                        type: 'brace',
+                        value,
+                        output
+                    }), decrement('braces'), braces.pop();
+                    continue;
+                }
+                if ('|' === value) {
+                    extglobs.length > 0 && extglobs[extglobs.length - 1].conditions++, push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (',' === value) {
+                    let output = value, brace = braces[braces.length - 1];
+                    brace && 'braces' === stack[stack.length - 1] && (brace.comma = !0, 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) {
+                        '.' === prev.value && (prev.output = DOT_LITERAL);
+                        let brace = braces[braces.length - 1];
+                        prev.type = 'dots', prev.output += value, prev.value += value, brace.dots = !0;
+                        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) {
+                    if (!(prev && '(' === prev.value) && !0 !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        extglobOpen('qmark', value);
+                        continue;
+                    }
+                    if (prev && 'paren' === prev.type) {
+                        let next = peek(), output = value;
+                        if ('<' === next && !utils.supportsLookbehinds()) throw Error('Node.js v10 or higher is required for regex lookbehinds');
+                        ('(' !== prev.value || /[!=<:]/.test(next)) && ('<' !== next || /<([!=]|\w+>)/.test(remaining())) || (output = `\\${value}`), push({
+                            type: 'text',
+                            value,
+                            output
+                        });
+                        continue;
+                    }
+                    if (!0 !== 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 (!0 !== opts.noextglob && '(' === peek() && ('?' !== peek(2) || !/[!=<:]/.test(peek(3)))) {
+                        extglobOpen('negate', value);
+                        continue;
+                    }
+                    if (!0 !== opts.nonegate && 0 === state.index) {
+                        negate();
+                        continue;
+                    }
+                }
+                if ('+' === value) {
+                    if (!0 !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        extglobOpen('plus', value);
+                        continue;
+                    }
+                    if (prev && '(' === prev.value || !1 === 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 (!0 !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        push({
+                            type: 'at',
+                            extglob: !0,
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if ('*' !== value) {
+                    ('$' === value || '^' === value) && (value = `\\${value}`);
+                    let match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+                    match && (value += match[0], state.index += match[0].length), push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (prev && ('globstar' === prev.type || !0 === prev.star)) {
+                    prev.type = 'star', prev.star = !0, prev.value += value, prev.output = star, state.backtrack = !0, state.globstar = !0, consume(value);
+                    continue;
+                }
+                let rest = remaining();
+                if (!0 !== opts.noextglob && /^\([^?]/.test(rest)) {
+                    extglobOpen('star', value);
+                    continue;
+                }
+                if ('star' === prev.type) {
+                    if (!0 === opts.noglobstar) {
+                        consume(value);
+                        continue;
+                    }
+                    let prior = prev.prev, before = prior.prev, isStart = 'slash' === prior.type || 'bos' === prior.type, afterStar = before && ('star' === before.type || 'globstar' === before.type);
+                    if (!0 === opts.bash && (!isStart || rest[0] && '/' !== rest[0])) {
+                        push({
+                            type: 'star',
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    let isBrace = state.braces > 0 && ('comma' === prior.type || 'brace' === prior.type), isExtglob = extglobs.length && ('pipe' === prior.type || 'paren' === prior.type);
+                    if (!isStart && 'paren' !== prior.type && !isBrace && !isExtglob) {
+                        push({
+                            type: 'star',
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    for(; '/**' === rest.slice(0, 3);){
+                        let 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 = !0, 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 = !0, state.output += prior.output + prev.output, consume(value);
+                        continue;
+                    }
+                    if ('slash' === prior.type && 'bos' !== prior.prev.type && '/' === rest[0]) {
+                        let 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 = !0, 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 = !0, 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 = !0, consume(value);
+                    continue;
+                }
+                let token = {
+                    type: 'star',
+                    value,
+                    output: star
+                };
+                if (!0 === opts.bash) {
+                    token.output = '.*?', ('bos' === prev.type || 'slash' === prev.type) && (token.output = nodot + token.output), push(token);
+                    continue;
+                }
+                if (prev && ('bracket' === prev.type || 'paren' === prev.type) && !0 === opts.regex) {
+                    token.output = value, push(token);
+                    continue;
+                }
+                (state.index === state.start || 'slash' === prev.type || 'dot' === prev.type) && ('dot' === prev.type ? (state.output += NO_DOT_SLASH, prev.output += NO_DOT_SLASH) : !0 === opts.dot ? (state.output += NO_DOTS_SLASH, prev.output += NO_DOTS_SLASH) : (state.output += nodot, prev.output += nodot), '*' !== peek() && (state.output += ONE_CHAR, prev.output += ONE_CHAR)), push(token);
+            }
+            for(; state.brackets > 0;){
+                if (!0 === opts.strictBrackets) throw SyntaxError(syntaxError('closing', ']'));
+                state.output = utils.escapeLast(state.output, '['), decrement('brackets');
+            }
+            for(; state.parens > 0;){
+                if (!0 === opts.strictBrackets) throw SyntaxError(syntaxError('closing', ')'));
+                state.output = utils.escapeLast(state.output, '('), decrement('parens');
+            }
+            for(; state.braces > 0;){
+                if (!0 === opts.strictBrackets) throw SyntaxError(syntaxError('closing', '}'));
+                state.output = utils.escapeLast(state.output, '{'), decrement('braces');
+            }
+            if (!0 !== opts.strictSlashes && ('star' === prev.type || 'bracket' === prev.type) && push({
+                type: 'maybe_slash',
+                value: '',
+                output: `${SLASH_LITERAL}?`
+            }), !0 === state.backtrack) for (let token of (state.output = '', state.tokens))state.output += null != token.output ? token.output : token.value, token.suffix && (state.output += token.suffix);
+            return state;
+        };
+        parse.fastpaths = (input, options)=>{
+            let opts = {
+                ...options
+            }, max = 'number' == typeof opts.maxLength ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH, len = input.length;
+            if (len > max) throw SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+            input = REPLACEMENTS[input] || input;
+            let win32 = utils.isWindows(options), { DOT_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants.globChars(win32), nodot = opts.dot ? NO_DOTS : NO_DOT, slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT, capture = opts.capture ? '' : '?:', star = !0 === opts.bash ? '.*?' : STAR;
+            opts.capture && (star = `(${star})`);
+            let globstar = (opts)=>!0 === opts.noglobstar ? star : `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`, 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:
+                        {
+                            let match = /^(.*?)\.(\w+)$/.exec(str);
+                            if (!match) return;
+                            let source = create(match[1]);
+                            if (!source) return;
+                            return source + DOT_LITERAL + match[2];
+                        }
+                }
+            }, source = create(utils.removePrefix(input, {
+                negated: !1,
+                prefix: ''
+            }));
+            return source && !0 !== opts.strictSlashes && (source += `${SLASH_LITERAL}?`), source;
+        }, module.exports = parse;
+    },
+    "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let path = __webpack_require__("path?37f5"), scan = __webpack_require__("../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/scan.js"), parse = __webpack_require__("../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/parse.js"), utils = __webpack_require__("../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js"), constants = __webpack_require__("../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js"), picomatch = (glob, options, returnState = !1)=>{
+            if (Array.isArray(glob)) {
+                let fns = glob.map((input)=>picomatch(input, options, returnState));
+                return (str)=>{
+                    for (let isMatch of fns){
+                        let state = isMatch(str);
+                        if (state) return state;
+                    }
+                    return !1;
+                };
+            }
+            let isState = glob && 'object' == typeof glob && !Array.isArray(glob) && glob.tokens && glob.input;
+            if ('' === glob || 'string' != typeof glob && !isState) throw TypeError('Expected pattern to be a non-empty string');
+            let opts = options || {}, posix = utils.isWindows(options), regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, !1, !0), state = regex.state;
+            delete regex.state;
+            let isIgnored = ()=>!1;
+            if (opts.ignore) {
+                let ignoreOpts = {
+                    ...options,
+                    ignore: null,
+                    onMatch: null,
+                    onResult: null
+                };
+                isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+            }
+            let matcher = (input, returnObject = !1)=>{
+                let { isMatch, match, output } = picomatch.test(input, regex, options, {
+                    glob,
+                    posix
+                }), result = {
+                    glob,
+                    state,
+                    regex,
+                    posix,
+                    input,
+                    output,
+                    match,
+                    isMatch
+                };
+                return ('function' == typeof opts.onResult && opts.onResult(result), !1 === isMatch) ? (result.isMatch = !1, !!returnObject && result) : isIgnored(input) ? ('function' == typeof opts.onIgnore && opts.onIgnore(result), result.isMatch = !1, !!returnObject && result) : ('function' == typeof opts.onMatch && opts.onMatch(result), !returnObject || result);
+            };
+            return returnState && (matcher.state = state), matcher;
+        };
+        picomatch.test = (input, regex, options, { glob, posix } = {})=>{
+            if ('string' != typeof input) throw TypeError('Expected input to be a string');
+            if ('' === input) return {
+                isMatch: !1,
+                output: ''
+            };
+            let opts = options || {}, format = opts.format || (posix ? utils.toPosixSlashes : null), match = input === glob, output = match && format ? format(input) : input;
+            return !1 === match && (match = (output = format ? format(input) : input) === glob), (!1 === match || !0 === opts.capture) && (match = !0 === opts.matchBase || !0 === opts.basename ? picomatch.matchBase(input, regex, options, posix) : regex.exec(output)), {
+                isMatch: !!match,
+                match,
+                output
+            };
+        }, picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options))=>(glob instanceof RegExp ? glob : picomatch.makeRe(glob, options)).test(path.basename(input)), picomatch.isMatch = (str, patterns, options)=>picomatch(patterns, options)(str), picomatch.parse = (pattern, options)=>Array.isArray(pattern) ? pattern.map((p)=>picomatch.parse(p, options)) : parse(pattern, {
+                ...options,
+                fastpaths: !1
+            }), picomatch.scan = (input, options)=>scan(input, options), picomatch.compileRe = (state, options, returnOutput = !1, returnState = !1)=>{
+            if (!0 === returnOutput) return state.output;
+            let opts = options || {}, prepend = opts.contains ? '' : '^', append = opts.contains ? '' : '$', source = `${prepend}(?:${state.output})${append}`;
+            state && !0 === state.negated && (source = `^(?!${source}).*$`);
+            let regex = picomatch.toRegex(source, options);
+            return !0 === returnState && (regex.state = state), regex;
+        }, picomatch.makeRe = (input, options = {}, returnOutput = !1, returnState = !1)=>{
+            if (!input || 'string' != typeof input) throw TypeError('Expected a non-empty string');
+            let parsed = {
+                negated: !1,
+                fastpaths: !0
+            };
+            return !1 !== options.fastpaths && ('.' === input[0] || '*' === input[0]) && (parsed.output = parse.fastpaths(input, options)), parsed.output || (parsed = parse(input, options)), picomatch.compileRe(parsed, options, returnOutput, returnState);
+        }, picomatch.toRegex = (source, options)=>{
+            try {
+                let opts = options || {};
+                return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+            } catch (err) {
+                if (options && !0 === options.debug) throw err;
+                return /$^/;
+            }
+        }, picomatch.constants = constants, module.exports = picomatch;
+    },
+    "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/scan.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let utils = __webpack_require__("../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js"), { 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.1/node_modules/picomatch/lib/constants.js"), isPathSeparator = (code)=>code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH, depth = (token)=>{
+            !0 !== token.isPrefix && (token.depth = token.isGlobstar ? 1 / 0 : 1);
+        };
+        module.exports = (input, options)=>{
+            let prev, code, opts = options || {}, length = input.length - 1, scanToEnd = !0 === opts.parts || !0 === opts.scanToEnd, slashes = [], tokens = [], parts = [], str = input, index = -1, start = 0, lastIndex = 0, isBrace = !1, isBracket = !1, isGlob = !1, isExtglob = !1, isGlobstar = !1, braceEscaped = !1, backslashes = !1, negated = !1, negatedExtglob = !1, finished = !1, braces = 0, token = {
+                value: '',
+                depth: 0,
+                isGlob: !1
+            }, eos = ()=>index >= length, peek = ()=>str.charCodeAt(index + 1), advance = ()=>(prev = code, str.charCodeAt(++index));
+            for(; index < length;){
+                let next;
+                if ((code = advance()) === CHAR_BACKWARD_SLASH) {
+                    backslashes = token.backslashes = !0, (code = advance()) === CHAR_LEFT_CURLY_BRACE && (braceEscaped = !0);
+                    continue;
+                }
+                if (!0 === braceEscaped || code === CHAR_LEFT_CURLY_BRACE) {
+                    for(braces++; !0 !== eos() && (code = advance());){
+                        if (code === CHAR_BACKWARD_SLASH) {
+                            backslashes = token.backslashes = !0, advance();
+                            continue;
+                        }
+                        if (code === CHAR_LEFT_CURLY_BRACE) {
+                            braces++;
+                            continue;
+                        }
+                        if (!0 !== braceEscaped && code === CHAR_DOT && (code = advance()) === CHAR_DOT || !0 !== braceEscaped && code === CHAR_COMMA) {
+                            if (isBrace = token.isBrace = !0, isGlob = token.isGlob = !0, finished = !0, !0 === scanToEnd) continue;
+                            break;
+                        }
+                        if (code === CHAR_RIGHT_CURLY_BRACE && 0 == --braces) {
+                            braceEscaped = !1, isBrace = token.isBrace = !0, finished = !0;
+                            break;
+                        }
+                    }
+                    if (!0 === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_FORWARD_SLASH) {
+                    if (slashes.push(index), tokens.push(token), token = {
+                        value: '',
+                        depth: 0,
+                        isGlob: !1
+                    }, !0 === finished) continue;
+                    if (prev === CHAR_DOT && index === start + 1) {
+                        start += 2;
+                        continue;
+                    }
+                    lastIndex = index + 1;
+                    continue;
+                }
+                if (!0 !== opts.noext && !0 == (code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK) && peek() === CHAR_LEFT_PARENTHESES) {
+                    if (isGlob = token.isGlob = !0, isExtglob = token.isExtglob = !0, finished = !0, code === CHAR_EXCLAMATION_MARK && index === start && (negatedExtglob = !0), !0 === scanToEnd) {
+                        for(; !0 !== eos() && (code = advance());){
+                            if (code === CHAR_BACKWARD_SLASH) {
+                                backslashes = token.backslashes = !0, code = advance();
+                                continue;
+                            }
+                            if (code === CHAR_RIGHT_PARENTHESES) {
+                                isGlob = token.isGlob = !0, finished = !0;
+                                break;
+                            }
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                if (code === CHAR_ASTERISK) {
+                    if (prev === CHAR_ASTERISK && (isGlobstar = token.isGlobstar = !0), isGlob = token.isGlob = !0, finished = !0, !0 === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_QUESTION_MARK) {
+                    if (isGlob = token.isGlob = !0, finished = !0, !0 === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_LEFT_SQUARE_BRACKET) {
+                    for(; !0 !== eos() && (next = advance());){
+                        if (next === CHAR_BACKWARD_SLASH) {
+                            backslashes = token.backslashes = !0, advance();
+                            continue;
+                        }
+                        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+                            isBracket = token.isBracket = !0, isGlob = token.isGlob = !0, finished = !0;
+                            break;
+                        }
+                    }
+                    if (!0 === scanToEnd) continue;
+                    break;
+                }
+                if (!0 !== opts.nonegate && code === CHAR_EXCLAMATION_MARK && index === start) {
+                    negated = token.negated = !0, start++;
+                    continue;
+                }
+                if (!0 !== opts.noparen && code === CHAR_LEFT_PARENTHESES) {
+                    if (isGlob = token.isGlob = !0, !0 === scanToEnd) {
+                        for(; !0 !== eos() && (code = advance());){
+                            if (code === CHAR_LEFT_PARENTHESES) {
+                                backslashes = token.backslashes = !0, code = advance();
+                                continue;
+                            }
+                            if (code === CHAR_RIGHT_PARENTHESES) {
+                                finished = !0;
+                                break;
+                            }
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                if (!0 === isGlob) {
+                    if (finished = !0, !0 === scanToEnd) continue;
+                    break;
+                }
+            }
+            !0 === opts.noext && (isExtglob = !1, isGlob = !1);
+            let base = str, prefix = '', glob = '';
+            start > 0 && (prefix = str.slice(0, start), str = str.slice(start), lastIndex -= start), base && !0 === isGlob && lastIndex > 0 ? (base = str.slice(0, lastIndex), glob = str.slice(lastIndex)) : !0 === isGlob ? (base = '', glob = str) : base = str, base && '' !== base && '/' !== base && base !== str && isPathSeparator(base.charCodeAt(base.length - 1)) && (base = base.slice(0, -1)), !0 === opts.unescape && (glob && (glob = utils.removeBackslashes(glob)), base && !0 === backslashes && (base = utils.removeBackslashes(base)));
+            let state = {
+                prefix,
+                input,
+                start,
+                base,
+                glob,
+                isBrace,
+                isBracket,
+                isGlob,
+                isExtglob,
+                isGlobstar,
+                negated,
+                negatedExtglob
+            };
+            if (!0 === opts.tokens && (state.maxDepth = 0, isPathSeparator(code) || tokens.push(token), state.tokens = tokens), !0 === opts.parts || !0 === opts.tokens) {
+                let prevIndex;
+                for(let idx = 0; idx < slashes.length; idx++){
+                    let n = prevIndex ? prevIndex + 1 : start, i = slashes[idx], value = input.slice(n, i);
+                    opts.tokens && (0 === idx && 0 !== start ? (tokens[idx].isPrefix = !0, tokens[idx].value = prefix) : tokens[idx].value = value, depth(tokens[idx]), state.maxDepth += tokens[idx].depth), (0 !== idx || '' !== value) && parts.push(value), prevIndex = i;
+                }
+                if (prevIndex && prevIndex + 1 < input.length) {
+                    let value = input.slice(prevIndex + 1);
+                    parts.push(value), 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;
+        };
+    },
+    "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js" (__unused_rspack_module, exports, __webpack_require__) {
+        let path = __webpack_require__("path?37f5"), win32 = 'win32' === process.platform, { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = __webpack_require__("../../node_modules/.pnpm/picomatch@2.3.1/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 = ()=>{
+            let segs = process.version.slice(1).split('.').map(Number);
+            return 3 === segs.length && !!(segs[0] >= 9) || 8 === segs[0] && !!(segs[1] >= 10);
+        }, exports.isWindows = (options)=>options && 'boolean' == typeof options.windows ? options.windows : !0 === win32 || '\\' === path.sep, exports.escapeLast = (input, char, lastIdx)=>{
+            let idx = input.lastIndexOf(char, lastIdx);
+            return -1 === idx ? input : '\\' === input[idx - 1] ? exports.escapeLast(input, char, idx - 1) : `${input.slice(0, idx)}\\${input.slice(idx)}`;
+        }, exports.removePrefix = (input, state = {})=>{
+            let output = input;
+            return output.startsWith('./') && (output = output.slice(2), state.prefix = './'), output;
+        }, exports.wrapOutput = (input, state = {}, options = {})=>{
+            let prepend = options.contains ? '' : '^', append = options.contains ? '' : '$', output = `${prepend}(?:${input})${append}`;
+            return !0 === state.negated && (output = `(?:^(?!${output}).*$)`), output;
+        };
+    },
+    "../../node_modules/.pnpm/requires-port@1.0.0/node_modules/requires-port/index.js" (module) {
+        module.exports = function required(port, protocol) {
+            if (protocol = protocol.split(':')[0], !(port *= 1)) return !1;
+            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 !1;
+            }
+            return 0 !== port;
+        };
+    },
+    "../../node_modules/.pnpm/to-regex-range@5.0.1/node_modules/to-regex-range/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let isNumber = __webpack_require__("../../node_modules/.pnpm/is-number@7.0.0/node_modules/is-number/index.js"), toRegexRange = (min, max, options)=>{
+            if (!1 === isNumber(min)) throw TypeError('toRegexRange: expected the first argument to be a number');
+            if (void 0 === max || min === max) return String(min);
+            if (!1 === isNumber(max)) throw TypeError('toRegexRange: expected the second argument to be a number.');
+            let opts = {
+                relaxZeros: !0,
+                ...options
+            };
+            'boolean' == typeof opts.strictZeros && (opts.relaxZeros = !1 === opts.strictZeros);
+            let cacheKey = min + ':' + max + '=' + String(opts.relaxZeros) + String(opts.shorthand) + String(opts.capture) + String(opts.wrap);
+            if (toRegexRange.cache.hasOwnProperty(cacheKey)) return toRegexRange.cache[cacheKey].result;
+            let a = Math.min(min, max), b = Math.max(min, max);
+            if (1 === Math.abs(a - b)) {
+                let result = min + '|' + max;
+                return opts.capture ? `(${result})` : !1 === opts.wrap ? result : `(?:${result})`;
+            }
+            let isPadded = hasPadding(min) || hasPadding(max), state = {
+                min,
+                max,
+                a,
+                b
+            }, positives = [], negatives = [];
+            return isPadded && (state.isPadded = isPadded, state.maxLen = String(state.max).length), a < 0 && (negatives = splitToPatterns(b < 0 ? Math.abs(b) : 1, Math.abs(a), state, opts), a = state.a = 0), b >= 0 && (positives = splitToPatterns(a, b, state, opts)), state.negatives = negatives, state.positives = positives, state.result = collatePatterns(negatives, positives, opts), !0 === opts.capture ? state.result = `(${state.result})` : !1 !== opts.wrap && positives.length + negatives.length > 1 && (state.result = `(?:${state.result})`), toRegexRange.cache[cacheKey] = state, state.result;
+        };
+        function collatePatterns(neg, pos, options) {
+            let onlyNegative = filterPatterns(neg, pos, '-', !1, options) || [], onlyPositive = filterPatterns(pos, neg, '', !1, options) || [], intersected = filterPatterns(neg, pos, '-?', !0, options) || [];
+            return onlyNegative.concat(intersected).concat(onlyPositive).join('|');
+        }
+        function splitToRanges(min, max) {
+            let nines = 1, zeros = 1, stop = countNines(min, 1), stops = new Set([
+                max
+            ]);
+            for(; min <= stop && stop <= max;)stops.add(stop), nines += 1, stop = countNines(min, nines);
+            for(stop = countZeros(max + 1, zeros) - 1; min < stop && stop <= max;)stops.add(stop), zeros += 1, stop = countZeros(max + 1, zeros) - 1;
+            return (stops = [
+                ...stops
+            ]).sort(compare), stops;
+        }
+        function rangeToPattern(start, stop, options) {
+            if (start === stop) return {
+                pattern: start,
+                count: [],
+                digits: 0
+            };
+            let zipped = zip(start, stop), digits = zipped.length, pattern = '', count = 0;
+            for(let i = 0; i < digits; i++){
+                let [startDigit, stopDigit] = zipped[i];
+                startDigit === stopDigit ? pattern += startDigit : '0' !== startDigit || '9' !== stopDigit ? pattern += toCharacterClass(startDigit, stopDigit, options) : count++;
+            }
+            return count && (pattern += !0 === options.shorthand ? '\\d' : '[0-9]'), {
+                pattern,
+                count: [
+                    count
+                ],
+                digits
+            };
+        }
+        function splitToPatterns(min, max, tok, options) {
+            let prev, ranges = splitToRanges(min, max), tokens = [], start = min;
+            for(let i = 0; i < ranges.length; i++){
+                let max = ranges[i], obj = rangeToPattern(String(start), String(max), options), zeros = '';
+                if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+                    prev.count.length > 1 && prev.count.pop(), prev.count.push(obj.count[0]), prev.string = prev.pattern + toQuantifier(prev.count), start = max + 1;
+                    continue;
+                }
+                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;
+                intersection || contains(comparison, 'string', string) || result.push(prefix + string), 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;
+            return stop || start > 1 ? `{${start + (stop ? ',' + stop : '')}}` : '';
+        }
+        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), relax = !1 !== 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;
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/configuration.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.verifyConfig = verifyConfig;
+        let errors_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/errors.js");
+        function verifyConfig(options) {
+            if (!options.target && !options.router) throw Error(errors_1.ERRORS.ERR_CONFIG_FACTORY_TARGET_MISSING);
+        }
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/debug.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.Debug = void 0, exports.Debug = __webpack_require__("../../node_modules/.pnpm/debug@4.4.3_supports-color@10.2.2/node_modules/debug/src/index.js")('http-proxy-middleware');
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/errors.js" (__unused_rspack_module, exports) {
+        var ERRORS, ERRORS1;
+        exports.ERRORS = void 0, (ERRORS1 = ERRORS || (exports.ERRORS = ERRORS = {})).ERR_CONFIG_FACTORY_TARGET_MISSING = "[HPM] Missing \"target\" option. Example: {target: \"http://www.example.org\"}", ERRORS1.ERR_CONTEXT_MATCHER_GENERIC = "[HPM] Invalid pathFilter. Expecting something like: \"/api\" or [\"/api\", \"/ajax\"]", ERRORS1.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\"].", ERRORS1.ERR_PATH_REWRITER_CONFIG = "[HPM] Invalid pathRewrite config. Expecting object with pathRewrite config or a rewrite function";
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/factory.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.createProxyMiddleware = createProxyMiddleware;
+        let http_proxy_middleware_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/http-proxy-middleware.js");
+        function createProxyMiddleware(options) {
+            let { middleware } = new http_proxy_middleware_1.HttpProxyMiddleware(options);
+            return middleware;
+        }
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/get-plugins.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.getPlugins = getPlugins;
+        let default_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/plugins/default/index.js");
+        function getPlugins(options) {
+            let maybeErrorResponsePlugin = options.on?.error ? [] : [
+                default_1.errorResponsePlugin
+            ];
+            return [
+                ...options.ejectPlugins ? [] : [
+                    default_1.debugProxyErrorsPlugin,
+                    default_1.proxyEventsPlugin,
+                    default_1.loggerPlugin,
+                    ...maybeErrorResponsePlugin
+                ],
+                ...options.plugins ?? []
+            ];
+        }
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/handlers/fix-request-body.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.fixRequestBody = fixRequestBody;
+        let querystring = __webpack_require__("querystring");
+        function fixRequestBody(proxyReq, req) {
+            if (0 !== req.readableLength) return;
+            let requestBody = req.body;
+            if (!requestBody) return;
+            let contentType = proxyReq.getHeader('Content-Type');
+            if (!contentType) return;
+            let writeBody = (bodyData)=>{
+                proxyReq.setHeader('Content-Length', Buffer.byteLength(bodyData)), proxyReq.write(bodyData);
+            };
+            contentType.includes('application/json') || contentType.includes('+json') ? writeBody(JSON.stringify(requestBody)) : contentType.includes('application/x-www-form-urlencoded') ? writeBody(querystring.stringify(requestBody)) : contentType.includes('multipart/form-data') && writeBody(handlerFormDataBodyData(contentType, requestBody));
+        }
+        function handlerFormDataBodyData(contentType, data) {
+            let boundary = contentType.replace(/^.*boundary=(.*)$/, '$1'), str = '';
+            for (let [key, value] of Object.entries(data))str += `--${boundary}\r\nContent-Disposition: form-data; name="${key}"\r\n\r\n${value}\r\n`;
+            return str;
+        }
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/handlers/index.js" (__unused_rspack_module, exports, __webpack_require__) {
+        var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+            void 0 === k2 && (k2 = k);
+            var desc = Object.getOwnPropertyDescriptor(m, k);
+            (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) && (desc = {
+                enumerable: !0,
+                get: function() {
+                    return m[k];
+                }
+            }), Object.defineProperty(o, k2, desc);
+        } : function(o, m, k, k2) {
+            void 0 === k2 && (k2 = k), o[k2] = m[k];
+        }), __exportStar = this && this.__exportStar || function(m, exports) {
+            for(var p in m)"default" === p || Object.prototype.hasOwnProperty.call(exports, p) || __createBinding(exports, m, p);
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), __exportStar(__webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/handlers/public.js"), exports);
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/handlers/public.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.fixRequestBody = exports.responseInterceptor = void 0;
+        var response_interceptor_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/handlers/response-interceptor.js");
+        Object.defineProperty(exports, "responseInterceptor", {
+            enumerable: !0,
+            get: function() {
+                return response_interceptor_1.responseInterceptor;
+            }
+        });
+        var fix_request_body_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/handlers/fix-request-body.js");
+        Object.defineProperty(exports, "fixRequestBody", {
+            enumerable: !0,
+            get: function() {
+                return fix_request_body_1.fixRequestBody;
+            }
+        });
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/handlers/response-interceptor.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.responseInterceptor = responseInterceptor;
+        let zlib = __webpack_require__("zlib"), debug_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/debug.js"), function_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/utils/function.js"), debug = debug_1.Debug.extend('response-interceptor');
+        function responseInterceptor(interceptor) {
+            return async function proxyResResponseInterceptor(proxyRes, req, res) {
+                debug('intercept proxy response');
+                let buffer = Buffer.from('', 'utf8'), _proxyRes = decompress(proxyRes, proxyRes.headers['content-encoding']);
+                _proxyRes.on('data', (chunk)=>buffer = Buffer.concat([
+                        buffer,
+                        chunk
+                    ])), _proxyRes.on('end', async ()=>{
+                    copyHeaders(proxyRes, res), debug('call interceptor function: %s', (0, function_1.getFunctionName)(interceptor));
+                    let interceptedBuffer = Buffer.from(await interceptor(buffer, proxyRes, req, res));
+                    debug('set content-length: %s', Buffer.byteLength(interceptedBuffer, 'utf8')), res.setHeader('content-length', Buffer.byteLength(interceptedBuffer, 'utf8')), debug('write intercepted response'), res.write(interceptedBuffer), res.end();
+                }), _proxyRes.on('error', (error)=>{
+                    res.end(`Error fetching proxied request: ${error.message}`);
+                });
+            };
+        }
+        function decompress(proxyRes, contentEncoding) {
+            let decompress, _proxyRes = proxyRes;
+            switch(contentEncoding){
+                case 'gzip':
+                    decompress = zlib.createGunzip();
+                    break;
+                case 'br':
+                    decompress = zlib.createBrotliDecompress();
+                    break;
+                case 'deflate':
+                    decompress = zlib.createInflate();
+            }
+            return decompress && (debug("decompress proxy response with 'content-encoding': %s", contentEncoding), _proxyRes.pipe(decompress), _proxyRes = decompress), _proxyRes;
+        }
+        function copyHeaders(originalResponse, response) {
+            if (debug('copy original response headers'), response.statusCode = originalResponse.statusCode, response.statusMessage = originalResponse.statusMessage, response.setHeader) {
+                let keys = Object.keys(originalResponse.headers);
+                (keys = keys.filter((key)=>![
+                        'content-encoding',
+                        'transfer-encoding'
+                    ].includes(key))).forEach((key)=>{
+                    let value = originalResponse.headers[key];
+                    'set-cookie' === key && (value = (value = Array.isArray(value) ? value : [
+                        value
+                    ]).map((x)=>x.replace(/Domain=[^;]+?/i, ''))), response.setHeader(key, value);
+                });
+            } else response.headers = originalResponse.headers;
+        }
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/http-proxy-middleware.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.HttpProxyMiddleware = void 0;
+        let httpProxy = __webpack_require__("../../node_modules/.pnpm/http-proxy@1.18.1_patch_hash=424b689da454f1f336d635615733f30568882789c1173f861c30f95ba8_7c4b684cae90eb7d05b3dfae37f0ceb4/node_modules/http-proxy/index.js"), configuration_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/configuration.js"), get_plugins_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/get-plugins.js"), path_filter_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/path-filter.js"), PathRewriter = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/path-rewriter.js"), Router = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/router.js"), debug_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/debug.js"), function_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/utils/function.js"), logger_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/logger.js");
+        exports.HttpProxyMiddleware = class {
+            constructor(options){
+                this.wsInternalSubscribed = !1, this.serverOnCloseSubscribed = !1, this.middleware = async (req, res, next)=>{
+                    if (this.shouldProxy(this.proxyOptions.pathFilter, req)) try {
+                        let activeProxyOptions = await this.prepareProxyRequest(req);
+                        (0, debug_1.Debug)("proxy request to target: %O", activeProxyOptions.target), this.proxy.web(req, res, activeProxyOptions);
+                    } catch (err) {
+                        next?.(err);
+                    }
+                    else next?.();
+                    let server = (req.socket ?? req.connection)?.server;
+                    server && !this.serverOnCloseSubscribed && (server.on('close', ()=>{
+                        (0, debug_1.Debug)('server close signal received: closing proxy server'), this.proxy.close();
+                    }), this.serverOnCloseSubscribed = !0), !0 === this.proxyOptions.ws && this.catchUpgradeRequest(server);
+                }, this.catchUpgradeRequest = (server)=>{
+                    this.wsInternalSubscribed || ((0, debug_1.Debug)('subscribing to server upgrade event'), server.on('upgrade', this.handleUpgrade), this.wsInternalSubscribed = !0);
+                }, this.handleUpgrade = async (req, socket, head)=>{
+                    try {
+                        if (this.shouldProxy(this.proxyOptions.pathFilter, req)) {
+                            let activeProxyOptions = await this.prepareProxyRequest(req);
+                            this.proxy.ws(req, socket, head, activeProxyOptions), (0, debug_1.Debug)('server upgrade event received. Proxying WebSocket');
+                        }
+                    } catch (err) {
+                        this.proxy.emit('error', err, req, socket);
+                    }
+                }, this.shouldProxy = (pathFilter, req)=>{
+                    try {
+                        return (0, path_filter_1.matchPathFilter)(pathFilter, req.url, req);
+                    } catch (err) {
+                        return (0, debug_1.Debug)('Error: matchPathFilter() called with request url: ', `"${req.url}"`), this.logger.error(err), !1;
+                    }
+                }, this.prepareProxyRequest = async (req)=>{
+                    this.middleware.__LEGACY_HTTP_PROXY_MIDDLEWARE__ && (req.url = req.originalUrl || req.url);
+                    let newProxyOptions = Object.assign({}, this.proxyOptions);
+                    return await this.applyRouter(req, newProxyOptions), await this.applyPathRewrite(req, this.pathRewriter), newProxyOptions;
+                }, this.applyRouter = async (req, options)=>{
+                    let newTarget;
+                    options.router && (newTarget = await Router.getTarget(req, options)) && ((0, debug_1.Debug)('router new target: "%s"', newTarget), options.target = newTarget);
+                }, this.applyPathRewrite = async (req, pathRewriter)=>{
+                    if (pathRewriter) {
+                        let path = await pathRewriter(req.url, req);
+                        'string' == typeof path ? ((0, debug_1.Debug)('pathRewrite new path: %s', req.url), req.url = path) : (0, debug_1.Debug)('pathRewrite: no rewritten path found: %s', req.url);
+                    }
+                }, (0, configuration_1.verifyConfig)(options), this.proxyOptions = options, this.logger = (0, logger_1.getLogger)(options), (0, debug_1.Debug)("create proxy server"), this.proxy = httpProxy.createProxyServer({}), this.registerPlugins(this.proxy, this.proxyOptions), this.pathRewriter = PathRewriter.createPathRewriter(this.proxyOptions.pathRewrite), this.middleware.upgrade = (req, socket, head)=>{
+                    this.wsInternalSubscribed || this.handleUpgrade(req, socket, head);
+                };
+            }
+            registerPlugins(proxy, options) {
+                (0, get_plugins_1.getPlugins)(options).forEach((plugin)=>{
+                    (0, debug_1.Debug)(`register plugin: "${(0, function_1.getFunctionName)(plugin)}"`), plugin(proxy, options);
+                });
+            }
+        };
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/index.js" (__unused_rspack_module, exports, __webpack_require__) {
+        var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+            void 0 === k2 && (k2 = k);
+            var desc = Object.getOwnPropertyDescriptor(m, k);
+            (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) && (desc = {
+                enumerable: !0,
+                get: function() {
+                    return m[k];
+                }
+            }), Object.defineProperty(o, k2, desc);
+        } : function(o, m, k, k2) {
+            void 0 === k2 && (k2 = k), o[k2] = m[k];
+        }), __exportStar = this && this.__exportStar || function(m, exports) {
+            for(var p in m)"default" === p || Object.prototype.hasOwnProperty.call(exports, p) || __createBinding(exports, m, p);
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), __exportStar(__webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/factory.js"), exports), __exportStar(__webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/handlers/index.js"), exports), __exportStar(__webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/plugins/default/index.js"), exports), __exportStar(__webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/legacy/index.js"), exports);
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/legacy/create-proxy-middleware.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.legacyCreateProxyMiddleware = legacyCreateProxyMiddleware;
+        let factory_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/factory.js"), debug_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/debug.js"), options_adapter_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/legacy/options-adapter.js"), debug = debug_1.Debug.extend('legacy-create-proxy-middleware');
+        function legacyCreateProxyMiddleware(legacyContext, legacyOptions) {
+            debug('init');
+            let options = (0, options_adapter_1.legacyOptionsAdapter)(legacyContext, legacyOptions), proxyMiddleware = (0, factory_1.createProxyMiddleware)(options);
+            return debug('add marker for patching req.url (old behavior)'), proxyMiddleware.__LEGACY_HTTP_PROXY_MIDDLEWARE__ = !0, proxyMiddleware;
+        }
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/legacy/index.js" (__unused_rspack_module, exports, __webpack_require__) {
+        var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+            void 0 === k2 && (k2 = k);
+            var desc = Object.getOwnPropertyDescriptor(m, k);
+            (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) && (desc = {
+                enumerable: !0,
+                get: function() {
+                    return m[k];
+                }
+            }), Object.defineProperty(o, k2, desc);
+        } : function(o, m, k, k2) {
+            void 0 === k2 && (k2 = k), o[k2] = m[k];
+        }), __exportStar = this && this.__exportStar || function(m, exports) {
+            for(var p in m)"default" === p || Object.prototype.hasOwnProperty.call(exports, p) || __createBinding(exports, m, p);
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), __exportStar(__webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/legacy/public.js"), exports);
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/legacy/options-adapter.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.legacyOptionsAdapter = legacyOptionsAdapter;
+        let url = __webpack_require__("url?5f07"), debug_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/debug.js"), logger_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/logger.js"), debug = debug_1.Debug.extend('legacy-options-adapter'), proxyEventMap = {
+            onError: 'error',
+            onProxyReq: 'proxyReq',
+            onProxyRes: 'proxyRes',
+            onProxyReqWs: 'proxyReqWs',
+            onOpen: 'open',
+            onClose: 'close'
+        };
+        function legacyOptionsAdapter(legacyContext, legacyOptions) {
+            let logger, options = {};
+            if ('string' == typeof legacyContext && url.parse(legacyContext).host) throw Error(`Shorthand syntax is removed from legacyCreateProxyMiddleware().
+      Please use "legacyCreateProxyMiddleware({ target: 'http://www.example.org' })" instead.
+
+      More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md#removed-shorthand-usage
+      `);
+            legacyContext && legacyOptions ? (debug('map legacy context/filter to options.pathFilter'), (logger = getLegacyLogger(options = {
+                ...legacyOptions,
+                pathFilter: legacyContext
+            })).warn(`[http-proxy-middleware] Legacy "context" argument is deprecated. Migrate your "context" to "options.pathFilter":
+
+      const options = {
+        pathFilter: '${legacyContext}',
+      }
+
+      More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md#removed-context-argument
+      `)) : logger = legacyContext && !legacyOptions ? getLegacyLogger(options = {
+                ...legacyContext
+            }) : getLegacyLogger({}), Object.entries(proxyEventMap).forEach(([legacyEventName, proxyEventName])=>{
+                options[legacyEventName] && (options.on = {
+                    ...options.on
+                }, options.on[proxyEventName] = options[legacyEventName], debug('map legacy event "%s" to "on.%s"', legacyEventName, proxyEventName), logger.warn(`[http-proxy-middleware] Legacy "${legacyEventName}" is deprecated. Migrate to "options.on.${proxyEventName}":
+
+        const options = {
+          on: {
+            ${proxyEventName}: () => {},
+          },
+        }
+
+        More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md#refactored-proxy-events
+        `));
+            });
+            let logProvider = options.logProvider && options.logProvider(), logLevel = options.logLevel;
+            return debug('legacy logLevel', logLevel), debug('legacy logProvider: %O', logProvider), 'string' == typeof logLevel && 'silent' !== logLevel && (debug('map "logProvider" to "logger"'), logger.warn(`[http-proxy-middleware] Legacy "logLevel" and "logProvider" are deprecated. Migrate to "options.logger":
+
+      const options = {
+        logger: console,
+      }
+
+      More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md#removed-logprovider-and-loglevel-options
+      `)), options;
+        }
+        function getLegacyLogger(options) {
+            let legacyLogger = options.logProvider && options.logProvider();
+            return legacyLogger && (options.logger = legacyLogger), (0, logger_1.getLogger)(options);
+        }
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/legacy/public.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.legacyCreateProxyMiddleware = void 0;
+        var create_proxy_middleware_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/legacy/create-proxy-middleware.js");
+        Object.defineProperty(exports, "legacyCreateProxyMiddleware", {
+            enumerable: !0,
+            get: function() {
+                return create_proxy_middleware_1.legacyCreateProxyMiddleware;
+            }
+        });
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/logger.js" (__unused_rspack_module, exports) {
+        exports.getLogger = getLogger;
+        let noopLogger = {
+            info: ()=>{},
+            warn: ()=>{},
+            error: ()=>{}
+        };
+        function getLogger(options) {
+            return options.logger || noopLogger;
+        }
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/path-filter.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.matchPathFilter = matchPathFilter;
+        let isGlob = __webpack_require__("../../node_modules/.pnpm/is-glob@4.0.3/node_modules/is-glob/index.js"), micromatch = __webpack_require__("../../node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js"), url = __webpack_require__("url?5f07"), errors_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/errors.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 Error(errors_1.ERRORS.ERR_CONTEXT_MATCHER_INVALID_ARRAY);
+            }
+            if ('function' == typeof pathFilter) return pathFilter(getUrlPathName(uri), req);
+            throw Error(errors_1.ERRORS.ERR_CONTEXT_MATCHER_GENERIC);
+        }
+        function matchSingleStringPath(pathFilter, uri) {
+            let pathname = getUrlPathName(uri);
+            return pathname?.indexOf(pathFilter) === 0;
+        }
+        function matchSingleGlobPath(pattern, uri) {
+            let matches = micromatch([
+                getUrlPathName(uri)
+            ], pattern);
+            return matches && matches.length > 0;
+        }
+        function matchMultiGlobPath(patternList, uri) {
+            return matchSingleGlobPath(patternList, uri);
+        }
+        function matchMultiPath(pathFilterList, uri) {
+            let isMultiPath = !1;
+            for (let context of pathFilterList)if (matchSingleStringPath(context, uri)) {
+                isMultiPath = !0;
+                break;
+            }
+            return isMultiPath;
+        }
+        function getUrlPathName(uri) {
+            return uri && url.parse(uri).pathname;
+        }
+        function isStringPath(pathFilter) {
+            return 'string' == typeof pathFilter && !isGlob(pathFilter);
+        }
+        function isGlobPath(pathFilter) {
+            return isGlob(pathFilter);
+        }
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/path-rewriter.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.createPathRewriter = createPathRewriter;
+        let is_plain_object_1 = __webpack_require__("../../node_modules/.pnpm/is-plain-object@5.0.0/node_modules/is-plain-object/dist/is-plain-object.js"), errors_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/errors.js"), debug = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/debug.js").Debug.extend('path-rewriter');
+        function createPathRewriter(rewriteConfig) {
+            let rulesCache;
+            if (isValidRewriteConfig(rewriteConfig)) if ('function' == typeof rewriteConfig) return rewriteConfig;
+            else return rulesCache = parsePathRewriteRules(rewriteConfig), rewritePath;
+            function rewritePath(path) {
+                let result = path;
+                for (let rule of rulesCache)if (rule.regex.test(path)) {
+                    debug('rewriting path from "%s" to "%s"', path, result = result.replace(rule.regex, rule.value));
+                    break;
+                }
+                return result;
+            }
+        }
+        function isValidRewriteConfig(rewriteConfig) {
+            if ('function' == typeof rewriteConfig) return !0;
+            if ((0, is_plain_object_1.isPlainObject)(rewriteConfig)) return 0 !== Object.keys(rewriteConfig).length;
+            if (null == rewriteConfig) return !1;
+            throw Error(errors_1.ERRORS.ERR_PATH_REWRITER_CONFIG);
+        }
+        function parsePathRewriteRules(rewriteConfig) {
+            let rules = [];
+            if ((0, is_plain_object_1.isPlainObject)(rewriteConfig)) for (let [key, value] of Object.entries(rewriteConfig))rules.push({
+                regex: new RegExp(key),
+                value: value
+            }), debug('rewrite rule created: "%s" ~> "%s"', key, value);
+            return rules;
+        }
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/plugins/default/debug-proxy-errors-plugin.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.debugProxyErrorsPlugin = void 0;
+        let debug = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/debug.js").Debug.extend('debug-proxy-errors-plugin');
+        exports.debugProxyErrorsPlugin = (proxyServer)=>{
+            proxyServer.on('error', (error, req, res, target)=>{
+                debug(`http-proxy 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', ()=>{
+                    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(`http-proxy econnreset event: \n%O`, error);
+            });
+        };
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/plugins/default/error-response-plugin.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.errorResponsePlugin = void 0;
+        let status_code_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/status-code.js");
+        function isResponseLike(obj) {
+            return obj && 'function' == typeof obj.writeHead;
+        }
+        function isSocketLike(obj) {
+            return obj && 'function' == typeof obj.write && !('writeHead' in obj);
+        }
+        exports.errorResponsePlugin = (proxyServer, options)=>{
+            proxyServer.on('error', (err, req, res, target)=>{
+                if (!req && !res) throw err;
+                if (isResponseLike(res)) {
+                    if (!res.headersSent) {
+                        let statusCode = (0, status_code_1.getStatusCode)(err.code);
+                        res.writeHead(statusCode);
+                    }
+                    let host = req.headers && req.headers.host;
+                    res.end(`Error occurred while trying to proxy: ${host}${req.url}`);
+                } else isSocketLike(res) && res.destroy();
+            });
+        };
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/plugins/default/index.js" (__unused_rspack_module, exports, __webpack_require__) {
+        var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+            void 0 === k2 && (k2 = k);
+            var desc = Object.getOwnPropertyDescriptor(m, k);
+            (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) && (desc = {
+                enumerable: !0,
+                get: function() {
+                    return m[k];
+                }
+            }), Object.defineProperty(o, k2, desc);
+        } : function(o, m, k, k2) {
+            void 0 === k2 && (k2 = k), o[k2] = m[k];
+        }), __exportStar = this && this.__exportStar || function(m, exports) {
+            for(var p in m)"default" === p || Object.prototype.hasOwnProperty.call(exports, p) || __createBinding(exports, m, p);
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), __exportStar(__webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/plugins/default/debug-proxy-errors-plugin.js"), exports), __exportStar(__webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/plugins/default/error-response-plugin.js"), exports), __exportStar(__webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/plugins/default/logger-plugin.js"), exports), __exportStar(__webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/plugins/default/proxy-events.js"), exports);
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/plugins/default/logger-plugin.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.loggerPlugin = void 0;
+        let url_1 = __webpack_require__("url?5f07"), logger_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/logger.js"), logger_plugin_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/utils/logger-plugin.js");
+        exports.loggerPlugin = (proxyServer, options)=>{
+            let logger = (0, logger_1.getLogger)(options);
+            proxyServer.on('error', (err, req, res, target)=>{
+                let hostname = req?.headers?.host, requestHref = `${hostname}${req?.url}`, targetHref = `${target?.href}`;
+                logger.error('[HPM] Error occurred while proxying request %s to %s [%s] (%s)', requestHref, targetHref, err.code || err, 'https://nodejs.org/api/errors.html#errors_common_system_errors');
+            }), proxyServer.on('proxyRes', (proxyRes, req, res)=>{
+                let target, originalUrl = req.originalUrl ?? `${req.baseUrl || ''}${req.url}`;
+                try {
+                    let port = (0, logger_plugin_1.getPort)(proxyRes.req?.agent?.sockets), obj = {
+                        protocol: proxyRes.req.protocol,
+                        host: proxyRes.req.host,
+                        pathname: proxyRes.req.path
+                    };
+                    target = new url_1.URL(`${obj.protocol}//${obj.host}${obj.pathname}`), port && (target.port = port);
+                } catch (err) {
+                    (target = new url_1.URL(options.target)).pathname = proxyRes.req.path;
+                }
+                let targetUrl = target.toString(), 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());
+            });
+        };
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/plugins/default/proxy-events.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.proxyEventsPlugin = void 0;
+        let debug_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/debug.js"), function_1 = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/utils/function.js"), debug = debug_1.Debug.extend('proxy-events-plugin');
+        exports.proxyEventsPlugin = (proxyServer, options)=>{
+            Object.entries(options.on || {}).forEach(([eventName, handler])=>{
+                debug(`register event handler: "${eventName}" -> "${(0, function_1.getFunctionName)(handler)}"`), proxyServer.on(eventName, handler);
+            });
+        };
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/router.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.getTarget = getTarget;
+        let is_plain_object_1 = __webpack_require__("../../node_modules/.pnpm/is-plain-object@5.0.0/node_modules/is-plain-object/dist/is-plain-object.js"), debug = __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/debug.js").Debug.extend('router');
+        async function getTarget(req, config) {
+            let newTarget, router = config.router;
+            return (0, is_plain_object_1.isPlainObject)(router) ? newTarget = getTargetFromProxyTable(req, router) : 'function' == typeof router && (newTarget = await router(req)), newTarget;
+        }
+        function getTargetFromProxyTable(req, table) {
+            let result, host = req.headers.host, hostAndPath = host + req.url;
+            for (let [key, value] of Object.entries(table))if (containsPath(key)) {
+                if (hostAndPath.indexOf(key) > -1) {
+                    debug('match: "%s" -> "%s"', key, result = value);
+                    break;
+                }
+            } else if (key === host) {
+                debug('match: "%s" -> "%s"', host, result = value);
+                break;
+            }
+            return result;
+        }
+        function containsPath(v) {
+            return v.indexOf('/') > -1;
+        }
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/status-code.js" (__unused_rspack_module, exports) {
+        exports.getStatusCode = getStatusCode;
+        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;
+            }
+            return statusCode;
+        }
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/utils/function.js" (__unused_rspack_module, exports) {
+        exports.getFunctionName = getFunctionName;
+        function getFunctionName(fn) {
+            return fn.name || '[anonymous Function]';
+        }
+    },
+    "../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/utils/logger-plugin.js" (__unused_rspack_module, exports) {
+        exports.getPort = getPort;
+        function getPort(sockets) {
+            return Object.keys(sockets || {})?.[0]?.split(':')[1];
+        }
+    }
+}), __webpack_require__("../../node_modules/.pnpm/http-proxy-middleware@3.0.5_supports-color@10.2.2/node_modules/http-proxy-middleware/dist/index.js");
+var dist__esModule = !0;
+export { dist__esModule as __esModule };