@powerlines/plugin-rspack 0.5.261 → 0.5.263

package/dist/unplugin-C-ffDFJ6.cjs

@@ -1,2359 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let powerlines_lib_unplugin = require("powerlines/lib/unplugin");
-let node_path = require("node:path");
-node_path = __toESM(node_path);
-let node_buffer = require("node:buffer");
-let node_fs = require("node:fs");
-node_fs = __toESM(node_fs);
-require("node:process");
-require("node:querystring");
-
-//#region ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js
-var require_constants = /* @__PURE__ */ __commonJSMin(((exports, 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 POSIX_CHARS = {
-		DOT_LITERAL,
-		PLUS_LITERAL,
-		QMARK_LITERAL,
-		SLASH_LITERAL,
-		ONE_CHAR,
-		QMARK,
-		END_ANCHOR,
-		DOTS_SLASH,
-		NO_DOT: `(?!${DOT_LITERAL})`,
-		NO_DOTS: `(?!${START_ANCHOR}${DOTS_SLASH})`,
-		NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`,
-		NO_DOTS_SLASH: `(?!${DOTS_SLASH})`,
-		QMARK_NO_DOT: `[^.${SLASH_LITERAL}]`,
-		STAR: `${QMARK}*?`,
-		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$1 = {
-		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: 1024 * 64,
-		POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
-		REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
-		REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
-		REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
-		REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
-		REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
-		REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
-		REPLACEMENTS: {
-			__proto__: null,
-			"***": "*",
-			"**/**": "**",
-			"**/**/**": "**"
-		},
-		CHAR_0: 48,
-		CHAR_9: 57,
-		CHAR_UPPERCASE_A: 65,
-		CHAR_LOWERCASE_A: 97,
-		CHAR_UPPERCASE_Z: 90,
-		CHAR_LOWERCASE_Z: 122,
-		CHAR_LEFT_PARENTHESES: 40,
-		CHAR_RIGHT_PARENTHESES: 41,
-		CHAR_ASTERISK: 42,
-		CHAR_AMPERSAND: 38,
-		CHAR_AT: 64,
-		CHAR_BACKWARD_SLASH: 92,
-		CHAR_CARRIAGE_RETURN: 13,
-		CHAR_CIRCUMFLEX_ACCENT: 94,
-		CHAR_COLON: 58,
-		CHAR_COMMA: 44,
-		CHAR_DOT: 46,
-		CHAR_DOUBLE_QUOTE: 34,
-		CHAR_EQUAL: 61,
-		CHAR_EXCLAMATION_MARK: 33,
-		CHAR_FORM_FEED: 12,
-		CHAR_FORWARD_SLASH: 47,
-		CHAR_GRAVE_ACCENT: 96,
-		CHAR_HASH: 35,
-		CHAR_HYPHEN_MINUS: 45,
-		CHAR_LEFT_ANGLE_BRACKET: 60,
-		CHAR_LEFT_CURLY_BRACE: 123,
-		CHAR_LEFT_SQUARE_BRACKET: 91,
-		CHAR_LINE_FEED: 10,
-		CHAR_NO_BREAK_SPACE: 160,
-		CHAR_PERCENT: 37,
-		CHAR_PLUS: 43,
-		CHAR_QUESTION_MARK: 63,
-		CHAR_RIGHT_ANGLE_BRACKET: 62,
-		CHAR_RIGHT_CURLY_BRACE: 125,
-		CHAR_RIGHT_SQUARE_BRACKET: 93,
-		CHAR_SEMICOLON: 59,
-		CHAR_SINGLE_QUOTE: 39,
-		CHAR_SPACE: 32,
-		CHAR_TAB: 9,
-		CHAR_UNDERSCORE: 95,
-		CHAR_VERTICAL_LINE: 124,
-		CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
-		extglobChars(chars$1) {
-			return {
-				"!": {
-					type: "negate",
-					open: "(?:(?!(?:",
-					close: `))${chars$1.STAR})`
-				},
-				"?": {
-					type: "qmark",
-					open: "(?:",
-					close: ")?"
-				},
-				"+": {
-					type: "plus",
-					open: "(?:",
-					close: ")+"
-				},
-				"*": {
-					type: "star",
-					open: "(?:",
-					close: ")*"
-				},
-				"@": {
-					type: "at",
-					open: "(?:",
-					close: ")"
-				}
-			};
-		},
-		globChars(win32) {
-			return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
-		}
-	};
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js
-var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
-	const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = require_constants();
-	exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
-	exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
-	exports.isRegexChar = (str) => str.length === 1 && exports.hasRegexChars(str);
-	exports.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
-	exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
-	exports.isWindows = () => {
-		if (typeof navigator !== "undefined" && navigator.platform) {
-			const platform = navigator.platform.toLowerCase();
-			return platform === "win32" || platform === "windows";
-		}
-		if (typeof process !== "undefined" && process.platform) return process.platform === "win32";
-		return false;
-	};
-	exports.removeBackslashes = (str) => {
-		return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
-			return match === "\\" ? "" : match;
-		});
-	};
-	exports.escapeLast = (input, char, lastIdx) => {
-		const idx = input.lastIndexOf(char, lastIdx);
-		if (idx === -1) 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 = {}) => {
-		let output = `${options.contains ? "" : "^"}(?:${input})${options.contains ? "" : "$"}`;
-		if (state.negated === true) output = `(?:^(?!${output}).*$)`;
-		return output;
-	};
-	exports.basename = (path$1, { windows } = {}) => {
-		const segs = path$1.split(windows ? /[\\/]/ : "/");
-		const last = segs[segs.length - 1];
-		if (last === "") return segs[segs.length - 2];
-		return last;
-	};
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/scan.js
-var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const utils$3 = require_utils();
-	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 } = require_constants();
-	const isPathSeparator = (code) => {
-		return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
-	};
-	const depth = (token) => {
-		if (token.isPrefix !== true) token.depth = token.isGlobstar ? Infinity : 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$1 = (input, options) => {
-		const opts = options || {};
-		const length = input.length - 1;
-		const scanToEnd = opts.parts === true || opts.scanToEnd === true;
-		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 (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
-				braces++;
-				while (eos() !== true && (code = advance())) {
-					if (code === CHAR_BACKWARD_SLASH) {
-						backslashes = token.backslashes = true;
-						advance();
-						continue;
-					}
-					if (code === CHAR_LEFT_CURLY_BRACE) {
-						braces++;
-						continue;
-					}
-					if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
-						isBrace = token.isBrace = true;
-						isGlob = token.isGlob = true;
-						finished = true;
-						if (scanToEnd === true) continue;
-						break;
-					}
-					if (braceEscaped !== true && code === CHAR_COMMA) {
-						isBrace = token.isBrace = true;
-						isGlob = token.isGlob = true;
-						finished = true;
-						if (scanToEnd === true) continue;
-						break;
-					}
-					if (code === CHAR_RIGHT_CURLY_BRACE) {
-						braces--;
-						if (braces === 0) {
-							braceEscaped = false;
-							isBrace = token.isBrace = true;
-							finished = true;
-							break;
-						}
-					}
-				}
-				if (scanToEnd === true) continue;
-				break;
-			}
-			if (code === CHAR_FORWARD_SLASH) {
-				slashes.push(index);
-				tokens.push(token);
-				token = {
-					value: "",
-					depth: 0,
-					isGlob: false
-				};
-				if (finished === true) continue;
-				if (prev === CHAR_DOT && index === start + 1) {
-					start += 2;
-					continue;
-				}
-				lastIndex = index + 1;
-				continue;
-			}
-			if (opts.noext !== true) {
-				if ((code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK) === true && peek() === CHAR_LEFT_PARENTHESES) {
-					isGlob = token.isGlob = true;
-					isExtglob = token.isExtglob = true;
-					finished = true;
-					if (code === CHAR_EXCLAMATION_MARK && index === start) negatedExtglob = true;
-					if (scanToEnd === true) {
-						while (eos() !== true && (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 (scanToEnd === true) continue;
-				break;
-			}
-			if (code === CHAR_QUESTION_MARK) {
-				isGlob = token.isGlob = true;
-				finished = true;
-				if (scanToEnd === true) continue;
-				break;
-			}
-			if (code === CHAR_LEFT_SQUARE_BRACKET) {
-				while (eos() !== true && (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 (scanToEnd === true) continue;
-				break;
-			}
-			if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
-				negated = token.negated = true;
-				start++;
-				continue;
-			}
-			if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
-				isGlob = token.isGlob = true;
-				if (scanToEnd === true) {
-					while (eos() !== true && (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 (isGlob === true) {
-				finished = true;
-				if (scanToEnd === true) continue;
-				break;
-			}
-		}
-		if (opts.noext === true) {
-			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 && isGlob === true && lastIndex > 0) {
-			base = str.slice(0, lastIndex);
-			glob = str.slice(lastIndex);
-		} else if (isGlob === true) {
-			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 (opts.unescape === true) {
-			if (glob) glob = utils$3.removeBackslashes(glob);
-			if (base && backslashes === true) base = utils$3.removeBackslashes(base);
-		}
-		const state = {
-			prefix,
-			input,
-			start,
-			base,
-			glob,
-			isBrace,
-			isBracket,
-			isGlob,
-			isExtglob,
-			isGlobstar,
-			negated,
-			negatedExtglob
-		};
-		if (opts.tokens === true) {
-			state.maxDepth = 0;
-			if (!isPathSeparator(code)) tokens.push(token);
-			state.tokens = tokens;
-		}
-		if (opts.parts === true || opts.tokens === true) {
-			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 (idx === 0 && start !== 0) {
-						tokens[idx].isPrefix = true;
-						tokens[idx].value = prefix;
-					} else tokens[idx].value = value;
-					depth(tokens[idx]);
-					state.maxDepth += tokens[idx].depth;
-				}
-				if (idx !== 0 || 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$1;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/parse.js
-var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const constants$1 = require_constants();
-	const utils$2 = require_utils();
-	/**
-	* Constants
-	*/
-	const { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants$1;
-	/**
-	* Helpers
-	*/
-	const expandRange = (args, options) => {
-		if (typeof options.expandRange === "function") return options.expandRange(...args, options);
-		args.sort();
-		const value = `[${args.join("-")}]`;
-		try {
-			new RegExp(value);
-		} catch (ex) {
-			return args.map((v) => utils$2.escapeRegex(v)).join("..");
-		}
-		return value;
-	};
-	/**
-	* Create the message for a syntax error
-	*/
-	const syntaxError = (type, char) => {
-		return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
-	};
-	/**
-	* Parse the given input string.
-	* @param {String} input
-	* @param {Object} options
-	* @return {Object}
-	*/
-	const parse$2 = (input, options) => {
-		if (typeof input !== "string") throw new TypeError("Expected a string");
-		input = REPLACEMENTS[input] || input;
-		const opts = { ...options };
-		const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-		let len = input.length;
-		if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-		const bos = {
-			type: "bos",
-			value: "",
-			output: opts.prepend || ""
-		};
-		const tokens = [bos];
-		const capture = opts.capture ? "" : "?:";
-		const PLATFORM_CHARS = constants$1.globChars(opts.windows);
-		const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);
-		const { DOT_LITERAL: DOT_LITERAL$1, PLUS_LITERAL: PLUS_LITERAL$1, SLASH_LITERAL: SLASH_LITERAL$1, ONE_CHAR: ONE_CHAR$1, DOTS_SLASH: DOTS_SLASH$1, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK: QMARK$1, QMARK_NO_DOT, STAR, START_ANCHOR: START_ANCHOR$1 } = PLATFORM_CHARS;
-		const globstar = (opts$1) => {
-			return `(${capture}(?:(?!${START_ANCHOR$1}${opts$1.dot ? DOTS_SLASH$1 : DOT_LITERAL$1}).)*?)`;
-		};
-		const nodot = opts.dot ? "" : NO_DOT;
-		const qmarkNoDot = opts.dot ? QMARK$1 : QMARK_NO_DOT;
-		let star = opts.bash === true ? globstar(opts) : STAR;
-		if (opts.capture) star = `(${star})`;
-		if (typeof opts.noext === "boolean") opts.noextglob = opts.noext;
-		const state = {
-			input,
-			index: -1,
-			start: 0,
-			dot: opts.dot === true,
-			consumed: "",
-			output: "",
-			prefix: "",
-			backtrack: false,
-			negated: false,
-			brackets: 0,
-			braces: 0,
-			parens: 0,
-			quotes: 0,
-			globstar: false,
-			tokens
-		};
-		input = utils$2.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$1 = "", num = 0) => {
-			state.consumed += value$1;
-			state.index += num;
-		};
-		const append = (token) => {
-			state.output += token.output != null ? 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 (prev.type === "globstar") {
-				const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
-				const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
-				if (tok.type !== "slash" && tok.type !== "paren" && !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 && tok.type !== "paren") extglobs[extglobs.length - 1].inner += tok.value;
-			if (tok.value || tok.output) append(tok);
-			if (prev && prev.type === "text" && tok.type === "text") {
-				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$1) => {
-			const token = {
-				...EXTGLOB_CHARS[value$1],
-				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: value$1,
-				output: state.output ? "" : ONE_CHAR$1
-			});
-			push({
-				type: "paren",
-				extglob: true,
-				value: advance(),
-				output
-			});
-			extglobs.push(token);
-		};
-		const extglobClose = (token) => {
-			let output = token.close + (opts.capture ? ")" : "");
-			let rest;
-			if (token.type === "negate") {
-				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)) output = token.close = `)${parse$2(rest, {
-					...options,
-					fastpaths: false
-				}).output})${extglobStar})`;
-				if (token.prev.type === "bos") state.negatedExtglob = true;
-			}
-			push({
-				type: "paren",
-				extglob: true,
-				value,
-				output
-			});
-			decrement("parens");
-		};
-		/**
-		* Fast paths
-		*/
-		if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
-			let backslashes = false;
-			let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars$1, first, rest, index) => {
-				if (first === "\\") {
-					backslashes = true;
-					return m;
-				}
-				if (first === "?") {
-					if (esc) return esc + first + (rest ? QMARK$1.repeat(rest.length) : "");
-					if (index === 0) return qmarkNoDot + (rest ? QMARK$1.repeat(rest.length) : "");
-					return QMARK$1.repeat(chars$1.length);
-				}
-				if (first === ".") return DOT_LITERAL$1.repeat(chars$1.length);
-				if (first === "*") {
-					if (esc) return esc + first + (rest ? star : "");
-					return star;
-				}
-				return esc ? m : `\\${m}`;
-			});
-			if (backslashes === true) if (opts.unescape === true) output = output.replace(/\\/g, "");
-			else output = output.replace(/\\+/g, (m) => {
-				return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
-			});
-			if (output === input && opts.contains === true) {
-				state.output = input;
-				return state;
-			}
-			state.output = utils$2.wrapOutput(output, state, options);
-			return state;
-		}
-		/**
-		* Tokenize input until we reach end-of-string
-		*/
-		while (!eos()) {
-			value = advance();
-			if (value === "\0") continue;
-			/**
-			* Escaped characters
-			*/
-			if (value === "\\") {
-				const next = peek();
-				if (next === "/" && opts.bash !== true) continue;
-				if (next === "." || next === ";") continue;
-				if (!next) {
-					value += "\\";
-					push({
-						type: "text",
-						value
-					});
-					continue;
-				}
-				const match = /^\\+/.exec(remaining());
-				let slashes = 0;
-				if (match && match[0].length > 2) {
-					slashes = match[0].length;
-					state.index += slashes;
-					if (slashes % 2 !== 0) value += "\\";
-				}
-				if (opts.unescape === true) value = advance();
-				else value += advance();
-				if (state.brackets === 0) {
-					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 (opts.posix !== false && 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 posix = POSIX_REGEX_SOURCE[prev.value.slice(idx + 2)];
-							if (posix) {
-								prev.value = pre + posix;
-								state.backtrack = true;
-								advance();
-								if (!bos.output && tokens.indexOf(prev) === 1) bos.output = ONE_CHAR$1;
-								continue;
-							}
-						}
-					}
-				}
-				if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") value = `\\${value}`;
-				if (value === "]" && (prev.value === "[" || prev.value === "[^")) value = `\\${value}`;
-				if (opts.posix === true && 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 (state.quotes === 1 && value !== "\"") {
-				value = utils$2.escapeRegex(value);
-				prev.value += value;
-				append({ value });
-				continue;
-			}
-			/**
-			* Double quotes
-			*/
-			if (value === "\"") {
-				state.quotes = state.quotes === 1 ? 0 : 1;
-				if (opts.keepQuotes === true) push({
-					type: "text",
-					value
-				});
-				continue;
-			}
-			/**
-			* Parentheses
-			*/
-			if (value === "(") {
-				increment("parens");
-				push({
-					type: "paren",
-					value
-				});
-				continue;
-			}
-			if (value === ")") {
-				if (state.parens === 0 && opts.strictBrackets === true) 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 (opts.nobracket === true || !remaining().includes("]")) {
-					if (opts.nobracket !== true && opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
-					value = `\\${value}`;
-				} else increment("brackets");
-				push({
-					type: "bracket",
-					value
-				});
-				continue;
-			}
-			if (value === "]") {
-				if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
-					push({
-						type: "text",
-						value,
-						output: `\\${value}`
-					});
-					continue;
-				}
-				if (state.brackets === 0) {
-					if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("opening", "["));
-					push({
-						type: "text",
-						value,
-						output: `\\${value}`
-					});
-					continue;
-				}
-				decrement("brackets");
-				const prevValue = prev.value.slice(1);
-				if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) value = `/${value}`;
-				prev.value += value;
-				append({ value });
-				if (opts.literalBrackets === false || utils$2.hasRegexChars(prevValue)) continue;
-				const escaped = utils$2.escapeRegex(prev.value);
-				state.output = state.output.slice(0, -prev.value.length);
-				if (opts.literalBrackets === true) {
-					state.output += escaped;
-					prev.value = escaped;
-					continue;
-				}
-				prev.value = `(${capture}${escaped}|${prev.value})`;
-				state.output += prev.value;
-				continue;
-			}
-			/**
-			* Braces
-			*/
-			if (value === "{" && opts.nobrace !== true) {
-				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 (opts.nobrace === true || !brace) {
-					push({
-						type: "text",
-						value,
-						output: value
-					});
-					continue;
-				}
-				let output = ")";
-				if (brace.dots === true) {
-					const arr = tokens.slice();
-					const range = [];
-					for (let i = arr.length - 1; i >= 0; i--) {
-						tokens.pop();
-						if (arr[i].type === "brace") break;
-						if (arr[i].type !== "dots") range.unshift(arr[i].value);
-					}
-					output = expandRange(range, opts);
-					state.backtrack = true;
-				}
-				if (brace.comma !== true && brace.dots !== true) {
-					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 && stack[stack.length - 1] === "braces") {
-					brace.comma = true;
-					output = "|";
-				}
-				push({
-					type: "comma",
-					value,
-					output
-				});
-				continue;
-			}
-			/**
-			* Slashes
-			*/
-			if (value === "/") {
-				if (prev.type === "dot" && state.index === state.start + 1) {
-					state.start = state.index + 1;
-					state.consumed = "";
-					state.output = "";
-					tokens.pop();
-					prev = bos;
-					continue;
-				}
-				push({
-					type: "slash",
-					value,
-					output: SLASH_LITERAL$1
-				});
-				continue;
-			}
-			/**
-			* Dots
-			*/
-			if (value === ".") {
-				if (state.braces > 0 && prev.type === "dot") {
-					if (prev.value === ".") prev.output = DOT_LITERAL$1;
-					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 && prev.type !== "bos" && prev.type !== "slash") {
-					push({
-						type: "text",
-						value,
-						output: DOT_LITERAL$1
-					});
-					continue;
-				}
-				push({
-					type: "dot",
-					value,
-					output: DOT_LITERAL$1
-				});
-				continue;
-			}
-			/**
-			* Question marks
-			*/
-			if (value === "?") {
-				if (!(prev && prev.value === "(") && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
-					extglobOpen("qmark", value);
-					continue;
-				}
-				if (prev && prev.type === "paren") {
-					const next = peek();
-					let output = value;
-					if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) output = `\\${value}`;
-					push({
-						type: "text",
-						value,
-						output
-					});
-					continue;
-				}
-				if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
-					push({
-						type: "qmark",
-						value,
-						output: QMARK_NO_DOT
-					});
-					continue;
-				}
-				push({
-					type: "qmark",
-					value,
-					output: QMARK$1
-				});
-				continue;
-			}
-			/**
-			* Exclamation
-			*/
-			if (value === "!") {
-				if (opts.noextglob !== true && peek() === "(") {
-					if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
-						extglobOpen("negate", value);
-						continue;
-					}
-				}
-				if (opts.nonegate !== true && state.index === 0) {
-					negate();
-					continue;
-				}
-			}
-			/**
-			* Plus
-			*/
-			if (value === "+") {
-				if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
-					extglobOpen("plus", value);
-					continue;
-				}
-				if (prev && prev.value === "(" || opts.regex === false) {
-					push({
-						type: "plus",
-						value,
-						output: PLUS_LITERAL$1
-					});
-					continue;
-				}
-				if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
-					push({
-						type: "plus",
-						value
-					});
-					continue;
-				}
-				push({
-					type: "plus",
-					value: PLUS_LITERAL$1
-				});
-				continue;
-			}
-			/**
-			* Plain text
-			*/
-			if (value === "@") {
-				if (opts.noextglob !== true && 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 && (prev.type === "globstar" || prev.star === true)) {
-				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 (opts.noextglob !== true && /^\([^?]/.test(rest)) {
-				extglobOpen("star", value);
-				continue;
-			}
-			if (prev.type === "star") {
-				if (opts.noglobstar === true) {
-					consume(value);
-					continue;
-				}
-				const prior = prev.prev;
-				const before = prior.prev;
-				const isStart = prior.type === "slash" || prior.type === "bos";
-				const afterStar = before && (before.type === "star" || before.type === "globstar");
-				if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
-					push({
-						type: "star",
-						value,
-						output: ""
-					});
-					continue;
-				}
-				const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
-				const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
-				if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
-					push({
-						type: "star",
-						value,
-						output: ""
-					});
-					continue;
-				}
-				while (rest.slice(0, 3) === "/**") {
-					const after = input[state.index + 4];
-					if (after && after !== "/") break;
-					rest = rest.slice(3);
-					consume("/**", 3);
-				}
-				if (prior.type === "bos" && eos()) {
-					prev.type = "globstar";
-					prev.value += value;
-					prev.output = globstar(opts);
-					state.output = prev.output;
-					state.globstar = true;
-					consume(value);
-					continue;
-				}
-				if (prior.type === "slash" && prior.prev.type !== "bos" && !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 (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
-					const end = rest[1] !== void 0 ? "|$" : "";
-					state.output = state.output.slice(0, -(prior.output + prev.output).length);
-					prior.output = `(?:${prior.output}`;
-					prev.type = "globstar";
-					prev.output = `${globstar(opts)}${SLASH_LITERAL$1}|${SLASH_LITERAL$1}${end})`;
-					prev.value += value;
-					state.output += prior.output + prev.output;
-					state.globstar = true;
-					consume(value + advance());
-					push({
-						type: "slash",
-						value: "/",
-						output: ""
-					});
-					continue;
-				}
-				if (prior.type === "bos" && rest[0] === "/") {
-					prev.type = "globstar";
-					prev.value += value;
-					prev.output = `(?:^|${SLASH_LITERAL$1}|${globstar(opts)}${SLASH_LITERAL$1})`;
-					state.output = prev.output;
-					state.globstar = true;
-					consume(value + advance());
-					push({
-						type: "slash",
-						value: "/",
-						output: ""
-					});
-					continue;
-				}
-				state.output = state.output.slice(0, -prev.output.length);
-				prev.type = "globstar";
-				prev.output = globstar(opts);
-				prev.value += value;
-				state.output += prev.output;
-				state.globstar = true;
-				consume(value);
-				continue;
-			}
-			const token = {
-				type: "star",
-				value,
-				output: star
-			};
-			if (opts.bash === true) {
-				token.output = ".*?";
-				if (prev.type === "bos" || prev.type === "slash") token.output = nodot + token.output;
-				push(token);
-				continue;
-			}
-			if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
-				token.output = value;
-				push(token);
-				continue;
-			}
-			if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
-				if (prev.type === "dot") {
-					state.output += NO_DOT_SLASH;
-					prev.output += NO_DOT_SLASH;
-				} else if (opts.dot === true) {
-					state.output += NO_DOTS_SLASH;
-					prev.output += NO_DOTS_SLASH;
-				} else {
-					state.output += nodot;
-					prev.output += nodot;
-				}
-				if (peek() !== "*") {
-					state.output += ONE_CHAR$1;
-					prev.output += ONE_CHAR$1;
-				}
-			}
-			push(token);
-		}
-		while (state.brackets > 0) {
-			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
-			state.output = utils$2.escapeLast(state.output, "[");
-			decrement("brackets");
-		}
-		while (state.parens > 0) {
-			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
-			state.output = utils$2.escapeLast(state.output, "(");
-			decrement("parens");
-		}
-		while (state.braces > 0) {
-			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
-			state.output = utils$2.escapeLast(state.output, "{");
-			decrement("braces");
-		}
-		if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) push({
-			type: "maybe_slash",
-			value: "",
-			output: `${SLASH_LITERAL$1}?`
-		});
-		if (state.backtrack === true) {
-			state.output = "";
-			for (const token of state.tokens) {
-				state.output += token.output != null ? 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$2.fastpaths = (input, options) => {
-		const opts = { ...options };
-		const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-		const len = input.length;
-		if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-		input = REPLACEMENTS[input] || input;
-		const { DOT_LITERAL: DOT_LITERAL$1, SLASH_LITERAL: SLASH_LITERAL$1, ONE_CHAR: ONE_CHAR$1, DOTS_SLASH: DOTS_SLASH$1, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR: START_ANCHOR$1 } = constants$1.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 = opts.bash === true ? ".*?" : STAR;
-		if (opts.capture) star = `(${star})`;
-		const globstar = (opts$1) => {
-			if (opts$1.noglobstar === true) return star;
-			return `(${capture}(?:(?!${START_ANCHOR$1}${opts$1.dot ? DOTS_SLASH$1 : DOT_LITERAL$1}).)*?)`;
-		};
-		const create = (str) => {
-			switch (str) {
-				case "*": return `${nodot}${ONE_CHAR$1}${star}`;
-				case ".*": return `${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
-				case "*.*": return `${nodot}${star}${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
-				case "*/*": return `${nodot}${star}${SLASH_LITERAL$1}${ONE_CHAR$1}${slashDot}${star}`;
-				case "**": return nodot + globstar(opts);
-				case "**/*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL$1})?${slashDot}${ONE_CHAR$1}${star}`;
-				case "**/*.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL$1})?${slashDot}${star}${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
-				case "**/.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL$1})?${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
-				default: {
-					const match = /^(.*?)\.(\w+)$/.exec(str);
-					if (!match) return;
-					const source$1 = create(match[1]);
-					if (!source$1) return;
-					return source$1 + DOT_LITERAL$1 + match[2];
-				}
-			}
-		};
-		let source = create(utils$2.removePrefix(input, state));
-		if (source && opts.strictSlashes !== true) source += `${SLASH_LITERAL$1}?`;
-		return source;
-	};
-	module.exports = parse$2;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/picomatch.js
-var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const scan = require_scan();
-	const parse$1 = require_parse();
-	const utils$1 = require_utils();
-	const constants = require_constants();
-	const isObject = (val) => val && typeof val === "object" && !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$2 = (glob, options, returnState = false) => {
-		if (Array.isArray(glob)) {
-			const fns = glob.map((input) => picomatch$2(input, options, returnState));
-			const arrayMatcher = (str) => {
-				for (const isMatch of fns) {
-					const state$1 = isMatch(str);
-					if (state$1) return state$1;
-				}
-				return false;
-			};
-			return arrayMatcher;
-		}
-		const isState = isObject(glob) && glob.tokens && glob.input;
-		if (glob === "" || typeof glob !== "string" && !isState) throw new TypeError("Expected pattern to be a non-empty string");
-		const opts = options || {};
-		const posix = opts.windows;
-		const regex = isState ? picomatch$2.compileRe(glob, options) : picomatch$2.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$2(opts.ignore, ignoreOpts, returnState);
-		}
-		const matcher = (input, returnObject = false) => {
-			const { isMatch, match, output } = picomatch$2.test(input, regex, options, {
-				glob,
-				posix
-			});
-			const result = {
-				glob,
-				state,
-				regex,
-				posix,
-				input,
-				output,
-				match,
-				isMatch
-			};
-			if (typeof opts.onResult === "function") opts.onResult(result);
-			if (isMatch === false) {
-				result.isMatch = false;
-				return returnObject ? result : false;
-			}
-			if (isIgnored(input)) {
-				if (typeof opts.onIgnore === "function") opts.onIgnore(result);
-				result.isMatch = false;
-				return returnObject ? result : false;
-			}
-			if (typeof opts.onMatch === "function") opts.onMatch(result);
-			return returnObject ? result : true;
-		};
-		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$2.test = (input, regex, options, { glob, posix } = {}) => {
-		if (typeof input !== "string") throw new TypeError("Expected input to be a string");
-		if (input === "") return {
-			isMatch: false,
-			output: ""
-		};
-		const opts = options || {};
-		const format = opts.format || (posix ? utils$1.toPosixSlashes : null);
-		let match = input === glob;
-		let output = match && format ? format(input) : input;
-		if (match === false) {
-			output = format ? format(input) : input;
-			match = output === glob;
-		}
-		if (match === false || opts.capture === true) if (opts.matchBase === true || opts.basename === true) match = picomatch$2.matchBase(input, regex, options, posix);
-		else match = 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$2.matchBase = (input, glob, options) => {
-		return (glob instanceof RegExp ? glob : picomatch$2.makeRe(glob, options)).test(utils$1.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$2.isMatch = (str, patterns, options) => picomatch$2(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$2.parse = (pattern, options) => {
-		if (Array.isArray(pattern)) return pattern.map((p) => picomatch$2.parse(p, options));
-		return parse$1(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$2.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$2.compileRe = (state, options, returnOutput = false, returnState = false) => {
-		if (returnOutput === true) return state.output;
-		const opts = options || {};
-		const prepend = opts.contains ? "" : "^";
-		const append = opts.contains ? "" : "$";
-		let source = `${prepend}(?:${state.output})${append}`;
-		if (state && state.negated === true) source = `^(?!${source}).*$`;
-		const regex = picomatch$2.toRegex(source, options);
-		if (returnState === true) 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$2.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
-		if (!input || typeof input !== "string") throw new TypeError("Expected a non-empty string");
-		let parsed = {
-			negated: false,
-			fastpaths: true
-		};
-		if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) parsed.output = parse$1.fastpaths(input, options);
-		if (!parsed.output) parsed = parse$1(input, options);
-		return picomatch$2.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$2.toRegex = (source, options) => {
-		try {
-			const opts = options || {};
-			return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
-		} catch (err) {
-			if (options && options.debug === true) throw err;
-			return /$^/;
-		}
-	};
-	/**
-	* Picomatch constants.
-	* @return {Object}
-	*/
-	picomatch$2.constants = constants;
-	/**
-	* Expose "picomatch"
-	*/
-	module.exports = picomatch$2;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js
-var require_picomatch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const pico = require_picomatch$1();
-	const utils = require_utils();
-	function picomatch$1(glob, options, returnState = false) {
-		if (options && (options.windows === null || options.windows === void 0)) options = {
-			...options,
-			windows: utils.isWindows()
-		};
-		return pico(glob, options, returnState);
-	}
-	Object.assign(picomatch$1, pico);
-	module.exports = picomatch$1;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/unplugin@3.0.0-beta.3/node_modules/unplugin/dist/parse-CRORloGP.mjs
-var import_picomatch = /* @__PURE__ */ __toESM(require_picomatch(), 1);
-function toArray(array) {
-	array = array || [];
-	if (Array.isArray(array)) return array;
-	return [array];
-}
-const BACKSLASH_REGEX = /\\/g;
-function normalize$1(path$1) {
-	return path$1.replace(BACKSLASH_REGEX, "/");
-}
-const ABSOLUTE_PATH_REGEX = /^(?:\/|(?:[A-Z]:)?[/\\|])/i;
-function isAbsolute$1$1(path$1) {
-	return ABSOLUTE_PATH_REGEX.test(path$1);
-}
-function getMatcherString(glob, cwd) {
-	if (glob.startsWith("**") || isAbsolute$1$1(glob)) return normalize$1(glob);
-	return normalize$1((0, node_path.resolve)(cwd, glob));
-}
-function patternToIdFilter(pattern) {
-	if (pattern instanceof RegExp) return (id) => {
-		const normalizedId = normalize$1(id);
-		const result = pattern.test(normalizedId);
-		pattern.lastIndex = 0;
-		return result;
-	};
-	const matcher = (0, import_picomatch.default)(getMatcherString(pattern, process.cwd()), { dot: true });
-	return (id) => {
-		return matcher(normalize$1(id));
-	};
-}
-function patternToCodeFilter(pattern) {
-	if (pattern instanceof RegExp) return (code) => {
-		const result = pattern.test(code);
-		pattern.lastIndex = 0;
-		return result;
-	};
-	return (code) => code.includes(pattern);
-}
-function createFilter(exclude, include) {
-	if (!exclude && !include) return;
-	return (input) => {
-		if (exclude?.some((filter) => filter(input))) return false;
-		if (include?.some((filter) => filter(input))) return true;
-		return !(include && include.length > 0);
-	};
-}
-function normalizeFilter(filter) {
-	if (typeof filter === "string" || filter instanceof RegExp) return { include: [filter] };
-	if (Array.isArray(filter)) return { include: filter };
-	return {
-		exclude: filter.exclude ? toArray(filter.exclude) : void 0,
-		include: filter.include ? toArray(filter.include) : void 0
-	};
-}
-function createIdFilter(filter) {
-	if (!filter) return;
-	const { exclude, include } = normalizeFilter(filter);
-	const excludeFilter = exclude?.map(patternToIdFilter);
-	const includeFilter = include?.map(patternToIdFilter);
-	return createFilter(excludeFilter, includeFilter);
-}
-function createCodeFilter(filter) {
-	if (!filter) return;
-	const { exclude, include } = normalizeFilter(filter);
-	const excludeFilter = exclude?.map(patternToCodeFilter);
-	const includeFilter = include?.map(patternToCodeFilter);
-	return createFilter(excludeFilter, includeFilter);
-}
-function createFilterForId(filter) {
-	const filterFunction = createIdFilter(filter);
-	return filterFunction ? (id) => !!filterFunction(id) : void 0;
-}
-function createFilterForTransform(idFilter, codeFilter) {
-	if (!idFilter && !codeFilter) return;
-	const idFilterFunction = createIdFilter(idFilter);
-	const codeFilterFunction = createCodeFilter(codeFilter);
-	return (id, code) => {
-		let fallback = true;
-		if (idFilterFunction) fallback &&= idFilterFunction(id);
-		if (!fallback) return false;
-		if (codeFilterFunction) fallback &&= codeFilterFunction(code);
-		return fallback;
-	};
-}
-function normalizeObjectHook(name, hook) {
-	let handler;
-	let filter;
-	if (typeof hook === "function") handler = hook;
-	else {
-		handler = hook.handler;
-		const hookFilter = hook.filter;
-		if (name === "resolveId" || name === "load") filter = createFilterForId(hookFilter?.id);
-		else filter = createFilterForTransform(hookFilter?.id, hookFilter?.code);
-	}
-	return {
-		handler,
-		filter: filter || (() => true)
-	};
-}
-let parseImpl;
-function parse(code, opts = {}) {
-	if (!parseImpl) throw new Error("Parse implementation is not set. Please call setParseImpl first.");
-	return parseImpl(code, opts);
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/unplugin@3.0.0-beta.3/node_modules/unplugin/dist/webpack-like-BU9ULG6P.mjs
-function transformUse(data, plugin, transformLoader) {
-	if (data.resource == null) return [];
-	const id = normalizeAbsolutePath(data.resource + (data.resourceQuery || ""));
-	if (plugin.transformInclude && !plugin.transformInclude(id)) return [];
-	const { filter } = normalizeObjectHook("load", plugin.transform);
-	if (!filter(id)) return [];
-	return [{
-		loader: transformLoader,
-		options: { plugin },
-		ident: plugin.name
-	}];
-}
-/**
-* Normalizes a given path when it's absolute. Normalizing means returning a new path by converting
-* the input path to the native os format. This is useful in cases where we want to normalize
-* the `id` argument of a hook. Any absolute ids should be in the default format
-* of the operating system. Any relative imports or node_module imports should remain
-* untouched.
-*
-* @param path - Path to normalize.
-* @returns a new normalized path.
-*/
-function normalizeAbsolutePath(path$1) {
-	if ((0, node_path.isAbsolute)(path$1)) return (0, node_path.normalize)(path$1);
-	else return path$1;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/unplugin@3.0.0-beta.3/node_modules/unplugin/dist/context-CehLHpzV.mjs
-function createBuildContext(compiler, compilation, loaderContext, inputSourceMap) {
-	return {
-		getNativeBuildContext() {
-			return {
-				framework: "rspack",
-				compiler,
-				compilation,
-				loaderContext,
-				inputSourceMap
-			};
-		},
-		addWatchFile(file) {
-			const cwd = process.cwd();
-			compilation.fileDependencies.add((0, node_path.resolve)(cwd, file));
-		},
-		getWatchFiles() {
-			return Array.from(compilation.fileDependencies);
-		},
-		parse,
-		emitFile(emittedFile) {
-			const outFileName = emittedFile.fileName || emittedFile.name;
-			if (emittedFile.source && outFileName) {
-				const { sources } = compilation.compiler.webpack;
-				compilation.emitAsset(outFileName, new sources.RawSource(typeof emittedFile.source === "string" ? emittedFile.source : node_buffer.Buffer.from(emittedFile.source)));
-			}
-		}
-	};
-}
-function normalizeMessage(error) {
-	const err = new Error(typeof error === "string" ? error : error.message);
-	if (typeof error === "object") {
-		err.stack = error.stack;
-		err.cause = error.meta;
-	}
-	return err;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/unplugin@3.0.0-beta.3/node_modules/unplugin/dist/utils-CuyC8gTr.mjs
-function encodeVirtualModuleId(id, plugin) {
-	return (0, node_path.resolve)(plugin.__virtualModulePrefix, encodeURIComponent(id));
-}
-function decodeVirtualModuleId(encoded, _plugin) {
-	return decodeURIComponent((0, node_path.basename)(encoded));
-}
-function isVirtualModuleId(encoded, plugin) {
-	return (0, node_path.dirname)(encoded) === plugin.__virtualModulePrefix;
-}
-var FakeVirtualModulesPlugin = class FakeVirtualModulesPlugin$1 {
-	name = "FakeVirtualModulesPlugin";
-	static counters = /* @__PURE__ */ new Map();
-	static initCleanup = false;
-	constructor(plugin) {
-		this.plugin = plugin;
-		if (!FakeVirtualModulesPlugin$1.initCleanup) {
-			FakeVirtualModulesPlugin$1.initCleanup = true;
-			process.once("exit", () => {
-				FakeVirtualModulesPlugin$1.counters.forEach((_, dir) => {
-					node_fs.default.rmSync(dir, {
-						recursive: true,
-						force: true
-					});
-				});
-			});
-		}
-	}
-	apply(compiler) {
-		const dir = this.plugin.__virtualModulePrefix;
-		if (!node_fs.default.existsSync(dir)) node_fs.default.mkdirSync(dir, { recursive: true });
-		const counter = FakeVirtualModulesPlugin$1.counters.get(dir) ?? 0;
-		FakeVirtualModulesPlugin$1.counters.set(dir, counter + 1);
-		compiler.hooks.shutdown.tap(this.name, () => {
-			const counter$1 = (FakeVirtualModulesPlugin$1.counters.get(dir) ?? 1) - 1;
-			if (counter$1 === 0) {
-				FakeVirtualModulesPlugin$1.counters.delete(dir);
-				node_fs.default.rmSync(dir, {
-					recursive: true,
-					force: true
-				});
-			} else FakeVirtualModulesPlugin$1.counters.set(dir, counter$1);
-		});
-	}
-	async writeModule(file) {
-		return node_fs.default.promises.writeFile(file, "");
-	}
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
-var comma = ",".charCodeAt(0);
-var semicolon = ";".charCodeAt(0);
-var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-var intToChar = new Uint8Array(64);
-var charToInt = new Uint8Array(128);
-for (let i = 0; i < chars.length; i++) {
-	const c = chars.charCodeAt(i);
-	intToChar[i] = c;
-	charToInt[c] = i;
-}
-var bufLength = 1024 * 16;
-
-//#endregion
-//#region ../../node_modules/.pnpm/webpack-virtual-modules@0.6.2/node_modules/webpack-virtual-modules/lib/virtual-stats.js
-var require_virtual_stats = /* @__PURE__ */ __commonJSMin(((exports) => {
-	var __importDefault = exports && exports.__importDefault || function(mod) {
-		return mod && mod.__esModule ? mod : { "default": mod };
-	};
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.VirtualStats = void 0;
-	const constants_1 = __importDefault(require("node:constants"));
-	var VirtualStats = class {
-		constructor(config) {
-			for (const key in config) {
-				if (!Object.prototype.hasOwnProperty.call(config, key)) continue;
-				this[key] = config[key];
-			}
-		}
-		_checkModeProperty(property) {
-			return (this.mode & constants_1.default.S_IFMT) === property;
-		}
-		isDirectory() {
-			return this._checkModeProperty(constants_1.default.S_IFDIR);
-		}
-		isFile() {
-			return this._checkModeProperty(constants_1.default.S_IFREG);
-		}
-		isBlockDevice() {
-			return this._checkModeProperty(constants_1.default.S_IFBLK);
-		}
-		isCharacterDevice() {
-			return this._checkModeProperty(constants_1.default.S_IFCHR);
-		}
-		isSymbolicLink() {
-			return this._checkModeProperty(constants_1.default.S_IFLNK);
-		}
-		isFIFO() {
-			return this._checkModeProperty(constants_1.default.S_IFIFO);
-		}
-		isSocket() {
-			return this._checkModeProperty(constants_1.default.S_IFSOCK);
-		}
-	};
-	exports.VirtualStats = VirtualStats;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/webpack-virtual-modules@0.6.2/node_modules/webpack-virtual-modules/lib/index.js
-var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const path_1 = (exports && exports.__importDefault || function(mod) {
-		return mod && mod.__esModule ? mod : { "default": mod };
-	})(require("node:path"));
-	const virtual_stats_1 = require_virtual_stats();
-	let inode = 45e6;
-	const ALL = "all";
-	const STATIC = "static";
-	const DYNAMIC = "dynamic";
-	function checkActivation(instance) {
-		if (!instance._compiler) throw new Error("You must use this plugin only after creating webpack instance!");
-	}
-	function getModulePath(filePath, compiler) {
-		return path_1.default.isAbsolute(filePath) ? filePath : path_1.default.join(compiler.context, filePath);
-	}
-	function createWebpackData(result) {
-		return (backendOrStorage) => {
-			if (backendOrStorage._data) {
-				const curLevelIdx = backendOrStorage._currentLevel;
-				return {
-					result,
-					level: backendOrStorage._levels[curLevelIdx]
-				};
-			}
-			return [null, result];
-		};
-	}
-	function getData(storage, key) {
-		if (storage._data instanceof Map) return storage._data.get(key);
-		else if (storage._data) return storage.data[key];
-		else if (storage.data instanceof Map) return storage.data.get(key);
-		else return storage.data[key];
-	}
-	function setData(backendOrStorage, key, valueFactory) {
-		const value = valueFactory(backendOrStorage);
-		if (backendOrStorage._data instanceof Map) backendOrStorage._data.set(key, value);
-		else if (backendOrStorage._data) backendOrStorage.data[key] = value;
-		else if (backendOrStorage.data instanceof Map) backendOrStorage.data.set(key, value);
-		else backendOrStorage.data[key] = value;
-	}
-	function getStatStorage(fileSystem) {
-		if (fileSystem._statStorage) return fileSystem._statStorage;
-		else if (fileSystem._statBackend) return fileSystem._statBackend;
-		else throw new Error("Couldn't find a stat storage");
-	}
-	function getFileStorage(fileSystem) {
-		if (fileSystem._readFileStorage) return fileSystem._readFileStorage;
-		else if (fileSystem._readFileBackend) return fileSystem._readFileBackend;
-		else throw new Error("Couldn't find a readFileStorage");
-	}
-	function getReadDirBackend(fileSystem) {
-		if (fileSystem._readdirBackend) return fileSystem._readdirBackend;
-		else if (fileSystem._readdirStorage) return fileSystem._readdirStorage;
-		else throw new Error("Couldn't find a readDirStorage from Webpack Internals");
-	}
-	function getRealpathBackend(fileSystem) {
-		if (fileSystem._realpathBackend) return fileSystem._realpathBackend;
-	}
-	var VirtualModulesPlugin$1 = class {
-		constructor(modules) {
-			this._compiler = null;
-			this._watcher = null;
-			this._staticModules = modules || null;
-		}
-		getModuleList(filter = ALL) {
-			var _a, _b;
-			let modules = {};
-			const shouldGetStaticModules = filter === ALL || filter === STATIC;
-			const shouldGetDynamicModules = filter === ALL || filter === DYNAMIC;
-			if (shouldGetStaticModules) modules = Object.assign(Object.assign({}, modules), this._staticModules);
-			if (shouldGetDynamicModules) {
-				const finalInputFileSystem = (_a = this._compiler) === null || _a === void 0 ? void 0 : _a.inputFileSystem;
-				const virtualFiles = (_b = finalInputFileSystem === null || finalInputFileSystem === void 0 ? void 0 : finalInputFileSystem._virtualFiles) !== null && _b !== void 0 ? _b : {};
-				const dynamicModules = {};
-				Object.keys(virtualFiles).forEach((key) => {
-					dynamicModules[key] = virtualFiles[key].contents;
-				});
-				modules = Object.assign(Object.assign({}, modules), dynamicModules);
-			}
-			return modules;
-		}
-		writeModule(filePath, contents) {
-			if (!this._compiler) throw new Error(`Plugin has not been initialized`);
-			checkActivation(this);
-			const len = contents ? contents.length : 0;
-			const time = Date.now();
-			const date = new Date(time);
-			const stats = new virtual_stats_1.VirtualStats({
-				dev: 8675309,
-				nlink: 0,
-				uid: 1e3,
-				gid: 1e3,
-				rdev: 0,
-				blksize: 4096,
-				ino: inode++,
-				mode: 33188,
-				size: len,
-				blocks: Math.floor(len / 4096),
-				atime: date,
-				mtime: date,
-				ctime: date,
-				birthtime: date
-			});
-			const modulePath = getModulePath(filePath, this._compiler);
-			if (process.env.WVM_DEBUG) console.log(this._compiler.name, "Write virtual module:", modulePath, contents);
-			let finalWatchFileSystem = this._watcher && this._watcher.watchFileSystem;
-			while (finalWatchFileSystem && finalWatchFileSystem.wfs) finalWatchFileSystem = finalWatchFileSystem.wfs;
-			let finalInputFileSystem = this._compiler.inputFileSystem;
-			while (finalInputFileSystem && finalInputFileSystem._inputFileSystem) finalInputFileSystem = finalInputFileSystem._inputFileSystem;
-			finalInputFileSystem._writeVirtualFile(modulePath, stats, contents);
-			if (finalWatchFileSystem && finalWatchFileSystem.watcher && (finalWatchFileSystem.watcher.fileWatchers.size || finalWatchFileSystem.watcher.fileWatchers.length)) {
-				const fileWatchers = finalWatchFileSystem.watcher.fileWatchers instanceof Map ? Array.from(finalWatchFileSystem.watcher.fileWatchers.values()) : finalWatchFileSystem.watcher.fileWatchers;
-				for (let fileWatcher of fileWatchers) {
-					if ("watcher" in fileWatcher) fileWatcher = fileWatcher.watcher;
-					if (fileWatcher.path === modulePath) {
-						if (process.env.DEBUG) console.log(this._compiler.name, "Emit file change:", modulePath, time);
-						delete fileWatcher.directoryWatcher._cachedTimeInfoEntries;
-						fileWatcher.emit("change", time, null);
-					}
-				}
-			}
-		}
-		apply(compiler) {
-			this._compiler = compiler;
-			const afterEnvironmentHook = () => {
-				let finalInputFileSystem = compiler.inputFileSystem;
-				while (finalInputFileSystem && finalInputFileSystem._inputFileSystem) finalInputFileSystem = finalInputFileSystem._inputFileSystem;
-				if (!finalInputFileSystem._writeVirtualFile) {
-					const originalPurge = finalInputFileSystem.purge;
-					finalInputFileSystem.purge = () => {
-						originalPurge.apply(finalInputFileSystem, []);
-						if (finalInputFileSystem._virtualFiles) Object.keys(finalInputFileSystem._virtualFiles).forEach((file) => {
-							const data = finalInputFileSystem._virtualFiles[file];
-							finalInputFileSystem._writeVirtualFile(file, data.stats, data.contents);
-						});
-					};
-					finalInputFileSystem._writeVirtualFile = (file, stats, contents) => {
-						const statStorage = getStatStorage(finalInputFileSystem);
-						const fileStorage = getFileStorage(finalInputFileSystem);
-						const readDirStorage = getReadDirBackend(finalInputFileSystem);
-						const realPathStorage = getRealpathBackend(finalInputFileSystem);
-						finalInputFileSystem._virtualFiles = finalInputFileSystem._virtualFiles || {};
-						finalInputFileSystem._virtualFiles[file] = {
-							stats,
-							contents
-						};
-						setData(statStorage, file, createWebpackData(stats));
-						setData(fileStorage, file, createWebpackData(contents));
-						const segments = file.split(/[\\/]/);
-						let count = segments.length - 1;
-						const minCount = segments[0] ? 1 : 0;
-						while (count > minCount) {
-							const dir = segments.slice(0, count).join(path_1.default.sep) || path_1.default.sep;
-							try {
-								finalInputFileSystem.readdirSync(dir);
-							} catch (e) {
-								const time = Date.now();
-								const dirStats = new virtual_stats_1.VirtualStats({
-									dev: 8675309,
-									nlink: 0,
-									uid: 1e3,
-									gid: 1e3,
-									rdev: 0,
-									blksize: 4096,
-									ino: inode++,
-									mode: 16877,
-									size: stats.size,
-									blocks: Math.floor(stats.size / 4096),
-									atime: time,
-									mtime: time,
-									ctime: time,
-									birthtime: time
-								});
-								setData(readDirStorage, dir, createWebpackData([]));
-								if (realPathStorage) setData(realPathStorage, dir, createWebpackData(dir));
-								setData(statStorage, dir, createWebpackData(dirStats));
-							}
-							let dirData = getData(getReadDirBackend(finalInputFileSystem), dir);
-							dirData = dirData[1] || dirData.result;
-							const filename = segments[count];
-							if (dirData.indexOf(filename) < 0) {
-								const files = dirData.concat([filename]).sort();
-								setData(getReadDirBackend(finalInputFileSystem), dir, createWebpackData(files));
-							} else break;
-							count--;
-						}
-					};
-				}
-			};
-			const afterResolversHook = () => {
-				if (this._staticModules) {
-					for (const [filePath, contents] of Object.entries(this._staticModules)) this.writeModule(filePath, contents);
-					this._staticModules = null;
-				}
-			};
-			const version = typeof compiler.webpack === "undefined" ? 4 : 5;
-			const watchRunHook = (watcher, callback) => {
-				this._watcher = watcher.compiler || watcher;
-				const virtualFiles = compiler.inputFileSystem._virtualFiles;
-				const fts = compiler.fileTimestamps;
-				if (virtualFiles && fts && typeof fts.set === "function") Object.keys(virtualFiles).forEach((file) => {
-					const mtime = +virtualFiles[file].stats.mtime;
-					fts.set(file, version === 4 ? mtime : {
-						safeTime: mtime,
-						timestamp: mtime
-					});
-				});
-				callback();
-			};
-			if (compiler.hooks) {
-				compiler.hooks.afterEnvironment.tap("VirtualModulesPlugin", afterEnvironmentHook);
-				compiler.hooks.afterResolvers.tap("VirtualModulesPlugin", afterResolversHook);
-				compiler.hooks.watchRun.tapAsync("VirtualModulesPlugin", watchRunHook);
-			} else {
-				compiler.plugin("after-environment", afterEnvironmentHook);
-				compiler.plugin("after-resolvers", afterResolversHook);
-				compiler.plugin("watch-run", watchRunHook);
-			}
-		}
-	};
-	module.exports = VirtualModulesPlugin$1;
-}));
-
-//#endregion
-//#region ../../node_modules/.pnpm/unplugin@3.0.0-beta.3/node_modules/unplugin/dist/index.mjs
-var import_lib = /* @__PURE__ */ __toESM(require_lib(), 1);
-const TRANSFORM_LOADER$1 = (0, node_path.resolve)(__dirname, "rspack/loaders/transform.mjs");
-const LOAD_LOADER$1 = (0, node_path.resolve)(__dirname, "rspack/loaders/load.mjs");
-function getRspackPlugin(factory) {
-	return (userOptions) => {
-		return { apply(compiler) {
-			const VIRTUAL_MODULE_PREFIX = (0, node_path.resolve)(compiler.options.context ?? process.cwd(), "node_modules/.virtual", compiler.rspack.experiments.VirtualModulesPlugin ? "" : process.pid.toString());
-			const meta = {
-				framework: "rspack",
-				rspack: { compiler }
-			};
-			const rawPlugins = toArray(factory(userOptions, meta));
-			for (const rawPlugin of rawPlugins) {
-				const plugin = Object.assign(rawPlugin, {
-					__unpluginMeta: meta,
-					__virtualModulePrefix: VIRTUAL_MODULE_PREFIX
-				});
-				const externalModules = /* @__PURE__ */ new Set();
-				if (plugin.resolveId) {
-					const createPlugin = (plugin$1) => {
-						if (compiler.rspack.experiments.VirtualModulesPlugin) return new compiler.rspack.experiments.VirtualModulesPlugin();
-						return new FakeVirtualModulesPlugin(plugin$1);
-					};
-					const vfs = createPlugin(plugin);
-					vfs.apply(compiler);
-					const vfsModules = /* @__PURE__ */ new Map();
-					plugin.__vfsModules = vfsModules;
-					plugin.__vfs = vfs;
-					compiler.hooks.compilation.tap(plugin.name, (compilation, { normalModuleFactory }) => {
-						normalModuleFactory.hooks.resolve.tapPromise(plugin.name, async (resolveData) => {
-							const id = normalizeAbsolutePath(resolveData.request);
-							const requestContext = resolveData.contextInfo;
-							let importer = requestContext.issuer !== "" ? requestContext.issuer : void 0;
-							const isEntry = requestContext.issuer === "";
-							if (importer?.startsWith(plugin.__virtualModulePrefix)) importer = decodeURIComponent(importer.slice(plugin.__virtualModulePrefix.length));
-							const context = createBuildContext(compiler, compilation);
-							let error;
-							const pluginContext = {
-								error(msg) {
-									if (error == null) error = normalizeMessage(msg);
-									else console.error(`unplugin/rspack: multiple errors returned from resolveId hook: ${msg}`);
-								},
-								warn(msg) {
-									console.warn(`unplugin/rspack: warning from resolveId hook: ${msg}`);
-								}
-							};
-							const { handler, filter } = normalizeObjectHook("resolveId", plugin.resolveId);
-							if (!filter(id)) return;
-							const resolveIdResult = await handler.call({
-								...context,
-								...pluginContext
-							}, id, importer, { isEntry });
-							if (error != null) throw error;
-							if (resolveIdResult == null) return;
-							let resolved = typeof resolveIdResult === "string" ? resolveIdResult : resolveIdResult.id;
-							if (typeof resolveIdResult === "string" ? false : resolveIdResult.external === true) externalModules.add(resolved);
-							let isVirtual = true;
-							try {
-								(compiler.inputFileSystem?.statSync ?? node_fs.default.statSync)(resolved);
-								isVirtual = false;
-							} catch {
-								isVirtual = !isVirtualModuleId(resolved, plugin);
-							}
-							if (isVirtual) {
-								const encodedVirtualPath = encodeVirtualModuleId(resolved, plugin);
-								if (!vfsModules.has(resolved)) {
-									const fsPromise = Promise.resolve(vfs.writeModule(encodedVirtualPath, ""));
-									vfsModules.set(resolved, fsPromise);
-									await fsPromise;
-								} else await vfsModules.get(resolved);
-								resolved = encodedVirtualPath;
-							}
-							resolveData.request = resolved;
-						});
-					});
-				}
-				if (plugin.load) compiler.options.module.rules.unshift({
-					enforce: plugin.enforce,
-					include(id) {
-						if (isVirtualModuleId(id, plugin)) id = decodeVirtualModuleId(id, plugin);
-						if (plugin.loadInclude && !plugin.loadInclude(id)) return false;
-						const { filter } = normalizeObjectHook("load", plugin.load);
-						if (!filter(id)) return false;
-						return !externalModules.has(id);
-					},
-					use: [{
-						loader: LOAD_LOADER$1,
-						options: { plugin }
-					}],
-					type: "javascript/auto"
-				});
-				if (plugin.transform) compiler.options.module.rules.unshift({
-					enforce: plugin.enforce,
-					use(data) {
-						return transformUse(data, plugin, TRANSFORM_LOADER$1);
-					}
-				});
-				if (plugin.rspack) plugin.rspack(compiler);
-				if (plugin.watchChange || plugin.buildStart) compiler.hooks.make.tapPromise(plugin.name, async (compilation) => {
-					const context = createBuildContext(compiler, compilation);
-					if (plugin.watchChange && (compiler.modifiedFiles || compiler.removedFiles)) {
-						const promises = [];
-						if (compiler.modifiedFiles) compiler.modifiedFiles.forEach((file) => promises.push(Promise.resolve(plugin.watchChange.call(context, file, { event: "update" }))));
-						if (compiler.removedFiles) compiler.removedFiles.forEach((file) => promises.push(Promise.resolve(plugin.watchChange.call(context, file, { event: "delete" }))));
-						await Promise.all(promises);
-					}
-					if (plugin.buildStart) return await plugin.buildStart.call(context);
-				});
-				if (plugin.buildEnd) compiler.hooks.emit.tapPromise(plugin.name, async (compilation) => {
-					await plugin.buildEnd.call(createBuildContext(compiler, compilation));
-				});
-				if (plugin.writeBundle) compiler.hooks.afterEmit.tapPromise(plugin.name, async () => {
-					await plugin.writeBundle();
-				});
-			}
-		} };
-	};
-}
-const TRANSFORM_LOADER = (0, node_path.resolve)(__dirname, "webpack/loaders/transform.mjs");
-const LOAD_LOADER = (0, node_path.resolve)(__dirname, "webpack/loaders/load.mjs");
-function createRspackPlugin(factory) {
-	return getRspackPlugin(factory);
-}
-
-//#endregion
-//#region src/helpers/unplugin.ts
-function createRspackPlugin$1(context) {
-	return createRspackPlugin((0, powerlines_lib_unplugin.createUnplugin)(context))({});
-}
-
-//#endregion
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});
-Object.defineProperty(exports, 'createRspackPlugin', {
-  enumerable: true,
-  get: function () {
-    return createRspackPlugin$1;
-  }
-});