@rspack/dev-server 2.0.0 → 2.0.2

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

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