heading-case 1.1.7 → 2.0.0

package/dist/index.js

@@ -1,2821 +1,49 @@
-import { execFileSync } from "node:child_process";
-import node_fs from "node:fs";
-import node_util from "node:util";
-import * as __rspack_external_fs from "fs";
-import { readdir, readdirSync, realpath, realpathSync, stat as external_fs_stat, statSync } from "fs";
-import { basename, dirname, isAbsolute, normalize, posix, relative as external_path_relative, resolve, sep } from "path";
-import { fileURLToPath } from "url";
-import { createRequire } from "module";
-var __webpack_modules__ = {};
-var __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
-}
-__webpack_require__.m = __webpack_modules__;
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.add = function(modules) {
-        Object.assign(__webpack_require__.m, modules);
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-__webpack_require__.add({
-    "./node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js" (module) {
-        let p = process || {}, argv = p.argv || [], env = p.env || {};
-        let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || "win32" === p.platform || (p.stdout || {}).isTTY && "dumb" !== env.TERM || !!env.CI);
-        let formatter = (open, close, replace = open)=>(input)=>{
-                let string = "" + input, index = string.indexOf(close, open.length);
-                return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
-            };
-        let replaceClose = (string, close, replace, index)=>{
-            let result = "", cursor = 0;
-            do {
-                result += string.substring(cursor, index) + replace;
-                cursor = index + close.length;
-                index = string.indexOf(close, cursor);
-            }while (~index);
-            return result + string.substring(cursor);
-        };
-        let createColors = (enabled = isColorSupported)=>{
-            let f = enabled ? formatter : ()=>String;
-            return {
-                isColorSupported: enabled,
-                reset: f("\x1b[0m", "\x1b[0m"),
-                bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
-                dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
-                italic: f("\x1b[3m", "\x1b[23m"),
-                underline: f("\x1b[4m", "\x1b[24m"),
-                inverse: f("\x1b[7m", "\x1b[27m"),
-                hidden: f("\x1b[8m", "\x1b[28m"),
-                strikethrough: f("\x1b[9m", "\x1b[29m"),
-                black: f("\x1b[30m", "\x1b[39m"),
-                red: f("\x1b[31m", "\x1b[39m"),
-                green: f("\x1b[32m", "\x1b[39m"),
-                yellow: f("\x1b[33m", "\x1b[39m"),
-                blue: f("\x1b[34m", "\x1b[39m"),
-                magenta: f("\x1b[35m", "\x1b[39m"),
-                cyan: f("\x1b[36m", "\x1b[39m"),
-                white: f("\x1b[37m", "\x1b[39m"),
-                gray: f("\x1b[90m", "\x1b[39m"),
-                bgBlack: f("\x1b[40m", "\x1b[49m"),
-                bgRed: f("\x1b[41m", "\x1b[49m"),
-                bgGreen: f("\x1b[42m", "\x1b[49m"),
-                bgYellow: f("\x1b[43m", "\x1b[49m"),
-                bgBlue: f("\x1b[44m", "\x1b[49m"),
-                bgMagenta: f("\x1b[45m", "\x1b[49m"),
-                bgCyan: f("\x1b[46m", "\x1b[49m"),
-                bgWhite: f("\x1b[47m", "\x1b[49m"),
-                blackBright: f("\x1b[90m", "\x1b[39m"),
-                redBright: f("\x1b[91m", "\x1b[39m"),
-                greenBright: f("\x1b[92m", "\x1b[39m"),
-                yellowBright: f("\x1b[93m", "\x1b[39m"),
-                blueBright: f("\x1b[94m", "\x1b[39m"),
-                magentaBright: f("\x1b[95m", "\x1b[39m"),
-                cyanBright: f("\x1b[96m", "\x1b[39m"),
-                whiteBright: f("\x1b[97m", "\x1b[39m"),
-                bgBlackBright: f("\x1b[100m", "\x1b[49m"),
-                bgRedBright: f("\x1b[101m", "\x1b[49m"),
-                bgGreenBright: f("\x1b[102m", "\x1b[49m"),
-                bgYellowBright: f("\x1b[103m", "\x1b[49m"),
-                bgBlueBright: f("\x1b[104m", "\x1b[49m"),
-                bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
-                bgCyanBright: f("\x1b[106m", "\x1b[49m"),
-                bgWhiteBright: f("\x1b[107m", "\x1b[49m")
-            };
-        };
-        module.exports = createColors();
-        module.exports.createColors = createColors;
-    },
-    "./node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/index.js" (module, __unused_rspack_exports, __webpack_require__) {
-        const pico = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/picomatch.js");
-        const utils = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/utils.js");
-        function picomatch(glob, options, returnState = false) {
-            if (options && (null === options.windows || void 0 === options.windows)) options = {
-                ...options,
-                windows: utils.isWindows()
-            };
-            return pico(glob, options, returnState);
-        }
-        Object.assign(picomatch, pico);
-        module.exports = picomatch;
-    },
-    "./node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/constants.js" (module) {
-        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 SEP = '/';
-        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,
-            SEP
-        };
-        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}]|$)`,
-            SEP: '\\'
-        };
-        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,
-            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@4.0.4/node_modules/picomatch/lib/parse.js" (module, __unused_rspack_exports, __webpack_require__) {
-        const constants = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/constants.js");
-        const utils = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.4/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 PLATFORM_CHARS = constants.globChars(opts.windows);
-            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.output = (prev.output || prev.value) + tok.value;
-                    prev.value += 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 ('(' === 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 { DOT_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants.globChars(opts.windows);
-            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@4.0.4/node_modules/picomatch/lib/picomatch.js" (module, __unused_rspack_exports, __webpack_require__) {
-        const scan = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/scan.js");
-        const parse = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/parse.js");
-        const utils = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/utils.js");
-        const constants = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.4/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 = opts.windows;
-            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)=>{
-            const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
-            return regex.test(utils.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@4.0.4/node_modules/picomatch/lib/scan.js" (module, __unused_rspack_exports, __webpack_require__) {
-        const utils = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.4/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@4.0.4/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@4.0.4/node_modules/picomatch/lib/utils.js" (__unused_rspack_module, exports, __webpack_require__) {
-        const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.4/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.isWindows = ()=>{
-            if ("u" > typeof navigator && navigator.platform) {
-                const platform = navigator.platform.toLowerCase();
-                return 'win32' === platform || 'windows' === platform;
-            }
-            if ("u" > typeof process && process.platform) return 'win32' === process.platform;
-            return false;
-        };
-        exports.removeBackslashes = (str)=>str.replace(REGEX_REMOVE_BACKSLASH, (match)=>'\\' === match ? '' : match);
-        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;
-        };
-        exports.basename = (path, { windows } = {})=>{
-            const segs = path.split(windows ? /[\\/]/ : '/');
-            const last = segs[segs.length - 1];
-            if ('' === last) return segs[segs.length - 2];
-            return last;
-        };
-    }
-});
-function checkNodeVersion() {
-    const { versions } = process;
-    if ("styleText" in node_util || !versions.node || versions.bun || versions.deno) return;
-    throw new Error(`Unsupported Node.js version: "${process.versions.node || 'unknown'}". Expected Node.js >= 20.`);
-}
-checkNodeVersion();
-const createStyler = (style)=>(text)=>node_util.styleText(style, String(text));
-const color = {
-    dim: createStyler('dim'),
-    red: createStyler('red'),
-    bold: createStyler('bold'),
-    blue: createStyler('blue'),
-    cyan: createStyler('cyan'),
-    gray: createStyler('gray'),
-    black: createStyler('black'),
-    green: createStyler('green'),
-    white: createStyler('white'),
-    reset: createStyler('reset'),
-    yellow: createStyler('yellow'),
-    magenta: createStyler('magenta'),
-    underline: createStyler('underline'),
-    strikethrough: createStyler('strikethrough')
-};
-const supportsTrueColor = true === process.stdout.isTTY && process.stdout.hasColors(2 ** 24, process.env);
-const boldMint = (text)=>supportsTrueColor ? `\x1b[1;38;2;132;225;199m${text}\x1b[39;22m` : color.bold(color.cyan(text));
-const LOG_LEVEL = {
-    silent: -1,
-    error: 0,
-    warn: 1,
-    info: 2,
-    log: 2,
-    verbose: 3
-};
-const createLogType = (label, level, style)=>{
-    let formattedLabel;
-    return {
-        get label () {
-            return formattedLabel ??= color.bold(style(label.padEnd(7)));
-        },
-        level
-    };
-};
-const LOG_TYPES = {
-    error: createLogType('error', 'error', color.red),
-    warn: createLogType('warn', 'warn', color.yellow),
-    info: createLogType('info', 'info', color.cyan),
-    start: createLogType('start', 'info', color.cyan),
-    ready: createLogType('ready', 'info', color.green),
-    success: createLogType('success', 'info', color.green),
-    log: {
-        level: 'info'
-    },
-    debug: createLogType('debug', 'verbose', color.magenta)
-};
-const ANSI_REGEXP = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, 'g');
-const stripAnsi = (text)=>text.replace(ANSI_REGEXP, '');
-const errorStackRegExp = /at [^\r\n]{0,200}(?::\d+:\d+[\s)]*|\(<anonymous>\)|\(index\s\d+\))$/;
-const isErrorStackMessage = (message)=>{
-    const stripped = stripAnsi(message);
-    return errorStackRegExp.test(stripped);
-};
-const normalizeErrorMessage = (err)=>{
-    if (err.stack) {
-        const [rawName, ...rest] = err.stack.split('\n');
-        const name = rawName.startsWith('Error: ') ? rawName.slice(7) : rawName;
-        return `${name}\n${color.gray(rest.join('\n'))}`;
-    }
-    return err.message;
-};
-const createLogger = (options = {})=>{
-    const { level = 'info', prefix, console: console1 = globalThis.console, alignMultiline } = options;
-    let maxLevel = level;
-    const log = (type, message, ...args)=>{
-        const logType = LOG_TYPES[type];
-        const { level } = logType;
-        if (LOG_LEVEL[level] > LOG_LEVEL[maxLevel]) return;
-        if (null == message) return console1.log();
-        const label = 'label' in logType ? logType.label : '';
-        const header = label ? prefix ? `${label} ${prefix}` : label : prefix;
-        let text = '';
-        const isErrorObject = message instanceof Error;
-        if (isErrorObject) {
-            text += normalizeErrorMessage(message);
-            const { cause } = message;
-            if (cause) {
-                text += color.yellow('\n  [cause]: ');
-                text += cause instanceof Error ? normalizeErrorMessage(cause) : String(cause);
-            }
-        } else if ('error' === level && 'string' == typeof message) {
-            const lines = message.split('\n');
-            text = lines.map((line)=>isErrorStackMessage(line) ? color.gray(line) : line).join('\n');
-        } else text = `${message}`;
-        if (alignMultiline && header && !isErrorObject && text.includes('\n')) {
-            const indent = ' '.repeat(stripAnsi(header).length + 1);
-            const skipStack = 'error' === level;
-            text = text.split('\n').map((line, i)=>0 === i || '' === line || skipStack && isErrorStackMessage(line) ? line : indent + line).join('\n');
-        }
-        const method = 'error' === level || 'warn' === level ? level : 'log';
-        console1[method](header ? `${header} ${text}` : text, ...args);
-    };
-    const logger = {
-        greet: (message)=>log('log', boldMint(message))
-    };
-    Object.keys(LOG_TYPES).forEach((key)=>{
-        logger[key] = (...args)=>log(key, ...args);
-    });
-    Object.defineProperty(logger, 'level', {
-        get: ()=>maxLevel,
-        set (val) {
-            maxLevel = val;
-        }
-    });
-    Object.defineProperty(logger, 'options', {
-        get: ()=>({
-                ...options
-            })
-    });
-    logger.override = (customLogger)=>{
-        Object.assign(logger, customLogger);
-    };
-    return logger;
-};
-const src_logger = createLogger();
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-function cleanPath(path) {
-    let normalized = normalize(path);
-    if (normalized.length > 1 && normalized[normalized.length - 1] === sep) normalized = normalized.substring(0, normalized.length - 1);
-    return normalized;
-}
-const SLASHES_REGEX = /[\\/]/g;
-function convertSlashes(path, separator) {
-    return path.replace(SLASHES_REGEX, separator);
-}
-const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
-function isRootDirectory(path) {
-    return "/" === path || WINDOWS_ROOT_DIR_REGEX.test(path);
-}
-function normalizePath(path, options) {
-    const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
-    const pathNeedsCleaning = "win32" === process.platform && path.includes("/") || path.startsWith(".");
-    if (resolvePaths) path = resolve(path);
-    if (normalizePath$1 || pathNeedsCleaning) path = cleanPath(path);
-    if ("." === path) return "";
-    const needsSeperator = path[path.length - 1] !== pathSeparator;
-    return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator);
-}
-function joinPathWithBasePath(filename, directoryPath) {
-    return directoryPath + filename;
-}
-function joinPathWithRelativePath(root, options) {
-    return function(filename, directoryPath) {
-        const sameRoot = directoryPath.startsWith(root);
-        if (sameRoot) return directoryPath.slice(root.length) + filename;
-        return convertSlashes(external_path_relative(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
-    };
-}
-function joinPath(filename) {
-    return filename;
-}
-function joinDirectoryPath(filename, directoryPath, separator) {
-    return directoryPath + filename + separator;
-}
-function build$7(root, options) {
-    const { relativePaths, includeBasePath } = options;
-    return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
-}
-function pushDirectoryWithRelativePath(root) {
-    return function(directoryPath, paths) {
-        paths.push(directoryPath.substring(root.length) || ".");
-    };
-}
-function pushDirectoryFilterWithRelativePath(root) {
-    return function(directoryPath, paths, filters) {
-        const relativePath = directoryPath.substring(root.length) || ".";
-        if (filters.every((filter)=>filter(relativePath, true))) paths.push(relativePath);
-    };
-}
-const pushDirectory = (directoryPath, paths)=>{
-    paths.push(directoryPath || ".");
-};
-const pushDirectoryFilter = (directoryPath, paths, filters)=>{
-    const path = directoryPath || ".";
-    if (filters.every((filter)=>filter(path, true))) paths.push(path);
-};
-const empty$2 = ()=>{};
-function build$6(root, options) {
-    const { includeDirs, filters, relativePaths } = options;
-    if (!includeDirs) return empty$2;
-    if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
-    return filters && filters.length ? pushDirectoryFilter : pushDirectory;
-}
-const pushFileFilterAndCount = (filename, _paths, counts, filters)=>{
-    if (filters.every((filter)=>filter(filename, false))) counts.files++;
-};
-const pushFileFilter = (filename, paths, _counts, filters)=>{
-    if (filters.every((filter)=>filter(filename, false))) paths.push(filename);
-};
-const pushFileCount = (_filename, _paths, counts, _filters)=>{
-    counts.files++;
-};
-const pushFile = (filename, paths)=>{
-    paths.push(filename);
-};
-const empty$1 = ()=>{};
-function build$5(options) {
-    const { excludeFiles, filters, onlyCounts } = options;
-    if (excludeFiles) return empty$1;
-    if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
-    if (onlyCounts) return pushFileCount;
-    return pushFile;
-}
-const getArray = (paths)=>paths;
-const getArrayGroup = ()=>[
-        ""
-    ].slice(0, 0);
-function build$4(options) {
-    return options.group ? getArrayGroup : getArray;
-}
-const groupFiles = (groups, directory, files)=>{
-    groups.push({
-        directory,
-        files,
-        dir: directory
-    });
-};
-const empty = ()=>{};
-function build$3(options) {
-    return options.group ? groupFiles : empty;
-}
-const resolveSymlinksAsync = function(path, state, callback$1) {
-    const { queue, fs, options: { suppressErrors } } = state;
-    queue.enqueue();
-    fs.realpath(path, (error, resolvedPath)=>{
-        if (error) return queue.dequeue(suppressErrors ? null : error, state);
-        fs.stat(resolvedPath, (error$1, stat)=>{
-            if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
-            if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return queue.dequeue(null, state);
-            callback$1(stat, resolvedPath);
-            queue.dequeue(null, state);
-        });
-    });
-};
-const resolveSymlinks = function(path, state, callback$1) {
-    const { queue, fs, options: { suppressErrors } } = state;
-    queue.enqueue();
-    try {
-        const resolvedPath = fs.realpathSync(path);
-        const stat = fs.statSync(resolvedPath);
-        if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return;
-        callback$1(stat, resolvedPath);
-    } catch (e) {
-        if (!suppressErrors) throw e;
-    }
-};
-function build$2(options, isSynchronous) {
-    if (!options.resolveSymlinks || options.excludeSymlinks) return null;
-    return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
-}
-function isRecursive(path, resolved, state) {
-    if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
-    let parent = dirname(path);
-    let depth = 1;
-    while(parent !== state.root && depth < 2){
-        const resolvedPath = state.symlinks.get(parent);
-        const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
-        if (isSameRoot) depth++;
-        else parent = dirname(parent);
-    }
-    state.symlinks.set(path, resolved);
-    return depth > 1;
-}
-function isRecursiveUsingRealPaths(resolved, state) {
-    return state.visited.includes(resolved + state.options.pathSeparator);
-}
-const onlyCountsSync = (state)=>state.counts;
-const groupsSync = (state)=>state.groups;
-const defaultSync = (state)=>state.paths;
-const limitFilesSync = (state)=>state.paths.slice(0, state.options.maxFiles);
-const onlyCountsAsync = (state, error, callback$1)=>{
-    report(error, callback$1, state.counts, state.options.suppressErrors);
-    return null;
-};
-const defaultAsync = (state, error, callback$1)=>{
-    report(error, callback$1, state.paths, state.options.suppressErrors);
-    return null;
-};
-const limitFilesAsync = (state, error, callback$1)=>{
-    report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
-    return null;
-};
-const groupsAsync = (state, error, callback$1)=>{
-    report(error, callback$1, state.groups, state.options.suppressErrors);
-    return null;
-};
-function report(error, callback$1, output, suppressErrors) {
-    callback$1(error && !suppressErrors ? error : null, output);
-}
-function build$1(options, isSynchronous) {
-    const { onlyCounts, group, maxFiles } = options;
-    if (onlyCounts) return isSynchronous ? onlyCountsSync : onlyCountsAsync;
-    if (group) return isSynchronous ? groupsSync : groupsAsync;
-    if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync;
-    return isSynchronous ? defaultSync : defaultAsync;
-}
-const readdirOpts = {
-    withFileTypes: true
-};
-const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1)=>{
-    state.queue.enqueue();
-    if (currentDepth < 0) return state.queue.dequeue(null, state);
-    const { fs } = state;
-    state.visited.push(crawlPath);
-    state.counts.directories++;
-    fs.readdir(crawlPath || ".", readdirOpts, (error, entries = [])=>{
-        callback$1(entries, directoryPath, currentDepth);
-        state.queue.dequeue(state.options.suppressErrors ? null : error, state);
-    });
-};
-const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1)=>{
-    const { fs } = state;
-    if (currentDepth < 0) return;
-    state.visited.push(crawlPath);
-    state.counts.directories++;
-    let entries = [];
-    try {
-        entries = fs.readdirSync(crawlPath || ".", readdirOpts);
-    } catch (e) {
-        if (!state.options.suppressErrors) throw e;
-    }
-    callback$1(entries, directoryPath, currentDepth);
-};
-function build(isSynchronous) {
-    return isSynchronous ? walkSync : walkAsync;
-}
-var Queue = class {
-    count = 0;
-    constructor(onQueueEmpty){
-        this.onQueueEmpty = onQueueEmpty;
-    }
-    enqueue() {
-        this.count++;
-        return this.count;
-    }
-    dequeue(error, output) {
-        if (this.onQueueEmpty && (--this.count <= 0 || error)) {
-            this.onQueueEmpty(error, output);
-            if (error) {
-                output.controller.abort();
-                this.onQueueEmpty = void 0;
-            }
-        }
-    }
-};
-var Counter = class {
-    _files = 0;
-    _directories = 0;
-    set files(num) {
-        this._files = num;
-    }
-    get files() {
-        return this._files;
-    }
-    set directories(num) {
-        this._directories = num;
-    }
-    get directories() {
-        return this._directories;
-    }
-    get dirs() {
-        return this._directories;
-    }
-};
-var Aborter = class {
-    aborted = false;
-    abort() {
-        this.aborted = true;
-    }
-};
-var Walker = class {
-    root;
-    isSynchronous;
-    state;
-    joinPath;
-    pushDirectory;
-    pushFile;
-    getArray;
-    groupFiles;
-    resolveSymlink;
-    walkDirectory;
-    callbackInvoker;
-    constructor(root, options, callback$1){
-        this.isSynchronous = !callback$1;
-        this.callbackInvoker = build$1(options, this.isSynchronous);
-        this.root = normalizePath(root, options);
-        this.state = {
-            root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1),
-            paths: [
-                ""
-            ].slice(0, 0),
-            groups: [],
-            counts: new Counter(),
-            options,
-            queue: new Queue((error, state)=>this.callbackInvoker(state, error, callback$1)),
-            symlinks: /* @__PURE__ */ new Map(),
-            visited: [
-                ""
-            ].slice(0, 0),
-            controller: new Aborter(),
-            fs: options.fs || __rspack_external_fs
-        };
-        this.joinPath = build$7(this.root, options);
-        this.pushDirectory = build$6(this.root, options);
-        this.pushFile = build$5(options);
-        this.getArray = build$4(options);
-        this.groupFiles = build$3(options);
-        this.resolveSymlink = build$2(options, this.isSynchronous);
-        this.walkDirectory = build(this.isSynchronous);
-    }
-    start() {
-        this.pushDirectory(this.root, this.state.paths, this.state.options.filters);
-        this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
-        return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
-    }
-    walk = (entries, directoryPath, depth)=>{
-        const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;
-        if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return;
-        const files = this.getArray(this.state.paths);
-        for(let i = 0; i < entries.length; ++i){
-            const entry = entries[i];
-            if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {
-                const filename = this.joinPath(entry.name, directoryPath);
-                this.pushFile(filename, files, this.state.counts, filters);
-            } else if (entry.isDirectory()) {
-                let path = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-                if (exclude && exclude(entry.name, path)) continue;
-                this.pushDirectory(path, paths, filters);
-                this.walkDirectory(this.state, path, path, depth - 1, this.walk);
-            } else if (this.resolveSymlink && entry.isSymbolicLink()) {
-                let path = joinPathWithBasePath(entry.name, directoryPath);
-                this.resolveSymlink(path, this.state, (stat, resolvedPath)=>{
-                    if (stat.isDirectory()) {
-                        resolvedPath = normalizePath(resolvedPath, this.state.options);
-                        if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator)) return;
-                        this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
-                    } else {
-                        resolvedPath = useRealPaths ? resolvedPath : path;
-                        const filename = basename(resolvedPath);
-                        const directoryPath$1 = normalizePath(dirname(resolvedPath), this.state.options);
-                        resolvedPath = this.joinPath(filename, directoryPath$1);
-                        this.pushFile(resolvedPath, files, this.state.counts, filters);
-                    }
-                });
-            }
-        }
-        this.groupFiles(this.state.groups, directoryPath, files);
-    };
-};
-function promise(root, options) {
-    return new Promise((resolve$1, reject)=>{
-        callback(root, options, (err, output)=>{
-            if (err) return reject(err);
-            resolve$1(output);
-        });
-    });
-}
-function callback(root, options, callback$1) {
-    let walker = new Walker(root, options, callback$1);
-    walker.start();
-}
-function sync(root, options) {
-    const walker = new Walker(root, options);
-    return walker.start();
-}
-var APIBuilder = class {
-    constructor(root, options){
-        this.root = root;
-        this.options = options;
-    }
-    withPromise() {
-        return promise(this.root, this.options);
-    }
-    withCallback(cb) {
-        callback(this.root, this.options, cb);
-    }
-    sync() {
-        return sync(this.root, this.options);
-    }
-};
-let pm = null;
-try {
-    __require.resolve("picomatch");
-    pm = __require("picomatch");
-} catch  {}
-var Builder = class {
-    globCache = {};
-    options = {
-        maxDepth: 1 / 0,
-        suppressErrors: true,
-        pathSeparator: sep,
-        filters: []
-    };
-    globFunction;
-    constructor(options){
-        this.options = {
-            ...this.options,
-            ...options
-        };
-        this.globFunction = this.options.globFunction;
-    }
-    group() {
-        this.options.group = true;
-        return this;
-    }
-    withPathSeparator(separator) {
-        this.options.pathSeparator = separator;
-        return this;
-    }
-    withBasePath() {
-        this.options.includeBasePath = true;
-        return this;
-    }
-    withRelativePaths() {
-        this.options.relativePaths = true;
-        return this;
-    }
-    withDirs() {
-        this.options.includeDirs = true;
-        return this;
-    }
-    withMaxDepth(depth) {
-        this.options.maxDepth = depth;
-        return this;
-    }
-    withMaxFiles(limit) {
-        this.options.maxFiles = limit;
-        return this;
-    }
-    withFullPaths() {
-        this.options.resolvePaths = true;
-        this.options.includeBasePath = true;
-        return this;
-    }
-    withErrors() {
-        this.options.suppressErrors = false;
-        return this;
-    }
-    withSymlinks({ resolvePaths = true } = {}) {
-        this.options.resolveSymlinks = true;
-        this.options.useRealPaths = resolvePaths;
-        return this.withFullPaths();
-    }
-    withAbortSignal(signal) {
-        this.options.signal = signal;
-        return this;
-    }
-    normalize() {
-        this.options.normalizePath = true;
-        return this;
-    }
-    filter(predicate) {
-        this.options.filters.push(predicate);
-        return this;
-    }
-    onlyDirs() {
-        this.options.excludeFiles = true;
-        this.options.includeDirs = true;
-        return this;
-    }
-    exclude(predicate) {
-        this.options.exclude = predicate;
-        return this;
-    }
-    onlyCounts() {
-        this.options.onlyCounts = true;
-        return this;
-    }
-    crawl(root) {
-        return new APIBuilder(root || ".", this.options);
-    }
-    withGlobFunction(fn) {
-        this.globFunction = fn;
-        return this;
-    }
-    crawlWithOptions(root, options) {
-        this.options = {
-            ...this.options,
-            ...options
-        };
-        return new APIBuilder(root || ".", this.options);
-    }
-    glob(...patterns) {
-        if (this.globFunction) return this.globWithOptions(patterns);
-        return this.globWithOptions(patterns, {
-            dot: true
-        });
-    }
-    globWithOptions(patterns, ...options) {
-        const globFn = this.globFunction || pm;
-        if (!globFn) throw new Error("Please specify a glob function to use glob matching.");
-        var isMatch = this.globCache[patterns.join("\0")];
-        if (!isMatch) {
-            isMatch = globFn(patterns, ...options);
-            this.globCache[patterns.join("\0")] = isMatch;
-        }
-        this.options.filters.push((path)=>isMatch(path));
-        return this;
-    }
-};
-const picomatch = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/index.js");
-const isReadonlyArray = Array.isArray;
-const BACKSLASHES = /\\/g;
-const DRIVE_RELATIVE_PATH = /^[A-Za-z]:$/;
-const isWin = "win32" === process.platform;
-const ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
-function getPartialMatcher(patterns, options = {}) {
-    const patternsCount = patterns.length;
-    const patternsParts = Array(patternsCount);
-    const matchers = Array(patternsCount);
-    let i, j;
-    for(i = 0; i < patternsCount; i++){
-        const parts = splitPattern(patterns[i]);
-        patternsParts[i] = parts;
-        const partsCount = parts.length;
-        const partMatchers = Array(partsCount);
-        for(j = 0; j < partsCount; j++)partMatchers[j] = picomatch(parts[j], options);
-        matchers[i] = partMatchers;
-    }
-    return (input)=>{
-        const inputParts = input.split("/");
-        if (".." === inputParts[0] && ONLY_PARENT_DIRECTORIES.test(input)) return true;
-        for(i = 0; i < patternsCount; i++){
-            const patternParts = patternsParts[i];
-            const matcher = matchers[i];
-            const inputPatternCount = inputParts.length;
-            const minParts = Math.min(inputPatternCount, patternParts.length);
-            j = 0;
-            while(j < minParts){
-                const part = patternParts[j];
-                if (part.includes("/")) return true;
-                if (!matcher[j](inputParts[j])) break;
-                if (!options.noglobstar && "**" === part) return true;
-                j++;
-            }
-            if (j === inputPatternCount) return true;
-        }
-        return false;
-    };
-}
-const WIN32_ROOT_DIR = /^[A-Z]:\/$/i;
-const isRoot = isWin ? (p)=>WIN32_ROOT_DIR.test(p) : (p)=>"/" === p;
-function buildFormat(cwd, root, absolute) {
-    if (cwd === root || root.startsWith(`${cwd}/`)) {
-        if (absolute) {
-            const start = cwd.length + +!isRoot(cwd);
-            return (p, isDir)=>p.slice(start, isDir ? -1 : void 0) || ".";
-        }
-        const prefix = root.slice(cwd.length + 1);
-        if (prefix) return (p, isDir)=>{
-            if ("." === p) return prefix;
-            const result = `${prefix}/${p}`;
-            return isDir ? result.slice(0, -1) : result;
-        };
-        return (p, isDir)=>isDir && "." !== p ? p.slice(0, -1) : p;
-    }
-    if (absolute) return (p)=>posix.relative(cwd, p) || ".";
-    return (p)=>posix.relative(cwd, `${root}/${p}`) || ".";
-}
-function buildRelative(cwd, root) {
-    if (root.startsWith(`${cwd}/`)) {
-        const prefix = root.slice(cwd.length + 1);
-        return (p)=>`${prefix}/${p}`;
-    }
-    return (p)=>{
-        const result = posix.relative(cwd, `${root}/${p}`);
-        return "/" === p[p.length - 1] && "" !== result ? `${result}/` : result || ".";
-    };
-}
-function ensureNonDriveRelativePath(path) {
-    return path.replace(DRIVE_RELATIVE_PATH, (match)=>`${match}/`);
-}
-const splitPatternOptions = {
-    parts: true
-};
-function splitPattern(path) {
-    var _result$parts;
-    const result = picomatch.scan(path, splitPatternOptions);
-    return (null == (_result$parts = result.parts) ? void 0 : _result$parts.length) ? result.parts : [
-        path
-    ];
-}
-const POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
-const WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
-const escapePosixPath = (path)=>path.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
-const escapeWin32Path = (path)=>path.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
-const escapePath = isWin ? escapeWin32Path : escapePosixPath;
-function isDynamicPattern(pattern, options) {
-    if ((null == options ? void 0 : options.caseSensitiveMatch) === false) return true;
-    const scan = picomatch.scan(pattern);
-    return scan.isGlob || scan.negated;
-}
-function dist_log(...tasks) {
-    console.log(`[tinyglobby ${/* @__PURE__ */ new Date().toLocaleTimeString("es")}]`, ...tasks);
-}
-function ensureStringArray(value) {
-    return "string" == typeof value ? [
-        value
-    ] : null != value ? value : [];
-}
-const PARENT_DIRECTORY = /^(\/?\.\.)+/;
-const ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
-function normalizePattern(pattern, opts, props, isIgnore) {
-    var _PARENT_DIRECTORY$exe;
-    const cwd = opts.cwd;
-    let result = pattern;
-    if ("/" === pattern[pattern.length - 1]) result = pattern.slice(0, -1);
-    if ("*" !== result[result.length - 1] && opts.expandDirectories) result += "/**";
-    const escapedCwd = escapePath(cwd);
-    result = isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")) ? posix.relative(escapedCwd, result) : posix.normalize(result);
-    const parentDir = null == (_PARENT_DIRECTORY$exe = PARENT_DIRECTORY.exec(result)) ? void 0 : _PARENT_DIRECTORY$exe[0];
-    const parts = splitPattern(result);
-    if (parentDir) {
-        const n = (parentDir.length + 1) / 3;
-        let i = 0;
-        const cwdParts = escapedCwd.split("/");
-        while(i < n && parts[i + n] === cwdParts[cwdParts.length + i - n]){
-            result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".";
-            i++;
-        }
-        const potentialRoot = posix.join(cwd, parentDir.slice(3 * i));
-        if ("." !== potentialRoot[0] && props.root.length > potentialRoot.length) {
-            props.root = ensureNonDriveRelativePath(potentialRoot);
-            props.depthOffset = -n + i;
-        }
-    }
-    if (!isIgnore && props.depthOffset >= 0) {
-        null != props.commonPath || (props.commonPath = parts);
-        const newCommonPath = [];
-        const length = Math.min(props.commonPath.length, parts.length);
-        for(let i = 0; i < length; i++){
-            const part = parts[i];
-            if ("**" === part && !parts[i + 1]) {
-                newCommonPath.pop();
-                break;
-            }
-            if (i === parts.length - 1 || part !== props.commonPath[i] || isDynamicPattern(part)) break;
-            newCommonPath.push(part);
-        }
-        props.depthOffset = newCommonPath.length;
-        props.commonPath = newCommonPath;
-        props.root = ensureNonDriveRelativePath(newCommonPath.length > 0 ? posix.join(cwd, ...newCommonPath) : cwd);
-    }
-    return result;
-}
-function processPatterns(options, patterns, props) {
-    const matchPatterns = [];
-    const ignorePatterns = [];
-    for (const pattern of options.ignore)if (pattern) {
-        if ("!" !== pattern[0] || "(" === pattern[1]) ignorePatterns.push(normalizePattern(pattern, options, props, true));
-    }
-    for (const pattern of patterns)if (pattern) {
-        if ("!" !== pattern[0] || "(" === pattern[1]) matchPatterns.push(normalizePattern(pattern, options, props, false));
-        else if ("!" !== pattern[1] || "(" === pattern[2]) ignorePatterns.push(normalizePattern(pattern.slice(1), options, props, true));
-    }
-    return {
-        match: matchPatterns,
-        ignore: ignorePatterns
-    };
-}
-function buildCrawler(options, patterns) {
-    const cwd = options.cwd;
-    const props = {
-        root: cwd,
-        depthOffset: 0
-    };
-    const processed = processPatterns(options, patterns, props);
-    if (options.debug) dist_log("internal processing patterns:", processed);
-    const { absolute, caseSensitiveMatch, debug, dot, followSymbolicLinks, onlyDirectories } = options;
-    const root = props.root.replace(BACKSLASHES, "");
-    const matchOptions = {
-        dot,
-        nobrace: false === options.braceExpansion,
-        nocase: !caseSensitiveMatch,
-        noextglob: false === options.extglob,
-        noglobstar: false === options.globstar,
-        posix: true
-    };
-    const matcher = picomatch(processed.match, matchOptions);
-    const ignore = picomatch(processed.ignore, matchOptions);
-    const partialMatcher = getPartialMatcher(processed.match, matchOptions);
-    const format = buildFormat(cwd, root, absolute);
-    const excludeFormatter = absolute ? format : buildFormat(cwd, root, true);
-    const excludePredicate = (_, p)=>{
-        const relativePath = excludeFormatter(p, true);
-        return "." !== relativePath && !partialMatcher(relativePath) || ignore(relativePath);
-    };
-    let maxDepth;
-    if (void 0 !== options.deep) maxDepth = Math.round(options.deep - props.depthOffset);
-    const crawler = new Builder({
-        filters: [
-            debug ? (p, isDirectory)=>{
-                const path = format(p, isDirectory);
-                const matches = matcher(path) && !ignore(path);
-                if (matches) dist_log(`matched ${path}`);
-                return matches;
-            } : (p, isDirectory)=>{
-                const path = format(p, isDirectory);
-                return matcher(path) && !ignore(path);
-            }
-        ],
-        exclude: debug ? (_, p)=>{
-            const skipped = excludePredicate(_, p);
-            dist_log(`${skipped ? "skipped" : "crawling"} ${p}`);
-            return skipped;
-        } : excludePredicate,
-        fs: options.fs,
-        pathSeparator: "/",
-        relativePaths: !absolute,
-        resolvePaths: absolute,
-        includeBasePath: absolute,
-        resolveSymlinks: followSymbolicLinks,
-        excludeSymlinks: !followSymbolicLinks,
-        excludeFiles: onlyDirectories,
-        includeDirs: onlyDirectories || !options.onlyFiles,
-        maxDepth,
-        signal: options.signal
-    }).crawl(root);
-    if (options.debug) dist_log("internal properties:", {
-        ...props,
-        root
-    });
-    return [
-        crawler,
-        cwd !== root && !absolute && buildRelative(cwd, root)
-    ];
-}
-function formatPaths(paths, mapper) {
-    if (mapper) for(let i = paths.length - 1; i >= 0; i--)paths[i] = mapper(paths[i]);
-    return paths;
-}
-const defaultOptions = {
-    caseSensitiveMatch: true,
-    debug: !!process.env.TINYGLOBBY_DEBUG,
-    expandDirectories: true,
-    followSymbolicLinks: true,
-    onlyFiles: true
-};
-function getOptions(options) {
-    const opts = Object.assign({}, options);
-    for(const key in defaultOptions)if (void 0 === opts[key]) Object.assign(opts, {
-        [key]: defaultOptions[key]
-    });
-    opts.cwd = (opts.cwd instanceof URL ? fileURLToPath(opts.cwd) : resolve(opts.cwd || process.cwd())).replace(BACKSLASHES, "/");
-    opts.ignore = ensureStringArray(opts.ignore);
-    opts.fs && (opts.fs = {
-        readdir: opts.fs.readdir || readdir,
-        readdirSync: opts.fs.readdirSync || readdirSync,
-        realpath: opts.fs.realpath || realpath,
-        realpathSync: opts.fs.realpathSync || realpathSync,
-        stat: opts.fs.stat || external_fs_stat,
-        statSync: opts.fs.statSync || statSync
-    });
-    if (opts.debug) dist_log("globbing with options:", opts);
-    return opts;
-}
-function getCrawler(globInput, inputOptions = {}) {
-    var _ref;
-    if (globInput && (null == inputOptions ? void 0 : inputOptions.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
-    const isModern = isReadonlyArray(globInput) || "string" == typeof globInput;
-    const patterns = ensureStringArray(null != (_ref = isModern ? globInput : globInput.patterns) ? _ref : "**/*");
-    const options = getOptions(isModern ? inputOptions : globInput);
-    return patterns.length > 0 ? buildCrawler(options, patterns) : [];
-}
-async function glob(globInput, options) {
-    const [crawler, relative] = getCrawler(globInput, options);
-    return crawler ? formatPaths(await crawler.withPromise(), relative) : [];
-}
-var abbreviates_namespaceObject = /*#__PURE__*/ JSON.parse('{"abi":"ABI","amd":"AMD","api":"API","ast":"AST","bom":"BOM","bsd":"BSD","cdn":"CDN","cjs":"CJS","cli":"CLI","cncf":"CNCF","cors":"CORS","cpu":"CPU","crud":"CRUD","csrf":"CSRF","css":"CSS","csv":"CSV","db2":"DB2","dns":"DNS","dom":"DOM","dos":"DOS","es6":"ES6","esm":"ESM","fbi":"FBI","ftp":"FTP","ftps":"FTPS","gcc":"GCC","gcp":"GCP","glsl":"GLSL","gorm":"GORM","gpl":"GPL","gps":"GPS","gpu":"GPU","gre":"GRE","gui":"GUI","hdmi":"HDMI","hmr":"HMR","html":"HTML","http":"HTTP","https":"HTTPS","iife":"IIFE","iot":"IoT","ipc":"IPC","ipfs":"IPFS","ipmi":"IPMI","jdbc":"JDBC","jdk":"JDK","jit":"JIT","jpeg":"JPEG","jpg":"JPG","jre":"JRE","jsf":"JSF","json":"JSON","jsonp":"JSONP","jsp":"JSP","jwt":"JWT","kcp":"KCP","kde":"KDE","kpi":"KPI","lfu":"LFU","llvm":"LLVM","lru":"LRU","lts":"LTS","mdn":"MDN","mdx":"MDX","mvc":"MVC","mvp":"MVP","mvvm":"MVVM","nft":"NFT","odbc":"ODBC","ont":"ONT","orm":"ORM","oss":"OSS","pdf":"PDF","pdo":"PDO","posix":"POSIX","pwa":"PWA","qemu":"QEMU","qgis":"QGIS","quic":"QUIC","rfc":"RFC","rom":"ROM","rpc":"RPC","rss":"RSS","rss3":"RSS3","sdk":"SDK","seo":"SEO","sip":"SIP","smtp":"SMTP","sql":"SQL","sre":"SRE","ssg":"SSG","ssh":"SSH","sso":"SSO","ssr":"SSR","stp":"STP","svg":"SVG","svn":"SVN","tcp":"TCP","tls":"TLS","toml":"TOML","tsc":"TSC","udp":"UDP","umd":"UMD","uri":"URI","url":"URL","usb":"USB","vlan":"VLAN","vnc":"VNC","vpn":"VPN","vps":"VPS","wgsl":"WGSL","wlan":"WLAN","wsa":"WSA","wsl":"WSL","xhtml":"XHTML","xml":"XML","xss":"XSS","yaml":"YAML"}');
-var brands_namespaceObject = /*#__PURE__*/ JSON.parse('{"airbnb":"Airbnb","alphago":"AlphaGo","bitbucket":"Bitbucket","bytedance":"ByteDance","circleci":"CircleCI","cloudflare":"Cloudflare","freecodecamp":"freeCodeCamp","gitea":"Gitea","gitee":"Gitee","github":"GitHub","gitlab":"GitLab","gitops":"GitOps","gitpod":"Gitpod","hp":"HP","ibm":"IBM","jsdelivr":"jsDelivr","kfc":"KFC","leetcode":"LeetCode","linkedin":"LinkedIn","mcdonald":"McDonald","nvidia":"NVIDIA","pagerduty":"PagerDuty","producthunt":"Product Hunt","stackblitz":"StackBlitz","stackit":"STACKIT","stackoverflow":"Stack Overflow","unjs":"UnJS","v2ex":"V2EX","vuefes":"Vue Fes","youtube":"YouTube"}');
-var general_namespaceObject = /*#__PURE__*/ JSON.parse('{"aiaas":"AIaaS","baas":"BaaS","caas":"CaaS","daas":"DaaS","ddos":"DDoS","devops":"DevOps","devtools":"DevTools","esim":"eSIM","faas":"FaaS","iac":"IaC","iaas":"IaaS","ioc":"IoC","ipsec":"IPsec","mpaas":"mPaaS","paas":"PaaS","saas":"SaaS","wifi":"Wi-Fi","xaas":"XaaS"}');
-var products_namespaceObject = /*#__PURE__*/ JSON.parse('{"airdrop":"AirDrop","airpods":"AirPods","airtag":"AirTag","homekit":"HomeKit","homepod":"HomePod","imac":"iMac","ipad":"iPad","iphone":"iPhone","ipod":"iPod","macbook":"MacBook","macbook air":"MacBook Air","macbook pro":"MacBook Pro","yubikey":"YubiKey"}');
-var softwares_namespaceObject = /*#__PURE__*/ JSON.parse('{"1password":"1Password","3dtiles":"3DTiles","actionscript":"ActionScript","adblock":"AdBlock","ajax":"AJAX","alipay":"Alipay","amap":"AMap","angularjs":"AngularJS","ant design":"Ant Design","ant design vue":"Ant Design Vue","antd":"AntD","antdesign":"AntDesign","antdesignvue":"AntDesignVue","antv":"AntV","apifox":"Apifox","app store":"App Store","apple pay":"Apple Pay","applescript":"AppleScript","appletalk":"AppleTalk","arangodb":"ArangoDB","arcgis":"ArcGIS","arcmap":"ArcMap","arcobjects":"ArcObjects","beego":"Beego","bittorrent":"BitTorrent","bluesky":"Bluesky","busybox":"BusyBox","centos":"CentOS","cesiumjs":"CesiumJS","chatgpt":"ChatGPT","citygml":"CityGML","cityjson":"CityJSON","ckeditor":"CKEditor","clashx":"ClashX","clickhouse":"ClickHouse","cloudfront":"CloudFront","cmake":"CMake","cockroachdb":"CockroachDB","cocoapods":"CocoaPods","codepen":"CodePen","codesandbox":"CodeSandbox","coffeescript":"CoffeeScript","commonjs":"CommonJS","composition api":"Composition API","compositionapi":"CompositionAPI","coredns":"CoreDNS","css modules":"CSS Modules","dapr":"Dapr","datadog":"Datadog","datagrip":"DataGrip","dbase":"dBase","definitelytyped":"DefinitelyTyped","denodeploy":"DenoDeploy","digital ocean":"DigitalOcean","digitalocean":"DigitalOcean","dingtalk":"DingTalk","directx":"DirectX","django":"Django","duckduckgo":"DuckDuckGo","dynamodb":"DynamoDB","echarts":"ECharts","ecmascript":"ECMAScript","edgedb":"EdgeDB","eggjs":"Egg.js","elasticsearch":"Elasticsearch","element plus":"Element Plus","elementui":"ElementUI","esbuild":"esbuild","eslint":"ESLint","esxi":"ESXi","etcd":"etcd","facetime":"FaceTime","fastapi":"FastAPI","ffmpeg":"FFmpeg","filezilla":"FileZilla","firefox":"Firefox","freemarker":"FreeMarker","gdnative":"GDNative","gdscript":"GDScript","geforce":"GeForce","geojson":"GeoJSON","geopackage":"GeoPackage","geopandas":"GeoPandas","geoserver":"GeoServer","gitbook":"GitBook","gitkraken":"GitKraken","gltf":"glTF","gnome":"GNOME","gnu":"GNU","gnupg":"GnuPG","goland":"GoLand","google pay":"Google Pay","graph rag":"Graph RAG","graphql":"GraphQL","graphrag":"GraphRAG","greensock":"GreenSock","grpc":"gRPC","hackernews":"Hacker News","hacpai":"HacPai","hbase":"HBase","hbuilderx":"HBuilderX","ibook":"iBook","icloud":"iCloud","idrac":"iDRAC","ilo":"iLO","imessage":"iMessage","imovie":"iMovie","imtoken":"imToken","influxdb":"InfluxDB","intellij":"IntelliJ","intellij idea":"IntelliJ IDEA","ios":"iOS","ipados":"iPadOS","iphoto":"iPhoto","iscsi":"iSCSI","iterm":"iTerm","itunes":"iTunes","iwork":"iWork","javascript":"JavaScript","jetbrains":"JetBrains","jquery":"jQuery","jsdoc":"JSDoc","jupyterlab":"JupyterLab","katex":"KaTeX","kubernetes":"Kubernetes","latex":"LaTeX","less":"Less","libreoffice":"LibreOffice","line pay":"LINE Pay","lineageos":"LineageOS","macos":"macOS","mariadb":"MariaDB","markdown":"Markdown","markdownlint":"MarkdownLint","mathjax":"MathJax","mathml":"MathML","mathtype":"MathType","matlab":"MATLAB","mediawiki":"MediaWiki","memcached":"Memcached","messagepack":"MessagePack","metamask":"MetaMask","mkdocs":"MkDocs","mlaas":"MLaaS","mlops":"MLOps","mobx":"MobX","mongodb":"MongoDB","mongoose":"Mongoose","ms-dos":"MS-DOS","mybatis":"MyBatis","mysql":"MySQL","naive ui":"Naive UI","naiveui":"NaiveUI","neo4j":"Neo4j","nestjs":"NestJS","netbeans":"NetBeans","netbios":"NetBIOS","nextjs":"Next.js","nixos":"NixOS","nocodb":"NocoDB","node.js":"Node.js","nosql":"NoSQL","notepad ++":"Notepad++","npm":"npm","numpy":"NumPy","nuxtjs":"NuxtJS","oauth":"OAuth","obs":"OBS","ocaml":"OCaml","onedrive":"OneDrive","onenote":"OneNote","openai":"OpenAI","openapi":"OpenAPI","opencv":"OpenCV","openfaas":"OpenFaaS","openflow":"OpenFlow","opengauss":"openGauss","opengl":"OpenGL","opengl es":"OpenGL ES","openjdk":"OpenJDK","openlayers":"OpenLayers","openpgp":"OpenPGP","opensea":"OpenSea","openssl":"OpenSSL","openstack":"OpenStack","openstreetmap":"OpenStreetMap","opensuse":"openSUSE","openvino":"OpenVINO","openwrt":"OpenWrt","opnsense":"OPNsense","pagp":"PAgP","paypal":"PayPal","photoshop":"Photoshop","php":"PHP","phpstorm":"PhpStorm","pihole":"Pi-hole","planetscale":"PlanetScale","postcss":"PostCSS","postgis":"PostGIS","postgresql":"PostgreSQL","potplayer":"PotPlayer","powerpoint":"PowerPoint","powershell":"PowerShell","premid":"PreMiD","primevue":"PrimeVue","protobuf":"Protobuf","pycharm":"PyCharm","pytorch":"PyTorch","qtscript":"QtScript","raii":"RAII","react native":"React Native","redhat":"RedHat","redisearch":"RediSearch","redisjson":"RedisJSON","rescript":"ReScript","restful":"RESTful","rethinkdb":"RethinkDB","rsshub":"RSSHub","rust":"Rust","rxdb":"RxDB","rxjs":"RxJS","samsung pay":"Samsung Pay","sass":"Sass","scss":"SCSS","segmentfault":"SegmentFault","socket.io":"Socket.IO","solarwinds":"SolarWinds","spatiallite":"SpatialLite","spir-v":"SPIR-V","springboot":"SpringBoot","springcloud":"SpringCloud","springmvc":"SpringMVC","sqlite":"SQLite","sqlserver":"SQLServer","storybook":"Storybook","stylus":"Stylus","sublime text":"Sublime Text","surrealdb":"SurrealDB","sveltekit":"SvelteKit","tailwind css":"Tailwind CSS","tailwindcss":"TailwindCSS","teamviewer":"TeamViewer","tensorflow":"TensorFlow","testflight":"TestFlight","tex":"TeX","threejs":"ThreeJS","tianocore":"TianoCore","tidb":"TiDB","tiflash":"TiFlash","tiktok":"TikTok","tikv":"TiKV","travis ci":"Travis CI","trpc":"tRPC","tsconfig":"TSConfig","tsdoc":"TSDoc","tsdx":"TSdx","turbopack":"Turbopack","turborepo":"Turborepo","typeorm":"TypeORM","typescript":"TypeScript","uniapp":"uniapp","unifi":"UniFi","unix":"UNIX","unocss":"UnoCSS","upnp":"UPnP","vercel":"Vercel","videolan":"VideoLAN","vim":"Vim","virtualbox":"VirtualBox","visual studio":"Visual Studio","visual studio code":"Visual Studio Code","vitepress":"VitePress","vividcortex":"VividCortex","vlc":"VLC","vmware":"VMware","voip":"VoIP","vs code":"VS Code","vs codium":"VSCodium","vscode":"VS Code","vscodium":"VSCodium","vue cli":"Vue CLI","vuepress":"VuePress","vueuse":"VueUse","vulkan":"Vulkan","w3c":"W3C","wasm":"Wasm","watchos":"watchOS","web assembly":"WebAssembly","webar":"WebAR","webassembly":"WebAssembly","webgl":"WebGL","webgpu":"WebGPU","webkit":"WebKit","webpack":"webpack","webrtc":"WebRTC","websocket":"WebSocket","webstorm":"WebStorm","webvr":"WebVR","webxr":"WebXR","wechat":"WeChat","wechat pay":"WeChat Pay","whatsapp":"WhatsApp","windi css":"Windi CSS","windicss":"WindiCSS","wireguard":"WireGuard","wordpress":"WordPress","xmind":"XMind","xstate":"XState","yapi":"YApi"}');
-const dict = [
-    ...Object.values(abbreviates_namespaceObject),
-    ...Object.values(brands_namespaceObject),
-    ...Object.values(general_namespaceObject),
-    ...Object.values(products_namespaceObject),
-    ...Object.values(softwares_namespaceObject),
-    'Angular',
-    'Agent Skills',
-    'API Report File',
-    'App Router',
-    'Babel',
-    'Baseline',
-    'Create React App',
-    'Cloudflare Pages',
-    'Cloudflare Workers',
-    'CSS Modules',
-    'Coding Agent',
-    'Coding Agents',
-    'Docusaurus',
-    'Docusaurus Faster',
-    'EJS',
-    'Emotion',
-    'Fast Refresh',
-    'Git',
-    'GitHub Actions',
-    'GitHub Pages',
-    'I',
-    'Jest',
-    'Lightning CSS',
-    'Lynx',
-    'Module Federation',
-    'Nextra',
-    'Netlify',
-    'Kinsta',
-    'Open Graph',
-    'Page Router',
-    'Parcel',
-    'Playwright',
-    'Preact',
-    'Preact Refresh',
-    'Relay',
-    'React',
-    'React Compiler',
-    'React Router',
-    'React Scan',
-    'React Server Components',
-    'Rollup',
-    'Rsbuild',
-    'Rsdoctor',
-    'Rslib',
-    'Rspack',
-    'Rstack',
-    'Rspack Stack',
-    'Rspress',
-    'Rstest',
-    'Rslint',
-    'Solid',
-    'Svelte',
-    'Server Action',
-    'Service Worker',
-    'TanStack Router',
-    'TanStack Start',
-    'Vite',
-    'Vitest',
-    'Vue',
-    'Web Workers',
-    'Xcode',
-    'Yarn',
-    'Zeabur',
-    'Zephyr',
-    'Zephyr Cloud'
-];
-const picocolors = __webpack_require__("./node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
-var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
-const DEFAULT_IGNORE = [
-    '**/node_modules',
-    '**/dist',
-    '**/.git',
-    '**/.cache',
-    '**/temp'
-];
-function getGitIgnorePatterns(cwd) {
-    try {
-        const stdout = execFileSync('git', [
-            'ls-files',
-            '--others',
-            '--ignored',
-            '--exclude-standard',
-            '--directory',
-            '-z'
-        ], {
-            cwd,
-            encoding: 'utf8',
-            stdio: [
-                'ignore',
-                'pipe',
-                'ignore'
-            ]
-        });
-        return stdout.split('\0').filter(Boolean).map((path)=>escapePath(path));
-    } catch  {
-        return [];
-    }
-}
-async function globMarkdownFiles(cwd) {
-    return glob([
-        '**/*.md',
-        '**/*.mdx'
-    ], {
-        cwd,
-        ignore: [
-            ...DEFAULT_IGNORE,
-            ...getGitIgnorePatterns(cwd)
-        ],
-        absolute: true
-    });
-}
-const isTitleLine = (line)=>/^#{1,6}\s+\S/.test(line.trim());
-const isEnglishWord = (word)=>/^[a-zA-Z]+$/.test(word);
-const isFirstCharUppercase = (word)=>/^[A-Z][a-z]*$/.test(word);
-const isTerm = (word, line)=>dict.some((term)=>{
-        if (term.includes(` ${word}`) || term.includes(`${word} `)) return line.includes(term);
-        return term === word;
-    });
-const shouldWrite = process.argv.includes('--write');
-const lineToWords = (line)=>{
-    const words = [];
-    let lastWord = {
-        type: 'word',
-        value: ''
-    };
-    for (const char of line.split(''))if (/\s/.test(char)) if ('space' === lastWord.type) lastWord.value += char;
-    else {
-        words.push(lastWord);
-        lastWord = {
-            type: 'space',
-            value: char
-        };
-    }
-    else if ('word' === lastWord.type) lastWord.value += char;
-    else {
-        words.push(lastWord);
-        lastWord = {
-            type: 'word',
-            value: char
-        };
-    }
-    words.push(lastWord);
-    return words;
-};
-const formatLine = (line)=>{
-    const words = lineToWords(line);
-    const englishWords = [];
-    for(let index = 0; index < words.length; index++){
-        const word = words[index];
-        const { type, value } = word;
-        if ('space' === type) continue;
-        if (isEnglishWord(value)) englishWords.push(value);
-        if (englishWords.length <= 1 || isTerm(value, line) || !isFirstCharUppercase(value)) continue;
-        const lowerCase = value.toLowerCase();
-        if (lowerCase !== value) word.value = lowerCase;
-    }
-    return words.map((word)=>word.value).join('');
-};
-function formatContent(content, filePath) {
-    const lines = content.split('\n');
-    return lines.map((originalLine)=>{
-        if (isTitleLine(originalLine)) {
-            const formattedLine = formatLine(originalLine);
-            if (!shouldWrite && formattedLine !== originalLine) {
-                src_logger.error(`Unexpected heading case in ${picocolors_default().dim(filePath)}`);
-                src_logger.log(`        Current: ${picocolors_default().cyan(originalLine)}`);
-                src_logger.log(`        Expected: ${picocolors_default().cyan(formattedLine)}\n`);
-            }
-            return formattedLine;
-        }
-        return originalLine;
-    }).join('\n');
-}
-async function formatFile(filePath) {
-    const content = await node_fs.promises.readFile(filePath, 'utf-8');
-    const formatted = formatContent(content, filePath);
-    const isChanged = formatted !== content;
-    if (isChanged && shouldWrite) {
-        await node_fs.promises.writeFile(filePath, formatted);
-        src_logger.success(`[heading-case] formatted: ${picocolors_default().dim(filePath)}`);
-    }
-    return isChanged;
-}
-async function headingCase({ root = process.cwd() } = {}) {
-    const files = await globMarkdownFiles(root);
-    let count = 0;
-    for (const file of files){
-        const isFormatted = await formatFile(file);
-        if (isFormatted) count++;
-    }
-    if (count) if (shouldWrite) src_logger.success(`[heading-case] formatted ${picocolors_default().yellow(count.toString())} files.`);
-    else {
-        src_logger.info(`[heading-case] found issues in ${picocolors_default().yellow(count.toString())} files.`);
-        process.exit(1);
-    }
-    else src_logger.success(`[heading-case] ${picocolors_default().yellow(files.length)} files scanned, no issues found.`);
-}
-export { formatLine, globMarkdownFiles, headingCase };
+import { parsers, printers } from "prettier/plugins/markdown";
+import { formatWords } from "./core.js";
+const AST_FORMAT = 'heading-case-mdast';
+const collectWordNodes = (node, words)=>{
+    if (('word' === node.type || 'whitespace' === node.type) && 'string' == typeof node.value) return void words.push(node);
+    for (const child of node.children ?? [])collectWordNodes(child, words);
+};
+const formatHeading = (heading)=>{
+    const wordNodes = [];
+    collectWordNodes(heading, wordNodes);
+    const words = wordNodes.map((node)=>({
+            type: 'whitespace' === node.type ? 'space' : 'word',
+            value: node.value ?? ''
+        }));
+    formatWords(words);
+    for(let index = 0; index < wordNodes.length; index++)wordNodes[index].value = words[index].value;
+};
+const formatHeadings = (node)=>{
+    if ('heading' === node.type) return void formatHeading(node);
+    for (const child of node.children ?? [])formatHeadings(child);
+};
+const wrapParser = (parser)=>({
+        ...parser,
+        astFormat: AST_FORMAT
+    });
+const src_parsers = {
+    markdown: wrapParser(parsers.markdown),
+    mdx: wrapParser(parsers.mdx),
+    remark: wrapParser(parsers.remark)
+};
+const markdownPrinter = printers.mdast;
+const printer = {
+    ...markdownPrinter,
+    async preprocess (ast, options) {
+        const preprocessed = markdownPrinter.preprocess ? await markdownPrinter.preprocess(ast, options) : ast;
+        if (void 0 === options.parentParser) formatHeadings(preprocessed);
+        return preprocessed;
+    }
+};
+const src_printers = {
+    [AST_FORMAT]: printer
+};
+const src_plugin = {
+    parsers: src_parsers,
+    printers: src_printers
+};
+const src = src_plugin;
+export default src;
+export { src_parsers as parsers, src_printers as printers };