@ariestools/toolchain 8.6.11

package/dist/bin/package/copy-assets-esm.mjs

@@ -0,0 +1,3634 @@
+#!/usr/bin/env node
+import process$1 from "node:process";
+import os from "node:os";
+import tty from "node:tty";
+import * as xi from "node:fs";
+import { copyFileSync, mkdirSync, readFileSync } from "node:fs";
+import PATH, { posix, win32 } from "node:path";
+import path from "node:path/posix";
+import { fileURLToPath } from "node:url";
+import { lstatSync, readdir, readdirSync, readlinkSync, realpathSync } from "fs";
+import { lstat, readdir as readdir$1, readlink, realpath } from "node:fs/promises";
+import { EventEmitter } from "node:events";
+import Pe from "node:stream";
+import { StringDecoder } from "node:string_decoder";
+//#region \0rolldown/runtime.js
+var __esmMin = (fn, res, err) => () => {
+	if (err) throw err[0];
+	try {
+		return fn && (res = fn(fn = 0)), res;
+	} catch (e) {
+		throw err = [e], e;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+const ANSI_BACKGROUND_OFFSET = 10;
+const wrapAnsi16 = (offset = 0) => (code) => `\u001B[${code + offset}m`;
+const wrapAnsi256 = (offset = 0) => (code) => `\u001B[${38 + offset};5;${code}m`;
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+const styles$1 = {
+	modifier: {
+		reset: [0, 0],
+		bold: [1, 22],
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		overline: [53, 55],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29]
+	},
+	color: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+		blackBright: [90, 39],
+		gray: [90, 39],
+		grey: [90, 39],
+		redBright: [91, 39],
+		greenBright: [92, 39],
+		yellowBright: [93, 39],
+		blueBright: [94, 39],
+		magentaBright: [95, 39],
+		cyanBright: [96, 39],
+		whiteBright: [97, 39]
+	},
+	bgColor: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49],
+		bgBlackBright: [100, 49],
+		bgGray: [100, 49],
+		bgGrey: [100, 49],
+		bgRedBright: [101, 49],
+		bgGreenBright: [102, 49],
+		bgYellowBright: [103, 49],
+		bgBlueBright: [104, 49],
+		bgMagentaBright: [105, 49],
+		bgCyanBright: [106, 49],
+		bgWhiteBright: [107, 49]
+	}
+};
+Object.keys(styles$1.modifier);
+const foregroundColorNames = Object.keys(styles$1.color);
+const backgroundColorNames = Object.keys(styles$1.bgColor);
+[...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+	const codes = /* @__PURE__ */ new Map();
+	for (const [groupName, group] of Object.entries(styles$1)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles$1[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`
+			};
+			group[styleName] = styles$1[styleName];
+			codes.set(style[0], style[1]);
+		}
+		Object.defineProperty(styles$1, groupName, {
+			value: group,
+			enumerable: false
+		});
+	}
+	Object.defineProperty(styles$1, "codes", {
+		value: codes,
+		enumerable: false
+	});
+	styles$1.color.close = "\x1B[39m";
+	styles$1.bgColor.close = "\x1B[49m";
+	styles$1.color.ansi = wrapAnsi16();
+	styles$1.color.ansi256 = wrapAnsi256();
+	styles$1.color.ansi16m = wrapAnsi16m();
+	styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+	Object.defineProperties(styles$1, {
+		rgbToAnsi256: {
+			value(red, green, blue) {
+				if (red === green && green === blue) {
+					if (red < 8) return 16;
+					if (red > 248) return 231;
+					return Math.round((red - 8) / 247 * 24) + 232;
+				}
+				return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+			},
+			enumerable: false
+		},
+		hexToRgb: {
+			value(hex) {
+				const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+				if (!matches) return [
+					0,
+					0,
+					0
+				];
+				let [colorString] = matches;
+				if (colorString.length === 3) colorString = [...colorString].map((character) => character + character).join("");
+				const integer = Number.parseInt(colorString, 16);
+				return [
+					integer >> 16 & 255,
+					integer >> 8 & 255,
+					integer & 255
+				];
+			},
+			enumerable: false
+		},
+		hexToAnsi256: {
+			value: (hex) => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
+			enumerable: false
+		},
+		ansi256ToAnsi: {
+			value(code) {
+				if (code < 8) return 30 + code;
+				if (code < 16) return 90 + (code - 8);
+				let red;
+				let green;
+				let blue;
+				if (code >= 232) {
+					red = ((code - 232) * 10 + 8) / 255;
+					green = red;
+					blue = red;
+				} else {
+					code -= 16;
+					const remainder = code % 36;
+					red = Math.floor(code / 36) / 5;
+					green = Math.floor(remainder / 6) / 5;
+					blue = remainder % 6 / 5;
+				}
+				const value = Math.max(red, green, blue) * 2;
+				if (value === 0) return 30;
+				let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+				if (value === 2) result += 60;
+				return result;
+			},
+			enumerable: false
+		},
+		rgbToAnsi: {
+			value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
+			enumerable: false
+		},
+		hexToAnsi: {
+			value: (hex) => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
+			enumerable: false
+		}
+	});
+	return styles$1;
+}
+const ansiStyles = assembleStyles();
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process$1.argv) {
+	const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf("--");
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+const { env } = process$1;
+let flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
+else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
+function envForceColor() {
+	if ("FORCE_COLOR" in env) {
+		if (env.FORCE_COLOR === "true") return 1;
+		if (env.FORCE_COLOR === "false") return 0;
+		return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+	}
+}
+function translateLevel(level) {
+	if (level === 0) return false;
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+	const noFlagForceColor = envForceColor();
+	if (noFlagForceColor !== void 0) flagForceColor = noFlagForceColor;
+	const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+	if (forceColor === 0) return 0;
+	if (sniffFlags) {
+		if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
+		if (hasFlag("color=256")) return 2;
+	}
+	if ("TF_BUILD" in env && "AGENT_NAME" in env) return 1;
+	if (haveStream && !streamIsTTY && forceColor === void 0) return 0;
+	const min = forceColor || 0;
+	if (env.TERM === "dumb") return min;
+	if (process$1.platform === "win32") {
+		const osRelease = os.release().split(".");
+		if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+		return 1;
+	}
+	if ("CI" in env) {
+		if ([
+			"GITHUB_ACTIONS",
+			"GITEA_ACTIONS",
+			"CIRCLECI"
+		].some((key) => key in env)) return 3;
+		if ([
+			"TRAVIS",
+			"APPVEYOR",
+			"GITLAB_CI",
+			"BUILDKITE",
+			"DRONE"
+		].some((sign) => sign in env) || env.CI_NAME === "codeship") return 1;
+		return min;
+	}
+	if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+	if (env.COLORTERM === "truecolor") return 3;
+	if (env.TERM === "xterm-kitty") return 3;
+	if (env.TERM === "xterm-ghostty") return 3;
+	if (env.TERM === "wezterm") return 3;
+	if ("TERM_PROGRAM" in env) {
+		const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+		switch (env.TERM_PROGRAM) {
+			case "iTerm.app": return version >= 3 ? 3 : 2;
+			case "Apple_Terminal": return 2;
+		}
+	}
+	if (/-256(color)?$/i.test(env.TERM)) return 2;
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+	if ("COLORTERM" in env) return 1;
+	return min;
+}
+function createSupportsColor(stream, options = {}) {
+	return translateLevel(_supportsColor(stream, {
+		streamIsTTY: stream && stream.isTTY,
+		...options
+	}));
+}
+const supportsColor = {
+	stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+	stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+	let index = string.indexOf(substring);
+	if (index === -1) return string;
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		returnValue += string.slice(endIndex, index) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		const gotCR = string[index - 1] === "\r";
+		returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+		endIndex = index + 1;
+		index = string.indexOf("\n", endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+const { stdout: stdoutColor, stderr: stderrColor } = supportsColor;
+const GENERATOR = Symbol("GENERATOR");
+const STYLER = Symbol("STYLER");
+const IS_EMPTY = Symbol("IS_EMPTY");
+const levelMapping = [
+	"ansi",
+	"ansi",
+	"ansi256",
+	"ansi16m"
+];
+const styles = Object.create(null);
+const applyOptions = (object, options = {}) => {
+	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) throw new Error("The `level` option should be an integer from 0 to 3");
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	object.level = options.level === void 0 ? colorLevel : options.level;
+};
+const chalkFactory = (options) => {
+	const chalk = (...strings) => strings.join(" ");
+	applyOptions(chalk, options);
+	Object.setPrototypeOf(chalk, createChalk.prototype);
+	return chalk;
+};
+function createChalk(options) {
+	return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansiStyles)) styles[styleName] = { get() {
+	const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+	Object.defineProperty(this, styleName, { value: builder });
+	return builder;
+} };
+styles.visible = { get() {
+	const builder = createBuilder(this, this[STYLER], true);
+	Object.defineProperty(this, "visible", { value: builder });
+	return builder;
+} };
+const getModelAnsi = (model, level, type, ...arguments_) => {
+	if (model === "rgb") {
+		if (level === "ansi16m") return ansiStyles[type].ansi16m(...arguments_);
+		if (level === "ansi256") return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
+		return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
+	}
+	if (model === "hex") return getModelAnsi("rgb", level, type, ...ansiStyles.hexToRgb(...arguments_));
+	return ansiStyles[type][model](...arguments_);
+};
+for (const model of [
+	"rgb",
+	"hex",
+	"ansi256"
+]) {
+	styles[model] = { get() {
+		const { level } = this;
+		return function(...arguments_) {
+			const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansiStyles.color.close, this[STYLER]);
+			return createBuilder(this, styler, this[IS_EMPTY]);
+		};
+	} };
+	const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+	styles[bgModel] = { get() {
+		const { level } = this;
+		return function(...arguments_) {
+			const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
+			return createBuilder(this, styler, this[IS_EMPTY]);
+		};
+	} };
+}
+const proto = Object.defineProperties(() => {}, {
+	...styles,
+	level: {
+		enumerable: true,
+		get() {
+			return this[GENERATOR].level;
+		},
+		set(level) {
+			this[GENERATOR].level = level;
+		}
+	}
+});
+const createStyler = (open, close, parent) => {
+	let openAll;
+	let closeAll;
+	if (parent === void 0) {
+		openAll = open;
+		closeAll = close;
+	} else {
+		openAll = parent.openAll + open;
+		closeAll = close + parent.closeAll;
+	}
+	return {
+		open,
+		close,
+		openAll,
+		closeAll,
+		parent
+	};
+};
+const createBuilder = (self, _styler, _isEmpty) => {
+	const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+	Object.setPrototypeOf(builder, proto);
+	builder[GENERATOR] = self;
+	builder[STYLER] = _styler;
+	builder[IS_EMPTY] = _isEmpty;
+	return builder;
+};
+const applyStyle = (self, string) => {
+	if (self.level <= 0 || !string) return self[IS_EMPTY] ? "" : string;
+	let styler = self[STYLER];
+	if (styler === void 0) return string;
+	const { openAll, closeAll } = styler;
+	if (string.includes("\x1B")) while (styler !== void 0) {
+		string = stringReplaceAll(string, styler.close, styler.open);
+		styler = styler.parent;
+	}
+	const lfIndex = string.indexOf("\n");
+	if (lfIndex !== -1) string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+	return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles);
+const chalk = createChalk();
+createChalk({ level: stderrColor ? stderrColor.level : 0 });
+//#endregion
+//#region ../../node_modules/.pnpm/glob@13.0.6/node_modules/glob/dist/esm/index.min.js
+function Ht(n) {
+	return isNaN(n) ? n.charCodeAt(0) : parseInt(n, 10);
+}
+function ps(n) {
+	return n.replace(as, fe).replace(ls, ue).replace(cs, qt).replace(fs, de).replace(us, pe);
+}
+function ms(n) {
+	return n.replace(is, "\\").replace(rs, "{").replace(ns, "}").replace(os$1, ",").replace(hs, ".");
+}
+function me(n) {
+	if (!n) return [""];
+	let t = [], e = Gt("{", "}", n);
+	if (!e) return n.split(",");
+	let { pre: s, body: i, post: r } = e, o = s.split(",");
+	o[o.length - 1] += "{" + i + "}";
+	let h = me(r);
+	return r.length && (o[o.length - 1] += h.shift(), o.push.apply(o, h)), t.push.apply(t, o), t;
+}
+function ge(n, t = {}) {
+	if (!n) return [];
+	let { max: e = ds } = t;
+	return n.slice(0, 2) === "{}" && (n = "\\{\\}" + n.slice(2)), ht(ps(n), e, !0).map(ms);
+}
+function gs(n) {
+	return "{" + n + "}";
+}
+function ws(n) {
+	return /^-?0\d/.test(n);
+}
+function ys(n, t) {
+	return n <= t;
+}
+function bs(n, t) {
+	return n >= t;
+}
+function ht(n, t, e) {
+	let s = [], i = Gt("{", "}", n);
+	if (!i) return [n];
+	let r = i.pre, o = i.post.length ? ht(i.post, t, !1) : [""];
+	if (/\$$/.test(i.pre)) for (let h = 0; h < o.length && h < t; h++) {
+		let a = r + "{" + i.body + "}" + o[h];
+		s.push(a);
+	}
+	else {
+		let h = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(i.body), a = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(i.body), l = h || a, u = i.body.indexOf(",") >= 0;
+		if (!l && !u) return i.post.match(/,(?!,).*\}/) ? (n = i.pre + "{" + i.body + qt + i.post, ht(n, t, !0)) : [n];
+		let c;
+		if (l) c = i.body.split(/\.\./);
+		else if (c = me(i.body), c.length === 1 && c[0] !== void 0 && (c = ht(c[0], t, !1).map(gs), c.length === 1)) return o.map((f) => i.pre + c[0] + f);
+		let d;
+		if (l && c[0] !== void 0 && c[1] !== void 0) {
+			let f = Ht(c[0]), m = Ht(c[1]), p = Math.max(c[0].length, c[1].length), w = c.length === 3 && c[2] !== void 0 ? Math.abs(Ht(c[2])) : 1, g = ys;
+			m < f && (w *= -1, g = bs);
+			let E = c.some(ws);
+			d = [];
+			for (let y = f; g(y, m); y += w) {
+				let b;
+				if (a) b = String.fromCharCode(y), b === "\\" && (b = "");
+				else if (b = String(y), E) {
+					let z = p - b.length;
+					if (z > 0) {
+						let $ = new Array(z + 1).join("0");
+						y < 0 ? b = "-" + $ + b.slice(1) : b = $ + b;
+					}
+				}
+				d.push(b);
+			}
+		} else {
+			d = [];
+			for (let f = 0; f < c.length; f++) d.push.apply(d, ht(c[f], t, !1));
+		}
+		for (let f = 0; f < d.length; f++) for (let m = 0; m < o.length && s.length < t; m++) {
+			let p = r + d[f] + o[m];
+			(!e || l || p) && s.push(p);
+		}
+	}
+	return s;
+}
+function Bt(n, t = {}) {
+	return new I(n, t).streamSync();
+}
+function Qe(n, t = {}) {
+	return new I(n, t).stream();
+}
+function ts(n, t = {}) {
+	return new I(n, t).walkSync();
+}
+async function Je(n, t = {}) {
+	return new I(n, t).walk();
+}
+function Ut(n, t = {}) {
+	return new I(n, t).iterateSync();
+}
+function es(n, t = {}) {
+	return new I(n, t).iterate();
+}
+var Gt, ce, ss, fe, ue, qt, de, pe, is, rs, ns, os$1, hs, as, ls, cs, fs, us, ds, at, Ss, lt, Es, we, ye, W, xs, be, vs, Ct, Cs, Ts, As, ks, Kt, Se, Ee, Q, tt, O, Rs, Os, Fs, Ds, Ms, Ns, _s, Ls, Ws, Ps, js, Is, zs, Bs, Us, $s, Gs, Hs, Ce, Te, Ae, xe, A, Vs, Ys, Xs, Js, N, Zs, ke, Qs, ti, ve, ei, D, si, Oe, Vt, Fe, At, Re, ii, q, De, Tt, ri, ft, Ne, oi, hi, ai, G, H, K, kt, ut, Rt, _e, Ot, Le, P, et, v, dt, st, C, F, T, Yt, Ft, k, x, Xt, Jt, We, Zt, B, Qt, Dt, pt, Y, M, mt, li, ci, fi, ui, Mt, te, di, pi, V, wt, Ue, $e, Ri, Oi, L, Ge, He, U, qe, Ke, X, Ve, _, gt, se, je, yt, j, Nt, Lt, Ie, Fi, ie, ze, bt, Be, _t, Wt, ne, Ye, R, Pt, jt, It, it, rt, St, Xe, Di, Mi, Ni, nt, _i, ot, oe, he, ae, Et, Li, zt, xt, vt, Pi, I, le, ji, Ii, zi, Bi, Ui, Ze;
+//#endregion
+//#region src/lib/copyAssetFiles.ts
+__esmMin((() => {
+	Gt = (n, t, e) => {
+		let s = n instanceof RegExp ? ce(n, e) : n, i = t instanceof RegExp ? ce(t, e) : t, r = s !== null && i != null && ss(s, i, e);
+		return r && {
+			start: r[0],
+			end: r[1],
+			pre: e.slice(0, r[0]),
+			body: e.slice(r[0] + s.length, r[1]),
+			post: e.slice(r[1] + i.length)
+		};
+	}, ce = (n, t) => {
+		let e = t.match(n);
+		return e ? e[0] : null;
+	}, ss = (n, t, e) => {
+		let s, i, r, o, h, a = e.indexOf(n), l = e.indexOf(t, a + 1), u = a;
+		if (a >= 0 && l > 0) {
+			if (n === t) return [a, l];
+			for (s = [], r = e.length; u >= 0 && !h;) {
+				if (u === a) s.push(u), a = e.indexOf(n, u + 1);
+				else if (s.length === 1) {
+					let c = s.pop();
+					c !== void 0 && (h = [c, l]);
+				} else i = s.pop(), i !== void 0 && i < r && (r = i, o = l), l = e.indexOf(t, u + 1);
+				u = a < l && a >= 0 ? a : l;
+			}
+			s.length && o !== void 0 && (h = [r, o]);
+		}
+		return h;
+	};
+	fe = "\0SLASH" + Math.random() + "\0", ue = "\0OPEN" + Math.random() + "\0", qt = "\0CLOSE" + Math.random() + "\0", de = "\0COMMA" + Math.random() + "\0", pe = "\0PERIOD" + Math.random() + "\0", is = new RegExp(fe, "g"), rs = new RegExp(ue, "g"), ns = new RegExp(qt, "g"), os$1 = new RegExp(de, "g"), hs = new RegExp(pe, "g"), as = /\\\\/g, ls = /\\{/g, cs = /\\}/g, fs = /\\,/g, us = /\\./g, ds = 1e5;
+	at = (n) => {
+		if (typeof n != "string") throw new TypeError("invalid pattern");
+		if (n.length > 65536) throw new TypeError("pattern is too long");
+	};
+	Ss = {
+		"[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", !0],
+		"[:alpha:]": ["\\p{L}\\p{Nl}", !0],
+		"[:ascii:]": ["\\x00-\\x7f", !1],
+		"[:blank:]": ["\\p{Zs}\\t", !0],
+		"[:cntrl:]": ["\\p{Cc}", !0],
+		"[:digit:]": ["\\p{Nd}", !0],
+		"[:graph:]": [
+			"\\p{Z}\\p{C}",
+			!0,
+			!0
+		],
+		"[:lower:]": ["\\p{Ll}", !0],
+		"[:print:]": ["\\p{C}", !0],
+		"[:punct:]": ["\\p{P}", !0],
+		"[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", !0],
+		"[:upper:]": ["\\p{Lu}", !0],
+		"[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", !0],
+		"[:xdigit:]": ["A-Fa-f0-9", !1]
+	}, lt = (n) => n.replace(/[[\]\\-]/g, "\\$&"), Es = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), we = (n) => n.join(""), ye = (n, t) => {
+		let e = t;
+		if (n.charAt(e) !== "[") throw new Error("not in a brace expression");
+		let s = [], i = [], r = e + 1, o = !1, h = !1, a = !1, l = !1, u = e, c = "";
+		t: for (; r < n.length;) {
+			let p = n.charAt(r);
+			if ((p === "!" || p === "^") && r === e + 1) {
+				l = !0, r++;
+				continue;
+			}
+			if (p === "]" && o && !a) {
+				u = r + 1;
+				break;
+			}
+			if (o = !0, p === "\\" && !a) {
+				a = !0, r++;
+				continue;
+			}
+			if (p === "[" && !a) {
+				for (let [w, [g, S, E]] of Object.entries(Ss)) if (n.startsWith(w, r)) {
+					if (c) return [
+						"$.",
+						!1,
+						n.length - e,
+						!0
+					];
+					r += w.length, E ? i.push(g) : s.push(g), h = h || S;
+					continue t;
+				}
+			}
+			if (a = !1, c) {
+				p > c ? s.push(lt(c) + "-" + lt(p)) : p === c && s.push(lt(p)), c = "", r++;
+				continue;
+			}
+			if (n.startsWith("-]", r + 1)) {
+				s.push(lt(p + "-")), r += 2;
+				continue;
+			}
+			if (n.startsWith("-", r + 1)) {
+				c = p, r += 2;
+				continue;
+			}
+			s.push(lt(p)), r++;
+		}
+		if (u < r) return [
+			"",
+			!1,
+			0,
+			!1
+		];
+		if (!s.length && !i.length) return [
+			"$.",
+			!1,
+			n.length - e,
+			!0
+		];
+		if (i.length === 0 && s.length === 1 && /^\\?.$/.test(s[0]) && !l) return [
+			Es(s[0].length === 2 ? s[0].slice(-1) : s[0]),
+			!1,
+			u - e,
+			!1
+		];
+		let d = "[" + (l ? "^" : "") + we(s) + "]", f = "[" + (l ? "" : "^") + we(i) + "]";
+		return [
+			s.length && i.length ? "(" + d + "|" + f + ")" : s.length ? d : f,
+			h,
+			u - e,
+			!0
+		];
+	};
+	W = (n, { windowsPathsNoEscape: t = !1, magicalBraces: e = !0 } = {}) => e ? t ? n.replace(/\[([^\/\\])\]/g, "$1") : n.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1") : t ? n.replace(/\[([^\/\\{}])\]/g, "$1") : n.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
+	xs = /* @__PURE__ */ new Set([
+		"!",
+		"?",
+		"+",
+		"*",
+		"@"
+	]), be = (n) => xs.has(n), vs = "(?!(?:^|/)\\.\\.?(?:$|/))", Ct = "(?!\\.)", Cs = /* @__PURE__ */ new Set(["[", "."]), Ts = /* @__PURE__ */ new Set(["..", "."]), As = /* @__PURE__ */ new Set("().*{}+?[]^$\\!"), ks = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), Kt = "[^/]", Se = Kt + "*?", Ee = Kt + "+?", Q = class n {
+		type;
+		#t;
+		#s;
+		#n = !1;
+		#r = [];
+		#o;
+		#S;
+		#w;
+		#c = !1;
+		#h;
+		#u;
+		#f = !1;
+		constructor(t, e, s = {}) {
+			this.type = t, t && (this.#s = !0), this.#o = e, this.#t = this.#o ? this.#o.#t : this, this.#h = this.#t === this ? s : this.#t.#h, this.#w = this.#t === this ? [] : this.#t.#w, t === "!" && !this.#t.#c && this.#w.push(this), this.#S = this.#o ? this.#o.#r.length : 0;
+		}
+		get hasMagic() {
+			if (this.#s !== void 0) return this.#s;
+			for (let t of this.#r) if (typeof t != "string" && (t.type || t.hasMagic)) return this.#s = !0;
+			return this.#s;
+		}
+		toString() {
+			return this.#u !== void 0 ? this.#u : this.type ? this.#u = this.type + "(" + this.#r.map((t) => String(t)).join("|") + ")" : this.#u = this.#r.map((t) => String(t)).join("");
+		}
+		#a() {
+			if (this !== this.#t) throw new Error("should only call on root");
+			if (this.#c) return this;
+			this.toString(), this.#c = !0;
+			let t;
+			for (; t = this.#w.pop();) {
+				if (t.type !== "!") continue;
+				let e = t, s = e.#o;
+				for (; s;) {
+					for (let i = e.#S + 1; !s.type && i < s.#r.length; i++) for (let r of t.#r) {
+						if (typeof r == "string") throw new Error("string part in extglob AST??");
+						r.copyIn(s.#r[i]);
+					}
+					e = s, s = e.#o;
+				}
+			}
+			return this;
+		}
+		push(...t) {
+			for (let e of t) if (e !== "") {
+				if (typeof e != "string" && !(e instanceof n && e.#o === this)) throw new Error("invalid part: " + e);
+				this.#r.push(e);
+			}
+		}
+		toJSON() {
+			let t = this.type === null ? this.#r.slice().map((e) => typeof e == "string" ? e : e.toJSON()) : [this.type, ...this.#r.map((e) => e.toJSON())];
+			return this.isStart() && !this.type && t.unshift([]), this.isEnd() && (this === this.#t || this.#t.#c && this.#o?.type === "!") && t.push({}), t;
+		}
+		isStart() {
+			if (this.#t === this) return !0;
+			if (!this.#o?.isStart()) return !1;
+			if (this.#S === 0) return !0;
+			let t = this.#o;
+			for (let e = 0; e < this.#S; e++) {
+				let s = t.#r[e];
+				if (!(s instanceof n && s.type === "!")) return !1;
+			}
+			return !0;
+		}
+		isEnd() {
+			if (this.#t === this || this.#o?.type === "!") return !0;
+			if (!this.#o?.isEnd()) return !1;
+			if (!this.type) return this.#o?.isEnd();
+			let t = this.#o ? this.#o.#r.length : 0;
+			return this.#S === t - 1;
+		}
+		copyIn(t) {
+			typeof t == "string" ? this.push(t) : this.push(t.clone(this));
+		}
+		clone(t) {
+			let e = new n(this.type, t);
+			for (let s of this.#r) e.copyIn(s);
+			return e;
+		}
+		static #i(t, e, s, i) {
+			let r = !1, o = !1, h = -1, a = !1;
+			if (e.type === null) {
+				let f = s, m = "";
+				for (; f < t.length;) {
+					let p = t.charAt(f++);
+					if (r || p === "\\") {
+						r = !r, m += p;
+						continue;
+					}
+					if (o) {
+						f === h + 1 ? (p === "^" || p === "!") && (a = !0) : p === "]" && !(f === h + 2 && a) && (o = !1), m += p;
+						continue;
+					} else if (p === "[") {
+						o = !0, h = f, a = !1, m += p;
+						continue;
+					}
+					if (!i.noext && be(p) && t.charAt(f) === "(") {
+						e.push(m), m = "";
+						let w = new n(p, e);
+						f = n.#i(t, w, f, i), e.push(w);
+						continue;
+					}
+					m += p;
+				}
+				return e.push(m), f;
+			}
+			let l = s + 1, u = new n(null, e), c = [], d = "";
+			for (; l < t.length;) {
+				let f = t.charAt(l++);
+				if (r || f === "\\") {
+					r = !r, d += f;
+					continue;
+				}
+				if (o) {
+					l === h + 1 ? (f === "^" || f === "!") && (a = !0) : f === "]" && !(l === h + 2 && a) && (o = !1), d += f;
+					continue;
+				} else if (f === "[") {
+					o = !0, h = l, a = !1, d += f;
+					continue;
+				}
+				if (be(f) && t.charAt(l) === "(") {
+					u.push(d), d = "";
+					let m = new n(f, u);
+					u.push(m), l = n.#i(t, m, l, i);
+					continue;
+				}
+				if (f === "|") {
+					u.push(d), d = "", c.push(u), u = new n(null, e);
+					continue;
+				}
+				if (f === ")") return d === "" && e.#r.length === 0 && (e.#f = !0), u.push(d), d = "", e.push(...c, u), l;
+				d += f;
+			}
+			return e.type = null, e.#s = void 0, e.#r = [t.substring(s - 1)], l;
+		}
+		static fromGlob(t, e = {}) {
+			let s = new n(null, void 0, e);
+			return n.#i(t, s, 0, e), s;
+		}
+		toMMPattern() {
+			if (this !== this.#t) return this.#t.toMMPattern();
+			let t = this.toString(), [e, s, i, r] = this.toRegExpSource();
+			if (!(i || this.#s || this.#h.nocase && !this.#h.nocaseMagicOnly && t.toUpperCase() !== t.toLowerCase())) return s;
+			let h = (this.#h.nocase ? "i" : "") + (r ? "u" : "");
+			return Object.assign(new RegExp(`^${e}$`, h), {
+				_src: e,
+				_glob: t
+			});
+		}
+		get options() {
+			return this.#h;
+		}
+		toRegExpSource(t) {
+			let e = t ?? !!this.#h.dot;
+			if (this.#t === this && this.#a(), !this.type) {
+				let a = this.isStart() && this.isEnd() && !this.#r.some((f) => typeof f != "string"), l = this.#r.map((f) => {
+					let [m, p, w, g] = typeof f == "string" ? n.#E(f, this.#s, a) : f.toRegExpSource(t);
+					return this.#s = this.#s || w, this.#n = this.#n || g, m;
+				}).join(""), u = "";
+				if (this.isStart() && typeof this.#r[0] == "string" && !(this.#r.length === 1 && Ts.has(this.#r[0]))) {
+					let m = Cs, p = e && m.has(l.charAt(0)) || l.startsWith("\\.") && m.has(l.charAt(2)) || l.startsWith("\\.\\.") && m.has(l.charAt(4)), w = !e && !t && m.has(l.charAt(0));
+					u = p ? vs : w ? Ct : "";
+				}
+				let c = "";
+				return this.isEnd() && this.#t.#c && this.#o?.type === "!" && (c = "(?:$|\\/)"), [
+					u + l + c,
+					W(l),
+					this.#s = !!this.#s,
+					this.#n
+				];
+			}
+			let s = this.type === "*" || this.type === "+", i = this.type === "!" ? "(?:(?!(?:" : "(?:", r = this.#d(e);
+			if (this.isStart() && this.isEnd() && !r && this.type !== "!") {
+				let a = this.toString();
+				return this.#r = [a], this.type = null, this.#s = void 0, [
+					a,
+					W(this.toString()),
+					!1,
+					!1
+				];
+			}
+			let o = !s || t || e || !Ct ? "" : this.#d(!0);
+			o === r && (o = ""), o && (r = `(?:${r})(?:${o})*?`);
+			let h = "";
+			if (this.type === "!" && this.#f) h = (this.isStart() && !e ? Ct : "") + Ee;
+			else {
+				let a = this.type === "!" ? "))" + (this.isStart() && !e && !t ? Ct : "") + Se + ")" : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && o ? ")" : this.type === "*" && o ? ")?" : `)${this.type}`;
+				h = i + r + a;
+			}
+			return [
+				h,
+				W(r),
+				this.#s = !!this.#s,
+				this.#n
+			];
+		}
+		#d(t) {
+			return this.#r.map((e) => {
+				if (typeof e == "string") throw new Error("string type in extglob ast??");
+				let [s, i, r, o] = e.toRegExpSource(t);
+				return this.#n = this.#n || o, s;
+			}).filter((e) => !(this.isStart() && this.isEnd()) || !!e).join("|");
+		}
+		static #E(t, e, s = !1) {
+			let i = !1, r = "", o = !1, h = !1;
+			for (let a = 0; a < t.length; a++) {
+				let l = t.charAt(a);
+				if (i) {
+					i = !1, r += (As.has(l) ? "\\" : "") + l;
+					continue;
+				}
+				if (l === "*") {
+					if (h) continue;
+					h = !0, r += s && /^[*]+$/.test(t) ? Ee : Se, e = !0;
+					continue;
+				} else h = !1;
+				if (l === "\\") {
+					a === t.length - 1 ? r += "\\\\" : i = !0;
+					continue;
+				}
+				if (l === "[") {
+					let [u, c, d, f] = ye(t, a);
+					if (d) {
+						r += u, o = o || c, a += d - 1, e = e || f;
+						continue;
+					}
+				}
+				if (l === "?") {
+					r += Kt, e = !0;
+					continue;
+				}
+				r += ks(l);
+			}
+			return [
+				r,
+				W(t),
+				!!e,
+				o
+			];
+		}
+	};
+	tt = (n, { windowsPathsNoEscape: t = !1, magicalBraces: e = !1 } = {}) => e ? t ? n.replace(/[?*()[\]{}]/g, "[$&]") : n.replace(/[?*()[\]\\{}]/g, "\\$&") : t ? n.replace(/[?*()[\]]/g, "[$&]") : n.replace(/[?*()[\]\\]/g, "\\$&");
+	O = (n, t, e = {}) => (at(t), !e.nocomment && t.charAt(0) === "#" ? !1 : new D(t, e).match(n)), Rs = /^\*+([^+@!?\*\[\(]*)$/, Os = (n) => (t) => !t.startsWith(".") && t.endsWith(n), Fs = (n) => (t) => t.endsWith(n), Ds = (n) => (n = n.toLowerCase(), (t) => !t.startsWith(".") && t.toLowerCase().endsWith(n)), Ms = (n) => (n = n.toLowerCase(), (t) => t.toLowerCase().endsWith(n)), Ns = /^\*+\.\*+$/, _s = (n) => !n.startsWith(".") && n.includes("."), Ls = (n) => n !== "." && n !== ".." && n.includes("."), Ws = /^\.\*+$/, Ps = (n) => n !== "." && n !== ".." && n.startsWith("."), js = /^\*+$/, Is = (n) => n.length !== 0 && !n.startsWith("."), zs = (n) => n.length !== 0 && n !== "." && n !== "..", Bs = /^\?+([^+@!?\*\[\(]*)?$/, Us = ([n, t = ""]) => {
+		let e = Ce([n]);
+		return t ? (t = t.toLowerCase(), (s) => e(s) && s.toLowerCase().endsWith(t)) : e;
+	}, $s = ([n, t = ""]) => {
+		let e = Te([n]);
+		return t ? (t = t.toLowerCase(), (s) => e(s) && s.toLowerCase().endsWith(t)) : e;
+	}, Gs = ([n, t = ""]) => {
+		let e = Te([n]);
+		return t ? (s) => e(s) && s.endsWith(t) : e;
+	}, Hs = ([n, t = ""]) => {
+		let e = Ce([n]);
+		return t ? (s) => e(s) && s.endsWith(t) : e;
+	}, Ce = ([n]) => {
+		let t = n.length;
+		return (e) => e.length === t && !e.startsWith(".");
+	}, Te = ([n]) => {
+		let t = n.length;
+		return (e) => e.length === t && e !== "." && e !== "..";
+	}, Ae = typeof process == "object" && process ? typeof process.env == "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix", xe = {
+		win32: { sep: "\\" },
+		posix: { sep: "/" }
+	};
+	O.sep = Ae === "win32" ? xe.win32.sep : xe.posix.sep;
+	A = Symbol("globstar **");
+	O.GLOBSTAR = A;
+	Vs = "[^/]*?", Ys = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", Xs = "(?:(?!(?:\\/|^)\\.).)*?", Js = (n, t = {}) => (e) => O(e, n, t);
+	O.filter = Js;
+	N = (n, t = {}) => Object.assign({}, n, t), Zs = (n) => {
+		if (!n || typeof n != "object" || !Object.keys(n).length) return O;
+		let t = O;
+		return Object.assign((s, i, r = {}) => t(s, i, N(n, r)), {
+			Minimatch: class extends t.Minimatch {
+				constructor(i, r = {}) {
+					super(i, N(n, r));
+				}
+				static defaults(i) {
+					return t.defaults(N(n, i)).Minimatch;
+				}
+			},
+			AST: class extends t.AST {
+				constructor(i, r, o = {}) {
+					super(i, r, N(n, o));
+				}
+				static fromGlob(i, r = {}) {
+					return t.AST.fromGlob(i, N(n, r));
+				}
+			},
+			unescape: (s, i = {}) => t.unescape(s, N(n, i)),
+			escape: (s, i = {}) => t.escape(s, N(n, i)),
+			filter: (s, i = {}) => t.filter(s, N(n, i)),
+			defaults: (s) => t.defaults(N(n, s)),
+			makeRe: (s, i = {}) => t.makeRe(s, N(n, i)),
+			braceExpand: (s, i = {}) => t.braceExpand(s, N(n, i)),
+			match: (s, i, r = {}) => t.match(s, i, N(n, r)),
+			sep: t.sep,
+			GLOBSTAR: A
+		});
+	};
+	O.defaults = Zs;
+	ke = (n, t = {}) => (at(n), t.nobrace || !/\{(?:(?!\{).)*\}/.test(n) ? [n] : ge(n, { max: t.braceExpandMax }));
+	O.braceExpand = ke;
+	Qs = (n, t = {}) => new D(n, t).makeRe();
+	O.makeRe = Qs;
+	ti = (n, t, e = {}) => {
+		let s = new D(t, e);
+		return n = n.filter((i) => s.match(i)), s.options.nonull && !n.length && n.push(t), n;
+	};
+	O.match = ti;
+	ve = /[?*]|[+@!]\(.*?\)|\[|\]/, ei = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), D = class {
+		options;
+		set;
+		pattern;
+		windowsPathsNoEscape;
+		nonegate;
+		negate;
+		comment;
+		empty;
+		preserveMultipleSlashes;
+		partial;
+		globSet;
+		globParts;
+		nocase;
+		isWindows;
+		platform;
+		windowsNoMagicRoot;
+		regexp;
+		constructor(t, e = {}) {
+			at(t), e = e || {}, this.options = e, this.pattern = t, this.platform = e.platform || Ae, this.isWindows = this.platform === "win32";
+			let s = "allowWindowsEscape";
+			this.windowsPathsNoEscape = !!e.windowsPathsNoEscape || e[s] === !1, this.windowsPathsNoEscape && (this.pattern = this.pattern.replace(/\\/g, "/")), this.preserveMultipleSlashes = !!e.preserveMultipleSlashes, this.regexp = null, this.negate = !1, this.nonegate = !!e.nonegate, this.comment = !1, this.empty = !1, this.partial = !!e.partial, this.nocase = !!this.options.nocase, this.windowsNoMagicRoot = e.windowsNoMagicRoot !== void 0 ? e.windowsNoMagicRoot : !!(this.isWindows && this.nocase), this.globSet = [], this.globParts = [], this.set = [], this.make();
+		}
+		hasMagic() {
+			if (this.options.magicalBraces && this.set.length > 1) return !0;
+			for (let t of this.set) for (let e of t) if (typeof e != "string") return !0;
+			return !1;
+		}
+		debug(...t) {}
+		make() {
+			let t = this.pattern, e = this.options;
+			if (!e.nocomment && t.charAt(0) === "#") {
+				this.comment = !0;
+				return;
+			}
+			if (!t) {
+				this.empty = !0;
+				return;
+			}
+			this.parseNegate(), this.globSet = [...new Set(this.braceExpand())], e.debug && (this.debug = (...r) => console.error(...r)), this.debug(this.pattern, this.globSet);
+			let s = this.globSet.map((r) => this.slashSplit(r));
+			this.globParts = this.preprocess(s), this.debug(this.pattern, this.globParts);
+			let i = this.globParts.map((r, o, h) => {
+				if (this.isWindows && this.windowsNoMagicRoot) {
+					let a = r[0] === "" && r[1] === "" && (r[2] === "?" || !ve.test(r[2])) && !ve.test(r[3]), l = /^[a-z]:/i.test(r[0]);
+					if (a) return [...r.slice(0, 4), ...r.slice(4).map((u) => this.parse(u))];
+					if (l) return [r[0], ...r.slice(1).map((u) => this.parse(u))];
+				}
+				return r.map((a) => this.parse(a));
+			});
+			if (this.debug(this.pattern, i), this.set = i.filter((r) => r.indexOf(!1) === -1), this.isWindows) for (let r = 0; r < this.set.length; r++) {
+				let o = this.set[r];
+				o[0] === "" && o[1] === "" && this.globParts[r][2] === "?" && typeof o[3] == "string" && /^[a-z]:$/i.test(o[3]) && (o[2] = "?");
+			}
+			this.debug(this.pattern, this.set);
+		}
+		preprocess(t) {
+			if (this.options.noglobstar) for (let s = 0; s < t.length; s++) for (let i = 0; i < t[s].length; i++) t[s][i] === "**" && (t[s][i] = "*");
+			let { optimizationLevel: e = 1 } = this.options;
+			return e >= 2 ? (t = this.firstPhasePreProcess(t), t = this.secondPhasePreProcess(t)) : e >= 1 ? t = this.levelOneOptimize(t) : t = this.adjascentGlobstarOptimize(t), t;
+		}
+		adjascentGlobstarOptimize(t) {
+			return t.map((e) => {
+				let s = -1;
+				for (; (s = e.indexOf("**", s + 1)) !== -1;) {
+					let i = s;
+					for (; e[i + 1] === "**";) i++;
+					i !== s && e.splice(s, i - s);
+				}
+				return e;
+			});
+		}
+		levelOneOptimize(t) {
+			return t.map((e) => (e = e.reduce((s, i) => {
+				let r = s[s.length - 1];
+				return i === "**" && r === "**" ? s : i === ".." && r && r !== ".." && r !== "." && r !== "**" ? (s.pop(), s) : (s.push(i), s);
+			}, []), e.length === 0 ? [""] : e));
+		}
+		levelTwoFileOptimize(t) {
+			Array.isArray(t) || (t = this.slashSplit(t));
+			let e = !1;
+			do {
+				if (e = !1, !this.preserveMultipleSlashes) {
+					for (let i = 1; i < t.length - 1; i++) {
+						let r = t[i];
+						i === 1 && r === "" && t[0] === "" || (r === "." || r === "") && (e = !0, t.splice(i, 1), i--);
+					}
+					t[0] === "." && t.length === 2 && (t[1] === "." || t[1] === "") && (e = !0, t.pop());
+				}
+				let s = 0;
+				for (; (s = t.indexOf("..", s + 1)) !== -1;) {
+					let i = t[s - 1];
+					i && i !== "." && i !== ".." && i !== "**" && (e = !0, t.splice(s - 1, 2), s -= 2);
+				}
+			} while (e);
+			return t.length === 0 ? [""] : t;
+		}
+		firstPhasePreProcess(t) {
+			let e = !1;
+			do {
+				e = !1;
+				for (let s of t) {
+					let i = -1;
+					for (; (i = s.indexOf("**", i + 1)) !== -1;) {
+						let o = i;
+						for (; s[o + 1] === "**";) o++;
+						o > i && s.splice(i + 1, o - i);
+						let h = s[i + 1], a = s[i + 2], l = s[i + 3];
+						if (h !== ".." || !a || a === "." || a === ".." || !l || l === "." || l === "..") continue;
+						e = !0, s.splice(i, 1);
+						let u = s.slice(0);
+						u[i] = "**", t.push(u), i--;
+					}
+					if (!this.preserveMultipleSlashes) {
+						for (let o = 1; o < s.length - 1; o++) {
+							let h = s[o];
+							o === 1 && h === "" && s[0] === "" || (h === "." || h === "") && (e = !0, s.splice(o, 1), o--);
+						}
+						s[0] === "." && s.length === 2 && (s[1] === "." || s[1] === "") && (e = !0, s.pop());
+					}
+					let r = 0;
+					for (; (r = s.indexOf("..", r + 1)) !== -1;) {
+						let o = s[r - 1];
+						if (o && o !== "." && o !== ".." && o !== "**") {
+							e = !0;
+							let a = r === 1 && s[r + 1] === "**" ? ["."] : [];
+							s.splice(r - 1, 2, ...a), s.length === 0 && s.push(""), r -= 2;
+						}
+					}
+				}
+			} while (e);
+			return t;
+		}
+		secondPhasePreProcess(t) {
+			for (let e = 0; e < t.length - 1; e++) for (let s = e + 1; s < t.length; s++) {
+				let i = this.partsMatch(t[e], t[s], !this.preserveMultipleSlashes);
+				if (i) {
+					t[e] = [], t[s] = i;
+					break;
+				}
+			}
+			return t.filter((e) => e.length);
+		}
+		partsMatch(t, e, s = !1) {
+			let i = 0, r = 0, o = [], h = "";
+			for (; i < t.length && r < e.length;) if (t[i] === e[r]) o.push(h === "b" ? e[r] : t[i]), i++, r++;
+			else if (s && t[i] === "**" && e[r] === t[i + 1]) o.push(t[i]), i++;
+			else if (s && e[r] === "**" && t[i] === e[r + 1]) o.push(e[r]), r++;
+			else if (t[i] === "*" && e[r] && (this.options.dot || !e[r].startsWith(".")) && e[r] !== "**") {
+				if (h === "b") return !1;
+				h = "a", o.push(t[i]), i++, r++;
+			} else if (e[r] === "*" && t[i] && (this.options.dot || !t[i].startsWith(".")) && t[i] !== "**") {
+				if (h === "a") return !1;
+				h = "b", o.push(e[r]), i++, r++;
+			} else return !1;
+			return t.length === e.length && o;
+		}
+		parseNegate() {
+			if (this.nonegate) return;
+			let t = this.pattern, e = !1, s = 0;
+			for (let i = 0; i < t.length && t.charAt(i) === "!"; i++) e = !e, s++;
+			s && (this.pattern = t.slice(s)), this.negate = e;
+		}
+		matchOne(t, e, s = !1) {
+			let i = this.options;
+			if (this.isWindows) {
+				let p = typeof t[0] == "string" && /^[a-z]:$/i.test(t[0]), w = !p && t[0] === "" && t[1] === "" && t[2] === "?" && /^[a-z]:$/i.test(t[3]), g = typeof e[0] == "string" && /^[a-z]:$/i.test(e[0]), S = !g && e[0] === "" && e[1] === "" && e[2] === "?" && typeof e[3] == "string" && /^[a-z]:$/i.test(e[3]), E = w ? 3 : p ? 0 : void 0, y = S ? 3 : g ? 0 : void 0;
+				if (typeof E == "number" && typeof y == "number") {
+					let [b, z] = [t[E], e[y]];
+					b.toLowerCase() === z.toLowerCase() && (e[y] = b, y > E ? e = e.slice(y) : E > y && (t = t.slice(E)));
+				}
+			}
+			let { optimizationLevel: r = 1 } = this.options;
+			r >= 2 && (t = this.levelTwoFileOptimize(t)), this.debug("matchOne", this, {
+				file: t,
+				pattern: e
+			}), this.debug("matchOne", t.length, e.length);
+			for (var o = 0, h = 0, a = t.length, l = e.length; o < a && h < l; o++, h++) {
+				this.debug("matchOne loop");
+				var u = e[h], c = t[o];
+				if (this.debug(e, u, c), u === !1) return !1;
+				if (u === A) {
+					this.debug("GLOBSTAR", [
+						e,
+						u,
+						c
+					]);
+					var d = o, f = h + 1;
+					if (f === l) {
+						for (this.debug("** at the end"); o < a; o++) if (t[o] === "." || t[o] === ".." || !i.dot && t[o].charAt(0) === ".") return !1;
+						return !0;
+					}
+					for (; d < a;) {
+						var m = t[d];
+						if (this.debug(`
+globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) return this.debug("globstar found match!", d, a, m), !0;
+						if (m === "." || m === ".." || !i.dot && m.charAt(0) === ".") {
+							this.debug("dot detected!", t, d, e, f);
+							break;
+						}
+						this.debug("globstar swallow a segment, and continue"), d++;
+					}
+					return !!(s && (this.debug(`
+>>> no match, partial?`, t, d, e, f), d === a));
+				}
+				let p;
+				if (typeof u == "string" ? (p = c === u, this.debug("string match", u, c, p)) : (p = u.test(c), this.debug("pattern match", u, c, p)), !p) return !1;
+			}
+			if (o === a && h === l) return !0;
+			if (o === a) return s;
+			if (h === l) return o === a - 1 && t[o] === "";
+			throw new Error("wtf?");
+		}
+		braceExpand() {
+			return ke(this.pattern, this.options);
+		}
+		parse(t) {
+			at(t);
+			let e = this.options;
+			if (t === "**") return A;
+			if (t === "") return "";
+			let s, i = null;
+			(s = t.match(js)) ? i = e.dot ? zs : Is : (s = t.match(Rs)) ? i = (e.nocase ? e.dot ? Ms : Ds : e.dot ? Fs : Os)(s[1]) : (s = t.match(Bs)) ? i = (e.nocase ? e.dot ? $s : Us : e.dot ? Gs : Hs)(s) : (s = t.match(Ns)) ? i = e.dot ? Ls : _s : (s = t.match(Ws)) && (i = Ps);
+			let r = Q.fromGlob(t, this.options).toMMPattern();
+			return i && typeof r == "object" && Reflect.defineProperty(r, "test", { value: i }), r;
+		}
+		makeRe() {
+			if (this.regexp || this.regexp === !1) return this.regexp;
+			let t = this.set;
+			if (!t.length) return this.regexp = !1, this.regexp;
+			let e = this.options, s = e.noglobstar ? Vs : e.dot ? Ys : Xs, i = new Set(e.nocase ? ["i"] : []), r = t.map((a) => {
+				let l = a.map((c) => {
+					if (c instanceof RegExp) for (let d of c.flags.split("")) i.add(d);
+					return typeof c == "string" ? ei(c) : c === A ? A : c._src;
+				});
+				l.forEach((c, d) => {
+					let f = l[d + 1], m = l[d - 1];
+					c !== A || m === A || (m === void 0 ? f !== void 0 && f !== A ? l[d + 1] = "(?:\\/|" + s + "\\/)?" + f : l[d] = s : f === void 0 ? l[d - 1] = m + "(?:\\/|\\/" + s + ")?" : f !== A && (l[d - 1] = m + "(?:\\/|\\/" + s + "\\/)" + f, l[d + 1] = A));
+				});
+				let u = l.filter((c) => c !== A);
+				if (this.partial && u.length >= 1) {
+					let c = [];
+					for (let d = 1; d <= u.length; d++) c.push(u.slice(0, d).join("/"));
+					return "(?:" + c.join("|") + ")";
+				}
+				return u.join("/");
+			}).join("|"), [o, h] = t.length > 1 ? ["(?:", ")"] : ["", ""];
+			r = "^" + o + r + h + "$", this.partial && (r = "^(?:\\/|" + o + r.slice(1, -1) + h + ")$"), this.negate && (r = "^(?!" + r + ").+$");
+			try {
+				this.regexp = new RegExp(r, [...i].join(""));
+			} catch {
+				this.regexp = !1;
+			}
+			return this.regexp;
+		}
+		slashSplit(t) {
+			return this.preserveMultipleSlashes ? t.split("/") : this.isWindows && /^\/\/[^\/]+/.test(t) ? ["", ...t.split(/\/+/)] : t.split(/\/+/);
+		}
+		match(t, e = this.partial) {
+			if (this.debug("match", t, this.pattern), this.comment) return !1;
+			if (this.empty) return t === "";
+			if (t === "/" && e) return !0;
+			let s = this.options;
+			this.isWindows && (t = t.split("\\").join("/"));
+			let i = this.slashSplit(t);
+			this.debug(this.pattern, "split", i);
+			let r = this.set;
+			this.debug(this.pattern, "set", r);
+			let o = i[i.length - 1];
+			if (!o) for (let h = i.length - 2; !o && h >= 0; h--) o = i[h];
+			for (let h = 0; h < r.length; h++) {
+				let a = r[h], l = i;
+				if (s.matchBase && a.length === 1 && (l = [o]), this.matchOne(l, a, e)) return s.flipNegate ? !0 : !this.negate;
+			}
+			return s.flipNegate ? !1 : this.negate;
+		}
+		static defaults(t) {
+			return O.defaults(t).Minimatch;
+		}
+	};
+	O.AST = Q;
+	O.Minimatch = D;
+	O.escape = tt;
+	O.unescape = W;
+	si = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date, Oe = /* @__PURE__ */ new Set(), Vt = typeof process == "object" && process ? process : {}, Fe = (n, t, e, s) => {
+		typeof Vt.emitWarning == "function" ? Vt.emitWarning(n, t, e, s) : console.error(`[${e}] ${t}: ${n}`);
+	}, At = globalThis.AbortController, Re = globalThis.AbortSignal;
+	if (typeof At > "u") {
+		Re = class {
+			onabort;
+			_onabort = [];
+			reason;
+			aborted = !1;
+			addEventListener(e, s) {
+				this._onabort.push(s);
+			}
+		}, At = class {
+			constructor() {
+				t();
+			}
+			signal = new Re();
+			abort(e) {
+				if (!this.signal.aborted) {
+					this.signal.reason = e, this.signal.aborted = !0;
+					for (let s of this.signal._onabort) s(e);
+					this.signal.onabort?.(e);
+				}
+			}
+		};
+		let n = Vt.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1", t = () => {
+			n && (n = !1, Fe("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", t));
+		};
+	}
+	ii = (n) => !Oe.has(n);
+	q = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n), De = (n) => q(n) ? n <= Math.pow(2, 8) ? Uint8Array : n <= Math.pow(2, 16) ? Uint16Array : n <= Math.pow(2, 32) ? Uint32Array : n <= Number.MAX_SAFE_INTEGER ? Tt : null : null, Tt = class extends Array {
+		constructor(n) {
+			super(n), this.fill(0);
+		}
+	}, ri = class ct {
+		heap;
+		length;
+		static #t = !1;
+		static create(t) {
+			let e = De(t);
+			if (!e) return [];
+			ct.#t = !0;
+			let s = new ct(t, e);
+			return ct.#t = !1, s;
+		}
+		constructor(t, e) {
+			if (!ct.#t) throw new TypeError("instantiate Stack using Stack.create(n)");
+			this.heap = new e(t), this.length = 0;
+		}
+		push(t) {
+			this.heap[this.length++] = t;
+		}
+		pop() {
+			return this.heap[--this.length];
+		}
+	}, ft = class Me {
+		#t;
+		#s;
+		#n;
+		#r;
+		#o;
+		#S;
+		#w;
+		#c;
+		get perf() {
+			return this.#c;
+		}
+		ttl;
+		ttlResolution;
+		ttlAutopurge;
+		updateAgeOnGet;
+		updateAgeOnHas;
+		allowStale;
+		noDisposeOnSet;
+		noUpdateTTL;
+		maxEntrySize;
+		sizeCalculation;
+		noDeleteOnFetchRejection;
+		noDeleteOnStaleGet;
+		allowStaleOnFetchAbort;
+		allowStaleOnFetchRejection;
+		ignoreFetchAbort;
+		#h;
+		#u;
+		#f;
+		#a;
+		#i;
+		#d;
+		#E;
+		#b;
+		#p;
+		#R;
+		#m;
+		#C;
+		#T;
+		#g;
+		#y;
+		#x;
+		#A;
+		#e;
+		#_;
+		static unsafeExposeInternals(t) {
+			return {
+				starts: t.#T,
+				ttls: t.#g,
+				autopurgeTimers: t.#y,
+				sizes: t.#C,
+				keyMap: t.#f,
+				keyList: t.#a,
+				valList: t.#i,
+				next: t.#d,
+				prev: t.#E,
+				get head() {
+					return t.#b;
+				},
+				get tail() {
+					return t.#p;
+				},
+				free: t.#R,
+				isBackgroundFetch: (e) => t.#l(e),
+				backgroundFetch: (e, s, i, r) => t.#U(e, s, i, r),
+				moveToTail: (e) => t.#W(e),
+				indexes: (e) => t.#F(e),
+				rindexes: (e) => t.#D(e),
+				isStale: (e) => t.#v(e)
+			};
+		}
+		get max() {
+			return this.#t;
+		}
+		get maxSize() {
+			return this.#s;
+		}
+		get calculatedSize() {
+			return this.#u;
+		}
+		get size() {
+			return this.#h;
+		}
+		get fetchMethod() {
+			return this.#S;
+		}
+		get memoMethod() {
+			return this.#w;
+		}
+		get dispose() {
+			return this.#n;
+		}
+		get onInsert() {
+			return this.#r;
+		}
+		get disposeAfter() {
+			return this.#o;
+		}
+		constructor(t) {
+			let { max: e = 0, ttl: s, ttlResolution: i = 1, ttlAutopurge: r, updateAgeOnGet: o, updateAgeOnHas: h, allowStale: a, dispose: l, onInsert: u, disposeAfter: c, noDisposeOnSet: d, noUpdateTTL: f, maxSize: m = 0, maxEntrySize: p = 0, sizeCalculation: w, fetchMethod: g, memoMethod: S, noDeleteOnFetchRejection: E, noDeleteOnStaleGet: y, allowStaleOnFetchRejection: b, allowStaleOnFetchAbort: z, ignoreFetchAbort: $, perf: J } = t;
+			if (J !== void 0 && typeof J?.now != "function") throw new TypeError("perf option must have a now() method if specified");
+			if (this.#c = J ?? si, e !== 0 && !q(e)) throw new TypeError("max option must be a nonnegative integer");
+			let Z = e ? De(e) : Array;
+			if (!Z) throw new Error("invalid max value: " + e);
+			if (this.#t = e, this.#s = m, this.maxEntrySize = p || this.#s, this.sizeCalculation = w, this.sizeCalculation) {
+				if (!this.#s && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+				if (typeof this.sizeCalculation != "function") throw new TypeError("sizeCalculation set to non-function");
+			}
+			if (S !== void 0 && typeof S != "function") throw new TypeError("memoMethod must be a function if defined");
+			if (this.#w = S, g !== void 0 && typeof g != "function") throw new TypeError("fetchMethod must be a function if specified");
+			if (this.#S = g, this.#A = !!g, this.#f = /* @__PURE__ */ new Map(), this.#a = new Array(e).fill(void 0), this.#i = new Array(e).fill(void 0), this.#d = new Z(e), this.#E = new Z(e), this.#b = 0, this.#p = 0, this.#R = ri.create(e), this.#h = 0, this.#u = 0, typeof l == "function" && (this.#n = l), typeof u == "function" && (this.#r = u), typeof c == "function" ? (this.#o = c, this.#m = []) : (this.#o = void 0, this.#m = void 0), this.#x = !!this.#n, this.#_ = !!this.#r, this.#e = !!this.#o, this.noDisposeOnSet = !!d, this.noUpdateTTL = !!f, this.noDeleteOnFetchRejection = !!E, this.allowStaleOnFetchRejection = !!b, this.allowStaleOnFetchAbort = !!z, this.ignoreFetchAbort = !!$, this.maxEntrySize !== 0) {
+				if (this.#s !== 0 && !q(this.#s)) throw new TypeError("maxSize must be a positive integer if specified");
+				if (!q(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
+				this.#G();
+			}
+			if (this.allowStale = !!a, this.noDeleteOnStaleGet = !!y, this.updateAgeOnGet = !!o, this.updateAgeOnHas = !!h, this.ttlResolution = q(i) || i === 0 ? i : 1, this.ttlAutopurge = !!r, this.ttl = s || 0, this.ttl) {
+				if (!q(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
+				this.#M();
+			}
+			if (this.#t === 0 && this.ttl === 0 && this.#s === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
+			if (!this.ttlAutopurge && !this.#t && !this.#s) {
+				let $t = "LRU_CACHE_UNBOUNDED";
+				ii($t) && (Oe.add($t), Fe("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", $t, Me));
+			}
+		}
+		getRemainingTTL(t) {
+			return this.#f.has(t) ? Infinity : 0;
+		}
+		#M() {
+			let t = new Tt(this.#t), e = new Tt(this.#t);
+			this.#g = t, this.#T = e;
+			let s = this.ttlAutopurge ? new Array(this.#t) : void 0;
+			this.#y = s, this.#j = (o, h, a = this.#c.now()) => {
+				if (e[o] = h !== 0 ? a : 0, t[o] = h, s?.[o] && (clearTimeout(s[o]), s[o] = void 0), h !== 0 && s) {
+					let l = setTimeout(() => {
+						this.#v(o) && this.#O(this.#a[o], "expire");
+					}, h + 1);
+					l.unref && l.unref(), s[o] = l;
+				}
+			}, this.#k = (o) => {
+				e[o] = t[o] !== 0 ? this.#c.now() : 0;
+			}, this.#N = (o, h) => {
+				if (t[h]) {
+					let a = t[h], l = e[h];
+					if (!a || !l) return;
+					o.ttl = a, o.start = l, o.now = i || r();
+					o.remainingTTL = a - (o.now - l);
+				}
+			};
+			let i = 0, r = () => {
+				let o = this.#c.now();
+				if (this.ttlResolution > 0) {
+					i = o;
+					let h = setTimeout(() => i = 0, this.ttlResolution);
+					h.unref && h.unref();
+				}
+				return o;
+			};
+			this.getRemainingTTL = (o) => {
+				let h = this.#f.get(o);
+				if (h === void 0) return 0;
+				let a = t[h], l = e[h];
+				if (!a || !l) return Infinity;
+				return a - ((i || r()) - l);
+			}, this.#v = (o) => {
+				let h = e[o], a = t[o];
+				return !!a && !!h && (i || r()) - h > a;
+			};
+		}
+		#k = () => {};
+		#N = () => {};
+		#j = () => {};
+		#v = () => !1;
+		#G() {
+			let t = new Tt(this.#t);
+			this.#u = 0, this.#C = t, this.#P = (e) => {
+				this.#u -= t[e], t[e] = 0;
+			}, this.#I = (e, s, i, r) => {
+				if (this.#l(s)) return 0;
+				if (!q(i)) if (r) {
+					if (typeof r != "function") throw new TypeError("sizeCalculation must be a function");
+					if (i = r(s, e), !q(i)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+				} else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+				return i;
+			}, this.#L = (e, s, i) => {
+				if (t[e] = s, this.#s) {
+					let r = this.#s - t[e];
+					for (; this.#u > r;) this.#B(!0);
+				}
+				this.#u += t[e], i && (i.entrySize = s, i.totalCalculatedSize = this.#u);
+			};
+		}
+		#P = (t) => {};
+		#L = (t, e, s) => {};
+		#I = (t, e, s, i) => {
+			if (s || i) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+			return 0;
+		};
+		*#F({ allowStale: t = this.allowStale } = {}) {
+			if (this.#h) for (let e = this.#p; !(!this.#z(e) || ((t || !this.#v(e)) && (yield e), e === this.#b));) e = this.#E[e];
+		}
+		*#D({ allowStale: t = this.allowStale } = {}) {
+			if (this.#h) for (let e = this.#b; !(!this.#z(e) || ((t || !this.#v(e)) && (yield e), e === this.#p));) e = this.#d[e];
+		}
+		#z(t) {
+			return t !== void 0 && this.#f.get(this.#a[t]) === t;
+		}
+		*entries() {
+			for (let t of this.#F()) this.#i[t] !== void 0 && this.#a[t] !== void 0 && !this.#l(this.#i[t]) && (yield [this.#a[t], this.#i[t]]);
+		}
+		*rentries() {
+			for (let t of this.#D()) this.#i[t] !== void 0 && this.#a[t] !== void 0 && !this.#l(this.#i[t]) && (yield [this.#a[t], this.#i[t]]);
+		}
+		*keys() {
+			for (let t of this.#F()) {
+				let e = this.#a[t];
+				e !== void 0 && !this.#l(this.#i[t]) && (yield e);
+			}
+		}
+		*rkeys() {
+			for (let t of this.#D()) {
+				let e = this.#a[t];
+				e !== void 0 && !this.#l(this.#i[t]) && (yield e);
+			}
+		}
+		*values() {
+			for (let t of this.#F()) this.#i[t] !== void 0 && !this.#l(this.#i[t]) && (yield this.#i[t]);
+		}
+		*rvalues() {
+			for (let t of this.#D()) this.#i[t] !== void 0 && !this.#l(this.#i[t]) && (yield this.#i[t]);
+		}
+		[Symbol.iterator]() {
+			return this.entries();
+		}
+		[Symbol.toStringTag] = "LRUCache";
+		find(t, e = {}) {
+			for (let s of this.#F()) {
+				let i = this.#i[s], r = this.#l(i) ? i.__staleWhileFetching : i;
+				if (r !== void 0 && t(r, this.#a[s], this)) return this.get(this.#a[s], e);
+			}
+		}
+		forEach(t, e = this) {
+			for (let s of this.#F()) {
+				let i = this.#i[s], r = this.#l(i) ? i.__staleWhileFetching : i;
+				r !== void 0 && t.call(e, r, this.#a[s], this);
+			}
+		}
+		rforEach(t, e = this) {
+			for (let s of this.#D()) {
+				let i = this.#i[s], r = this.#l(i) ? i.__staleWhileFetching : i;
+				r !== void 0 && t.call(e, r, this.#a[s], this);
+			}
+		}
+		purgeStale() {
+			let t = !1;
+			for (let e of this.#D({ allowStale: !0 })) this.#v(e) && (this.#O(this.#a[e], "expire"), t = !0);
+			return t;
+		}
+		info(t) {
+			let e = this.#f.get(t);
+			if (e === void 0) return;
+			let s = this.#i[e], i = this.#l(s) ? s.__staleWhileFetching : s;
+			if (i === void 0) return;
+			let r = { value: i };
+			if (this.#g && this.#T) {
+				let o = this.#g[e], h = this.#T[e];
+				if (o && h) r.ttl = o - (this.#c.now() - h), r.start = Date.now();
+			}
+			return this.#C && (r.size = this.#C[e]), r;
+		}
+		dump() {
+			let t = [];
+			for (let e of this.#F({ allowStale: !0 })) {
+				let s = this.#a[e], i = this.#i[e], r = this.#l(i) ? i.__staleWhileFetching : i;
+				if (r === void 0 || s === void 0) continue;
+				let o = { value: r };
+				if (this.#g && this.#T) {
+					o.ttl = this.#g[e];
+					let h = this.#c.now() - this.#T[e];
+					o.start = Math.floor(Date.now() - h);
+				}
+				this.#C && (o.size = this.#C[e]), t.unshift([s, o]);
+			}
+			return t;
+		}
+		load(t) {
+			this.clear();
+			for (let [e, s] of t) {
+				if (s.start) {
+					let i = Date.now() - s.start;
+					s.start = this.#c.now() - i;
+				}
+				this.set(e, s.value, s);
+			}
+		}
+		set(t, e, s = {}) {
+			if (e === void 0) return this.delete(t), this;
+			let { ttl: i = this.ttl, start: r, noDisposeOnSet: o = this.noDisposeOnSet, sizeCalculation: h = this.sizeCalculation, status: a } = s, { noUpdateTTL: l = this.noUpdateTTL } = s, u = this.#I(t, e, s.size || 0, h);
+			if (this.maxEntrySize && u > this.maxEntrySize) return a && (a.set = "miss", a.maxEntrySizeExceeded = !0), this.#O(t, "set"), this;
+			let c = this.#h === 0 ? void 0 : this.#f.get(t);
+			if (c === void 0) c = this.#h === 0 ? this.#p : this.#R.length !== 0 ? this.#R.pop() : this.#h === this.#t ? this.#B(!1) : this.#h, this.#a[c] = t, this.#i[c] = e, this.#f.set(t, c), this.#d[this.#p] = c, this.#E[c] = this.#p, this.#p = c, this.#h++, this.#L(c, u, a), a && (a.set = "add"), l = !1, this.#_ && this.#r?.(e, t, "add");
+			else {
+				this.#W(c);
+				let d = this.#i[c];
+				if (e !== d) {
+					if (this.#A && this.#l(d)) {
+						d.__abortController.abort(/* @__PURE__ */ new Error("replaced"));
+						let { __staleWhileFetching: f } = d;
+						f !== void 0 && !o && (this.#x && this.#n?.(f, t, "set"), this.#e && this.#m?.push([
+							f,
+							t,
+							"set"
+						]));
+					} else o || (this.#x && this.#n?.(d, t, "set"), this.#e && this.#m?.push([
+						d,
+						t,
+						"set"
+					]));
+					if (this.#P(c), this.#L(c, u, a), this.#i[c] = e, a) {
+						a.set = "replace";
+						let f = d && this.#l(d) ? d.__staleWhileFetching : d;
+						f !== void 0 && (a.oldValue = f);
+					}
+				} else a && (a.set = "update");
+				this.#_ && this.onInsert?.(e, t, e === d ? "update" : "replace");
+			}
+			if (i !== 0 && !this.#g && this.#M(), this.#g && (l || this.#j(c, i, r), a && this.#N(a, c)), !o && this.#e && this.#m) {
+				let d = this.#m, f;
+				for (; f = d?.shift();) this.#o?.(...f);
+			}
+			return this;
+		}
+		pop() {
+			try {
+				for (; this.#h;) {
+					let t = this.#i[this.#b];
+					if (this.#B(!0), this.#l(t)) {
+						if (t.__staleWhileFetching) return t.__staleWhileFetching;
+					} else if (t !== void 0) return t;
+				}
+			} finally {
+				if (this.#e && this.#m) {
+					let t = this.#m, e;
+					for (; e = t?.shift();) this.#o?.(...e);
+				}
+			}
+		}
+		#B(t) {
+			let e = this.#b, s = this.#a[e], i = this.#i[e];
+			return this.#A && this.#l(i) ? i.__abortController.abort(/* @__PURE__ */ new Error("evicted")) : (this.#x || this.#e) && (this.#x && this.#n?.(i, s, "evict"), this.#e && this.#m?.push([
+				i,
+				s,
+				"evict"
+			])), this.#P(e), this.#y?.[e] && (clearTimeout(this.#y[e]), this.#y[e] = void 0), t && (this.#a[e] = void 0, this.#i[e] = void 0, this.#R.push(e)), this.#h === 1 ? (this.#b = this.#p = 0, this.#R.length = 0) : this.#b = this.#d[e], this.#f.delete(s), this.#h--, e;
+		}
+		has(t, e = {}) {
+			let { updateAgeOnHas: s = this.updateAgeOnHas, status: i } = e, r = this.#f.get(t);
+			if (r !== void 0) {
+				let o = this.#i[r];
+				if (this.#l(o) && o.__staleWhileFetching === void 0) return !1;
+				if (this.#v(r)) i && (i.has = "stale", this.#N(i, r));
+				else return s && this.#k(r), i && (i.has = "hit", this.#N(i, r)), !0;
+			} else i && (i.has = "miss");
+			return !1;
+		}
+		peek(t, e = {}) {
+			let { allowStale: s = this.allowStale } = e, i = this.#f.get(t);
+			if (i === void 0 || !s && this.#v(i)) return;
+			let r = this.#i[i];
+			return this.#l(r) ? r.__staleWhileFetching : r;
+		}
+		#U(t, e, s, i) {
+			let r = e === void 0 ? void 0 : this.#i[e];
+			if (this.#l(r)) return r;
+			let o = new At(), { signal: h } = s;
+			h?.addEventListener("abort", () => o.abort(h.reason), { signal: o.signal });
+			let a = {
+				signal: o.signal,
+				options: s,
+				context: i
+			}, l = (p, w = !1) => {
+				let { aborted: g } = o.signal, S = s.ignoreFetchAbort && p !== void 0, E = s.ignoreFetchAbort || !!(s.allowStaleOnFetchAbort && p !== void 0);
+				if (s.status && (g && !w ? (s.status.fetchAborted = !0, s.status.fetchError = o.signal.reason, S && (s.status.fetchAbortIgnored = !0)) : s.status.fetchResolved = !0), g && !S && !w) return c(o.signal.reason, E);
+				let y = f, b = this.#i[e];
+				return (b === f || S && w && b === void 0) && (p === void 0 ? y.__staleWhileFetching !== void 0 ? this.#i[e] = y.__staleWhileFetching : this.#O(t, "fetch") : (s.status && (s.status.fetchUpdated = !0), this.set(t, p, a.options))), p;
+			}, u = (p) => (s.status && (s.status.fetchRejected = !0, s.status.fetchError = p), c(p, !1)), c = (p, w) => {
+				let { aborted: g } = o.signal, S = g && s.allowStaleOnFetchAbort, E = S || s.allowStaleOnFetchRejection, y = E || s.noDeleteOnFetchRejection, b = f;
+				if (this.#i[e] === f && (!y || !w && b.__staleWhileFetching === void 0 ? this.#O(t, "fetch") : S || (this.#i[e] = b.__staleWhileFetching)), E) return s.status && b.__staleWhileFetching !== void 0 && (s.status.returnedStale = !0), b.__staleWhileFetching;
+				if (b.__returned === b) throw p;
+			}, d = (p, w) => {
+				let g = this.#S?.(t, r, a);
+				g && g instanceof Promise && g.then((S) => p(S === void 0 ? void 0 : S), w), o.signal.addEventListener("abort", () => {
+					(!s.ignoreFetchAbort || s.allowStaleOnFetchAbort) && (p(void 0), s.allowStaleOnFetchAbort && (p = (S) => l(S, !0)));
+				});
+			};
+			s.status && (s.status.fetchDispatched = !0);
+			let f = new Promise(d).then(l, u), m = Object.assign(f, {
+				__abortController: o,
+				__staleWhileFetching: r,
+				__returned: void 0
+			});
+			return e === void 0 ? (this.set(t, m, {
+				...a.options,
+				status: void 0
+			}), e = this.#f.get(t)) : this.#i[e] = m, m;
+		}
+		#l(t) {
+			if (!this.#A) return !1;
+			let e = t;
+			return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof At;
+		}
+		async fetch(t, e = {}) {
+			let { allowStale: s = this.allowStale, updateAgeOnGet: i = this.updateAgeOnGet, noDeleteOnStaleGet: r = this.noDeleteOnStaleGet, ttl: o = this.ttl, noDisposeOnSet: h = this.noDisposeOnSet, size: a = 0, sizeCalculation: l = this.sizeCalculation, noUpdateTTL: u = this.noUpdateTTL, noDeleteOnFetchRejection: c = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: d = this.allowStaleOnFetchRejection, ignoreFetchAbort: f = this.ignoreFetchAbort, allowStaleOnFetchAbort: m = this.allowStaleOnFetchAbort, context: p, forceRefresh: w = !1, status: g, signal: S } = e;
+			if (!this.#A) return g && (g.fetch = "get"), this.get(t, {
+				allowStale: s,
+				updateAgeOnGet: i,
+				noDeleteOnStaleGet: r,
+				status: g
+			});
+			let E = {
+				allowStale: s,
+				updateAgeOnGet: i,
+				noDeleteOnStaleGet: r,
+				ttl: o,
+				noDisposeOnSet: h,
+				size: a,
+				sizeCalculation: l,
+				noUpdateTTL: u,
+				noDeleteOnFetchRejection: c,
+				allowStaleOnFetchRejection: d,
+				allowStaleOnFetchAbort: m,
+				ignoreFetchAbort: f,
+				status: g,
+				signal: S
+			}, y = this.#f.get(t);
+			if (y === void 0) {
+				g && (g.fetch = "miss");
+				let b = this.#U(t, y, E, p);
+				return b.__returned = b;
+			} else {
+				let b = this.#i[y];
+				if (this.#l(b)) {
+					let Z = s && b.__staleWhileFetching !== void 0;
+					return g && (g.fetch = "inflight", Z && (g.returnedStale = !0)), Z ? b.__staleWhileFetching : b.__returned = b;
+				}
+				let z = this.#v(y);
+				if (!w && !z) return g && (g.fetch = "hit"), this.#W(y), i && this.#k(y), g && this.#N(g, y), b;
+				let $ = this.#U(t, y, E, p), J = $.__staleWhileFetching !== void 0 && s;
+				return g && (g.fetch = z ? "stale" : "refresh", J && z && (g.returnedStale = !0)), J ? $.__staleWhileFetching : $.__returned = $;
+			}
+		}
+		async forceFetch(t, e = {}) {
+			let s = await this.fetch(t, e);
+			if (s === void 0) throw new Error("fetch() returned undefined");
+			return s;
+		}
+		memo(t, e = {}) {
+			let s = this.#w;
+			if (!s) throw new Error("no memoMethod provided to constructor");
+			let { context: i, forceRefresh: r, ...o } = e, h = this.get(t, o);
+			if (!r && h !== void 0) return h;
+			let a = s(t, h, {
+				options: o,
+				context: i
+			});
+			return this.set(t, a, o), a;
+		}
+		get(t, e = {}) {
+			let { allowStale: s = this.allowStale, updateAgeOnGet: i = this.updateAgeOnGet, noDeleteOnStaleGet: r = this.noDeleteOnStaleGet, status: o } = e, h = this.#f.get(t);
+			if (h !== void 0) {
+				let a = this.#i[h], l = this.#l(a);
+				return o && this.#N(o, h), this.#v(h) ? (o && (o.get = "stale"), l ? (o && s && a.__staleWhileFetching !== void 0 && (o.returnedStale = !0), s ? a.__staleWhileFetching : void 0) : (r || this.#O(t, "expire"), o && s && (o.returnedStale = !0), s ? a : void 0)) : (o && (o.get = "hit"), l ? a.__staleWhileFetching : (this.#W(h), i && this.#k(h), a));
+			} else o && (o.get = "miss");
+		}
+		#$(t, e) {
+			this.#E[e] = t, this.#d[t] = e;
+		}
+		#W(t) {
+			t !== this.#p && (t === this.#b ? this.#b = this.#d[t] : this.#$(this.#E[t], this.#d[t]), this.#$(this.#p, t), this.#p = t);
+		}
+		delete(t) {
+			return this.#O(t, "delete");
+		}
+		#O(t, e) {
+			let s = !1;
+			if (this.#h !== 0) {
+				let i = this.#f.get(t);
+				if (i !== void 0) if (this.#y?.[i] && (clearTimeout(this.#y?.[i]), this.#y[i] = void 0), s = !0, this.#h === 1) this.#H(e);
+				else {
+					this.#P(i);
+					let r = this.#i[i];
+					if (this.#l(r) ? r.__abortController.abort(/* @__PURE__ */ new Error("deleted")) : (this.#x || this.#e) && (this.#x && this.#n?.(r, t, e), this.#e && this.#m?.push([
+						r,
+						t,
+						e
+					])), this.#f.delete(t), this.#a[i] = void 0, this.#i[i] = void 0, i === this.#p) this.#p = this.#E[i];
+					else if (i === this.#b) this.#b = this.#d[i];
+					else {
+						let o = this.#E[i];
+						this.#d[o] = this.#d[i];
+						let h = this.#d[i];
+						this.#E[h] = this.#E[i];
+					}
+					this.#h--, this.#R.push(i);
+				}
+			}
+			if (this.#e && this.#m?.length) {
+				let i = this.#m, r;
+				for (; r = i?.shift();) this.#o?.(...r);
+			}
+			return s;
+		}
+		clear() {
+			return this.#H("delete");
+		}
+		#H(t) {
+			for (let e of this.#D({ allowStale: !0 })) {
+				let s = this.#i[e];
+				if (this.#l(s)) s.__abortController.abort(/* @__PURE__ */ new Error("deleted"));
+				else {
+					let i = this.#a[e];
+					this.#x && this.#n?.(s, i, t), this.#e && this.#m?.push([
+						s,
+						i,
+						t
+					]);
+				}
+			}
+			if (this.#f.clear(), this.#i.fill(void 0), this.#a.fill(void 0), this.#g && this.#T) {
+				this.#g.fill(0), this.#T.fill(0);
+				for (let e of this.#y ?? []) e !== void 0 && clearTimeout(e);
+				this.#y?.fill(void 0);
+			}
+			if (this.#C && this.#C.fill(0), this.#b = 0, this.#p = 0, this.#R.length = 0, this.#u = 0, this.#h = 0, this.#e && this.#m) {
+				let e = this.#m, s;
+				for (; s = e?.shift();) this.#o?.(...s);
+			}
+		}
+	};
+	Ne = typeof process == "object" && process ? process : {
+		stdout: null,
+		stderr: null
+	}, oi = (n) => !!n && typeof n == "object" && (n instanceof V || n instanceof Pe || hi(n) || ai(n)), hi = (n) => !!n && typeof n == "object" && n instanceof EventEmitter && typeof n.pipe == "function" && n.pipe !== Pe.Writable.prototype.pipe, ai = (n) => !!n && typeof n == "object" && n instanceof EventEmitter && typeof n.write == "function" && typeof n.end == "function", G = Symbol("EOF"), H = Symbol("maybeEmitEnd"), K = Symbol("emittedEnd"), kt = Symbol("emittingEnd"), ut = Symbol("emittedError"), Rt = Symbol("closed"), _e = Symbol("read"), Ot = Symbol("flush"), Le = Symbol("flushChunk"), P = Symbol("encoding"), et = Symbol("decoder"), v = Symbol("flowing"), dt = Symbol("paused"), st = Symbol("resume"), C = Symbol("buffer"), F = Symbol("pipes"), T = Symbol("bufferLength"), Yt = Symbol("bufferPush"), Ft = Symbol("bufferShift"), k = Symbol("objectMode"), x = Symbol("destroyed"), Xt = Symbol("error"), Jt = Symbol("emitData"), We = Symbol("emitEnd"), Zt = Symbol("emitEnd2"), B = Symbol("async"), Qt = Symbol("abort"), Dt = Symbol("aborted"), pt = Symbol("signal"), Y = Symbol("dataListeners"), M = Symbol("discarded"), mt = (n) => Promise.resolve().then(n), li = (n) => n(), ci = (n) => n === "end" || n === "finish" || n === "prefinish", fi = (n) => n instanceof ArrayBuffer || !!n && typeof n == "object" && n.constructor && n.constructor.name === "ArrayBuffer" && n.byteLength >= 0, ui = (n) => !Buffer.isBuffer(n) && ArrayBuffer.isView(n), Mt = class {
+		src;
+		dest;
+		opts;
+		ondrain;
+		constructor(t, e, s) {
+			this.src = t, this.dest = e, this.opts = s, this.ondrain = () => t[st](), this.dest.on("drain", this.ondrain);
+		}
+		unpipe() {
+			this.dest.removeListener("drain", this.ondrain);
+		}
+		proxyErrors(t) {}
+		end() {
+			this.unpipe(), this.opts.end && this.dest.end();
+		}
+	}, te = class extends Mt {
+		unpipe() {
+			this.src.removeListener("error", this.proxyErrors), super.unpipe();
+		}
+		constructor(t, e, s) {
+			super(t, e, s), this.proxyErrors = (i) => this.dest.emit("error", i), t.on("error", this.proxyErrors);
+		}
+	}, di = (n) => !!n.objectMode, pi = (n) => !n.objectMode && !!n.encoding && n.encoding !== "buffer", V = class extends EventEmitter {
+		[v] = !1;
+		[dt] = !1;
+		[F] = [];
+		[C] = [];
+		[k];
+		[P];
+		[B];
+		[et];
+		[G] = !1;
+		[K] = !1;
+		[kt] = !1;
+		[Rt] = !1;
+		[ut] = null;
+		[T] = 0;
+		[x] = !1;
+		[pt];
+		[Dt] = !1;
+		[Y] = 0;
+		[M] = !1;
+		writable = !0;
+		readable = !0;
+		constructor(...t) {
+			let e = t[0] || {};
+			if (super(), e.objectMode && typeof e.encoding == "string") throw new TypeError("Encoding and objectMode may not be used together");
+			di(e) ? (this[k] = !0, this[P] = null) : pi(e) ? (this[P] = e.encoding, this[k] = !1) : (this[k] = !1, this[P] = null), this[B] = !!e.async, this[et] = this[P] ? new StringDecoder(this[P]) : null, e && e.debugExposeBuffer === !0 && Object.defineProperty(this, "buffer", { get: () => this[C] }), e && e.debugExposePipes === !0 && Object.defineProperty(this, "pipes", { get: () => this[F] });
+			let { signal: s } = e;
+			s && (this[pt] = s, s.aborted ? this[Qt]() : s.addEventListener("abort", () => this[Qt]()));
+		}
+		get bufferLength() {
+			return this[T];
+		}
+		get encoding() {
+			return this[P];
+		}
+		set encoding(t) {
+			throw new Error("Encoding must be set at instantiation time");
+		}
+		setEncoding(t) {
+			throw new Error("Encoding must be set at instantiation time");
+		}
+		get objectMode() {
+			return this[k];
+		}
+		set objectMode(t) {
+			throw new Error("objectMode must be set at instantiation time");
+		}
+		get async() {
+			return this[B];
+		}
+		set async(t) {
+			this[B] = this[B] || !!t;
+		}
+		[Qt]() {
+			this[Dt] = !0, this.emit("abort", this[pt]?.reason), this.destroy(this[pt]?.reason);
+		}
+		get aborted() {
+			return this[Dt];
+		}
+		set aborted(t) {}
+		write(t, e, s) {
+			if (this[Dt]) return !1;
+			if (this[G]) throw new Error("write after end");
+			if (this[x]) return this.emit("error", Object.assign(/* @__PURE__ */ new Error("Cannot call write after a stream was destroyed"), { code: "ERR_STREAM_DESTROYED" })), !0;
+			typeof e == "function" && (s = e, e = "utf8"), e || (e = "utf8");
+			let i = this[B] ? mt : li;
+			if (!this[k] && !Buffer.isBuffer(t)) {
+				if (ui(t)) t = Buffer.from(t.buffer, t.byteOffset, t.byteLength);
+				else if (fi(t)) t = Buffer.from(t);
+				else if (typeof t != "string") throw new Error("Non-contiguous data written to non-objectMode stream");
+			}
+			return this[k] ? (this[v] && this[T] !== 0 && this[Ot](!0), this[v] ? this.emit("data", t) : this[Yt](t), this[T] !== 0 && this.emit("readable"), s && i(s), this[v]) : t.length ? (typeof t == "string" && !(e === this[P] && !this[et]?.lastNeed) && (t = Buffer.from(t, e)), Buffer.isBuffer(t) && this[P] && (t = this[et].write(t)), this[v] && this[T] !== 0 && this[Ot](!0), this[v] ? this.emit("data", t) : this[Yt](t), this[T] !== 0 && this.emit("readable"), s && i(s), this[v]) : (this[T] !== 0 && this.emit("readable"), s && i(s), this[v]);
+		}
+		read(t) {
+			if (this[x]) return null;
+			if (this[M] = !1, this[T] === 0 || t === 0 || t && t > this[T]) return this[H](), null;
+			this[k] && (t = null), this[C].length > 1 && !this[k] && (this[C] = [this[P] ? this[C].join("") : Buffer.concat(this[C], this[T])]);
+			let e = this[_e](t || null, this[C][0]);
+			return this[H](), e;
+		}
+		[_e](t, e) {
+			if (this[k]) this[Ft]();
+			else {
+				let s = e;
+				t === s.length || t === null ? this[Ft]() : typeof s == "string" ? (this[C][0] = s.slice(t), e = s.slice(0, t), this[T] -= t) : (this[C][0] = s.subarray(t), e = s.subarray(0, t), this[T] -= t);
+			}
+			return this.emit("data", e), !this[C].length && !this[G] && this.emit("drain"), e;
+		}
+		end(t, e, s) {
+			return typeof t == "function" && (s = t, t = void 0), typeof e == "function" && (s = e, e = "utf8"), t !== void 0 && this.write(t, e), s && this.once("end", s), this[G] = !0, this.writable = !1, (this[v] || !this[dt]) && this[H](), this;
+		}
+		[st]() {
+			this[x] || (!this[Y] && !this[F].length && (this[M] = !0), this[dt] = !1, this[v] = !0, this.emit("resume"), this[C].length ? this[Ot]() : this[G] ? this[H]() : this.emit("drain"));
+		}
+		resume() {
+			return this[st]();
+		}
+		pause() {
+			this[v] = !1, this[dt] = !0, this[M] = !1;
+		}
+		get destroyed() {
+			return this[x];
+		}
+		get flowing() {
+			return this[v];
+		}
+		get paused() {
+			return this[dt];
+		}
+		[Yt](t) {
+			this[k] ? this[T] += 1 : this[T] += t.length, this[C].push(t);
+		}
+		[Ft]() {
+			return this[k] ? this[T] -= 1 : this[T] -= this[C][0].length, this[C].shift();
+		}
+		[Ot](t = !1) {
+			do			;
+while (this[Le](this[Ft]()) && this[C].length);
+			!t && !this[C].length && !this[G] && this.emit("drain");
+		}
+		[Le](t) {
+			return this.emit("data", t), this[v];
+		}
+		pipe(t, e) {
+			if (this[x]) return t;
+			this[M] = !1;
+			let s = this[K];
+			return e = e || {}, t === Ne.stdout || t === Ne.stderr ? e.end = !1 : e.end = e.end !== !1, e.proxyErrors = !!e.proxyErrors, s ? e.end && t.end() : (this[F].push(e.proxyErrors ? new te(this, t, e) : new Mt(this, t, e)), this[B] ? mt(() => this[st]()) : this[st]()), t;
+		}
+		unpipe(t) {
+			let e = this[F].find((s) => s.dest === t);
+			e && (this[F].length === 1 ? (this[v] && this[Y] === 0 && (this[v] = !1), this[F] = []) : this[F].splice(this[F].indexOf(e), 1), e.unpipe());
+		}
+		addListener(t, e) {
+			return this.on(t, e);
+		}
+		on(t, e) {
+			let s = super.on(t, e);
+			if (t === "data") this[M] = !1, this[Y]++, !this[F].length && !this[v] && this[st]();
+			else if (t === "readable" && this[T] !== 0) super.emit("readable");
+			else if (ci(t) && this[K]) super.emit(t), this.removeAllListeners(t);
+			else if (t === "error" && this[ut]) {
+				let i = e;
+				this[B] ? mt(() => i.call(this, this[ut])) : i.call(this, this[ut]);
+			}
+			return s;
+		}
+		removeListener(t, e) {
+			return this.off(t, e);
+		}
+		off(t, e) {
+			let s = super.off(t, e);
+			return t === "data" && (this[Y] = this.listeners("data").length, this[Y] === 0 && !this[M] && !this[F].length && (this[v] = !1)), s;
+		}
+		removeAllListeners(t) {
+			let e = super.removeAllListeners(t);
+			return (t === "data" || t === void 0) && (this[Y] = 0, !this[M] && !this[F].length && (this[v] = !1)), e;
+		}
+		get emittedEnd() {
+			return this[K];
+		}
+		[H]() {
+			!this[kt] && !this[K] && !this[x] && this[C].length === 0 && this[G] && (this[kt] = !0, this.emit("end"), this.emit("prefinish"), this.emit("finish"), this[Rt] && this.emit("close"), this[kt] = !1);
+		}
+		emit(t, ...e) {
+			let s = e[0];
+			if (t !== "error" && t !== "close" && t !== x && this[x]) return !1;
+			if (t === "data") return !this[k] && !s ? !1 : this[B] ? (mt(() => this[Jt](s)), !0) : this[Jt](s);
+			if (t === "end") return this[We]();
+			if (t === "close") {
+				if (this[Rt] = !0, !this[K] && !this[x]) return !1;
+				let r = super.emit("close");
+				return this.removeAllListeners("close"), r;
+			} else if (t === "error") {
+				this[ut] = s, super.emit(Xt, s);
+				let r = !this[pt] || this.listeners("error").length ? super.emit("error", s) : !1;
+				return this[H](), r;
+			} else if (t === "resume") {
+				let r = super.emit("resume");
+				return this[H](), r;
+			} else if (t === "finish" || t === "prefinish") {
+				let r = super.emit(t);
+				return this.removeAllListeners(t), r;
+			}
+			let i = super.emit(t, ...e);
+			return this[H](), i;
+		}
+		[Jt](t) {
+			for (let s of this[F]) s.dest.write(t) === !1 && this.pause();
+			let e = this[M] ? !1 : super.emit("data", t);
+			return this[H](), e;
+		}
+		[We]() {
+			return this[K] ? !1 : (this[K] = !0, this.readable = !1, this[B] ? (mt(() => this[Zt]()), !0) : this[Zt]());
+		}
+		[Zt]() {
+			if (this[et]) {
+				let e = this[et].end();
+				if (e) {
+					for (let s of this[F]) s.dest.write(e);
+					this[M] || super.emit("data", e);
+				}
+			}
+			for (let e of this[F]) e.end();
+			let t = super.emit("end");
+			return this.removeAllListeners("end"), t;
+		}
+		async collect() {
+			let t = Object.assign([], { dataLength: 0 });
+			this[k] || (t.dataLength = 0);
+			let e = this.promise();
+			return this.on("data", (s) => {
+				t.push(s), this[k] || (t.dataLength += s.length);
+			}), await e, t;
+		}
+		async concat() {
+			if (this[k]) throw new Error("cannot concat in objectMode");
+			let t = await this.collect();
+			return this[P] ? t.join("") : Buffer.concat(t, t.dataLength);
+		}
+		async promise() {
+			return new Promise((t, e) => {
+				this.on(x, () => e(/* @__PURE__ */ new Error("stream destroyed"))), this.on("error", (s) => e(s)), this.on("end", () => t());
+			});
+		}
+		[Symbol.asyncIterator]() {
+			this[M] = !1;
+			let t = !1, e = async () => (this.pause(), t = !0, {
+				value: void 0,
+				done: !0
+			});
+			return {
+				next: () => {
+					if (t) return e();
+					let i = this.read();
+					if (i !== null) return Promise.resolve({
+						done: !1,
+						value: i
+					});
+					if (this[G]) return e();
+					let r, o, h = (c) => {
+						this.off("data", a), this.off("end", l), this.off(x, u), e(), o(c);
+					}, a = (c) => {
+						this.off("error", h), this.off("end", l), this.off(x, u), this.pause(), r({
+							value: c,
+							done: !!this[G]
+						});
+					}, l = () => {
+						this.off("error", h), this.off("data", a), this.off(x, u), e(), r({
+							done: !0,
+							value: void 0
+						});
+					}, u = () => h(/* @__PURE__ */ new Error("stream destroyed"));
+					return new Promise((c, d) => {
+						o = d, r = c, this.once(x, u), this.once("error", h), this.once("end", l), this.once("data", a);
+					});
+				},
+				throw: e,
+				return: e,
+				[Symbol.asyncIterator]() {
+					return this;
+				},
+				[Symbol.asyncDispose]: async () => {}
+			};
+		}
+		[Symbol.iterator]() {
+			this[M] = !1;
+			let t = !1, e = () => (this.pause(), this.off(Xt, e), this.off(x, e), this.off("end", e), t = !0, {
+				done: !0,
+				value: void 0
+			}), s = () => {
+				if (t) return e();
+				let i = this.read();
+				return i === null ? e() : {
+					done: !1,
+					value: i
+				};
+			};
+			return this.once("end", e), this.once(Xt, e), this.once(x, e), {
+				next: s,
+				throw: e,
+				return: e,
+				[Symbol.iterator]() {
+					return this;
+				},
+				[Symbol.dispose]: () => {}
+			};
+		}
+		destroy(t) {
+			if (this[x]) return t ? this.emit("error", t) : this.emit(x), this;
+			this[x] = !0, this[M] = !0, this[C].length = 0, this[T] = 0;
+			let e = this;
+			return typeof e.close == "function" && !this[Rt] && e.close(), t ? this.emit("error", t) : this.emit(x), this;
+		}
+		static get isStream() {
+			return oi;
+		}
+	}, wt = {
+		lstatSync,
+		readdir,
+		readdirSync,
+		readlinkSync,
+		realpathSync: realpathSync.native,
+		promises: {
+			lstat,
+			readdir: readdir$1,
+			readlink,
+			realpath
+		}
+	}, Ue = (n) => !n || n === wt || n === xi ? wt : {
+		...wt,
+		...n,
+		promises: {
+			...wt.promises,
+			...n.promises || {}
+		}
+	}, $e = /^\\\\\?\\([a-z]:)\\?$/i, Ri = (n) => n.replace(/\//g, "\\").replace($e, "$1\\"), Oi = /[\\\/]/, L = 0, Ge = 1, He = 2, U = 4, qe = 6, Ke = 8, X = 10, Ve = 12, _ = 15, gt = ~_, se = 16, je = 32, yt = 64, j = 128, Nt = 256, Lt = 512, Ie = yt | j | Lt, Fi = 1023, ie = (n) => n.isFile() ? Ke : n.isDirectory() ? U : n.isSymbolicLink() ? X : n.isCharacterDevice() ? He : n.isBlockDevice() ? qe : n.isSocket() ? Ve : n.isFIFO() ? Ge : L, ze = new ft({ max: 2 ** 12 }), bt = (n) => {
+		let t = ze.get(n);
+		if (t) return t;
+		let e = n.normalize("NFKD");
+		return ze.set(n, e), e;
+	}, Be = new ft({ max: 2 ** 12 }), _t = (n) => {
+		let t = Be.get(n);
+		if (t) return t;
+		let e = bt(n.toLowerCase());
+		return Be.set(n, e), e;
+	}, Wt = class extends ft {
+		constructor() {
+			super({ max: 256 });
+		}
+	}, ne = class extends ft {
+		constructor(t = 16 * 1024) {
+			super({
+				maxSize: t,
+				sizeCalculation: (e) => e.length + 1
+			});
+		}
+	}, Ye = Symbol("PathScurry setAsCwd"), R = class {
+		name;
+		root;
+		roots;
+		parent;
+		nocase;
+		isCWD = !1;
+		#t;
+		#s;
+		get dev() {
+			return this.#s;
+		}
+		#n;
+		get mode() {
+			return this.#n;
+		}
+		#r;
+		get nlink() {
+			return this.#r;
+		}
+		#o;
+		get uid() {
+			return this.#o;
+		}
+		#S;
+		get gid() {
+			return this.#S;
+		}
+		#w;
+		get rdev() {
+			return this.#w;
+		}
+		#c;
+		get blksize() {
+			return this.#c;
+		}
+		#h;
+		get ino() {
+			return this.#h;
+		}
+		#u;
+		get size() {
+			return this.#u;
+		}
+		#f;
+		get blocks() {
+			return this.#f;
+		}
+		#a;
+		get atimeMs() {
+			return this.#a;
+		}
+		#i;
+		get mtimeMs() {
+			return this.#i;
+		}
+		#d;
+		get ctimeMs() {
+			return this.#d;
+		}
+		#E;
+		get birthtimeMs() {
+			return this.#E;
+		}
+		#b;
+		get atime() {
+			return this.#b;
+		}
+		#p;
+		get mtime() {
+			return this.#p;
+		}
+		#R;
+		get ctime() {
+			return this.#R;
+		}
+		#m;
+		get birthtime() {
+			return this.#m;
+		}
+		#C;
+		#T;
+		#g;
+		#y;
+		#x;
+		#A;
+		#e;
+		#_;
+		#M;
+		#k;
+		get parentPath() {
+			return (this.parent || this).fullpath();
+		}
+		get path() {
+			return this.parentPath;
+		}
+		constructor(t, e = L, s, i, r, o, h) {
+			this.name = t, this.#C = r ? _t(t) : bt(t), this.#e = e & Fi, this.nocase = r, this.roots = i, this.root = s || this, this.#_ = o, this.#g = h.fullpath, this.#x = h.relative, this.#A = h.relativePosix, this.parent = h.parent, this.parent ? this.#t = this.parent.#t : this.#t = Ue(h.fs);
+		}
+		depth() {
+			return this.#T !== void 0 ? this.#T : this.parent ? this.#T = this.parent.depth() + 1 : this.#T = 0;
+		}
+		childrenCache() {
+			return this.#_;
+		}
+		resolve(t) {
+			if (!t) return this;
+			let e = this.getRootString(t), i = t.substring(e.length).split(this.splitSep);
+			return e ? this.getRoot(e).#N(i) : this.#N(i);
+		}
+		#N(t) {
+			let e = this;
+			for (let s of t) e = e.child(s);
+			return e;
+		}
+		children() {
+			let t = this.#_.get(this);
+			if (t) return t;
+			let e = Object.assign([], { provisional: 0 });
+			return this.#_.set(this, e), this.#e &= ~se, e;
+		}
+		child(t, e) {
+			if (t === "" || t === ".") return this;
+			if (t === "..") return this.parent || this;
+			let s = this.children(), i = this.nocase ? _t(t) : bt(t);
+			for (let a of s) if (a.#C === i) return a;
+			let r = this.parent ? this.sep : "", o = this.#g ? this.#g + r + t : void 0, h = this.newChild(t, L, {
+				...e,
+				parent: this,
+				fullpath: o
+			});
+			return this.canReaddir() || (h.#e |= j), s.push(h), h;
+		}
+		relative() {
+			if (this.isCWD) return "";
+			if (this.#x !== void 0) return this.#x;
+			let t = this.name, e = this.parent;
+			if (!e) return this.#x = this.name;
+			let s = e.relative();
+			return s + (!s || !e.parent ? "" : this.sep) + t;
+		}
+		relativePosix() {
+			if (this.sep === "/") return this.relative();
+			if (this.isCWD) return "";
+			if (this.#A !== void 0) return this.#A;
+			let t = this.name, e = this.parent;
+			if (!e) return this.#A = this.fullpathPosix();
+			let s = e.relativePosix();
+			return s + (!s || !e.parent ? "" : "/") + t;
+		}
+		fullpath() {
+			if (this.#g !== void 0) return this.#g;
+			let t = this.name, e = this.parent;
+			if (!e) return this.#g = this.name;
+			let i = e.fullpath() + (e.parent ? this.sep : "") + t;
+			return this.#g = i;
+		}
+		fullpathPosix() {
+			if (this.#y !== void 0) return this.#y;
+			if (this.sep === "/") return this.#y = this.fullpath();
+			if (!this.parent) {
+				let i = this.fullpath().replace(/\\/g, "/");
+				return /^[a-z]:\//i.test(i) ? this.#y = `//?/${i}` : this.#y = i;
+			}
+			let t = this.parent, e = t.fullpathPosix(), s = e + (!e || !t.parent ? "" : "/") + this.name;
+			return this.#y = s;
+		}
+		isUnknown() {
+			return (this.#e & _) === L;
+		}
+		isType(t) {
+			return this[`is${t}`]();
+		}
+		getType() {
+			return this.isUnknown() ? "Unknown" : this.isDirectory() ? "Directory" : this.isFile() ? "File" : this.isSymbolicLink() ? "SymbolicLink" : this.isFIFO() ? "FIFO" : this.isCharacterDevice() ? "CharacterDevice" : this.isBlockDevice() ? "BlockDevice" : this.isSocket() ? "Socket" : "Unknown";
+		}
+		isFile() {
+			return (this.#e & _) === Ke;
+		}
+		isDirectory() {
+			return (this.#e & _) === U;
+		}
+		isCharacterDevice() {
+			return (this.#e & _) === He;
+		}
+		isBlockDevice() {
+			return (this.#e & _) === qe;
+		}
+		isFIFO() {
+			return (this.#e & _) === Ge;
+		}
+		isSocket() {
+			return (this.#e & _) === Ve;
+		}
+		isSymbolicLink() {
+			return (this.#e & X) === X;
+		}
+		lstatCached() {
+			return this.#e & je ? this : void 0;
+		}
+		readlinkCached() {
+			return this.#M;
+		}
+		realpathCached() {
+			return this.#k;
+		}
+		readdirCached() {
+			let t = this.children();
+			return t.slice(0, t.provisional);
+		}
+		canReadlink() {
+			if (this.#M) return !0;
+			if (!this.parent) return !1;
+			let t = this.#e & _;
+			return !(t !== L && t !== X || this.#e & Nt || this.#e & j);
+		}
+		calledReaddir() {
+			return !!(this.#e & se);
+		}
+		isENOENT() {
+			return !!(this.#e & j);
+		}
+		isNamed(t) {
+			return this.nocase ? this.#C === _t(t) : this.#C === bt(t);
+		}
+		async readlink() {
+			let t = this.#M;
+			if (t) return t;
+			if (this.canReadlink() && this.parent) try {
+				let e = await this.#t.promises.readlink(this.fullpath()), s = (await this.parent.realpath())?.resolve(e);
+				if (s) return this.#M = s;
+			} catch (e) {
+				this.#D(e.code);
+				return;
+			}
+		}
+		readlinkSync() {
+			let t = this.#M;
+			if (t) return t;
+			if (this.canReadlink() && this.parent) try {
+				let e = this.#t.readlinkSync(this.fullpath()), s = this.parent.realpathSync()?.resolve(e);
+				if (s) return this.#M = s;
+			} catch (e) {
+				this.#D(e.code);
+				return;
+			}
+		}
+		#j(t) {
+			this.#e |= se;
+			for (let e = t.provisional; e < t.length; e++) {
+				let s = t[e];
+				s && s.#v();
+			}
+		}
+		#v() {
+			this.#e & j || (this.#e = (this.#e | j) & gt, this.#G());
+		}
+		#G() {
+			let t = this.children();
+			t.provisional = 0;
+			for (let e of t) e.#v();
+		}
+		#P() {
+			this.#e |= Lt, this.#L();
+		}
+		#L() {
+			if (this.#e & yt) return;
+			let t = this.#e;
+			(t & _) === U && (t &= gt), this.#e = t | yt, this.#G();
+		}
+		#I(t = "") {
+			t === "ENOTDIR" || t === "EPERM" ? this.#L() : t === "ENOENT" ? this.#v() : this.children().provisional = 0;
+		}
+		#F(t = "") {
+			t === "ENOTDIR" ? this.parent.#L() : t === "ENOENT" && this.#v();
+		}
+		#D(t = "") {
+			let e = this.#e;
+			e |= Nt, t === "ENOENT" && (e |= j), (t === "EINVAL" || t === "UNKNOWN") && (e &= gt), this.#e = e, t === "ENOTDIR" && this.parent && this.parent.#L();
+		}
+		#z(t, e) {
+			return this.#U(t, e) || this.#B(t, e);
+		}
+		#B(t, e) {
+			let s = ie(t), i = this.newChild(t.name, s, { parent: this }), r = i.#e & _;
+			return r !== U && r !== X && r !== L && (i.#e |= yt), e.unshift(i), e.provisional++, i;
+		}
+		#U(t, e) {
+			for (let s = e.provisional; s < e.length; s++) {
+				let i = e[s];
+				if ((this.nocase ? _t(t.name) : bt(t.name)) === i.#C) return this.#l(t, i, s, e);
+			}
+		}
+		#l(t, e, s, i) {
+			let r = e.name;
+			return e.#e = e.#e & gt | ie(t), r !== t.name && (e.name = t.name), s !== i.provisional && (s === i.length - 1 ? i.pop() : i.splice(s, 1), i.unshift(e)), i.provisional++, e;
+		}
+		async lstat() {
+			if ((this.#e & j) === 0) try {
+				return this.#$(await this.#t.promises.lstat(this.fullpath())), this;
+			} catch (t) {
+				this.#F(t.code);
+			}
+		}
+		lstatSync() {
+			if ((this.#e & j) === 0) try {
+				return this.#$(this.#t.lstatSync(this.fullpath())), this;
+			} catch (t) {
+				this.#F(t.code);
+			}
+		}
+		#$(t) {
+			let { atime: e, atimeMs: s, birthtime: i, birthtimeMs: r, blksize: o, blocks: h, ctime: a, ctimeMs: l, dev: u, gid: c, ino: d, mode: f, mtime: m, mtimeMs: p, nlink: w, rdev: g, size: S, uid: E } = t;
+			this.#b = e, this.#a = s, this.#m = i, this.#E = r, this.#c = o, this.#f = h, this.#R = a, this.#d = l, this.#s = u, this.#S = c, this.#h = d, this.#n = f, this.#p = m, this.#i = p, this.#r = w, this.#w = g, this.#u = S, this.#o = E;
+			let y = ie(t);
+			this.#e = this.#e & gt | y | je, y !== L && y !== U && y !== X && (this.#e |= yt);
+		}
+		#W = [];
+		#O = !1;
+		#H(t) {
+			this.#O = !1;
+			let e = this.#W.slice();
+			this.#W.length = 0, e.forEach((s) => s(null, t));
+		}
+		readdirCB(t, e = !1) {
+			if (!this.canReaddir()) {
+				e ? t(null, []) : queueMicrotask(() => t(null, []));
+				return;
+			}
+			let s = this.children();
+			if (this.calledReaddir()) {
+				let r = s.slice(0, s.provisional);
+				e ? t(null, r) : queueMicrotask(() => t(null, r));
+				return;
+			}
+			if (this.#W.push(t), this.#O) return;
+			this.#O = !0;
+			let i = this.fullpath();
+			this.#t.readdir(i, { withFileTypes: !0 }, (r, o) => {
+				if (r) this.#I(r.code), s.provisional = 0;
+				else {
+					for (let h of o) this.#z(h, s);
+					this.#j(s);
+				}
+				this.#H(s.slice(0, s.provisional));
+			});
+		}
+		#q;
+		async readdir() {
+			if (!this.canReaddir()) return [];
+			let t = this.children();
+			if (this.calledReaddir()) return t.slice(0, t.provisional);
+			let e = this.fullpath();
+			if (this.#q) await this.#q;
+			else {
+				let s = () => {};
+				this.#q = new Promise((i) => s = i);
+				try {
+					for (let i of await this.#t.promises.readdir(e, { withFileTypes: !0 })) this.#z(i, t);
+					this.#j(t);
+				} catch (i) {
+					this.#I(i.code), t.provisional = 0;
+				}
+				this.#q = void 0, s();
+			}
+			return t.slice(0, t.provisional);
+		}
+		readdirSync() {
+			if (!this.canReaddir()) return [];
+			let t = this.children();
+			if (this.calledReaddir()) return t.slice(0, t.provisional);
+			let e = this.fullpath();
+			try {
+				for (let s of this.#t.readdirSync(e, { withFileTypes: !0 })) this.#z(s, t);
+				this.#j(t);
+			} catch (s) {
+				this.#I(s.code), t.provisional = 0;
+			}
+			return t.slice(0, t.provisional);
+		}
+		canReaddir() {
+			if (this.#e & Ie) return !1;
+			let t = _ & this.#e;
+			return t === L || t === U || t === X;
+		}
+		shouldWalk(t, e) {
+			return (this.#e & U) === U && !(this.#e & Ie) && !t.has(this) && (!e || e(this));
+		}
+		async realpath() {
+			if (this.#k) return this.#k;
+			if (!((Lt | Nt | j) & this.#e)) try {
+				let t = await this.#t.promises.realpath(this.fullpath());
+				return this.#k = this.resolve(t);
+			} catch {
+				this.#P();
+			}
+		}
+		realpathSync() {
+			if (this.#k) return this.#k;
+			if (!((Lt | Nt | j) & this.#e)) try {
+				let t = this.#t.realpathSync(this.fullpath());
+				return this.#k = this.resolve(t);
+			} catch {
+				this.#P();
+			}
+		}
+		[Ye](t) {
+			if (t === this) return;
+			t.isCWD = !1, this.isCWD = !0;
+			let e = /* @__PURE__ */ new Set([]), s = [], i = this;
+			for (; i && i.parent;) e.add(i), i.#x = s.join(this.sep), i.#A = s.join("/"), i = i.parent, s.push("..");
+			for (i = t; i && i.parent && !e.has(i);) i.#x = void 0, i.#A = void 0, i = i.parent;
+		}
+	}, Pt = class n extends R {
+		sep = "\\";
+		splitSep = Oi;
+		constructor(t, e = L, s, i, r, o, h) {
+			super(t, e, s, i, r, o, h);
+		}
+		newChild(t, e = L, s = {}) {
+			return new n(t, e, this.root, this.roots, this.nocase, this.childrenCache(), s);
+		}
+		getRootString(t) {
+			return win32.parse(t).root;
+		}
+		getRoot(t) {
+			if (t = Ri(t.toUpperCase()), t === this.root.name) return this.root;
+			for (let [e, s] of Object.entries(this.roots)) if (this.sameRoot(t, e)) return this.roots[t] = s;
+			return this.roots[t] = new it(t, this).root;
+		}
+		sameRoot(t, e = this.root.name) {
+			return t = t.toUpperCase().replace(/\//g, "\\").replace($e, "$1\\"), t === e;
+		}
+	}, jt = class n extends R {
+		splitSep = "/";
+		sep = "/";
+		constructor(t, e = L, s, i, r, o, h) {
+			super(t, e, s, i, r, o, h);
+		}
+		getRootString(t) {
+			return t.startsWith("/") ? "/" : "";
+		}
+		getRoot(t) {
+			return this.root;
+		}
+		newChild(t, e = L, s = {}) {
+			return new n(t, e, this.root, this.roots, this.nocase, this.childrenCache(), s);
+		}
+	}, It = class {
+		root;
+		rootPath;
+		roots;
+		cwd;
+		#t;
+		#s;
+		#n;
+		nocase;
+		#r;
+		constructor(t = process.cwd(), e, s, { nocase: i, childrenCacheSize: r = 16 * 1024, fs: o = wt } = {}) {
+			this.#r = Ue(o), (t instanceof URL || t.startsWith("file://")) && (t = fileURLToPath(t));
+			let h = e.resolve(t);
+			this.roots = Object.create(null), this.rootPath = this.parseRootPath(h), this.#t = new Wt(), this.#s = new Wt(), this.#n = new ne(r);
+			let a = h.substring(this.rootPath.length).split(s);
+			if (a.length === 1 && !a[0] && a.pop(), i === void 0) throw new TypeError("must provide nocase setting to PathScurryBase ctor");
+			this.nocase = i, this.root = this.newRoot(this.#r), this.roots[this.rootPath] = this.root;
+			let l = this.root, u = a.length - 1, c = e.sep, d = this.rootPath, f = !1;
+			for (let m of a) {
+				let p = u--;
+				l = l.child(m, {
+					relative: new Array(p).fill("..").join(c),
+					relativePosix: new Array(p).fill("..").join("/"),
+					fullpath: d += (f ? "" : c) + m
+				}), f = !0;
+			}
+			this.cwd = l;
+		}
+		depth(t = this.cwd) {
+			return typeof t == "string" && (t = this.cwd.resolve(t)), t.depth();
+		}
+		childrenCache() {
+			return this.#n;
+		}
+		resolve(...t) {
+			let e = "";
+			for (let r = t.length - 1; r >= 0; r--) {
+				let o = t[r];
+				if (!(!o || o === ".") && (e = e ? `${o}/${e}` : o, this.isAbsolute(o))) break;
+			}
+			let s = this.#t.get(e);
+			if (s !== void 0) return s;
+			let i = this.cwd.resolve(e).fullpath();
+			return this.#t.set(e, i), i;
+		}
+		resolvePosix(...t) {
+			let e = "";
+			for (let r = t.length - 1; r >= 0; r--) {
+				let o = t[r];
+				if (!(!o || o === ".") && (e = e ? `${o}/${e}` : o, this.isAbsolute(o))) break;
+			}
+			let s = this.#s.get(e);
+			if (s !== void 0) return s;
+			let i = this.cwd.resolve(e).fullpathPosix();
+			return this.#s.set(e, i), i;
+		}
+		relative(t = this.cwd) {
+			return typeof t == "string" && (t = this.cwd.resolve(t)), t.relative();
+		}
+		relativePosix(t = this.cwd) {
+			return typeof t == "string" && (t = this.cwd.resolve(t)), t.relativePosix();
+		}
+		basename(t = this.cwd) {
+			return typeof t == "string" && (t = this.cwd.resolve(t)), t.name;
+		}
+		dirname(t = this.cwd) {
+			return typeof t == "string" && (t = this.cwd.resolve(t)), (t.parent || t).fullpath();
+		}
+		async readdir(t = this.cwd, e = { withFileTypes: !0 }) {
+			typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+			let { withFileTypes: s } = e;
+			if (t.canReaddir()) {
+				let i = await t.readdir();
+				return s ? i : i.map((r) => r.name);
+			} else return [];
+		}
+		readdirSync(t = this.cwd, e = { withFileTypes: !0 }) {
+			typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+			let { withFileTypes: s = !0 } = e;
+			return t.canReaddir() ? s ? t.readdirSync() : t.readdirSync().map((i) => i.name) : [];
+		}
+		async lstat(t = this.cwd) {
+			return typeof t == "string" && (t = this.cwd.resolve(t)), t.lstat();
+		}
+		lstatSync(t = this.cwd) {
+			return typeof t == "string" && (t = this.cwd.resolve(t)), t.lstatSync();
+		}
+		async readlink(t = this.cwd, { withFileTypes: e } = { withFileTypes: !1 }) {
+			typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t.withFileTypes, t = this.cwd);
+			let s = await t.readlink();
+			return e ? s : s?.fullpath();
+		}
+		readlinkSync(t = this.cwd, { withFileTypes: e } = { withFileTypes: !1 }) {
+			typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t.withFileTypes, t = this.cwd);
+			let s = t.readlinkSync();
+			return e ? s : s?.fullpath();
+		}
+		async realpath(t = this.cwd, { withFileTypes: e } = { withFileTypes: !1 }) {
+			typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t.withFileTypes, t = this.cwd);
+			let s = await t.realpath();
+			return e ? s : s?.fullpath();
+		}
+		realpathSync(t = this.cwd, { withFileTypes: e } = { withFileTypes: !1 }) {
+			typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t.withFileTypes, t = this.cwd);
+			let s = t.realpathSync();
+			return e ? s : s?.fullpath();
+		}
+		async walk(t = this.cwd, e = {}) {
+			typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+			let { withFileTypes: s = !0, follow: i = !1, filter: r, walkFilter: o } = e, h = [];
+			(!r || r(t)) && h.push(s ? t : t.fullpath());
+			let a = /* @__PURE__ */ new Set(), l = (c, d) => {
+				a.add(c), c.readdirCB((f, m) => {
+					if (f) return d(f);
+					let p = m.length;
+					if (!p) return d();
+					let w = () => {
+						--p === 0 && d();
+					};
+					for (let g of m) (!r || r(g)) && h.push(s ? g : g.fullpath()), i && g.isSymbolicLink() ? g.realpath().then((S) => S?.isUnknown() ? S.lstat() : S).then((S) => S?.shouldWalk(a, o) ? l(S, w) : w()) : g.shouldWalk(a, o) ? l(g, w) : w();
+				}, !0);
+			}, u = t;
+			return new Promise((c, d) => {
+				l(u, (f) => {
+					if (f) return d(f);
+					c(h);
+				});
+			});
+		}
+		walkSync(t = this.cwd, e = {}) {
+			typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+			let { withFileTypes: s = !0, follow: i = !1, filter: r, walkFilter: o } = e, h = [];
+			(!r || r(t)) && h.push(s ? t : t.fullpath());
+			let a = /* @__PURE__ */ new Set([t]);
+			for (let l of a) {
+				let u = l.readdirSync();
+				for (let c of u) {
+					(!r || r(c)) && h.push(s ? c : c.fullpath());
+					let d = c;
+					if (c.isSymbolicLink()) {
+						if (!(i && (d = c.realpathSync()))) continue;
+						d.isUnknown() && d.lstatSync();
+					}
+					d.shouldWalk(a, o) && a.add(d);
+				}
+			}
+			return h;
+		}
+		[Symbol.asyncIterator]() {
+			return this.iterate();
+		}
+		iterate(t = this.cwd, e = {}) {
+			return typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd), this.stream(t, e)[Symbol.asyncIterator]();
+		}
+		[Symbol.iterator]() {
+			return this.iterateSync();
+		}
+		*iterateSync(t = this.cwd, e = {}) {
+			typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+			let { withFileTypes: s = !0, follow: i = !1, filter: r, walkFilter: o } = e;
+			(!r || r(t)) && (yield s ? t : t.fullpath());
+			let h = /* @__PURE__ */ new Set([t]);
+			for (let a of h) {
+				let l = a.readdirSync();
+				for (let u of l) {
+					(!r || r(u)) && (yield s ? u : u.fullpath());
+					let c = u;
+					if (u.isSymbolicLink()) {
+						if (!(i && (c = u.realpathSync()))) continue;
+						c.isUnknown() && c.lstatSync();
+					}
+					c.shouldWalk(h, o) && h.add(c);
+				}
+			}
+		}
+		stream(t = this.cwd, e = {}) {
+			typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+			let { withFileTypes: s = !0, follow: i = !1, filter: r, walkFilter: o } = e, h = new V({ objectMode: !0 });
+			(!r || r(t)) && h.write(s ? t : t.fullpath());
+			let a = /* @__PURE__ */ new Set(), l = [t], u = 0, c = () => {
+				let d = !1;
+				for (; !d;) {
+					let f = l.shift();
+					if (!f) {
+						u === 0 && h.end();
+						return;
+					}
+					u++, a.add(f);
+					let m = (w, g, S = !1) => {
+						if (w) return h.emit("error", w);
+						if (i && !S) {
+							let E = [];
+							for (let y of g) y.isSymbolicLink() && E.push(y.realpath().then((b) => b?.isUnknown() ? b.lstat() : b));
+							if (E.length) {
+								Promise.all(E).then(() => m(null, g, !0));
+								return;
+							}
+						}
+						for (let E of g) E && (!r || r(E)) && (h.write(s ? E : E.fullpath()) || (d = !0));
+						u--;
+						for (let E of g) {
+							let y = E.realpathCached() || E;
+							y.shouldWalk(a, o) && l.push(y);
+						}
+						d && !h.flowing ? h.once("drain", c) : p || c();
+					}, p = !0;
+					f.readdirCB(m, !0), p = !1;
+				}
+			};
+			return c(), h;
+		}
+		streamSync(t = this.cwd, e = {}) {
+			typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof R || (e = t, t = this.cwd);
+			let { withFileTypes: s = !0, follow: i = !1, filter: r, walkFilter: o } = e, h = new V({ objectMode: !0 }), a = /* @__PURE__ */ new Set();
+			(!r || r(t)) && h.write(s ? t : t.fullpath());
+			let l = [t], u = 0, c = () => {
+				let d = !1;
+				for (; !d;) {
+					let f = l.shift();
+					if (!f) {
+						u === 0 && h.end();
+						return;
+					}
+					u++, a.add(f);
+					let m = f.readdirSync();
+					for (let p of m) (!r || r(p)) && (h.write(s ? p : p.fullpath()) || (d = !0));
+					u--;
+					for (let p of m) {
+						let w = p;
+						if (p.isSymbolicLink()) {
+							if (!(i && (w = p.realpathSync()))) continue;
+							w.isUnknown() && w.lstatSync();
+						}
+						w.shouldWalk(a, o) && l.push(w);
+					}
+				}
+				d && !h.flowing && h.once("drain", c);
+			};
+			return c(), h;
+		}
+		chdir(t = this.cwd) {
+			let e = this.cwd;
+			this.cwd = typeof t == "string" ? this.cwd.resolve(t) : t, this.cwd[Ye](e);
+		}
+	}, it = class extends It {
+		sep = "\\";
+		constructor(t = process.cwd(), e = {}) {
+			let { nocase: s = !0 } = e;
+			super(t, win32, "\\", {
+				...e,
+				nocase: s
+			}), this.nocase = s;
+			for (let i = this.cwd; i; i = i.parent) i.nocase = this.nocase;
+		}
+		parseRootPath(t) {
+			return win32.parse(t).root.toUpperCase();
+		}
+		newRoot(t) {
+			return new Pt(this.rootPath, U, void 0, this.roots, this.nocase, this.childrenCache(), { fs: t });
+		}
+		isAbsolute(t) {
+			return t.startsWith("/") || t.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(t);
+		}
+	}, rt = class extends It {
+		sep = "/";
+		constructor(t = process.cwd(), e = {}) {
+			let { nocase: s = !1 } = e;
+			super(t, posix, "/", {
+				...e,
+				nocase: s
+			}), this.nocase = s;
+		}
+		parseRootPath(t) {
+			return "/";
+		}
+		newRoot(t) {
+			return new jt(this.rootPath, U, void 0, this.roots, this.nocase, this.childrenCache(), { fs: t });
+		}
+		isAbsolute(t) {
+			return t.startsWith("/");
+		}
+	}, St = class extends rt {
+		constructor(t = process.cwd(), e = {}) {
+			let { nocase: s = !0 } = e;
+			super(t, {
+				...e,
+				nocase: s
+			});
+		}
+	};
+	process.platform;
+	Xe = process.platform === "win32" ? it : process.platform === "darwin" ? St : rt;
+	Di = (n) => n.length >= 1, Mi = (n) => n.length >= 1, Ni = Symbol.for("nodejs.util.inspect.custom"), nt = class n {
+		#t;
+		#s;
+		#n;
+		length;
+		#r;
+		#o;
+		#S;
+		#w;
+		#c;
+		#h;
+		#u = !0;
+		constructor(t, e, s, i) {
+			if (!Di(t)) throw new TypeError("empty pattern list");
+			if (!Mi(e)) throw new TypeError("empty glob list");
+			if (e.length !== t.length) throw new TypeError("mismatched pattern list and glob list lengths");
+			if (this.length = t.length, s < 0 || s >= this.length) throw new TypeError("index out of range");
+			if (this.#t = t, this.#s = e, this.#n = s, this.#r = i, this.#n === 0) {
+				if (this.isUNC()) {
+					let [r, o, h, a, ...l] = this.#t, [u, c, d, f, ...m] = this.#s;
+					l[0] === "" && (l.shift(), m.shift());
+					let p = [
+						r,
+						o,
+						h,
+						a,
+						""
+					].join("/"), w = [
+						u,
+						c,
+						d,
+						f,
+						""
+					].join("/");
+					this.#t = [p, ...l], this.#s = [w, ...m], this.length = this.#t.length;
+				} else if (this.isDrive() || this.isAbsolute()) {
+					let [r, ...o] = this.#t, [h, ...a] = this.#s;
+					o[0] === "" && (o.shift(), a.shift());
+					let l = r + "/", u = h + "/";
+					this.#t = [l, ...o], this.#s = [u, ...a], this.length = this.#t.length;
+				}
+			}
+		}
+		[Ni]() {
+			return "Pattern <" + this.#s.slice(this.#n).join("/") + ">";
+		}
+		pattern() {
+			return this.#t[this.#n];
+		}
+		isString() {
+			return typeof this.#t[this.#n] == "string";
+		}
+		isGlobstar() {
+			return this.#t[this.#n] === A;
+		}
+		isRegExp() {
+			return this.#t[this.#n] instanceof RegExp;
+		}
+		globString() {
+			return this.#S = this.#S || (this.#n === 0 ? this.isAbsolute() ? this.#s[0] + this.#s.slice(1).join("/") : this.#s.join("/") : this.#s.slice(this.#n).join("/"));
+		}
+		hasMore() {
+			return this.length > this.#n + 1;
+		}
+		rest() {
+			return this.#o !== void 0 ? this.#o : this.hasMore() ? (this.#o = new n(this.#t, this.#s, this.#n + 1, this.#r), this.#o.#h = this.#h, this.#o.#c = this.#c, this.#o.#w = this.#w, this.#o) : this.#o = null;
+		}
+		isUNC() {
+			let t = this.#t;
+			return this.#c !== void 0 ? this.#c : this.#c = this.#r === "win32" && this.#n === 0 && t[0] === "" && t[1] === "" && typeof t[2] == "string" && !!t[2] && typeof t[3] == "string" && !!t[3];
+		}
+		isDrive() {
+			let t = this.#t;
+			return this.#w !== void 0 ? this.#w : this.#w = this.#r === "win32" && this.#n === 0 && this.length > 1 && typeof t[0] == "string" && /^[a-z]:$/i.test(t[0]);
+		}
+		isAbsolute() {
+			let t = this.#t;
+			return this.#h !== void 0 ? this.#h : this.#h = t[0] === "" && t.length > 1 || this.isDrive() || this.isUNC();
+		}
+		root() {
+			let t = this.#t[0];
+			return typeof t == "string" && this.isAbsolute() && this.#n === 0 ? t : "";
+		}
+		checkFollowGlobstar() {
+			return !(this.#n === 0 || !this.isGlobstar() || !this.#u);
+		}
+		markFollowGlobstar() {
+			return this.#n === 0 || !this.isGlobstar() || !this.#u ? !1 : (this.#u = !1, !0);
+		}
+	};
+	_i = typeof process == "object" && process && typeof process.platform == "string" ? process.platform : "linux", ot = class {
+		relative;
+		relativeChildren;
+		absolute;
+		absoluteChildren;
+		platform;
+		mmopts;
+		constructor(t, { nobrace: e, nocase: s, noext: i, noglobstar: r, platform: o = _i }) {
+			this.relative = [], this.absolute = [], this.relativeChildren = [], this.absoluteChildren = [], this.platform = o, this.mmopts = {
+				dot: !0,
+				nobrace: e,
+				nocase: s,
+				noext: i,
+				noglobstar: r,
+				optimizationLevel: 2,
+				platform: o,
+				nocomment: !0,
+				nonegate: !0
+			};
+			for (let h of t) this.add(h);
+		}
+		add(t) {
+			let e = new D(t, this.mmopts);
+			for (let s = 0; s < e.set.length; s++) {
+				let i = e.set[s], r = e.globParts[s];
+				if (!i || !r) throw new Error("invalid pattern object");
+				for (; i[0] === "." && r[0] === ".";) i.shift(), r.shift();
+				let o = new nt(i, r, 0, this.platform), h = new D(o.globString(), this.mmopts), a = r[r.length - 1] === "**", l = o.isAbsolute();
+				l ? this.absolute.push(h) : this.relative.push(h), a && (l ? this.absoluteChildren.push(h) : this.relativeChildren.push(h));
+			}
+		}
+		ignored(t) {
+			let e = t.fullpath(), s = `${e}/`, i = t.relative() || ".", r = `${i}/`;
+			for (let o of this.relative) if (o.match(i) || o.match(r)) return !0;
+			for (let o of this.absolute) if (o.match(e) || o.match(s)) return !0;
+			return !1;
+		}
+		childrenIgnored(t) {
+			let e = t.fullpath() + "/", s = (t.relative() || ".") + "/";
+			for (let i of this.relativeChildren) if (i.match(s)) return !0;
+			for (let i of this.absoluteChildren) if (i.match(e)) return !0;
+			return !1;
+		}
+	};
+	oe = class n {
+		store;
+		constructor(t = /* @__PURE__ */ new Map()) {
+			this.store = t;
+		}
+		copy() {
+			return new n(new Map(this.store));
+		}
+		hasWalked(t, e) {
+			return this.store.get(t.fullpath())?.has(e.globString());
+		}
+		storeWalked(t, e) {
+			let s = t.fullpath(), i = this.store.get(s);
+			i ? i.add(e.globString()) : this.store.set(s, /* @__PURE__ */ new Set([e.globString()]));
+		}
+	}, he = class {
+		store = /* @__PURE__ */ new Map();
+		add(t, e, s) {
+			let i = (e ? 2 : 0) | (s ? 1 : 0), r = this.store.get(t);
+			this.store.set(t, r === void 0 ? i : i & r);
+		}
+		entries() {
+			return [...this.store.entries()].map(([t, e]) => [
+				t,
+				!!(e & 2),
+				!!(e & 1)
+			]);
+		}
+	}, ae = class {
+		store = /* @__PURE__ */ new Map();
+		add(t, e) {
+			if (!t.canReaddir()) return;
+			let s = this.store.get(t);
+			s ? s.find((i) => i.globString() === e.globString()) || s.push(e) : this.store.set(t, [e]);
+		}
+		get(t) {
+			let e = this.store.get(t);
+			if (!e) throw new Error("attempting to walk unknown path");
+			return e;
+		}
+		entries() {
+			return this.keys().map((t) => [t, this.store.get(t)]);
+		}
+		keys() {
+			return [...this.store.keys()].filter((t) => t.canReaddir());
+		}
+	}, Et = class n {
+		hasWalkedCache;
+		matches = new he();
+		subwalks = new ae();
+		patterns;
+		follow;
+		dot;
+		opts;
+		constructor(t, e) {
+			this.opts = t, this.follow = !!t.follow, this.dot = !!t.dot, this.hasWalkedCache = e ? e.copy() : new oe();
+		}
+		processPatterns(t, e) {
+			this.patterns = e;
+			let s = e.map((i) => [t, i]);
+			for (let [i, r] of s) {
+				this.hasWalkedCache.storeWalked(i, r);
+				let o = r.root(), h = r.isAbsolute() && this.opts.absolute !== !1;
+				if (o) {
+					i = i.resolve(o === "/" && this.opts.root !== void 0 ? this.opts.root : o);
+					let c = r.rest();
+					if (c) r = c;
+					else {
+						this.matches.add(i, !0, !1);
+						continue;
+					}
+				}
+				if (i.isENOENT()) continue;
+				let a, l, u = !1;
+				for (; typeof (a = r.pattern()) == "string" && (l = r.rest());) i = i.resolve(a), r = l, u = !0;
+				if (a = r.pattern(), l = r.rest(), u) {
+					if (this.hasWalkedCache.hasWalked(i, r)) continue;
+					this.hasWalkedCache.storeWalked(i, r);
+				}
+				if (typeof a == "string") {
+					let c = a === ".." || a === "" || a === ".";
+					this.matches.add(i.resolve(a), h, c);
+					continue;
+				} else if (a === A) {
+					(!i.isSymbolicLink() || this.follow || r.checkFollowGlobstar()) && this.subwalks.add(i, r);
+					let c = l?.pattern(), d = l?.rest();
+					if (!l || (c === "" || c === ".") && !d) this.matches.add(i, h, c === "" || c === ".");
+					else if (c === "..") {
+						let f = i.parent || i;
+						d ? this.hasWalkedCache.hasWalked(f, d) || this.subwalks.add(f, d) : this.matches.add(f, h, !0);
+					}
+				} else a instanceof RegExp && this.subwalks.add(i, r);
+			}
+			return this;
+		}
+		subwalkTargets() {
+			return this.subwalks.keys();
+		}
+		child() {
+			return new n(this.opts, this.hasWalkedCache);
+		}
+		filterEntries(t, e) {
+			let s = this.subwalks.get(t), i = this.child();
+			for (let r of e) for (let o of s) {
+				let h = o.isAbsolute(), a = o.pattern(), l = o.rest();
+				a === A ? i.testGlobstar(r, o, l, h) : a instanceof RegExp ? i.testRegExp(r, a, l, h) : i.testString(r, a, l, h);
+			}
+			return i;
+		}
+		testGlobstar(t, e, s, i) {
+			if ((this.dot || !t.name.startsWith(".")) && (e.hasMore() || this.matches.add(t, i, !1), t.canReaddir() && (this.follow || !t.isSymbolicLink() ? this.subwalks.add(t, e) : t.isSymbolicLink() && (s && e.checkFollowGlobstar() ? this.subwalks.add(t, s) : e.markFollowGlobstar() && this.subwalks.add(t, e)))), s) {
+				let r = s.pattern();
+				if (typeof r == "string" && r !== ".." && r !== "" && r !== ".") this.testString(t, r, s.rest(), i);
+				else if (r === "..") {
+					let o = t.parent || t;
+					this.subwalks.add(o, s);
+				} else r instanceof RegExp && this.testRegExp(t, r, s.rest(), i);
+			}
+		}
+		testRegExp(t, e, s, i) {
+			e.test(t.name) && (s ? this.subwalks.add(t, s) : this.matches.add(t, i, !1));
+		}
+		testString(t, e, s, i) {
+			t.isNamed(e) && (s ? this.subwalks.add(t, s) : this.matches.add(t, i, !1));
+		}
+	};
+	Li = (n, t) => typeof n == "string" ? new ot([n], t) : Array.isArray(n) ? new ot(n, t) : n, zt = class {
+		path;
+		patterns;
+		opts;
+		seen = /* @__PURE__ */ new Set();
+		paused = !1;
+		aborted = !1;
+		#t = [];
+		#s;
+		#n;
+		signal;
+		maxDepth;
+		includeChildMatches;
+		constructor(t, e, s) {
+			if (this.patterns = t, this.path = e, this.opts = s, this.#n = !s.posix && s.platform === "win32" ? "\\" : "/", this.includeChildMatches = s.includeChildMatches !== !1, (s.ignore || !this.includeChildMatches) && (this.#s = Li(s.ignore ?? [], s), !this.includeChildMatches && typeof this.#s.add != "function")) throw new Error("cannot ignore child matches, ignore lacks add() method.");
+			this.maxDepth = s.maxDepth || Infinity, s.signal && (this.signal = s.signal, this.signal.addEventListener("abort", () => {
+				this.#t.length = 0;
+			}));
+		}
+		#r(t) {
+			return this.seen.has(t) || !!this.#s?.ignored?.(t);
+		}
+		#o(t) {
+			return !!this.#s?.childrenIgnored?.(t);
+		}
+		pause() {
+			this.paused = !0;
+		}
+		resume() {
+			if (this.signal?.aborted) return;
+			this.paused = !1;
+			let t;
+			for (; !this.paused && (t = this.#t.shift());) t();
+		}
+		onResume(t) {
+			this.signal?.aborted || (this.paused ? this.#t.push(t) : t());
+		}
+		async matchCheck(t, e) {
+			if (e && this.opts.nodir) return;
+			let s;
+			if (this.opts.realpath) {
+				if (s = t.realpathCached() || await t.realpath(), !s) return;
+				t = s;
+			}
+			let r = t.isUnknown() || this.opts.stat ? await t.lstat() : t;
+			if (this.opts.follow && this.opts.nodir && r?.isSymbolicLink()) {
+				let o = await r.realpath();
+				o && (o.isUnknown() || this.opts.stat) && await o.lstat();
+			}
+			return this.matchCheckTest(r, e);
+		}
+		matchCheckTest(t, e) {
+			return t && (this.maxDepth === Infinity || t.depth() <= this.maxDepth) && (!e || t.canReaddir()) && (!this.opts.nodir || !t.isDirectory()) && (!this.opts.nodir || !this.opts.follow || !t.isSymbolicLink() || !t.realpathCached()?.isDirectory()) && !this.#r(t) ? t : void 0;
+		}
+		matchCheckSync(t, e) {
+			if (e && this.opts.nodir) return;
+			let s;
+			if (this.opts.realpath) {
+				if (s = t.realpathCached() || t.realpathSync(), !s) return;
+				t = s;
+			}
+			let r = t.isUnknown() || this.opts.stat ? t.lstatSync() : t;
+			if (this.opts.follow && this.opts.nodir && r?.isSymbolicLink()) {
+				let o = r.realpathSync();
+				o && (o?.isUnknown() || this.opts.stat) && o.lstatSync();
+			}
+			return this.matchCheckTest(r, e);
+		}
+		matchFinish(t, e) {
+			if (this.#r(t)) return;
+			if (!this.includeChildMatches && this.#s?.add) {
+				let r = `${t.relativePosix()}/**`;
+				this.#s.add(r);
+			}
+			let s = this.opts.absolute === void 0 ? e : this.opts.absolute;
+			this.seen.add(t);
+			let i = this.opts.mark && t.isDirectory() ? this.#n : "";
+			if (this.opts.withFileTypes) this.matchEmit(t);
+			else if (s) {
+				let r = this.opts.posix ? t.fullpathPosix() : t.fullpath();
+				this.matchEmit(r + i);
+			} else {
+				let r = this.opts.posix ? t.relativePosix() : t.relative(), o = this.opts.dotRelative && !r.startsWith(".." + this.#n) ? "." + this.#n : "";
+				this.matchEmit(r ? o + r + i : "." + i);
+			}
+		}
+		async match(t, e, s) {
+			let i = await this.matchCheck(t, s);
+			i && this.matchFinish(i, e);
+		}
+		matchSync(t, e, s) {
+			let i = this.matchCheckSync(t, s);
+			i && this.matchFinish(i, e);
+		}
+		walkCB(t, e, s) {
+			this.signal?.aborted && s(), this.walkCB2(t, e, new Et(this.opts), s);
+		}
+		walkCB2(t, e, s, i) {
+			if (this.#o(t)) return i();
+			if (this.signal?.aborted && i(), this.paused) {
+				this.onResume(() => this.walkCB2(t, e, s, i));
+				return;
+			}
+			s.processPatterns(t, e);
+			let r = 1, o = () => {
+				--r === 0 && i();
+			};
+			for (let [h, a, l] of s.matches.entries()) this.#r(h) || (r++, this.match(h, a, l).then(() => o()));
+			for (let h of s.subwalkTargets()) {
+				if (this.maxDepth !== Infinity && h.depth() >= this.maxDepth) continue;
+				r++;
+				let a = h.readdirCached();
+				h.calledReaddir() ? this.walkCB3(h, a, s, o) : h.readdirCB((l, u) => this.walkCB3(h, u, s, o), !0);
+			}
+			o();
+		}
+		walkCB3(t, e, s, i) {
+			s = s.filterEntries(t, e);
+			let r = 1, o = () => {
+				--r === 0 && i();
+			};
+			for (let [h, a, l] of s.matches.entries()) this.#r(h) || (r++, this.match(h, a, l).then(() => o()));
+			for (let [h, a] of s.subwalks.entries()) r++, this.walkCB2(h, a, s.child(), o);
+			o();
+		}
+		walkCBSync(t, e, s) {
+			this.signal?.aborted && s(), this.walkCB2Sync(t, e, new Et(this.opts), s);
+		}
+		walkCB2Sync(t, e, s, i) {
+			if (this.#o(t)) return i();
+			if (this.signal?.aborted && i(), this.paused) {
+				this.onResume(() => this.walkCB2Sync(t, e, s, i));
+				return;
+			}
+			s.processPatterns(t, e);
+			let r = 1, o = () => {
+				--r === 0 && i();
+			};
+			for (let [h, a, l] of s.matches.entries()) this.#r(h) || this.matchSync(h, a, l);
+			for (let h of s.subwalkTargets()) {
+				if (this.maxDepth !== Infinity && h.depth() >= this.maxDepth) continue;
+				r++;
+				let a = h.readdirSync();
+				this.walkCB3Sync(h, a, s, o);
+			}
+			o();
+		}
+		walkCB3Sync(t, e, s, i) {
+			s = s.filterEntries(t, e);
+			let r = 1, o = () => {
+				--r === 0 && i();
+			};
+			for (let [h, a, l] of s.matches.entries()) this.#r(h) || this.matchSync(h, a, l);
+			for (let [h, a] of s.subwalks.entries()) r++, this.walkCB2Sync(h, a, s.child(), o);
+			o();
+		}
+	}, xt = class extends zt {
+		matches = /* @__PURE__ */ new Set();
+		constructor(t, e, s) {
+			super(t, e, s);
+		}
+		matchEmit(t) {
+			this.matches.add(t);
+		}
+		async walk() {
+			if (this.signal?.aborted) throw this.signal.reason;
+			return this.path.isUnknown() && await this.path.lstat(), await new Promise((t, e) => {
+				this.walkCB(this.path, this.patterns, () => {
+					this.signal?.aborted ? e(this.signal.reason) : t(this.matches);
+				});
+			}), this.matches;
+		}
+		walkSync() {
+			if (this.signal?.aborted) throw this.signal.reason;
+			return this.path.isUnknown() && this.path.lstatSync(), this.walkCBSync(this.path, this.patterns, () => {
+				if (this.signal?.aborted) throw this.signal.reason;
+			}), this.matches;
+		}
+	}, vt = class extends zt {
+		results;
+		constructor(t, e, s) {
+			super(t, e, s), this.results = new V({
+				signal: this.signal,
+				objectMode: !0
+			}), this.results.on("drain", () => this.resume()), this.results.on("resume", () => this.resume());
+		}
+		matchEmit(t) {
+			this.results.write(t), this.results.flowing || this.pause();
+		}
+		stream() {
+			let t = this.path;
+			return t.isUnknown() ? t.lstat().then(() => {
+				this.walkCB(t, this.patterns, () => this.results.end());
+			}) : this.walkCB(t, this.patterns, () => this.results.end()), this.results;
+		}
+		streamSync() {
+			return this.path.isUnknown() && this.path.lstatSync(), this.walkCBSync(this.path, this.patterns, () => this.results.end()), this.results;
+		}
+	};
+	Pi = typeof process == "object" && process && typeof process.platform == "string" ? process.platform : "linux", I = class {
+		absolute;
+		cwd;
+		root;
+		dot;
+		dotRelative;
+		follow;
+		ignore;
+		magicalBraces;
+		mark;
+		matchBase;
+		maxDepth;
+		nobrace;
+		nocase;
+		nodir;
+		noext;
+		noglobstar;
+		pattern;
+		platform;
+		realpath;
+		scurry;
+		stat;
+		signal;
+		windowsPathsNoEscape;
+		withFileTypes;
+		includeChildMatches;
+		opts;
+		patterns;
+		constructor(t, e) {
+			if (!e) throw new TypeError("glob options required");
+			if (this.withFileTypes = !!e.withFileTypes, this.signal = e.signal, this.follow = !!e.follow, this.dot = !!e.dot, this.dotRelative = !!e.dotRelative, this.nodir = !!e.nodir, this.mark = !!e.mark, e.cwd ? (e.cwd instanceof URL || e.cwd.startsWith("file://")) && (e.cwd = fileURLToPath(e.cwd)) : this.cwd = "", this.cwd = e.cwd || "", this.root = e.root, this.magicalBraces = !!e.magicalBraces, this.nobrace = !!e.nobrace, this.noext = !!e.noext, this.realpath = !!e.realpath, this.absolute = e.absolute, this.includeChildMatches = e.includeChildMatches !== !1, this.noglobstar = !!e.noglobstar, this.matchBase = !!e.matchBase, this.maxDepth = typeof e.maxDepth == "number" ? e.maxDepth : Infinity, this.stat = !!e.stat, this.ignore = e.ignore, this.withFileTypes && this.absolute !== void 0) throw new Error("cannot set absolute and withFileTypes:true");
+			if (typeof t == "string" && (t = [t]), this.windowsPathsNoEscape = !!e.windowsPathsNoEscape || e.allowWindowsEscape === !1, this.windowsPathsNoEscape && (t = t.map((a) => a.replace(/\\/g, "/"))), this.matchBase) {
+				if (e.noglobstar) throw new TypeError("base matching requires globstar");
+				t = t.map((a) => a.includes("/") ? a : `./**/${a}`);
+			}
+			if (this.pattern = t, this.platform = e.platform || Pi, this.opts = {
+				...e,
+				platform: this.platform
+			}, e.scurry) {
+				if (this.scurry = e.scurry, e.nocase !== void 0 && e.nocase !== e.scurry.nocase) throw new Error("nocase option contradicts provided scurry option");
+			} else {
+				let a = e.platform === "win32" ? it : e.platform === "darwin" ? St : e.platform ? rt : Xe;
+				this.scurry = new a(this.cwd, {
+					nocase: e.nocase,
+					fs: e.fs
+				});
+			}
+			this.nocase = this.scurry.nocase;
+			let s = this.platform === "darwin" || this.platform === "win32", i = {
+				braceExpandMax: 1e4,
+				...e,
+				dot: this.dot,
+				matchBase: this.matchBase,
+				nobrace: this.nobrace,
+				nocase: this.nocase,
+				nocaseMagicOnly: s,
+				nocomment: !0,
+				noext: this.noext,
+				nonegate: !0,
+				optimizationLevel: 2,
+				platform: this.platform,
+				windowsPathsNoEscape: this.windowsPathsNoEscape,
+				debug: !!this.opts.debug
+			}, [o, h] = this.pattern.map((a) => new D(a, i)).reduce((a, l) => (a[0].push(...l.set), a[1].push(...l.globParts), a), [[], []]);
+			this.patterns = o.map((a, l) => {
+				let u = h[l];
+				if (!u) throw new Error("invalid pattern object");
+				return new nt(a, u, 0, this.platform);
+			});
+		}
+		async walk() {
+			return [...await new xt(this.patterns, this.scurry.cwd, {
+				...this.opts,
+				maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
+				platform: this.platform,
+				nocase: this.nocase,
+				includeChildMatches: this.includeChildMatches
+			}).walk()];
+		}
+		walkSync() {
+			return [...new xt(this.patterns, this.scurry.cwd, {
+				...this.opts,
+				maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
+				platform: this.platform,
+				nocase: this.nocase,
+				includeChildMatches: this.includeChildMatches
+			}).walkSync()];
+		}
+		stream() {
+			return new vt(this.patterns, this.scurry.cwd, {
+				...this.opts,
+				maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
+				platform: this.platform,
+				nocase: this.nocase,
+				includeChildMatches: this.includeChildMatches
+			}).stream();
+		}
+		streamSync() {
+			return new vt(this.patterns, this.scurry.cwd, {
+				...this.opts,
+				maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
+				platform: this.platform,
+				nocase: this.nocase,
+				includeChildMatches: this.includeChildMatches
+			}).streamSync();
+		}
+		iterateSync() {
+			return this.streamSync()[Symbol.iterator]();
+		}
+		[Symbol.iterator]() {
+			return this.iterateSync();
+		}
+		iterate() {
+			return this.stream()[Symbol.asyncIterator]();
+		}
+		[Symbol.asyncIterator]() {
+			return this.iterate();
+		}
+	};
+	le = (n, t = {}) => {
+		Array.isArray(n) || (n = [n]);
+		for (let e of n) if (new D(e, t).hasMagic()) return !0;
+		return !1;
+	};
+	ji = Bt, Ii = Object.assign(Qe, { sync: Bt }), zi = Ut, Bi = Object.assign(es, { sync: Ut }), Ui = Object.assign(ts, {
+		stream: Bt,
+		iterate: Ut
+	}), Ze = Object.assign(Je, {
+		glob: Je,
+		globSync: ts,
+		sync: Ui,
+		globStream: Qe,
+		stream: Ii,
+		globStreamSync: Bt,
+		streamSync: ji,
+		globIterate: es,
+		iterate: Bi,
+		globIterateSync: Ut,
+		iterateSync: zi,
+		Glob: I,
+		hasMagic: le,
+		escape: tt,
+		unescape: W
+	});
+	Ze.glob = Ze;
+}))();
+/** Glob patterns for binary/style assets copied alongside compiled output. */
+const ASSET_PATTERNS = [
+	"**/*.jpg",
+	"**/*.png",
+	"**/*.gif",
+	"**/*.svg",
+	"**/*.webp",
+	"**/*.sass",
+	"**/*.scss",
+	"**/*.css"
+];
+/**
+* Copies asset files matching {@link ASSET_PATTERNS} from `srcDir` into
+* `destDir`, preserving each file's relative directory structure, and returns
+* the list of destination paths written. Replaces the `cpy` dependency with the
+* already-present `glob` plus `node:fs`.
+*/
+function copyAssetFiles(srcDir, destDir) {
+	const matches = ts(ASSET_PATTERNS, {
+		cwd: srcDir,
+		nodir: true
+	});
+	const copied = [];
+	for (const relativePath of matches) {
+		const from = path.join(srcDir, relativePath);
+		const to = path.join(destDir, relativePath);
+		mkdirSync(path.dirname(to), { recursive: true });
+		copyFileSync(from, to);
+		copied.push(to);
+	}
+	return copied;
+}
+//#endregion
+//#region src/lib/initCwd.ts
+function INIT_CWD() {
+	return process.env.INIT_CWD ?? process.cwd();
+}
+//#endregion
+//#region src/lib/packageName.ts
+function packageName() {
+	if (process.env.npm_package_name != null && process.env.npm_package_name.length > 0) return process.env.npm_package_name;
+	try {
+		const pkgPath = PATH.join(INIT_CWD(), "package.json");
+		return JSON.parse(readFileSync(pkgPath, "utf8")).name;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/actions/package/copy-assets.ts
+const copyTargetAssets = async (target, name, location) => {
+	try {
+		const srcDir = path.join(location, "src");
+		const values = copyAssetFiles(srcDir, path.join(srcDir, "..", "dist", target));
+		if (values.length > 0) console.log(chalk.green(`Copying Assets [${target.toUpperCase()}] - ${name} - ${location}`));
+		for (const value of values) console.log(`${value.split("/").pop()} => ./dist/${target}`);
+		return 0;
+	} catch (ex) {
+		console.log(`Copy Assets Failed: ${name}: ${ex.message}`);
+		return 1;
+	}
+};
+const packageCopyAssets = async ({ target }) => {
+	const pkg = INIT_CWD();
+	const pkgName = packageName() ?? "Unknown";
+	switch (target) {
+		case "esm": return await copyTargetAssets("esm", pkgName, pkg);
+		case "cjs": return await copyTargetAssets("cjs", pkgName, pkg);
+		default: return await copyTargetAssets("esm", pkgName, pkg) || await copyTargetAssets("cjs", pkgName, pkg);
+	}
+};
+//#endregion
+//#region src/bin/package/copy-assets-esm.ts
+try {
+	process.exitCode = await packageCopyAssets({ target: "esm" });
+} catch (reason) {
+	console.error(chalk.red(reason));
+	process.exitCode = 1;
+}
+//#endregion
+export {};
+
+//# sourceMappingURL=copy-assets-esm.mjs.map