@hot-updater/plugin-core 0.16.4 → 0.16.5

package/dist/index.cjs

@@ -8919,6 +8919,545 @@ var __webpack_modules__ = {
             return new RegExp(pattern, onlyFirst ? void 0 : 'g');
         };
     },
+    "../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const stringify = __webpack_require__("../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/stringify.js");
+        const compile = __webpack_require__("../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/compile.js");
+        const expand = __webpack_require__("../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/expand.js");
+        const parse = __webpack_require__("../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/parse.js");
+        const braces = (input, options = {})=>{
+            let output = [];
+            if (Array.isArray(input)) for (let pattern of input){
+                let result = braces.create(pattern, options);
+                if (Array.isArray(result)) output.push(...result);
+                else output.push(result);
+            }
+            else output = [].concat(braces.create(input, options));
+            if (options && true === options.expand && true === options.nodupes) output = [
+                ...new Set(output)
+            ];
+            return output;
+        };
+        braces.parse = (input, options = {})=>parse(input, options);
+        braces.stringify = (input, options = {})=>{
+            if ('string' == typeof input) return stringify(braces.parse(input, options), options);
+            return stringify(input, options);
+        };
+        braces.compile = (input, options = {})=>{
+            if ('string' == typeof input) input = braces.parse(input, options);
+            return compile(input, options);
+        };
+        braces.expand = (input, options = {})=>{
+            if ('string' == typeof input) input = braces.parse(input, options);
+            let result = expand(input, options);
+            if (true === options.noempty) result = result.filter(Boolean);
+            if (true === options.nodupes) result = [
+                ...new Set(result)
+            ];
+            return result;
+        };
+        braces.create = (input, options = {})=>{
+            if ('' === input || input.length < 3) return [
+                input
+            ];
+            return true !== options.expand ? braces.compile(input, options) : braces.expand(input, options);
+        };
+        module.exports = braces;
+    },
+    "../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/compile.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const fill = __webpack_require__("../../node_modules/.pnpm/fill-range@7.0.1/node_modules/fill-range/index.js");
+        const utils = __webpack_require__("../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/utils.js");
+        const compile = (ast, options = {})=>{
+            let walk = (node, parent = {})=>{
+                let invalidBlock = utils.isInvalidBrace(parent);
+                let invalidNode = true === node.invalid && true === options.escapeInvalid;
+                let invalid = true === invalidBlock || true === invalidNode;
+                let prefix = true === options.escapeInvalid ? '\\' : '';
+                let output = '';
+                if (true === node.isOpen) return prefix + node.value;
+                if (true === node.isClose) return prefix + node.value;
+                if ('open' === node.type) return invalid ? prefix + node.value : '(';
+                if ('close' === node.type) return invalid ? prefix + node.value : ')';
+                if ('comma' === node.type) return 'comma' === node.prev.type ? '' : invalid ? node.value : '|';
+                if (node.value) return node.value;
+                if (node.nodes && node.ranges > 0) {
+                    let args = utils.reduce(node.nodes);
+                    let range = fill(...args, {
+                        ...options,
+                        wrap: false,
+                        toRegex: true
+                    });
+                    if (0 !== range.length) return args.length > 1 && range.length > 1 ? `(${range})` : range;
+                }
+                if (node.nodes) for (let child of node.nodes)output += walk(child, node);
+                return output;
+            };
+            return walk(ast);
+        };
+        module.exports = compile;
+    },
+    "../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/constants.js": function(module) {
+        "use strict";
+        module.exports = {
+            MAX_LENGTH: 65536,
+            CHAR_0: '0',
+            CHAR_9: '9',
+            CHAR_UPPERCASE_A: 'A',
+            CHAR_LOWERCASE_A: 'a',
+            CHAR_UPPERCASE_Z: 'Z',
+            CHAR_LOWERCASE_Z: 'z',
+            CHAR_LEFT_PARENTHESES: '(',
+            CHAR_RIGHT_PARENTHESES: ')',
+            CHAR_ASTERISK: '*',
+            CHAR_AMPERSAND: '&',
+            CHAR_AT: '@',
+            CHAR_BACKSLASH: '\\',
+            CHAR_BACKTICK: '`',
+            CHAR_CARRIAGE_RETURN: '\r',
+            CHAR_CIRCUMFLEX_ACCENT: '^',
+            CHAR_COLON: ':',
+            CHAR_COMMA: ',',
+            CHAR_DOLLAR: '$',
+            CHAR_DOT: '.',
+            CHAR_DOUBLE_QUOTE: '"',
+            CHAR_EQUAL: '=',
+            CHAR_EXCLAMATION_MARK: '!',
+            CHAR_FORM_FEED: '\f',
+            CHAR_FORWARD_SLASH: '/',
+            CHAR_HASH: '#',
+            CHAR_HYPHEN_MINUS: '-',
+            CHAR_LEFT_ANGLE_BRACKET: '<',
+            CHAR_LEFT_CURLY_BRACE: '{',
+            CHAR_LEFT_SQUARE_BRACKET: '[',
+            CHAR_LINE_FEED: '\n',
+            CHAR_NO_BREAK_SPACE: '\u00A0',
+            CHAR_PERCENT: '%',
+            CHAR_PLUS: '+',
+            CHAR_QUESTION_MARK: '?',
+            CHAR_RIGHT_ANGLE_BRACKET: '>',
+            CHAR_RIGHT_CURLY_BRACE: '}',
+            CHAR_RIGHT_SQUARE_BRACKET: ']',
+            CHAR_SEMICOLON: ';',
+            CHAR_SINGLE_QUOTE: '\'',
+            CHAR_SPACE: ' ',
+            CHAR_TAB: '\t',
+            CHAR_UNDERSCORE: '_',
+            CHAR_VERTICAL_LINE: '|',
+            CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF'
+        };
+    },
+    "../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/expand.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const fill = __webpack_require__("../../node_modules/.pnpm/fill-range@7.0.1/node_modules/fill-range/index.js");
+        const stringify = __webpack_require__("../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/stringify.js");
+        const utils = __webpack_require__("../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/utils.js");
+        const append = (queue = '', stash = '', enclose = false)=>{
+            let result = [];
+            queue = [].concat(queue);
+            stash = [].concat(stash);
+            if (!stash.length) return queue;
+            if (!queue.length) return enclose ? utils.flatten(stash).map((ele)=>`{${ele}}`) : stash;
+            for (let item of queue)if (Array.isArray(item)) for (let value1 of item)result.push(append(value1, stash, enclose));
+            else for (let ele of stash){
+                if (true === enclose && 'string' == typeof ele) ele = `{${ele}}`;
+                result.push(Array.isArray(ele) ? append(item, ele, enclose) : item + ele);
+            }
+            return utils.flatten(result);
+        };
+        const expand = (ast, options = {})=>{
+            let rangeLimit = void 0 === options.rangeLimit ? 1000 : options.rangeLimit;
+            let walk = (node, parent = {})=>{
+                node.queue = [];
+                let p = parent;
+                let q = parent.queue;
+                while('brace' !== p.type && 'root' !== p.type && p.parent){
+                    p = p.parent;
+                    q = p.queue;
+                }
+                if (node.invalid || node.dollar) return void q.push(append(q.pop(), stringify(node, options)));
+                if ('brace' === node.type && true !== node.invalid && 2 === node.nodes.length) return void q.push(append(q.pop(), [
+                    '{}'
+                ]));
+                if (node.nodes && node.ranges > 0) {
+                    let args = utils.reduce(node.nodes);
+                    if (utils.exceedsLimit(...args, options.step, rangeLimit)) throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
+                    let range = fill(...args, options);
+                    if (0 === range.length) range = stringify(node, options);
+                    q.push(append(q.pop(), range));
+                    node.nodes = [];
+                    return;
+                }
+                let enclose = utils.encloseBrace(node);
+                let queue = node.queue;
+                let block = node;
+                while('brace' !== block.type && 'root' !== block.type && block.parent){
+                    block = block.parent;
+                    queue = block.queue;
+                }
+                for(let i = 0; i < node.nodes.length; i++){
+                    let child = node.nodes[i];
+                    if ('comma' === child.type && 'brace' === node.type) {
+                        if (1 === i) queue.push('');
+                        queue.push('');
+                        continue;
+                    }
+                    if ('close' === child.type) {
+                        q.push(append(q.pop(), queue, enclose));
+                        continue;
+                    }
+                    if (child.value && 'open' !== child.type) {
+                        queue.push(append(queue.pop(), child.value));
+                        continue;
+                    }
+                    if (child.nodes) walk(child, node);
+                }
+                return queue;
+            };
+            return utils.flatten(walk(ast));
+        };
+        module.exports = expand;
+    },
+    "../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/parse.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const stringify = __webpack_require__("../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/stringify.js");
+        const { MAX_LENGTH, CHAR_BACKSLASH, CHAR_BACKTICK, CHAR_COMMA, CHAR_DOT, CHAR_LEFT_PARENTHESES, CHAR_RIGHT_PARENTHESES, CHAR_LEFT_CURLY_BRACE, CHAR_RIGHT_CURLY_BRACE, CHAR_LEFT_SQUARE_BRACKET, CHAR_RIGHT_SQUARE_BRACKET, CHAR_DOUBLE_QUOTE, CHAR_SINGLE_QUOTE, CHAR_NO_BREAK_SPACE, CHAR_ZERO_WIDTH_NOBREAK_SPACE } = __webpack_require__("../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/constants.js");
+        const parse = (input, options = {})=>{
+            if ('string' != typeof input) throw new TypeError('Expected a string');
+            let opts = options || {};
+            let max = 'number' == typeof opts.maxLength ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+            if (input.length > max) throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
+            let ast = {
+                type: 'root',
+                input,
+                nodes: []
+            };
+            let stack = [
+                ast
+            ];
+            let block = ast;
+            let prev = ast;
+            let brackets = 0;
+            let length = input.length;
+            let index = 0;
+            let depth = 0;
+            let value1;
+            const advance = ()=>input[index++];
+            const push = (node)=>{
+                if ('text' === node.type && 'dot' === prev.type) prev.type = 'text';
+                if (prev && 'text' === prev.type && 'text' === node.type) {
+                    prev.value += node.value;
+                    return;
+                }
+                block.nodes.push(node);
+                node.parent = block;
+                node.prev = prev;
+                prev = node;
+                return node;
+            };
+            push({
+                type: 'bos'
+            });
+            while(index < length){
+                block = stack[stack.length - 1];
+                value1 = advance();
+                if (value1 === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value1 === CHAR_NO_BREAK_SPACE) continue;
+                if (value1 === CHAR_BACKSLASH) {
+                    push({
+                        type: 'text',
+                        value: (options.keepEscaping ? value1 : '') + advance()
+                    });
+                    continue;
+                }
+                if (value1 === CHAR_RIGHT_SQUARE_BRACKET) {
+                    push({
+                        type: 'text',
+                        value: '\\' + value1
+                    });
+                    continue;
+                }
+                if (value1 === CHAR_LEFT_SQUARE_BRACKET) {
+                    brackets++;
+                    let next;
+                    while(index < length && (next = advance())){
+                        value1 += next;
+                        if (next === CHAR_LEFT_SQUARE_BRACKET) {
+                            brackets++;
+                            continue;
+                        }
+                        if (next === CHAR_BACKSLASH) {
+                            value1 += advance();
+                            continue;
+                        }
+                        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+                            brackets--;
+                            if (0 === brackets) break;
+                        }
+                    }
+                    push({
+                        type: 'text',
+                        value: value1
+                    });
+                    continue;
+                }
+                if (value1 === CHAR_LEFT_PARENTHESES) {
+                    block = push({
+                        type: 'paren',
+                        nodes: []
+                    });
+                    stack.push(block);
+                    push({
+                        type: 'text',
+                        value: value1
+                    });
+                    continue;
+                }
+                if (value1 === CHAR_RIGHT_PARENTHESES) {
+                    if ('paren' !== block.type) {
+                        push({
+                            type: 'text',
+                            value: value1
+                        });
+                        continue;
+                    }
+                    block = stack.pop();
+                    push({
+                        type: 'text',
+                        value: value1
+                    });
+                    block = stack[stack.length - 1];
+                    continue;
+                }
+                if (value1 === CHAR_DOUBLE_QUOTE || value1 === CHAR_SINGLE_QUOTE || value1 === CHAR_BACKTICK) {
+                    let open = value1;
+                    let next;
+                    if (true !== options.keepQuotes) value1 = '';
+                    while(index < length && (next = advance())){
+                        if (next === CHAR_BACKSLASH) {
+                            value1 += next + advance();
+                            continue;
+                        }
+                        if (next === open) {
+                            if (true === options.keepQuotes) value1 += next;
+                            break;
+                        }
+                        value1 += next;
+                    }
+                    push({
+                        type: 'text',
+                        value: value1
+                    });
+                    continue;
+                }
+                if (value1 === CHAR_LEFT_CURLY_BRACE) {
+                    depth++;
+                    let dollar = prev.value && '$' === prev.value.slice(-1) || true === block.dollar;
+                    let brace = {
+                        type: 'brace',
+                        open: true,
+                        close: false,
+                        dollar,
+                        depth,
+                        commas: 0,
+                        ranges: 0,
+                        nodes: []
+                    };
+                    block = push(brace);
+                    stack.push(block);
+                    push({
+                        type: 'open',
+                        value: value1
+                    });
+                    continue;
+                }
+                if (value1 === CHAR_RIGHT_CURLY_BRACE) {
+                    if ('brace' !== block.type) {
+                        push({
+                            type: 'text',
+                            value: value1
+                        });
+                        continue;
+                    }
+                    let type = 'close';
+                    block = stack.pop();
+                    block.close = true;
+                    push({
+                        type,
+                        value: value1
+                    });
+                    depth--;
+                    block = stack[stack.length - 1];
+                    continue;
+                }
+                if (value1 === CHAR_COMMA && depth > 0) {
+                    if (block.ranges > 0) {
+                        block.ranges = 0;
+                        let open = block.nodes.shift();
+                        block.nodes = [
+                            open,
+                            {
+                                type: 'text',
+                                value: stringify(block)
+                            }
+                        ];
+                    }
+                    push({
+                        type: 'comma',
+                        value: value1
+                    });
+                    block.commas++;
+                    continue;
+                }
+                if (value1 === CHAR_DOT && depth > 0 && 0 === block.commas) {
+                    let siblings = block.nodes;
+                    if (0 === depth || 0 === siblings.length) {
+                        push({
+                            type: 'text',
+                            value: value1
+                        });
+                        continue;
+                    }
+                    if ('dot' === prev.type) {
+                        block.range = [];
+                        prev.value += value1;
+                        prev.type = 'range';
+                        if (3 !== block.nodes.length && 5 !== block.nodes.length) {
+                            block.invalid = true;
+                            block.ranges = 0;
+                            prev.type = 'text';
+                            continue;
+                        }
+                        block.ranges++;
+                        block.args = [];
+                        continue;
+                    }
+                    if ('range' === prev.type) {
+                        siblings.pop();
+                        let before = siblings[siblings.length - 1];
+                        before.value += prev.value + value1;
+                        prev = before;
+                        block.ranges--;
+                        continue;
+                    }
+                    push({
+                        type: 'dot',
+                        value: value1
+                    });
+                    continue;
+                }
+                push({
+                    type: 'text',
+                    value: value1
+                });
+            }
+            do {
+                block = stack.pop();
+                if ('root' !== block.type) {
+                    block.nodes.forEach((node)=>{
+                        if (!node.nodes) {
+                            if ('open' === node.type) node.isOpen = true;
+                            if ('close' === node.type) node.isClose = true;
+                            if (!node.nodes) node.type = 'text';
+                            node.invalid = true;
+                        }
+                    });
+                    let parent = stack[stack.length - 1];
+                    let index = parent.nodes.indexOf(block);
+                    parent.nodes.splice(index, 1, ...block.nodes);
+                }
+            }while (stack.length > 0);
+            push({
+                type: 'eos'
+            });
+            return ast;
+        };
+        module.exports = parse;
+    },
+    "../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/stringify.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const utils = __webpack_require__("../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/utils.js");
+        module.exports = (ast, options = {})=>{
+            let stringify = (node, parent = {})=>{
+                let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
+                let invalidNode = true === node.invalid && true === options.escapeInvalid;
+                let output = '';
+                if (node.value) {
+                    if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) return '\\' + node.value;
+                    return node.value;
+                }
+                if (node.value) return node.value;
+                if (node.nodes) for (let child of node.nodes)output += stringify(child);
+                return output;
+            };
+            return stringify(ast);
+        };
+    },
+    "../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/utils.js": function(__unused_webpack_module, exports1) {
+        "use strict";
+        exports1.isInteger = (num)=>{
+            if ('number' == typeof num) return Number.isInteger(num);
+            if ('string' == typeof num && '' !== num.trim()) return Number.isInteger(Number(num));
+            return false;
+        };
+        exports1.find = (node, type)=>node.nodes.find((node)=>node.type === type);
+        exports1.exceedsLimit = (min, max, step = 1, limit)=>{
+            if (false === limit) return false;
+            if (!exports1.isInteger(min) || !exports1.isInteger(max)) return false;
+            return (Number(max) - Number(min)) / Number(step) >= limit;
+        };
+        exports1.escapeNode = (block, n = 0, type)=>{
+            let node = block.nodes[n];
+            if (!node) return;
+            if (type && node.type === type || 'open' === node.type || 'close' === node.type) {
+                if (true !== node.escaped) {
+                    node.value = '\\' + node.value;
+                    node.escaped = true;
+                }
+            }
+        };
+        exports1.encloseBrace = (node)=>{
+            if ('brace' !== node.type) return false;
+            if (node.commas >> 0 + node.ranges >> 0 === 0) {
+                node.invalid = true;
+                return true;
+            }
+            return false;
+        };
+        exports1.isInvalidBrace = (block)=>{
+            if ('brace' !== block.type) return false;
+            if (true === block.invalid || block.dollar) return true;
+            if (block.commas >> 0 + block.ranges >> 0 === 0) {
+                block.invalid = true;
+                return true;
+            }
+            if (true !== block.open || true !== block.close) {
+                block.invalid = true;
+                return true;
+            }
+            return false;
+        };
+        exports1.isOpenOrClose = (node)=>{
+            if ('open' === node.type || 'close' === node.type) return true;
+            return true === node.open || true === node.close;
+        };
+        exports1.reduce = (nodes)=>nodes.reduce((acc, node)=>{
+                if ('text' === node.type) acc.push(node.value);
+                if ('range' === node.type) node.type = 'text';
+                return acc;
+            }, []);
+        exports1.flatten = (...args)=>{
+            const result = [];
+            const flat = (arr)=>{
+                for(let i = 0; i < arr.length; i++){
+                    let ele = arr[i];
+                    Array.isArray(ele) ? flat(ele, result) : void 0 !== ele && result.push(ele);
+                }
+                return result;
+            };
+            flat(args);
+            return result;
+        };
+    },
     "../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
         "use strict";
         const stringify = __webpack_require__("../../node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js");
@@ -10852,7 +11391,7 @@ var __webpack_modules__ = {
         exports1.removeDuplicateSlashes = exports1.matchAny = exports1.convertPatternsToRe = exports1.makeRe = exports1.getPatternParts = exports1.expandBraceExpansion = exports1.expandPatternsWithBraceExpansion = exports1.isAffectDepthOfReadingPattern = exports1.endsWithSlashGlobStar = exports1.hasGlobStar = exports1.getBaseDirectory = exports1.isPatternRelatedToParentDirectory = exports1.getPatternsOutsideCurrentDirectory = exports1.getPatternsInsideCurrentDirectory = exports1.getPositivePatterns = exports1.getNegativePatterns = exports1.isPositivePattern = exports1.isNegativePattern = exports1.convertToNegativePattern = exports1.convertToPositivePattern = exports1.isDynamicPattern = exports1.isStaticPattern = void 0;
         const path = __webpack_require__("path");
         const globParent = __webpack_require__("../../node_modules/.pnpm/glob-parent@5.1.2/node_modules/glob-parent/index.js");
-        const micromatch = __webpack_require__("../../node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js");
+        const micromatch = __webpack_require__("../../node_modules/.pnpm/micromatch@4.0.5/node_modules/micromatch/index.js");
         const GLOBSTAR = '**';
         const ESCAPE_SYMBOL = '\\';
         const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
@@ -11185,49 +11724,221 @@ var __webpack_modules__ = {
                     cb(null, res);
                 }, cb);
             }
-            var queue = fastqueue(context, asyncWrapper, concurrency);
-            var pushCb = queue.push;
-            var unshiftCb = queue.unshift;
-            queue.push = push;
-            queue.unshift = unshift;
-            queue.drained = drained;
-            return queue;
-            function push(value1) {
-                var p = new Promise(function(resolve, reject) {
-                    pushCb(value1, function(err, result) {
-                        if (err) return void reject(err);
-                        resolve(result);
-                    });
-                });
-                p.catch(noop);
-                return p;
+            var queue = fastqueue(context, asyncWrapper, concurrency);
+            var pushCb = queue.push;
+            var unshiftCb = queue.unshift;
+            queue.push = push;
+            queue.unshift = unshift;
+            queue.drained = drained;
+            return queue;
+            function push(value1) {
+                var p = new Promise(function(resolve, reject) {
+                    pushCb(value1, function(err, result) {
+                        if (err) return void reject(err);
+                        resolve(result);
+                    });
+                });
+                p.catch(noop);
+                return p;
+            }
+            function unshift(value1) {
+                var p = new Promise(function(resolve, reject) {
+                    unshiftCb(value1, function(err, result) {
+                        if (err) return void reject(err);
+                        resolve(result);
+                    });
+                });
+                p.catch(noop);
+                return p;
+            }
+            function drained() {
+                if (queue.idle()) return new Promise(function(resolve) {
+                    resolve();
+                });
+                var previousDrain = queue.drain;
+                var p = new Promise(function(resolve) {
+                    queue.drain = function() {
+                        previousDrain();
+                        resolve();
+                    };
+                });
+                return p;
+            }
+        }
+        module.exports = fastqueue;
+        module.exports.promise = queueAsPromised;
+    },
+    "../../node_modules/.pnpm/fill-range@7.0.1/node_modules/fill-range/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        /*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */ const util = __webpack_require__("util");
+        const toRegexRange = __webpack_require__("../../node_modules/.pnpm/to-regex-range@5.0.1/node_modules/to-regex-range/index.js");
+        const isObject = (val)=>null !== val && 'object' == typeof val && !Array.isArray(val);
+        const transform = (toNumber)=>(value1)=>true === toNumber ? Number(value1) : String(value1);
+        const isValidValue = (value1)=>'number' == typeof value1 || 'string' == typeof value1 && '' !== value1;
+        const isNumber = (num)=>Number.isInteger(+num);
+        const zeros = (input)=>{
+            let value1 = `${input}`;
+            let index = -1;
+            if ('-' === value1[0]) value1 = value1.slice(1);
+            if ('0' === value1) return false;
+            while('0' === value1[++index]);
+            return index > 0;
+        };
+        const stringify = (start, end, options)=>{
+            if ('string' == typeof start || 'string' == typeof end) return true;
+            return true === options.stringify;
+        };
+        const pad = (input, maxLength, toNumber)=>{
+            if (maxLength > 0) {
+                let dash = '-' === input[0] ? '-' : '';
+                if (dash) input = input.slice(1);
+                input = dash + input.padStart(dash ? maxLength - 1 : maxLength, '0');
+            }
+            if (false === toNumber) return String(input);
+            return input;
+        };
+        const toMaxLen = (input, maxLength)=>{
+            let negative = '-' === input[0] ? '-' : '';
+            if (negative) {
+                input = input.slice(1);
+                maxLength--;
+            }
+            while(input.length < maxLength)input = '0' + input;
+            return negative ? '-' + input : input;
+        };
+        const toSequence = (parts, options)=>{
+            parts.negatives.sort((a, b)=>a < b ? -1 : a > b ? 1 : 0);
+            parts.positives.sort((a, b)=>a < b ? -1 : a > b ? 1 : 0);
+            let prefix = options.capture ? '' : '?:';
+            let positives = '';
+            let negatives = '';
+            let result;
+            if (parts.positives.length) positives = parts.positives.join('|');
+            if (parts.negatives.length) negatives = `-(${prefix}${parts.negatives.join('|')})`;
+            result = positives && negatives ? `${positives}|${negatives}` : positives || negatives;
+            if (options.wrap) return `(${prefix}${result})`;
+            return result;
+        };
+        const toRange = (a, b, isNumbers, options)=>{
+            if (isNumbers) return toRegexRange(a, b, {
+                wrap: false,
+                ...options
+            });
+            let start = String.fromCharCode(a);
+            if (a === b) return start;
+            let stop = String.fromCharCode(b);
+            return `[${start}-${stop}]`;
+        };
+        const toRegex = (start, end, options)=>{
+            if (Array.isArray(start)) {
+                let wrap = true === options.wrap;
+                let prefix = options.capture ? '' : '?:';
+                return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
+            }
+            return toRegexRange(start, end, options);
+        };
+        const rangeError = (...args)=>new RangeError('Invalid range arguments: ' + util.inspect(...args));
+        const invalidRange = (start, end, options)=>{
+            if (true === options.strictRanges) throw rangeError([
+                start,
+                end
+            ]);
+            return [];
+        };
+        const invalidStep = (step, options)=>{
+            if (true === options.strictRanges) throw new TypeError(`Expected step "${step}" to be a number`);
+            return [];
+        };
+        const fillNumbers = (start, end, step = 1, options = {})=>{
+            let a = Number(start);
+            let b = Number(end);
+            if (!Number.isInteger(a) || !Number.isInteger(b)) {
+                if (true === options.strictRanges) throw rangeError([
+                    start,
+                    end
+                ]);
+                return [];
+            }
+            if (0 === a) a = 0;
+            if (0 === b) b = 0;
+            let descending = a > b;
+            let startString = String(start);
+            let endString = String(end);
+            let stepString = String(step);
+            step = Math.max(Math.abs(step), 1);
+            let padded = zeros(startString) || zeros(endString) || zeros(stepString);
+            let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
+            let toNumber = false === padded && false === stringify(start, end, options);
+            let format = options.transform || transform(toNumber);
+            if (options.toRegex && 1 === step) return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
+            let parts = {
+                negatives: [],
+                positives: []
+            };
+            let push = (num)=>parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));
+            let range = [];
+            let index = 0;
+            while(descending ? a >= b : a <= b){
+                if (true === options.toRegex && step > 1) push(a);
+                else range.push(pad(format(a, index), maxLen, toNumber));
+                a = descending ? a - step : a + step;
+                index++;
             }
-            function unshift(value1) {
-                var p = new Promise(function(resolve, reject) {
-                    unshiftCb(value1, function(err, result) {
-                        if (err) return void reject(err);
-                        resolve(result);
-                    });
-                });
-                p.catch(noop);
-                return p;
+            if (true === options.toRegex) return step > 1 ? toSequence(parts, options) : toRegex(range, null, {
+                wrap: false,
+                ...options
+            });
+            return range;
+        };
+        const fillLetters = (start, end, step = 1, options = {})=>{
+            if (!isNumber(start) && start.length > 1 || !isNumber(end) && end.length > 1) return invalidRange(start, end, options);
+            let format = options.transform || ((val)=>String.fromCharCode(val));
+            let a = `${start}`.charCodeAt(0);
+            let b = `${end}`.charCodeAt(0);
+            let descending = a > b;
+            let min = Math.min(a, b);
+            let max = Math.max(a, b);
+            if (options.toRegex && 1 === step) return toRange(min, max, false, options);
+            let range = [];
+            let index = 0;
+            while(descending ? a >= b : a <= b){
+                range.push(format(a, index));
+                a = descending ? a - step : a + step;
+                index++;
             }
-            function drained() {
-                if (queue.idle()) return new Promise(function(resolve) {
-                    resolve();
-                });
-                var previousDrain = queue.drain;
-                var p = new Promise(function(resolve) {
-                    queue.drain = function() {
-                        previousDrain();
-                        resolve();
-                    };
-                });
-                return p;
+            if (true === options.toRegex) return toRegex(range, null, {
+                wrap: false,
+                options
+            });
+            return range;
+        };
+        const fill = (start, end, step, options = {})=>{
+            if (null == end && isValidValue(start)) return [
+                start
+            ];
+            if (!isValidValue(start) || !isValidValue(end)) return invalidRange(start, end, options);
+            if ('function' == typeof step) return fill(start, end, 1, {
+                transform: step
+            });
+            if (isObject(step)) return fill(start, end, 0, step);
+            let opts = {
+                ...options
+            };
+            if (true === opts.capture) opts.wrap = true;
+            step = step || opts.step || 1;
+            if (!isNumber(step)) {
+                if (null != step && !isObject(step)) return invalidStep(step, opts);
+                return fill(start, end, 1, step);
             }
-        }
-        module.exports = fastqueue;
-        module.exports.promise = queueAsPromised;
+            if (isNumber(start) && isNumber(end)) return fillNumbers(start, end, step, opts);
+            return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
+        };
+        module.exports = fill;
     },
     "../../node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
         "use strict";
@@ -17752,6 +18463,145 @@ var __webpack_modules__ = {
             return streams;
         }
     },
+    "../../node_modules/.pnpm/micromatch@4.0.5/node_modules/micromatch/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const util = __webpack_require__("util");
+        const braces = __webpack_require__("../../node_modules/.pnpm/braces@3.0.2/node_modules/braces/index.js");
+        const picomatch = __webpack_require__("../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/index.js");
+        const utils = __webpack_require__("../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js");
+        const isEmptyString = (val)=>'' === val || './' === val;
+        const micromatch = (list, patterns, options)=>{
+            patterns = [].concat(patterns);
+            list = [].concat(list);
+            let omit = new Set();
+            let keep = new Set();
+            let items = new Set();
+            let negatives = 0;
+            let onResult = (state)=>{
+                items.add(state.output);
+                if (options && options.onResult) options.onResult(state);
+            };
+            for(let i = 0; i < patterns.length; i++){
+                let isMatch = picomatch(String(patterns[i]), {
+                    ...options,
+                    onResult
+                }, true);
+                let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
+                if (negated) negatives++;
+                for (let item of list){
+                    let matched = isMatch(item, true);
+                    let match = negated ? !matched.isMatch : matched.isMatch;
+                    if (match) if (negated) omit.add(matched.output);
+                    else {
+                        omit.delete(matched.output);
+                        keep.add(matched.output);
+                    }
+                }
+            }
+            let result = negatives === patterns.length ? [
+                ...items
+            ] : [
+                ...keep
+            ];
+            let matches = result.filter((item)=>!omit.has(item));
+            if (options && 0 === matches.length) {
+                if (true === options.failglob) throw new Error(`No matches found for "${patterns.join(', ')}"`);
+                if (true === options.nonull || true === options.nullglob) return options.unescape ? patterns.map((p)=>p.replace(/\\/g, '')) : patterns;
+            }
+            return matches;
+        };
+        micromatch.match = micromatch;
+        micromatch.matcher = (pattern, options)=>picomatch(pattern, options);
+        micromatch.isMatch = (str, patterns, options)=>picomatch(patterns, options)(str);
+        micromatch.any = micromatch.isMatch;
+        micromatch.not = (list, patterns, options = {})=>{
+            patterns = [].concat(patterns).map(String);
+            let result = new Set();
+            let items = [];
+            let onResult = (state)=>{
+                if (options.onResult) options.onResult(state);
+                items.push(state.output);
+            };
+            let matches = new Set(micromatch(list, patterns, {
+                ...options,
+                onResult
+            }));
+            for (let item of items)if (!matches.has(item)) result.add(item);
+            return [
+                ...result
+            ];
+        };
+        micromatch.contains = (str, pattern, options)=>{
+            if ('string' != typeof str) throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+            if (Array.isArray(pattern)) return pattern.some((p)=>micromatch.contains(str, p, options));
+            if ('string' == typeof pattern) {
+                if (isEmptyString(str) || isEmptyString(pattern)) return false;
+                if (str.includes(pattern) || str.startsWith('./') && str.slice(2).includes(pattern)) return true;
+            }
+            return micromatch.isMatch(str, pattern, {
+                ...options,
+                contains: true
+            });
+        };
+        micromatch.matchKeys = (obj, patterns, options)=>{
+            if (!utils.isObject(obj)) throw new TypeError('Expected the first argument to be an object');
+            let keys = micromatch(Object.keys(obj), patterns, options);
+            let res = {};
+            for (let key of keys)res[key] = obj[key];
+            return res;
+        };
+        micromatch.some = (list, patterns, options)=>{
+            let items = [].concat(list);
+            for (let pattern of [].concat(patterns)){
+                let isMatch = picomatch(String(pattern), options);
+                if (items.some((item)=>isMatch(item))) return true;
+            }
+            return false;
+        };
+        micromatch.every = (list, patterns, options)=>{
+            let items = [].concat(list);
+            for (let pattern of [].concat(patterns)){
+                let isMatch = picomatch(String(pattern), options);
+                if (!items.every((item)=>isMatch(item))) return false;
+            }
+            return true;
+        };
+        micromatch.all = (str, patterns, options)=>{
+            if ('string' != typeof str) throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+            return [].concat(patterns).every((p)=>picomatch(p, options)(str));
+        };
+        micromatch.capture = (glob, input, options)=>{
+            let posix = utils.isWindows(options);
+            let regex = picomatch.makeRe(String(glob), {
+                ...options,
+                capture: true
+            });
+            let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
+            if (match) return match.slice(1).map((v)=>void 0 === v ? '' : v);
+        };
+        micromatch.makeRe = (...args)=>picomatch.makeRe(...args);
+        micromatch.scan = (...args)=>picomatch.scan(...args);
+        micromatch.parse = (patterns, options)=>{
+            let res = [];
+            for (let pattern of [].concat(patterns || []))for (let str of braces(String(pattern), options))res.push(picomatch.parse(str, options));
+            return res;
+        };
+        micromatch.braces = (pattern, options)=>{
+            if ('string' != typeof pattern) throw new TypeError('Expected a string');
+            if (options && true === options.nobrace || !/\{.*\}/.test(pattern)) return [
+                pattern
+            ];
+            return braces(pattern, options);
+        };
+        micromatch.braceExpand = (pattern, options)=>{
+            if ('string' != typeof pattern) throw new TypeError('Expected a string');
+            return micromatch.braces(pattern, {
+                ...options,
+                expand: true
+            });
+        };
+        module.exports = micromatch;
+    },
     "../../node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
         "use strict";
         const util = __webpack_require__("util");