heading-case 0.0.0 → 0.0.1

package/dist/index.js

@@ -1 +1,2995 @@
-// TODO
+import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
+import * as __WEBPACK_EXTERNAL_MODULE_path__ from "path";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs__ from "node:fs";
+import * as __WEBPACK_EXTERNAL_MODULE_process__ from "process";
+import * as __WEBPACK_EXTERNAL_MODULE_os__ from "os";
+import * as __WEBPACK_EXTERNAL_MODULE_tty__ from "tty";
+var __webpack_modules__ = {
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/async.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.callback = exports.promise = void 0;
+        const walker_1 = __webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/walker.js");
+        function promise(root, options) {
+            return new Promise((resolve, reject)=>{
+                callback(root, options, (err, output)=>{
+                    if (err) return reject(err);
+                    resolve(output);
+                });
+            });
+        }
+        exports.promise = promise;
+        function callback(root, options, callback) {
+            let walker = new walker_1.Walker(root, options, callback);
+            walker.start();
+        }
+        exports.callback = callback;
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/counter.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.Counter = void 0;
+        class Counter {
+            _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;
+            }
+            /**
+     * @deprecated use `directories` instead
+     */ /* c8 ignore next 3 */ get dirs() {
+                return this._directories;
+            }
+        }
+        exports.Counter = Counter;
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/functions/get-array.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.build = void 0;
+        const getArray = (paths)=>paths;
+        const getArrayGroup = ()=>[
+                ""
+            ].slice(0, 0);
+        function build(options) {
+            return options.group ? getArrayGroup : getArray;
+        }
+        exports.build = build;
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/functions/group-files.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.build = void 0;
+        const groupFiles = (groups, directory, files)=>{
+            groups.push({
+                directory,
+                files,
+                dir: directory
+            });
+        };
+        const empty = ()=>{};
+        function build(options) {
+            return options.group ? groupFiles : empty;
+        }
+        exports.build = build;
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/functions/invoke-callback.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.build = void 0;
+        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)=>{
+            report(error, callback, state.counts, state.options.suppressErrors);
+            return null;
+        };
+        const defaultAsync = (state, error, callback)=>{
+            report(error, callback, state.paths, state.options.suppressErrors);
+            return null;
+        };
+        const limitFilesAsync = (state, error, callback)=>{
+            report(error, callback, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
+            return null;
+        };
+        const groupsAsync = (state, error, callback)=>{
+            report(error, callback, state.groups, state.options.suppressErrors);
+            return null;
+        };
+        function report(error, callback, output, suppressErrors) {
+            callback(error && !suppressErrors ? error : null, output);
+        }
+        function build(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;
+            else return isSynchronous ? defaultSync : defaultAsync;
+        }
+        exports.build = build;
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/functions/join-path.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.build = exports.joinDirectoryPath = exports.joinPathWithBasePath = void 0;
+        const path_1 = __webpack_require__("path");
+        const utils_1 = __webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/utils.js");
+        function joinPathWithBasePath(filename, directoryPath) {
+            return directoryPath + filename;
+        }
+        exports.joinPathWithBasePath = joinPathWithBasePath;
+        function joinPathWithRelativePath(root, options) {
+            return function(filename, directoryPath) {
+                const sameRoot = directoryPath.startsWith(root);
+                if (sameRoot) return directoryPath.replace(root, "") + filename;
+                return (0, utils_1.convertSlashes)((0, path_1.relative)(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
+            };
+        }
+        function joinPath(filename) {
+            return filename;
+        }
+        function joinDirectoryPath(filename, directoryPath, separator) {
+            return directoryPath + filename + separator;
+        }
+        exports.joinDirectoryPath = joinDirectoryPath;
+        function build(root, options) {
+            const { relativePaths, includeBasePath } = options;
+            return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
+        }
+        exports.build = build;
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/functions/push-directory.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.build = void 0;
+        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 = ()=>{};
+        function build(root, options) {
+            const { includeDirs, filters, relativePaths } = options;
+            if (!includeDirs) return empty;
+            if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
+            return filters && filters.length ? pushDirectoryFilter : pushDirectory;
+        }
+        exports.build = build;
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/functions/push-file.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.build = void 0;
+        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 = ()=>{};
+        function build(options) {
+            const { excludeFiles, filters, onlyCounts } = options;
+            if (excludeFiles) return empty;
+            if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
+            if (onlyCounts) return pushFileCount;
+            return pushFile;
+        }
+        exports.build = build;
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/functions/resolve-symlink.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        var __importDefault = this && this.__importDefault || function(mod) {
+            return mod && mod.__esModule ? mod : {
+                default: mod
+            };
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.build = void 0;
+        const fs_1 = __importDefault(__webpack_require__("fs"));
+        const path_1 = __webpack_require__("path");
+        const resolveSymlinksAsync = function(path, state, callback) {
+            const { queue, options: { suppressErrors } } = state;
+            queue.enqueue();
+            fs_1.default.realpath(path, (error, resolvedPath)=>{
+                if (error) return queue.dequeue(suppressErrors ? null : error, state);
+                fs_1.default.stat(resolvedPath, (error, stat)=>{
+                    if (error) return queue.dequeue(suppressErrors ? null : error, state);
+                    if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return queue.dequeue(null, state);
+                    callback(stat, resolvedPath);
+                    queue.dequeue(null, state);
+                });
+            });
+        };
+        const resolveSymlinks = function(path, state, callback) {
+            const { queue, options: { suppressErrors } } = state;
+            queue.enqueue();
+            try {
+                const resolvedPath = fs_1.default.realpathSync(path);
+                const stat = fs_1.default.statSync(resolvedPath);
+                if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return;
+                callback(stat, resolvedPath);
+            } catch (e) {
+                if (!suppressErrors) throw e;
+            }
+        };
+        function build(options, isSynchronous) {
+            if (!options.resolveSymlinks || options.excludeSymlinks) return null;
+            return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+        }
+        exports.build = build;
+        function isRecursive(path, resolved, state) {
+            if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
+            let parent = (0, path_1.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 = (0, path_1.dirname)(parent);
+            }
+            state.symlinks.set(path, resolved);
+            return depth > 1;
+        }
+        function isRecursiveUsingRealPaths(resolved, state) {
+            return state.visited.includes(resolved + state.options.pathSeparator);
+        }
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/functions/walk-directory.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        var __importDefault = this && this.__importDefault || function(mod) {
+            return mod && mod.__esModule ? mod : {
+                default: mod
+            };
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.build = void 0;
+        const fs_1 = __importDefault(__webpack_require__("fs"));
+        const readdirOpts = {
+            withFileTypes: true
+        };
+        const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback)=>{
+            if (currentDepth < 0) return state.queue.dequeue(null, state);
+            state.visited.push(crawlPath);
+            state.counts.directories++;
+            state.queue.enqueue();
+            // Perf: Node >= 10 introduced withFileTypes that helps us
+            // skip an extra fs.stat call.
+            fs_1.default.readdir(crawlPath || ".", readdirOpts, (error, entries = [])=>{
+                callback(entries, directoryPath, currentDepth);
+                state.queue.dequeue(state.options.suppressErrors ? null : error, state);
+            });
+        };
+        const walkSync = (state, crawlPath, directoryPath, currentDepth, callback)=>{
+            if (currentDepth < 0) return;
+            state.visited.push(crawlPath);
+            state.counts.directories++;
+            let entries = [];
+            try {
+                entries = fs_1.default.readdirSync(crawlPath || ".", readdirOpts);
+            } catch (e) {
+                if (!state.options.suppressErrors) throw e;
+            }
+            callback(entries, directoryPath, currentDepth);
+        };
+        function build(isSynchronous) {
+            return isSynchronous ? walkSync : walkAsync;
+        }
+        exports.build = build;
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/queue.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.Queue = void 0;
+        /**
+ * This is a custom stateless queue to track concurrent async fs calls.
+ * It increments a counter whenever a call is queued and decrements it
+ * as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
+ */ class Queue {
+            onQueueEmpty;
+            count = 0;
+            constructor(onQueueEmpty){
+                this.onQueueEmpty = onQueueEmpty;
+            }
+            enqueue() {
+                this.count++;
+            }
+            dequeue(error, output) {
+                if (--this.count <= 0 || error) this.onQueueEmpty(error, output);
+            }
+        }
+        exports.Queue = Queue;
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/sync.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.sync = void 0;
+        const walker_1 = __webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/walker.js");
+        function sync(root, options) {
+            const walker = new walker_1.Walker(root, options);
+            return walker.start();
+        }
+        exports.sync = sync;
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/walker.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+            if (void 0 === k2) k2 = k;
+            var desc = Object.getOwnPropertyDescriptor(m, k);
+            if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+                enumerable: true,
+                get: function() {
+                    return m[k];
+                }
+            };
+            Object.defineProperty(o, k2, desc);
+        } : function(o, m, k, k2) {
+            if (void 0 === k2) k2 = k;
+            o[k2] = m[k];
+        });
+        var __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function(o, v) {
+            Object.defineProperty(o, "default", {
+                enumerable: true,
+                value: v
+            });
+        } : function(o, v) {
+            o["default"] = v;
+        });
+        var __importStar = this && this.__importStar || function(mod) {
+            if (mod && mod.__esModule) return mod;
+            var result = {};
+            if (null != mod) {
+                for(var k in mod)if ("default" !== k && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+            }
+            __setModuleDefault(result, mod);
+            return result;
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.Walker = void 0;
+        const path_1 = __webpack_require__("path");
+        const utils_1 = __webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/utils.js");
+        const joinPath = __importStar(__webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/functions/join-path.js"));
+        const pushDirectory = __importStar(__webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/functions/push-directory.js"));
+        const pushFile = __importStar(__webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/functions/push-file.js"));
+        const getArray = __importStar(__webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/functions/get-array.js"));
+        const groupFiles = __importStar(__webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/functions/group-files.js"));
+        const resolveSymlink = __importStar(__webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/functions/resolve-symlink.js"));
+        const invokeCallback = __importStar(__webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/functions/invoke-callback.js"));
+        const walkDirectory = __importStar(__webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/functions/walk-directory.js"));
+        const queue_1 = __webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/queue.js");
+        const counter_1 = __webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/counter.js");
+        class Walker {
+            root;
+            isSynchronous;
+            state;
+            joinPath;
+            pushDirectory;
+            pushFile;
+            getArray;
+            groupFiles;
+            resolveSymlink;
+            walkDirectory;
+            callbackInvoker;
+            constructor(root, options, callback){
+                this.isSynchronous = !callback;
+                this.callbackInvoker = invokeCallback.build(options, this.isSynchronous);
+                this.root = (0, utils_1.normalizePath)(root, options);
+                this.state = {
+                    root: this.root.slice(0, -1),
+                    // Perf: we explicitly tell the compiler to optimize for String arrays
+                    paths: [
+                        ""
+                    ].slice(0, 0),
+                    groups: [],
+                    counts: new counter_1.Counter(),
+                    options,
+                    queue: new queue_1.Queue((error, state)=>this.callbackInvoker(state, error, callback)),
+                    symlinks: new Map(),
+                    visited: [
+                        ""
+                    ].slice(0, 0)
+                };
+                /*
+         * Perf: We conditionally change functions according to options. This gives a slight
+         * performance boost. Since these functions are so small, they are automatically inlined
+         * by the javascript engine so there's no function call overhead (in most cases).
+         */ this.joinPath = joinPath.build(this.root, options);
+                this.pushDirectory = pushDirectory.build(this.root, options);
+                this.pushFile = pushFile.build(options);
+                this.getArray = getArray.build(options);
+                this.groupFiles = groupFiles.build(options);
+                this.resolveSymlink = resolveSymlink.build(options, this.isSynchronous);
+                this.walkDirectory = walkDirectory.build(this.isSynchronous);
+            }
+            start() {
+                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, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator } } = this.state;
+                if (signal && signal.aborted || maxFiles && paths.length > maxFiles) return;
+                this.pushDirectory(directoryPath, paths, filters);
+                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 && !excludeSymlinks) {
+                        const filename = this.joinPath(entry.name, directoryPath);
+                        this.pushFile(filename, files, this.state.counts, filters);
+                    } else if (entry.isDirectory()) {
+                        let path = joinPath.joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+                        if (exclude && exclude(entry.name, path)) continue;
+                        this.walkDirectory(this.state, path, path, depth - 1, this.walk);
+                    } else if (entry.isSymbolicLink() && this.resolveSymlink) {
+                        let path = joinPath.joinPathWithBasePath(entry.name, directoryPath);
+                        this.resolveSymlink(path, this.state, (stat, resolvedPath)=>{
+                            if (stat.isDirectory()) {
+                                resolvedPath = (0, utils_1.normalizePath)(resolvedPath, this.state.options);
+                                if (exclude && exclude(entry.name, resolvedPath)) return;
+                                this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
+                            } else {
+                                resolvedPath = useRealPaths ? resolvedPath : path;
+                                const filename = (0, path_1.basename)(resolvedPath);
+                                const directoryPath = (0, utils_1.normalizePath)((0, path_1.dirname)(resolvedPath), this.state.options);
+                                resolvedPath = this.joinPath(filename, directoryPath);
+                                this.pushFile(resolvedPath, files, this.state.counts, filters);
+                            }
+                        });
+                    }
+                }
+                this.groupFiles(this.state.groups, directoryPath, files);
+            };
+        }
+        exports.Walker = Walker;
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/builder/api-builder.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.APIBuilder = void 0;
+        const async_1 = __webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/async.js");
+        const sync_1 = __webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/api/sync.js");
+        class APIBuilder {
+            root;
+            options;
+            constructor(root, options){
+                this.root = root;
+                this.options = options;
+            }
+            withPromise() {
+                return (0, async_1.promise)(this.root, this.options);
+            }
+            withCallback(cb) {
+                (0, async_1.callback)(this.root, this.options, cb);
+            }
+            sync() {
+                return (0, sync_1.sync)(this.root, this.options);
+            }
+        }
+        exports.APIBuilder = APIBuilder;
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/builder/index.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.Builder = void 0;
+        const path_1 = __webpack_require__("path");
+        const api_builder_1 = __webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/builder/api-builder.js");
+        var pm = null;
+        /* c8 ignore next 6 */ try {
+            require.resolve("picomatch");
+            pm = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/index.js");
+        } catch (_e) {
+        // do nothing
+        }
+        class Builder {
+            globCache = {};
+            options = {
+                maxDepth: 1 / 0,
+                suppressErrors: true,
+                pathSeparator: path_1.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 api_builder_1.APIBuilder(root || ".", this.options);
+            }
+            withGlobFunction(fn) {
+                // cast this since we don't have the new type params yet
+                this.globFunction = fn;
+                return this;
+            }
+            /**
+     * @deprecated Pass options using the constructor instead:
+     * ```ts
+     * new fdir(options).crawl("/path/to/root");
+     * ```
+     * This method will be removed in v7.0
+     */ /* c8 ignore next 4 */ crawlWithOptions(root, options) {
+                this.options = {
+                    ...this.options,
+                    ...options
+                };
+                return new api_builder_1.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;
+                /* c8 ignore next 5 */ 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;
+            }
+        }
+        exports.Builder = Builder;
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/index.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+            if (void 0 === k2) k2 = k;
+            var desc = Object.getOwnPropertyDescriptor(m, k);
+            if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+                enumerable: true,
+                get: function() {
+                    return m[k];
+                }
+            };
+            Object.defineProperty(o, k2, desc);
+        } : function(o, m, k, k2) {
+            if (void 0 === k2) k2 = k;
+            o[k2] = m[k];
+        });
+        var __exportStar = this && this.__exportStar || function(m, exports) {
+            for(var p in m)if ("default" !== p && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.fdir = void 0;
+        const builder_1 = __webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/builder/index.js");
+        Object.defineProperty(exports, "fdir", {
+            enumerable: true,
+            get: function() {
+                return builder_1.Builder;
+            }
+        });
+        __exportStar(__webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/types.js"), exports);
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/types.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+    },
+    "./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/utils.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.normalizePath = exports.convertSlashes = exports.cleanPath = void 0;
+        const path_1 = __webpack_require__("path");
+        function cleanPath(path) {
+            let normalized = (0, path_1.normalize)(path);
+            // we have to remove the last path separator
+            // to account for / root path
+            if (normalized.length > 1 && normalized[normalized.length - 1] === path_1.sep) normalized = normalized.substring(0, normalized.length - 1);
+            return normalized;
+        }
+        exports.cleanPath = cleanPath;
+        const SLASHES_REGEX = /[\\/]/g;
+        function convertSlashes(path, separator) {
+            return path.replace(SLASHES_REGEX, separator);
+        }
+        exports.convertSlashes = convertSlashes;
+        function normalizePath(path, options) {
+            const { resolvePaths, normalizePath, pathSeparator } = options;
+            const pathNeedsCleaning = "win32" === process.platform && path.includes("/") || path.startsWith(".");
+            if (resolvePaths) path = (0, path_1.resolve)(path);
+            if (normalizePath || pathNeedsCleaning) path = cleanPath(path);
+            if ("." === path) return "";
+            const needsSeperator = path[path.length - 1] !== pathSeparator;
+            return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator);
+        }
+        exports.normalizePath = normalizePath;
+    },
+    "./node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js": function(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.2/node_modules/picomatch/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const pico = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/picomatch.js");
+        const utils = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/utils.js");
+        function picomatch(glob, options, returnState = false) {
+            // default to os.platform()
+            if (options && (null === options.windows || void 0 === options.windows)) // don't mutate the original options object
+            options = {
+                ...options,
+                windows: utils.isWindows()
+            };
+            return pico(glob, options, returnState);
+        }
+        Object.assign(picomatch, pico);
+        module.exports = picomatch;
+    },
+    "./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/constants.js": function(module) {
+        const WIN_SLASH = '\\\\/';
+        const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+        /**
+ * Posix glob regex
+ */ 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
+        };
+        /**
+ * Windows glob regex
+ */ 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: '\\'
+        };
+        /**
+ * POSIX Bracket Regex
+ */ const POSIX_REGEX_SOURCE = {
+            alnum: 'a-zA-Z0-9',
+            alpha: 'a-zA-Z',
+            ascii: '\\x00-\\x7F',
+            blank: ' \\t',
+            cntrl: '\\x00-\\x1F\\x7F',
+            digit: '0-9',
+            graph: '\\x21-\\x7E',
+            lower: 'a-z',
+            print: '\\x20-\\x7E ',
+            punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+            space: ' \\t\\r\\n\\v\\f',
+            upper: 'A-Z',
+            word: 'A-Za-z0-9_',
+            xdigit: 'A-Fa-f0-9'
+        };
+        module.exports = {
+            MAX_LENGTH: 65536,
+            POSIX_REGEX_SOURCE,
+            // regular expressions
+            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,
+            // Replace globs with equivalent patterns to reduce parsing time.
+            REPLACEMENTS: {
+                '***': '*',
+                '**/**': '**',
+                '**/**/**': '**'
+            },
+            // Digits
+            CHAR_0: 48,
+            /* 0 */ CHAR_9: 57,
+            /* 9 */ // Alphabet chars.
+            CHAR_UPPERCASE_A: 65,
+            /* A */ CHAR_LOWERCASE_A: 97,
+            /* a */ CHAR_UPPERCASE_Z: 90,
+            /* Z */ CHAR_LOWERCASE_Z: 122,
+            /* z */ CHAR_LEFT_PARENTHESES: 40,
+            /* ( */ CHAR_RIGHT_PARENTHESES: 41,
+            /* ) */ CHAR_ASTERISK: 42,
+            /* * */ // Non-alphabetic chars.
+            CHAR_AMPERSAND: 38,
+            /* & */ CHAR_AT: 64,
+            /* @ */ CHAR_BACKWARD_SLASH: 92,
+            /* \ */ CHAR_CARRIAGE_RETURN: 13,
+            /* \r */ 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,
+            /* \f */ 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,
+            /* \n */ CHAR_NO_BREAK_SPACE: 160,
+            /* \u00A0 */ 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,
+            /* \t */ CHAR_UNDERSCORE: 95,
+            /* _ */ CHAR_VERTICAL_LINE: 124,
+            /* | */ CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+            /* \uFEFF */ /**
+   * Create EXTGLOB_CHARS
+   */ 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: ')'
+                    }
+                };
+            },
+            /**
+   * Create GLOB_CHARS
+   */ globChars (win32) {
+                return true === win32 ? WINDOWS_CHARS : POSIX_CHARS;
+            }
+        };
+    },
+    "./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/parse.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const constants = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/constants.js");
+        const utils = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/utils.js");
+        /**
+ * Constants
+ */ const { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants;
+        /**
+ * Helpers
+ */ const expandRange = (args, options)=>{
+            if ('function' == typeof options.expandRange) return options.expandRange(...args, options);
+            args.sort();
+            const value = `[${args.join('-')}]`;
+            try {
+                /* eslint-disable-next-line no-new */ new RegExp(value);
+            } catch (ex) {
+                return args.map((v)=>utils.escapeRegex(v)).join('..');
+            }
+            return value;
+        };
+        /**
+ * Create the message for a syntax error
+ */ const syntaxError = (type, char)=>`Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+        /**
+ * Parse the given input string.
+ * @param {String} input
+ * @param {Object} options
+ * @return {Object}
+ */ 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 ? '' : '?:';
+            // create constants based on platform, for windows or posix
+            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})`;
+            // minimatch options support
+            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;
+            /**
+   * Tokenizing helpers
+   */ 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();
+            };
+            /**
+   * Push tokens onto the tokens array. This helper speeds up
+   * tokenizing by 1) helping us avoid backtracking as much as possible,
+   * and 2) helping us avoid creating extra tokens when consecutive
+   * characters are plain text. This improves performance and simplifies
+   * lookbehinds.
+   */ 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;
+                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)=>{
+                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)) {
+                        // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
+                        // In this case, we need to parse the string and use it in the output of the original pattern.
+                        // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
+                        //
+                        // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
+                        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');
+            };
+            /**
+   * Fast paths
+   */ 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;
+            }
+            /**
+   * Tokenize input until we reach end-of-string
+   */ while(!eos()){
+                value = advance();
+                if ('\u0000' === value) continue;
+                /**
+     * Escaped characters
+     */ if ('\\' === value) {
+                    const next = peek();
+                    if ('/' === next && true !== opts.bash) continue;
+                    if ('.' === next || ';' === next) continue;
+                    if (!next) {
+                        value += '\\';
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                    // collapse slashes to reduce potential for exploits
+                    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 we're inside a regex character class, continue
+     * until we reach the closing bracket.
+     */ 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 we're inside a quoted string, continue
+     * until we reach the closing double quote.
+     */ if (1 === state.quotes && '"' !== value) {
+                    value = utils.escapeRegex(value);
+                    prev.value += value;
+                    append({
+                        value
+                    });
+                    continue;
+                }
+                /**
+     * Double quotes
+     */ if ('"' === value) {
+                    state.quotes = 1 === state.quotes ? 0 : 1;
+                    if (true === opts.keepQuotes) push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                /**
+     * Parentheses
+     */ 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;
+                }
+                /**
+     * Square brackets
+     */ 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
+                    });
+                    // when literal brackets are explicitly disabled
+                    // assume we should match with a regex character class
+                    if (false === opts.literalBrackets || utils.hasRegexChars(prevValue)) continue;
+                    const escaped = utils.escapeRegex(prev.value);
+                    state.output = state.output.slice(0, -prev.value.length);
+                    // when literal brackets are explicitly enabled
+                    // assume we should escape the brackets to match literal characters
+                    if (true === opts.literalBrackets) {
+                        state.output += escaped;
+                        prev.value = escaped;
+                        continue;
+                    }
+                    // when the user specifies nothing, try to match both
+                    prev.value = `(${capture}${escaped}|${prev.value})`;
+                    state.output += prev.value;
+                    continue;
+                }
+                /**
+     * Braces
+     */ 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;
+                }
+                /**
+     * Pipes
+     */ if ('|' === value) {
+                    if (extglobs.length > 0) extglobs[extglobs.length - 1].conditions++;
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                /**
+     * Commas
+     */ 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;
+                }
+                /**
+     * Slashes
+     */ if ('/' === value) {
+                    // if the beginning of the glob is "./", advance the start
+                    // to the current index, and don't add the "./" characters
+                    // to the state. This greatly simplifies lookbehinds when
+                    // checking for BOS characters like "!" and "." (not "./")
+                    if ('dot' === prev.type && state.index === state.start + 1) {
+                        state.start = state.index + 1;
+                        state.consumed = '';
+                        state.output = '';
+                        tokens.pop();
+                        prev = bos; // reset "prev" to the first token
+                        continue;
+                    }
+                    push({
+                        type: 'slash',
+                        value,
+                        output: SLASH_LITERAL
+                    });
+                    continue;
+                }
+                /**
+     * Dots
+     */ 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;
+                }
+                /**
+     * Question marks
+     */ 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;
+                }
+                /**
+     * Exclamation
+     */ 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;
+                    }
+                }
+                /**
+     * Plus
+     */ 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;
+                }
+                /**
+     * Plain text
+     */ if ('@' === value) {
+                    if (true !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        push({
+                            type: 'at',
+                            extglob: true,
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                /**
+     * Plain text
+     */ 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;
+                }
+                /**
+     * Stars
+     */ 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;
+                    }
+                    // strip consecutive `/**/`
+                    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;
+                    }
+                    // remove single star from output
+                    state.output = state.output.slice(0, -prev.output.length);
+                    // reset previous token to globstar
+                    prev.type = 'globstar';
+                    prev.output = globstar(opts);
+                    prev.value += value;
+                    // reset output with globstar
+                    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}?`
+            });
+            // rebuild the output if we had to backtrack at any point
+            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;
+        };
+        /**
+ * Fast paths for creating regular expressions for common glob patterns.
+ * This can significantly speed up processing and has very little downside
+ * impact when none of the fast paths match.
+ */ 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;
+            // create constants based on platform, for windows or posix
+            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.2/node_modules/picomatch/lib/picomatch.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const scan = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/scan.js");
+        const parse = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/parse.js");
+        const utils = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/utils.js");
+        const constants = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/constants.js");
+        const isObject = (val)=>val && 'object' == typeof val && !Array.isArray(val);
+        /**
+ * Creates a matcher function from one or more glob patterns. The
+ * returned function takes a string to match as its first argument,
+ * and returns true if the string is a match. The returned matcher
+ * function also takes a boolean as the second argument that, when true,
+ * returns an object with additional information.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch(glob[, options]);
+ *
+ * const isMatch = picomatch('*.!(*a)');
+ * console.log(isMatch('a.a')); //=> false
+ * console.log(isMatch('a.b')); //=> true
+ * ```
+ * @name picomatch
+ * @param {String|Array} `globs` One or more glob patterns.
+ * @param {Object=} `options`
+ * @return {Function=} Returns a matcher function.
+ * @api public
+ */ 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;
+                }
+                if (isIgnored(input)) {
+                    if ('function' == typeof opts.onIgnore) opts.onIgnore(result);
+                    result.isMatch = false;
+                    return !!returnObject && result;
+                }
+                if ('function' == typeof opts.onMatch) opts.onMatch(result);
+                return !returnObject || result;
+            };
+            if (returnState) matcher.state = state;
+            return matcher;
+        };
+        /**
+ * Test `input` with the given `regex`. This is used by the main
+ * `picomatch()` function to test the input string.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.test(input, regex[, options]);
+ *
+ * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+ * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+ * ```
+ * @param {String} `input` String to test.
+ * @param {RegExp} `regex`
+ * @return {Object} Returns an object with matching info.
+ * @api public
+ */ 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
+            };
+        };
+        /**
+ * Match the basename of a filepath.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.matchBase(input, glob[, options]);
+ * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+ * ```
+ * @param {String} `input` String to test.
+ * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+ * @return {Boolean}
+ * @api public
+ */ picomatch.matchBase = (input, glob, options)=>{
+            const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+            return regex.test(utils.basename(input));
+        };
+        /**
+ * Returns true if **any** of the given glob `patterns` match the specified `string`.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.isMatch(string, patterns[, options]);
+ *
+ * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+ * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+ * ```
+ * @param {String|Array} str The string to test.
+ * @param {String|Array} patterns One or more glob patterns to use for matching.
+ * @param {Object} [options] See available [options](#options).
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */ picomatch.isMatch = (str, patterns, options)=>picomatch(patterns, options)(str);
+        /**
+ * Parse a glob pattern to create the source string for a regular
+ * expression.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * const result = picomatch.parse(pattern[, options]);
+ * ```
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+ * @api public
+ */ picomatch.parse = (pattern, options)=>{
+            if (Array.isArray(pattern)) return pattern.map((p)=>picomatch.parse(p, options));
+            return parse(pattern, {
+                ...options,
+                fastpaths: false
+            });
+        };
+        /**
+ * Scan a glob pattern to separate the pattern into segments.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.scan(input[, options]);
+ *
+ * const result = picomatch.scan('!./foo/*.js');
+ * console.log(result);
+ * { prefix: '!./',
+ *   input: '!./foo/*.js',
+ *   start: 3,
+ *   base: 'foo',
+ *   glob: '*.js',
+ *   isBrace: false,
+ *   isBracket: false,
+ *   isGlob: true,
+ *   isExtglob: false,
+ *   isGlobstar: false,
+ *   negated: true }
+ * ```
+ * @param {String} `input` Glob pattern to scan.
+ * @param {Object} `options`
+ * @return {Object} Returns an object with
+ * @api public
+ */ picomatch.scan = (input, options)=>scan(input, options);
+        /**
+ * Compile a regular expression from the `state` object returned by the
+ * [parse()](#parse) method.
+ *
+ * @param {Object} `state`
+ * @param {Object} `options`
+ * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+ * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+ * @return {RegExp}
+ * @api public
+ */ 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;
+        };
+        /**
+ * Create a regular expression from a parsed glob pattern.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * const state = picomatch.parse('*.js');
+ * // picomatch.compileRe(state[, options]);
+ *
+ * console.log(picomatch.compileRe(state));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `state` The object returned from the `.parse` method.
+ * @param {Object} `options`
+ * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+ * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+ * @return {RegExp} Returns a regex created from the given pattern.
+ * @api public
+ */ 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);
+        };
+        /**
+ * Create a regular expression from the given regex source string.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.toRegex(source[, options]);
+ *
+ * const { output } = picomatch.parse('*.js');
+ * console.log(picomatch.toRegex(output));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `source` Regular expression source string.
+ * @param {Object} `options`
+ * @return {RegExp}
+ * @api public
+ */ 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.
+ * @return {Object}
+ */ picomatch.constants = constants;
+        /**
+ * Expose "picomatch"
+ */ module.exports = picomatch;
+    },
+    "./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/scan.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        const utils = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/utils.js");
+        const { CHAR_ASTERISK, /* * */ CHAR_AT, /* @ */ CHAR_BACKWARD_SLASH, /* \ */ CHAR_COMMA, /* , */ CHAR_DOT, /* . */ CHAR_EXCLAMATION_MARK, /* ! */ CHAR_FORWARD_SLASH, /* / */ CHAR_LEFT_CURLY_BRACE, /* { */ CHAR_LEFT_PARENTHESES, /* ( */ CHAR_LEFT_SQUARE_BRACKET, /* [ */ CHAR_PLUS, /* + */ CHAR_QUESTION_MARK, /* ? */ CHAR_RIGHT_CURLY_BRACE, /* } */ CHAR_RIGHT_PARENTHESES, /* ) */ CHAR_RIGHT_SQUARE_BRACKET/* ] */  } = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/constants.js");
+        const isPathSeparator = (code)=>code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+        const depth = (token)=>{
+            if (true !== token.isPrefix) token.depth = token.isGlobstar ? 1 / 0 : 1;
+        };
+        /**
+ * Quickly scans a glob pattern and returns an object with a handful of
+ * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+ * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+ * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+ *
+ * ```js
+ * const pm = require('picomatch');
+ * console.log(pm.scan('foo/bar/*.js'));
+ * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with tokens and regex source string.
+ * @api public
+ */ 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.2/node_modules/picomatch/lib/utils.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        /*global navigator*/ const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/lib/constants.js");
+        exports.isObject = (val)=>null !== val && 'object' == typeof val && !Array.isArray(val);
+        exports.hasRegexChars = (str)=>REGEX_SPECIAL_CHARS.test(str);
+        exports.isRegexChar = (str)=>1 === str.length && exports.hasRegexChars(str);
+        exports.escapeRegex = (str)=>str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+        exports.toPosixSlashes = (str)=>str.replace(REGEX_BACKSLASH, '/');
+        exports.isWindows = ()=>{
+            if ('undefined' != typeof navigator && navigator.platform) {
+                const platform = navigator.platform.toLowerCase();
+                return 'win32' === platform || 'windows' === platform;
+            }
+            if ('undefined' != 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;
+        };
+    },
+    fs: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_fs__;
+    },
+    path: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_path__;
+    }
+};
+/************************************************************************/ // The module cache
+var __webpack_module_cache__ = {};
+// The require function
+function __webpack_require__(moduleId) {
+    // Check if module is in cache
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    // Create a new module (and put it into the cache)
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    // Execute the module function
+    __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+    // Return the exports of the module
+    return module.exports;
+}
+/************************************************************************/ // webpack/runtime/compat_get_default_export
+(()=>{
+    // getDefaultExport function for compatibility with non-ESM modules
+    __webpack_require__.n = function(module) {
+        var getter = module && module.__esModule ? function() {
+            return module['default'];
+        } : function() {
+            return module;
+        };
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+// webpack/runtime/define_property_getters
+(()=>{
+    __webpack_require__.d = function(exports, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+// webpack/runtime/has_own_property
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+// EXTERNAL MODULE: ./node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var picocolors = __webpack_require__("./node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+// node_modules/.pnpm/supports-color@9.4.0/node_modules/supports-color/index.js
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : __WEBPACK_EXTERNAL_MODULE_process__["default"].argv) {
+    const prefix = flag.startsWith("-") ? "" : 1 === flag.length ? "-" : "--";
+    const position = argv.indexOf(prefix + flag);
+    const terminatorPosition = argv.indexOf("--");
+    return -1 !== position && (-1 === terminatorPosition || position < terminatorPosition);
+}
+var { env } = __WEBPACK_EXTERNAL_MODULE_process__["default"];
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
+else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
+function envForceColor() {
+    if ("FORCE_COLOR" in env) {
+        if ("true" === env.FORCE_COLOR) return 1;
+        if ("false" === env.FORCE_COLOR) return 0;
+        return 0 === env.FORCE_COLOR.length ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+    }
+}
+function translateLevel(level) {
+    if (0 === level) return false;
+    return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+    };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+    const noFlagForceColor = envForceColor();
+    if (void 0 !== noFlagForceColor) flagForceColor = noFlagForceColor;
+    const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+    if (0 === forceColor) return 0;
+    if (sniffFlags) {
+        if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
+        if (hasFlag("color=256")) return 2;
+    }
+    if ("TF_BUILD" in env && "AGENT_NAME" in env) return 1;
+    if (haveStream && !streamIsTTY && void 0 === forceColor) return 0;
+    const min = forceColor || 0;
+    if ("dumb" === env.TERM) return min;
+    if ("win32" === __WEBPACK_EXTERNAL_MODULE_process__["default"].platform) {
+        const osRelease = __WEBPACK_EXTERNAL_MODULE_os__["default"].release().split(".");
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        return 1;
+    }
+    if ("CI" in env) {
+        if ("GITHUB_ACTIONS" in env || "GITEA_ACTIONS" in env) return 3;
+        if ([
+            "TRAVIS",
+            "CIRCLECI",
+            "APPVEYOR",
+            "GITLAB_CI",
+            "BUILDKITE",
+            "DRONE"
+        ].some((sign)=>sign in env) || "codeship" === env.CI_NAME) return 1;
+        return min;
+    }
+    if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+    if ("truecolor" === env.COLORTERM) return 3;
+    if ("xterm-kitty" === env.TERM) return 3;
+    if ("TERM_PROGRAM" in env) {
+        const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch(env.TERM_PROGRAM){
+            case "iTerm.app":
+                return version >= 3 ? 3 : 2;
+            case "Apple_Terminal":
+                return 2;
+        }
+    }
+    if (/-256(color)?$/i.test(env.TERM)) return 2;
+    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+    if ("COLORTERM" in env) return 1;
+    return min;
+}
+function createSupportsColor(stream, options = {}) {
+    const level = _supportsColor(stream, {
+        streamIsTTY: stream && stream.isTTY,
+        ...options
+    });
+    return translateLevel(level);
+}
+var supportsColor = {
+    stdout: createSupportsColor({
+        isTTY: __WEBPACK_EXTERNAL_MODULE_tty__["default"].isatty(1)
+    }),
+    stderr: createSupportsColor({
+        isTTY: __WEBPACK_EXTERNAL_MODULE_tty__["default"].isatty(2)
+    })
+};
+var supports_color_default = supportsColor;
+// src/utils.ts
+var colorLevel = supports_color_default.stdout ? supports_color_default.stdout.level : 0;
+var errorStackRegExp = /at\s.*:\d+:\d+[\s\)]*$/;
+var anonymousErrorStackRegExp = /at\s.*\(<anonymous>\)$/;
+var isErrorStackMessage = (message)=>errorStackRegExp.test(message) || anonymousErrorStackRegExp.test(message);
+// src/color.ts
+var formatter = (open, close, replace = open)=>colorLevel >= 2 ? (input)=>{
+        let string = "" + input;
+        let index = string.indexOf(close, open.length);
+        return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    } : String;
+var replaceClose = (string, close, replace, index)=>{
+    let start = string.substring(0, index) + replace;
+    let end = string.substring(index + close.length);
+    let nextIndex = end.indexOf(close);
+    return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end;
+};
+var bold = formatter("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m");
+var red = formatter("\x1B[31m", "\x1B[39m");
+var green = formatter("\x1B[32m", "\x1B[39m");
+var yellow = formatter("\x1B[33m", "\x1B[39m");
+var magenta = formatter("\x1B[35m", "\x1B[39m");
+var cyan = formatter("\x1B[36m", "\x1B[39m");
+var gray = formatter("\x1B[90m", "\x1B[39m");
+// src/gradient.ts
+var startColor = [
+    189,
+    255,
+    243
+];
+var endColor = [
+    74,
+    194,
+    154
+];
+var isWord = (char)=>!/[\s\n]/.test(char);
+var gradient = (message)=>{
+    if (colorLevel < 3) return 2 === colorLevel ? bold(cyan(message)) : message;
+    let chars = [
+        ...message
+    ];
+    let steps = chars.filter(isWord).length;
+    let r = startColor[0];
+    let g = startColor[1];
+    let b = startColor[2];
+    let rStep = (endColor[0] - r) / steps;
+    let gStep = (endColor[1] - g) / steps;
+    let bStep = (endColor[2] - b) / steps;
+    let output = "";
+    for (let char of chars){
+        if (isWord(char)) {
+            r += rStep;
+            g += gStep;
+            b += bStep;
+        }
+        output += `\x1B[38;2;${Math.round(r)};${Math.round(g)};${Math.round(b)}m${char}\x1B[39m`;
+    }
+    return bold(output);
+};
+// src/constants.ts
+var LOG_LEVEL = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    log: 3,
+    verbose: 4
+};
+var LOG_TYPES = {
+    // Level error
+    error: {
+        label: "error",
+        level: "error",
+        color: red
+    },
+    // Level warn
+    warn: {
+        label: "warn",
+        level: "warn",
+        color: yellow
+    },
+    // Level info
+    info: {
+        label: "info",
+        level: "info",
+        color: cyan
+    },
+    start: {
+        label: "start",
+        level: "info",
+        color: cyan
+    },
+    ready: {
+        label: "ready",
+        level: "info",
+        color: green
+    },
+    success: {
+        label: "success",
+        level: "info",
+        color: green
+    },
+    // Level log
+    log: {
+        level: "log"
+    },
+    // Level debug
+    debug: {
+        label: "debug",
+        level: "verbose",
+        color: magenta
+    }
+};
+// src/createLogger.ts
+var createLogger = (options = {})=>{
+    let maxLevel = options.level || "log";
+    let log = (type, message, ...args)=>{
+        if (LOG_LEVEL[LOG_TYPES[type].level] > LOG_LEVEL[maxLevel]) return;
+        if (null == message) return console.log();
+        let logType = LOG_TYPES[type];
+        let label = "";
+        let text = "";
+        if ("label" in logType) {
+            label = (logType.label || "").padEnd(7);
+            label = bold(logType.color ? logType.color(label) : label);
+        }
+        if (message instanceof Error) {
+            if (message.stack) {
+                let [name, ...rest] = message.stack.split("\n");
+                if (name.startsWith("Error: ")) name = name.slice(7);
+                text = `${name}
+${gray(rest.join("\n"))}`;
+            } else text = message.message;
+        } else if ("error" === logType.level && "string" == typeof message) {
+            let lines = message.split("\n");
+            text = lines.map((line)=>isErrorStackMessage(line) ? gray(line) : line).join("\n");
+        } else text = `${message}`;
+        console.log(label.length ? `${label} ${text}` : text, ...args);
+    };
+    let logger2 = {
+        greet: (message)=>log("log", gradient(message))
+    };
+    Object.keys(LOG_TYPES).forEach((key)=>{
+        logger2[key] = (...args)=>log(key, ...args);
+    });
+    Object.defineProperty(logger2, "level", {
+        get: ()=>maxLevel,
+        set (val) {
+            maxLevel = val;
+        }
+    });
+    logger2.override = (customLogger)=>{
+        Object.assign(logger2, customLogger);
+    };
+    return logger2;
+};
+// src/index.ts
+var logger = createLogger();
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__("path");
+// EXTERNAL MODULE: ./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/index.js
+var dist = __webpack_require__("./node_modules/.pnpm/fdir@6.4.2_picomatch@4.0.2/node_modules/fdir/dist/index.js");
+// EXTERNAL MODULE: ./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/index.js
+var picomatch = __webpack_require__("./node_modules/.pnpm/picomatch@4.0.2/node_modules/picomatch/index.js");
+// src/index.ts
+// src/utils.ts
+var ESCAPED_WIN32_BACKSLASHES = /\\(?![()[\]{}!+@])/g;
+function convertPosixPathToPattern(path2) {
+    return escapePosixPath(path2);
+}
+function convertWin32PathToPattern(path2) {
+    return escapeWin32Path(path2).replace(ESCAPED_WIN32_BACKSLASHES, "/");
+}
+process.platform;
+var POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
+var WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
+var escapePosixPath = (path2)=>path2.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+var escapeWin32Path = (path2)=>path2.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+process.platform;
+function isDynamicPattern(pattern, options) {
+    if ((null == options ? void 0 : options.caseSensitiveMatch) === false) return true;
+    const scan = picomatch.scan(pattern);
+    return scan.isGlob || scan.negated;
+}
+// src/index.ts
+function normalizePattern(pattern, expandDirectories, cwd, properties, isIgnore) {
+    var _a;
+    let result = pattern;
+    if (pattern.endsWith("/")) result = pattern.slice(0, -1);
+    if (!result.endsWith("*") && expandDirectories) result += "/**";
+    result = external_path_["default"].isAbsolute(result.replace(/\\(?=[()[\]{}!*+?@|])/g, "")) ? external_path_.posix.relative(cwd, result) : external_path_.posix.normalize(result);
+    const parentDirectoryMatch = /^(\/?\.\.)+/.exec(result);
+    if (null == parentDirectoryMatch ? void 0 : parentDirectoryMatch[0]) {
+        const potentialRoot = external_path_.posix.join(cwd, parentDirectoryMatch[0]);
+        if (properties.root.length > potentialRoot.length) {
+            properties.root = potentialRoot;
+            properties.depthOffset = -(parentDirectoryMatch[0].length + 1) / 3;
+        }
+    } else if (!isIgnore && properties.depthOffset >= 0) {
+        const current = result.split("/");
+        null != (_a = properties.commonPath) || (properties.commonPath = current);
+        const newCommonPath = [];
+        for(let i = 0; i < Math.min(properties.commonPath.length, current.length); i++){
+            const part = current[i];
+            if ("**" === part && !current[i + 1]) {
+                newCommonPath.pop();
+                break;
+            }
+            if (part !== properties.commonPath[i] || isDynamicPattern(part) || i === current.length - 1) break;
+            newCommonPath.push(part);
+        }
+        properties.depthOffset = newCommonPath.length;
+        properties.commonPath = newCommonPath;
+        properties.root = newCommonPath.length > 0 ? `${cwd}/${newCommonPath.join("/")}` : cwd;
+    }
+    return result;
+}
+function processPatterns({ patterns, ignore = [], expandDirectories = true }, cwd, properties) {
+    if ("string" == typeof patterns) patterns = [
+        patterns
+    ];
+    else if (!patterns) patterns = [
+        "**/*"
+    ];
+    if ("string" == typeof ignore) ignore = [
+        ignore
+    ];
+    const matchPatterns = [];
+    const ignorePatterns = [];
+    for (const pattern of ignore)if (!pattern.startsWith("!") || "(" === pattern[1]) {
+        const newPattern = normalizePattern(pattern, expandDirectories, cwd, properties, true);
+        ignorePatterns.push(newPattern);
+    }
+    for (const pattern of patterns)if (pattern.startsWith("!") && "(" !== pattern[1]) {
+        if ("!" !== pattern[1] || "(" === pattern[2]) {
+            const newPattern = normalizePattern(pattern.slice(1), expandDirectories, cwd, properties, true);
+            ignorePatterns.push(newPattern);
+        }
+    } else {
+        const newPattern = normalizePattern(pattern, expandDirectories, cwd, properties, false);
+        matchPatterns.push(newPattern);
+    }
+    return {
+        match: matchPatterns,
+        ignore: ignorePatterns
+    };
+}
+function getRelativePath(path2, cwd, root) {
+    return external_path_.posix.relative(cwd, `${root}/${path2}`);
+}
+function processPath(path2, cwd, root, isDirectory, absolute) {
+    const relativePath = absolute ? path2.slice(root.length + 1) || "." : path2;
+    if (root === cwd) return isDirectory && "." !== relativePath ? relativePath.slice(0, -1) : relativePath;
+    return getRelativePath(relativePath, cwd, root);
+}
+function crawl(options, cwd, sync) {
+    const properties = {
+        root: cwd,
+        commonPath: null,
+        depthOffset: 0
+    };
+    const processed = processPatterns(options, cwd, properties);
+    const matcher = picomatch(processed.match, {
+        dot: options.dot,
+        nocase: false === options.caseSensitiveMatch,
+        ignore: processed.ignore
+    });
+    const exclude = picomatch(processed.ignore, {
+        dot: options.dot,
+        nocase: false === options.caseSensitiveMatch
+    });
+    const fdirOptions = {
+        // use relative paths in the matcher
+        filters: [
+            (p, isDirectory)=>matcher(processPath(p, cwd, properties.root, isDirectory, options.absolute))
+        ],
+        exclude: (_, p)=>exclude(processPath(p, cwd, properties.root, true, true)),
+        pathSeparator: "/",
+        relativePaths: true,
+        resolveSymlinks: true
+    };
+    if (options.deep) fdirOptions.maxDepth = Math.round(options.deep - properties.depthOffset);
+    if (options.absolute) {
+        fdirOptions.relativePaths = false;
+        fdirOptions.resolvePaths = true;
+        fdirOptions.includeBasePath = true;
+    }
+    if (false === options.followSymbolicLinks) {
+        fdirOptions.resolveSymlinks = false;
+        fdirOptions.excludeSymlinks = true;
+    }
+    if (options.onlyDirectories) {
+        fdirOptions.excludeFiles = true;
+        fdirOptions.includeDirs = true;
+    } else if (false === options.onlyFiles) fdirOptions.includeDirs = true;
+    properties.root = properties.root.replace(/\\/g, "");
+    const api = new dist.fdir(fdirOptions).crawl(properties.root);
+    if (cwd === properties.root || options.absolute) return sync ? api.sync() : api.withPromise();
+    return sync ? api.sync().map((p)=>getRelativePath(p, cwd, properties.root) + (!p || p.endsWith("/") ? "/" : "")) : api.withPromise().then((paths)=>paths.map((p)=>getRelativePath(p, cwd, properties.root) + (!p || p.endsWith("/") ? "/" : "")));
+}
+async function glob(patternsOrOptions, options) {
+    if (patternsOrOptions && (null == options ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+    const opts = Array.isArray(patternsOrOptions) || "string" == typeof patternsOrOptions ? {
+        ...options,
+        patterns: patternsOrOptions
+    } : patternsOrOptions;
+    const cwd = opts.cwd ? external_path_["default"].resolve(opts.cwd).replace(/\\/g, "/") : process.cwd().replace(/\\/g, "/");
+    return crawl(opts, cwd, false);
+}
+var abbreviates_namespaceObject = 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"}'); // CONCATENATED MODULE: ./node_modules/.pnpm/case-police@0.7.2/node_modules/case-police/dict/brands.json
+var brands_namespaceObject = 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","youtube":"YouTube"}'); // CONCATENATED MODULE: ./node_modules/.pnpm/case-police@0.7.2/node_modules/case-police/dict/general.json
+var general_namespaceObject = 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"}'); // CONCATENATED MODULE: ./node_modules/.pnpm/case-police@0.7.2/node_modules/case-police/dict/products.json
+var products_namespaceObject = 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"}'); // CONCATENATED MODULE: ./node_modules/.pnpm/case-police@0.7.2/node_modules/case-police/dict/softwares.json
+var softwares_namespaceObject = 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","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","graphql":"GraphQL","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","mathieu":"MATHIEU","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"}'); // CONCATENATED MODULE: ./src/dict.ts
+const dict = [
+    ...Object.values(abbreviates_namespaceObject),
+    ...Object.values(brands_namespaceObject),
+    ...Object.values(general_namespaceObject),
+    ...Object.values(products_namespaceObject),
+    ...Object.values(softwares_namespaceObject),
+    'EJS',
+    'Rspack',
+    'Rsbuild',
+    'Rsdoctor',
+    'Rslib',
+    'Rspress',
+    'Rstest',
+    'Rollup',
+    'Parcel',
+    'Vite',
+    'Module Federation',
+    'CSS Modules',
+    'Web Workers',
+    'Create React App',
+    'React Router'
+];
+async function globMarkdownFiles(cwd) {
+    return glob([
+        '**/*.md',
+        '**/*.mdx'
+    ], {
+        cwd,
+        ignore: [
+            '**/node_modules',
+            '**/dist',
+            '**/.git',
+            '**/.cache',
+            '**/temp'
+        ],
+        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 formatLine = (originalLine)=>{
+    let line = originalLine;
+    const words = line.trim().split(/\s+/);
+    const englishWords = [];
+    for(let index = 0; index < words.length; index++){
+        const word = words[index];
+        if (isEnglishWord(word)) englishWords.push(word);
+        if (englishWords.length <= 1 || // ignore terms
+        isTerm(word, originalLine) || // only format the first-char-uppercase English words
+        !isFirstCharUppercase(word)) continue;
+        const lowerCaseWord = word.toLowerCase();
+        if (lowerCaseWord !== word) line = line.replace(new RegExp(`\\b${word}\\b`, 'g'), lowerCaseWord);
+    }
+    return line;
+};
+function formatContent(content) {
+    const lines = content.split('\n');
+    return lines.map((originalLine)=>{
+        if (isTitleLine(originalLine)) return formatLine(originalLine);
+        return originalLine;
+    }).join('\n');
+}
+async function formatFile(filePath) {
+    const content = await __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].promises.readFile(filePath, 'utf-8');
+    const formatted = formatContent(content);
+    const isChanged = formatted !== content;
+    if (isChanged) {
+        await __WEBPACK_EXTERNAL_MODULE_node_fs__["default"].promises.writeFile(filePath, formatted);
+        logger.success(`${picocolors_default().green('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) logger.success(`[heading-case] formatted ${picocolors_default().yellow(count.toString())} files.`);
+}
+export { globMarkdownFiles, headingCase };