@adamhl8/configs 0.15.24 → 0.16.0

package/dist/ts-import-fix

@@ -0,0 +1,2783 @@
+#!/usr/bin/env node
+import ve from "node:module";
+import path from "node:path";
+import process$1 from "node:process";
+import fss from "node:fs";
+import fs from "node:fs/promises";
+import Ae from "fs";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+function message(message$1, ...values$1) {
+	const messageTerms = [];
+	for (let i = 0; i < message$1.length; i++) {
+		if (message$1[i] !== "") messageTerms.push({
+			type: "text",
+			text: message$1[i]
+		});
+		if (i >= values$1.length) continue;
+		const value$1 = values$1[i];
+		if (typeof value$1 === "string") messageTerms.push({
+			type: "value",
+			value: value$1
+		});
+		else if (Array.isArray(value$1)) messageTerms.push(...value$1);
+		else if (typeof value$1 === "object" && value$1 != null && "type" in value$1) messageTerms.push(value$1);
+		else throw new TypeError(`Invalid value type in message: ${typeof value$1}.`);
+	}
+	return messageTerms;
+}
+function text(text$1) {
+	return {
+		type: "text",
+		text: text$1
+	};
+}
+function optionName(name) {
+	return {
+		type: "optionName",
+		optionName: name
+	};
+}
+function optionNames(names) {
+	return {
+		type: "optionNames",
+		optionNames: names
+	};
+}
+function metavar(metavar$1) {
+	return {
+		type: "metavar",
+		metavar: metavar$1
+	};
+}
+function formatMessage(msg, options = {}) {
+	const colorConfig = options.colors ?? false;
+	const useColors = typeof colorConfig === "boolean" ? colorConfig : true;
+	const resetSuffix = typeof colorConfig === "object" ? colorConfig.resetSuffix ?? "" : "";
+	const useQuotes = options.quotes ?? true;
+	const resetSequence = `\x1b[0m${resetSuffix}`;
+	function* stream() {
+		const wordPattern = /\s*\S+\s*/g;
+		for (const term of msg) if (term.type === "text") while (true) {
+			const match = wordPattern.exec(term.text);
+			if (match == null) break;
+			yield {
+				text: match[0],
+				width: match[0].length
+			};
+		}
+		else if (term.type === "optionName") {
+			const name = useQuotes ? `\`${term.optionName}\`` : term.optionName;
+			yield {
+				text: useColors ? `\x1b[3m${name}${resetSequence}` : name,
+				width: name.length
+			};
+		} else if (term.type === "optionNames") {
+			const names = term.optionNames.map((name) => useQuotes ? `\`${name}\`` : name);
+			let i = 0;
+			for (const name of names) {
+				if (i > 0) yield {
+					text: "/",
+					width: 1
+				};
+				yield {
+					text: useColors ? `\x1b[3m${name}${resetSequence}` : name,
+					width: name.length
+				};
+				i++;
+			}
+		} else if (term.type === "metavar") {
+			const metavar$1 = useQuotes ? `\`${term.metavar}\`` : term.metavar;
+			yield {
+				text: useColors ? `\x1b[1m${metavar$1}${resetSequence}` : metavar$1,
+				width: metavar$1.length
+			};
+		} else if (term.type === "value") {
+			const value$1 = useQuotes ? `${JSON.stringify(term.value)}` : term.value;
+			yield {
+				text: useColors ? `\x1b[32m${value$1}${resetSequence}` : value$1,
+				width: value$1.length
+			};
+		} else if (term.type === "values") for (let i = 0; i < term.values.length; i++) {
+			if (i > 0) yield {
+				text: " ",
+				width: 1
+			};
+			const value$1 = useQuotes ? JSON.stringify(term.values[i]) : term.values[i];
+			yield {
+				text: useColors ? i <= 0 ? `\x1b[32m${value$1}` : i + 1 >= term.values.length ? `${value$1}${resetSequence}` : value$1 : value$1,
+				width: value$1.length
+			};
+		}
+		else if (term.type === "envVar") {
+			const envVar$1 = useQuotes ? `\`${term.envVar}\`` : term.envVar;
+			yield {
+				text: useColors ? `\x1b[1;4m${envVar$1}${resetSequence}` : envVar$1,
+				width: envVar$1.length
+			};
+		} else throw new TypeError(`Invalid MessageTerm type: ${term["type"]}.`);
+	}
+	let output = "";
+	let totalWidth = 0;
+	for (const { text: text$1, width } of stream()) {
+		if (options.maxWidth != null && totalWidth + width > options.maxWidth) {
+			output += "\n";
+			totalWidth = 0;
+		}
+		output += text$1;
+		totalWidth += width;
+	}
+	return output;
+}
+function longestMatch(...args) {
+	let parsers;
+	let options;
+	if (args.length > 0 && args[args.length - 1] && typeof args[args.length - 1] === "object" && !("$valueType" in args[args.length - 1])) {
+		options = args[args.length - 1];
+		parsers = args.slice(0, -1);
+	} else {
+		parsers = args;
+		options = void 0;
+	}
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: Math.max(...parsers.map((p$2) => p$2.priority)),
+		usage: [{
+			type: "exclusive",
+			terms: parsers.map((p$2) => p$2.usage)
+		}],
+		initialState: void 0,
+		complete(state) {
+			if (state == null) return {
+				success: false,
+				error: options?.errors?.noMatch ?? message`No matching option or command found.`
+			};
+			const [i, result] = state;
+			if (result.success) return parsers[i].complete(result.next.state);
+			return {
+				success: false,
+				error: result.error
+			};
+		},
+		parse(context) {
+			let bestMatch = null;
+			let error = {
+				consumed: 0,
+				error: context.buffer.length < 1 ? options?.errors?.noMatch ?? message`No matching option or command found.` : (() => {
+					const token = context.buffer[0];
+					const defaultMsg = message`Unexpected option or subcommand: ${optionName(token)}.`;
+					return options?.errors?.unexpectedInput != null ? typeof options.errors.unexpectedInput === "function" ? options.errors.unexpectedInput(token) : options.errors.unexpectedInput : defaultMsg;
+				})()
+			};
+			for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				const result = parser.parse({
+					...context,
+					state: context.state == null || context.state[0] !== i || !context.state[1].success ? parser.initialState : context.state[1].next.state
+				});
+				if (result.success) {
+					const consumed = context.buffer.length - result.next.buffer.length;
+					if (bestMatch === null || consumed > bestMatch.consumed) bestMatch = {
+						index: i,
+						result,
+						consumed
+					};
+				} else if (error.consumed < result.consumed) error = result;
+			}
+			if (bestMatch && bestMatch.result.success) return {
+				success: true,
+				next: {
+					...context,
+					buffer: bestMatch.result.next.buffer,
+					optionsTerminated: bestMatch.result.next.optionsTerminated,
+					state: [bestMatch.index, bestMatch.result]
+				},
+				consumed: bestMatch.result.consumed
+			};
+			return {
+				...error,
+				success: false
+			};
+		},
+		getDocFragments(state, _defaultValue) {
+			let description;
+			let fragments;
+			if (state.kind === "unavailable" || state.state == null) fragments = parsers.flatMap((p$2) => p$2.getDocFragments({ kind: "unavailable" }).fragments);
+			else {
+				const [i, result] = state.state;
+				if (result.success) {
+					const docResult = parsers[i].getDocFragments({
+						kind: "available",
+						state: result.next.state
+					});
+					description = docResult.description;
+					fragments = docResult.fragments;
+				} else fragments = parsers.flatMap((p$2) => p$2.getDocFragments({ kind: "unavailable" }).fragments);
+			}
+			return {
+				description,
+				fragments
+			};
+		}
+	};
+}
+function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
+	const label = typeof labelOrParsers === "string" ? labelOrParsers : void 0;
+	let parsers;
+	let options = {};
+	if (typeof labelOrParsers === "string") {
+		parsers = maybeParsersOrOptions;
+		options = maybeOptions ?? {};
+	} else {
+		parsers = labelOrParsers;
+		options = maybeParsersOrOptions ?? {};
+	}
+	const parserPairs = Object.entries(parsers);
+	parserPairs.sort(([_$1, parserA], [__, parserB]) => parserB.priority - parserA.priority);
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: Math.max(...Object.values(parsers).map((p$2) => p$2.priority)),
+		usage: parserPairs.flatMap(([_$1, p$2]) => p$2.usage),
+		initialState: Object.fromEntries(Object.entries(parsers).map(([key, parser]) => [key, parser.initialState])),
+		parse(context) {
+			let error = {
+				consumed: 0,
+				error: context.buffer.length > 0 ? (() => {
+					const token = context.buffer[0];
+					const customMessage = options.errors?.unexpectedInput;
+					return customMessage ? typeof customMessage === "function" ? customMessage(token) : customMessage : message`Unexpected option or argument: ${token}.`;
+				})() : options.errors?.endOfInput ?? message`Expected an option or argument, but got end of input.`
+			};
+			let currentContext = context;
+			let anySuccess = false;
+			const allConsumed = [];
+			let madeProgress = true;
+			while (madeProgress && currentContext.buffer.length > 0) {
+				madeProgress = false;
+				for (const [field, parser] of parserPairs) {
+					const result = parser.parse({
+						...currentContext,
+						state: currentContext.state && typeof currentContext.state === "object" && field in currentContext.state ? currentContext.state[field] : parser.initialState
+					});
+					if (result.success && result.consumed.length > 0) {
+						currentContext = {
+							...currentContext,
+							buffer: result.next.buffer,
+							optionsTerminated: result.next.optionsTerminated,
+							state: {
+								...currentContext.state,
+								[field]: result.next.state
+							}
+						};
+						allConsumed.push(...result.consumed);
+						anySuccess = true;
+						madeProgress = true;
+						break;
+					} else if (!result.success && error.consumed < result.consumed) error = result;
+				}
+			}
+			if (anySuccess) return {
+				success: true,
+				next: currentContext,
+				consumed: allConsumed
+			};
+			if (context.buffer.length === 0) {
+				let allCanComplete = true;
+				for (const [field, parser] of parserPairs) {
+					const fieldState = context.state && typeof context.state === "object" && field in context.state ? context.state[field] : parser.initialState;
+					if (!parser.complete(fieldState).success) {
+						allCanComplete = false;
+						break;
+					}
+				}
+				if (allCanComplete) return {
+					success: true,
+					next: context,
+					consumed: []
+				};
+			}
+			return {
+				...error,
+				success: false
+			};
+		},
+		complete(state) {
+			const result = {};
+			for (const field in state) {
+				if (!(field in parsers)) continue;
+				const valueResult = parsers[field].complete(state[field]);
+				if (valueResult.success) result[field] = valueResult.value;
+				else return {
+					success: false,
+					error: valueResult.error
+				};
+			}
+			return {
+				success: true,
+				value: result
+			};
+		},
+		getDocFragments(state, defaultValue) {
+			const fragments = parserPairs.flatMap(([field, p$2]) => {
+				const fieldState = state.kind === "unavailable" ? { kind: "unavailable" } : {
+					kind: "available",
+					state: state.state[field]
+				};
+				return p$2.getDocFragments(fieldState, defaultValue?.[field]).fragments;
+			});
+			const entries = fragments.filter((d$1) => d$1.type === "entry");
+			const sections = [];
+			for (const fragment of fragments) {
+				if (fragment.type !== "section") continue;
+				if (fragment.title == null) entries.push(...fragment.entries);
+				else sections.push(fragment);
+			}
+			const section = {
+				title: label,
+				entries
+			};
+			sections.push(section);
+			return { fragments: sections.map((s$1) => ({
+				...s$1,
+				type: "section"
+			})) };
+		}
+	};
+}
+function formatUsage(programName, usage, options = {}) {
+	usage = normalizeUsage(usage);
+	if (options.expandCommands) {
+		const lastTerm = usage.at(-1);
+		if (usage.length > 0 && usage.slice(0, -1).every((t) => t.type === "command") && lastTerm.type === "exclusive" && lastTerm.terms.every((t) => t.length > 0 && (t[0].type === "command" || t[0].type === "option" || t[0].type === "argument" || t[0].type === "optional" && t[0].terms.length === 1 && (t[0].terms[0].type === "command" || t[0].terms[0].type === "option" || t[0].terms[0].type === "argument")))) {
+			const lines = [];
+			for (let command$1 of lastTerm.terms) {
+				if (usage.length > 1) command$1 = [...usage.slice(0, -1), ...command$1];
+				lines.push(formatUsage(programName, command$1, options));
+			}
+			return lines.join("\n");
+		}
+	}
+	let output = options.colors ? `\x1b[1m${programName}\x1b[0m ` : `${programName} `;
+	let lineWidth = programName.length + 1;
+	for (const { text: text$1, width } of formatUsageTerms(usage, options)) {
+		if (options.maxWidth != null && lineWidth + width > options.maxWidth) {
+			output += "\n";
+			lineWidth = 0;
+			if (text$1 === " ") continue;
+		}
+		output += text$1;
+		lineWidth += width;
+	}
+	return output;
+}
+function normalizeUsage(usage) {
+	const terms = usage.map(normalizeUsageTerm);
+	terms.sort((a$1, b) => {
+		const aCmd = a$1.type === "command";
+		const bCmd = b.type === "command";
+		const aArg = a$1.type === "argument" || (a$1.type === "optional" || a$1.type === "multiple") && a$1.terms.at(-1)?.type === "argument";
+		const bArg = b.type === "argument" || (b.type === "optional" || b.type === "multiple") && b.terms.at(-1)?.type === "argument";
+		return aCmd === bCmd ? aArg === bArg ? 0 : aArg ? 1 : -1 : aCmd ? -1 : 1;
+	});
+	return terms;
+}
+function normalizeUsageTerm(term) {
+	if (term.type === "optional") return {
+		type: "optional",
+		terms: normalizeUsage(term.terms)
+	};
+	else if (term.type === "multiple") return {
+		type: "multiple",
+		terms: normalizeUsage(term.terms),
+		min: term.min
+	};
+	else if (term.type === "exclusive") {
+		const terms = [];
+		for (const usage of term.terms) {
+			const normalized = normalizeUsage(usage);
+			if (normalized.length === 1 && normalized[0].type === "exclusive") for (const subUsage of normalized[0].terms) terms.push(subUsage);
+			else terms.push(normalized);
+		}
+		return {
+			type: "exclusive",
+			terms
+		};
+	} else return term;
+}
+function* formatUsageTerms(terms, options) {
+	let i = 0;
+	for (const t of terms) {
+		if (i > 0) yield {
+			text: " ",
+			width: 1
+		};
+		yield* formatUsageTermInternal(t, options);
+		i++;
+	}
+}
+function formatUsageTerm(term, options = {}) {
+	let lineWidth = 0;
+	let output = "";
+	for (const { text: text$1, width } of formatUsageTermInternal(term, options)) {
+		if (options.maxWidth != null && lineWidth + width > options.maxWidth) {
+			output += "\n";
+			lineWidth = 0;
+			if (text$1 === " ") continue;
+		}
+		output += text$1;
+		lineWidth += width;
+	}
+	return output;
+}
+function* formatUsageTermInternal(term, options) {
+	const optionsSeparator = options.optionsSeparator ?? "/";
+	if (term.type === "argument") yield {
+		text: options?.colors ? `\x1b[4m${term.metavar}\x1b[0m` : term.metavar,
+		width: term.metavar.length
+	};
+	else if (term.type === "option") if (options?.onlyShortestOptions) {
+		const shortestName = term.names.reduce((a$1, b) => a$1.length <= b.length ? a$1 : b);
+		yield {
+			text: options?.colors ? `\x1b[3m${shortestName}\x1b[0m` : shortestName,
+			width: shortestName.length
+		};
+	} else {
+		let i = 0;
+		for (const optionName$1 of term.names) {
+			if (i > 0) yield {
+				text: options?.colors ? `\x1b[2m${optionsSeparator}\x1b[0m` : optionsSeparator,
+				width: optionsSeparator.length
+			};
+			yield {
+				text: options?.colors ? `\x1b[3m${optionName$1}\x1b[0m` : optionName$1,
+				width: optionName$1.length
+			};
+			i++;
+		}
+		if (term.metavar != null) {
+			yield {
+				text: " ",
+				width: 1
+			};
+			yield {
+				text: options?.colors ? `\x1b[4m\x1b[2m${term.metavar}\x1b[0m` : term.metavar,
+				width: term.metavar.length
+			};
+		}
+	}
+	else if (term.type === "command") yield {
+		text: options?.colors ? `\x1b[1m${term.name}\x1b[0m` : term.name,
+		width: term.name.length
+	};
+	else if (term.type === "optional") {
+		yield {
+			text: options?.colors ? `\x1b[2m[\x1b[0m` : "[",
+			width: 1
+		};
+		yield* formatUsageTerms(term.terms, options);
+		yield {
+			text: options?.colors ? `\x1b[2m]\x1b[0m` : "]",
+			width: 1
+		};
+	} else if (term.type === "exclusive") {
+		yield {
+			text: options?.colors ? `\x1b[2m(\x1b[0m` : "(",
+			width: 1
+		};
+		let i = 0;
+		for (const termGroup of term.terms) {
+			if (i > 0) {
+				yield {
+					text: " ",
+					width: 1
+				};
+				yield {
+					text: "|",
+					width: 1
+				};
+				yield {
+					text: " ",
+					width: 1
+				};
+			}
+			yield* formatUsageTerms(termGroup, options);
+			i++;
+		}
+		yield {
+			text: options?.colors ? `\x1b[2m)\x1b[0m` : ")",
+			width: 1
+		};
+	} else if (term.type === "multiple") {
+		if (term.min < 1) yield {
+			text: options?.colors ? `\x1b[2m[\x1b[0m` : "[",
+			width: 1
+		};
+		for (let i = 0; i < Math.max(1, term.min); i++) {
+			if (i > 0) yield {
+				text: " ",
+				width: 1
+			};
+			yield* formatUsageTerms(term.terms, options);
+		}
+		yield {
+			text: options?.colors ? `\x1b[2m...\x1b[0m` : "...",
+			width: 3
+		};
+		if (term.min < 1) yield {
+			text: options?.colors ? `\x1b[2m]\x1b[0m` : "]",
+			width: 1
+		};
+	} else throw new TypeError(`Unknown usage term type: ${term["type"]}.`);
+}
+function formatDocPage(programName, page, options = {}) {
+	const termIndent = options.termIndent ?? 2;
+	const termWidth = options.termWidth ?? 26;
+	let output = "";
+	if (page.brief != null) {
+		output += formatMessage(page.brief, {
+			colors: options.colors,
+			maxWidth: options.maxWidth,
+			quotes: !options.colors
+		});
+		output += "\n";
+	}
+	if (page.usage != null) {
+		output += "Usage: ";
+		output += indentLines$1(formatUsage(programName, page.usage, {
+			colors: options.colors,
+			maxWidth: options.maxWidth == null ? void 0 : options.maxWidth - 7,
+			expandCommands: true
+		}), 7);
+		output += "\n";
+	}
+	if (page.description != null) {
+		output += "\n";
+		output += formatMessage(page.description, {
+			colors: options.colors,
+			maxWidth: options.maxWidth,
+			quotes: !options.colors
+		});
+		output += "\n";
+	}
+	const sections = page.sections.toSorted((a$1, b) => a$1.title == null && b.title == null ? 0 : a$1.title == null ? -1 : 1);
+	for (const section of sections) {
+		output += "\n";
+		if (section.title != null) output += `${section.title}:\n`;
+		for (const entry of section.entries) {
+			const term = formatUsageTerm(entry.term, {
+				colors: options.colors,
+				optionsSeparator: ", ",
+				maxWidth: options.maxWidth == null ? void 0 : options.maxWidth - termIndent
+			});
+			let description = entry.description == null ? "" : formatMessage(entry.description, {
+				colors: options.colors,
+				quotes: !options.colors,
+				maxWidth: options.maxWidth == null ? void 0 : options.maxWidth - termIndent - termWidth - 2
+			});
+			if (options.showDefault && entry.default != null) {
+				const prefix = typeof options.showDefault === "object" ? options.showDefault.prefix ?? " [" : " [";
+				const suffix = typeof options.showDefault === "object" ? options.showDefault.suffix ?? "]" : "]";
+				const defaultText = `${prefix}${formatMessage(entry.default, {
+					colors: options.colors ? { resetSuffix: "\x1B[2m" } : false,
+					quotes: !options.colors
+				})}${suffix}`;
+				const formattedDefault = options.colors ? `\x1b[2m${defaultText}\x1b[0m` : defaultText;
+				description += formattedDefault;
+			}
+			output += `${" ".repeat(termIndent)}${ansiAwareRightPad(term, termWidth)}  ${description === "" ? "" : indentLines$1(description, termIndent + termWidth + 2)}\n`;
+		}
+	}
+	if (page.footer != null) {
+		output += "\n";
+		output += formatMessage(page.footer, {
+			colors: options.colors,
+			maxWidth: options.maxWidth,
+			quotes: !options.colors
+		});
+	}
+	return output;
+}
+function indentLines$1(text$1, indent) {
+	return text$1.split("\n").join("\n" + " ".repeat(indent));
+}
+function ansiAwareRightPad(text$1, length, char = " ") {
+	const strippedText = text$1.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+	if (strippedText.length >= length) return text$1;
+	return text$1 + char.repeat(length - strippedText.length);
+}
+function optional(parser) {
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: parser.priority,
+		usage: [{
+			type: "optional",
+			terms: parser.usage
+		}],
+		initialState: void 0,
+		parse(context) {
+			const result = parser.parse({
+				...context,
+				state: typeof context.state === "undefined" ? parser.initialState : context.state[0]
+			});
+			if (result.success) return {
+				success: true,
+				next: {
+					...result.next,
+					state: [result.next.state]
+				},
+				consumed: result.consumed
+			};
+			return result;
+		},
+		complete(state) {
+			if (typeof state === "undefined") return {
+				success: true,
+				value: void 0
+			};
+			return parser.complete(state[0]);
+		},
+		getDocFragments(state, defaultValue) {
+			const innerState = state.kind === "unavailable" ? { kind: "unavailable" } : state.state === void 0 ? { kind: "unavailable" } : {
+				kind: "available",
+				state: state.state[0]
+			};
+			return parser.getDocFragments(innerState, defaultValue);
+		}
+	};
+}
+function multiple(parser, options = {}) {
+	const { min = 0, max = Infinity } = options;
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: parser.priority,
+		usage: [{
+			type: "multiple",
+			terms: parser.usage,
+			min
+		}],
+		initialState: [],
+		parse(context) {
+			let added = context.state.length < 1;
+			let result = parser.parse({
+				...context,
+				state: context.state.at(-1) ?? parser.initialState
+			});
+			if (!result.success) if (!added) {
+				result = parser.parse({
+					...context,
+					state: parser.initialState
+				});
+				if (!result.success) return result;
+				added = true;
+			} else return result;
+			return {
+				success: true,
+				next: {
+					...result.next,
+					state: [...added ? context.state : context.state.slice(0, -1), result.next.state]
+				},
+				consumed: result.consumed
+			};
+		},
+		complete(state) {
+			const result = [];
+			for (const s$1 of state) {
+				const valueResult = parser.complete(s$1);
+				if (valueResult.success) result.push(valueResult.value);
+				else return {
+					success: false,
+					error: valueResult.error
+				};
+			}
+			if (result.length < min) {
+				const customMessage = options.errors?.tooFew;
+				return {
+					success: false,
+					error: customMessage ? typeof customMessage === "function" ? customMessage(min, result.length) : customMessage : message`Expected at least ${text(min.toLocaleString("en"))} values, but got only ${text(result.length.toLocaleString("en"))}.`
+				};
+			} else if (result.length > max) {
+				const customMessage = options.errors?.tooMany;
+				return {
+					success: false,
+					error: customMessage ? typeof customMessage === "function" ? customMessage(max, result.length) : customMessage : message`Expected at most ${text(max.toLocaleString("en"))} values, but got ${text(result.length.toLocaleString("en"))}.`
+				};
+			}
+			return {
+				success: true,
+				value: result
+			};
+		},
+		getDocFragments(state, defaultValue) {
+			const innerState = state.kind === "unavailable" ? { kind: "unavailable" } : state.state.length > 0 ? {
+				kind: "available",
+				state: state.state.at(-1)
+			} : { kind: "unavailable" };
+			return parser.getDocFragments(innerState, defaultValue != null && defaultValue.length > 0 ? defaultValue[0] : void 0);
+		}
+	};
+}
+function isValueParser(object$1) {
+	return typeof object$1 === "object" && object$1 != null && "metavar" in object$1 && typeof object$1.metavar === "string" && "parse" in object$1 && typeof object$1.parse === "function" && "format" in object$1 && typeof object$1.format === "function";
+}
+function string(options = {}) {
+	return {
+		metavar: options.metavar ?? "STRING",
+		parse(input) {
+			if (options.pattern != null && !options.pattern.test(input)) return {
+				success: false,
+				error: options.errors?.patternMismatch ? typeof options.errors.patternMismatch === "function" ? options.errors.patternMismatch(input, options.pattern) : options.errors.patternMismatch : message`Expected a string matching pattern ${text(options.pattern.source)}, but got ${input}.`
+			};
+			return {
+				success: true,
+				value: input
+			};
+		},
+		format(value) {
+			return value;
+		}
+	};
+}
+function constant(value) {
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: 0,
+		usage: [],
+		initialState: value,
+		parse(context) {
+			return {
+				success: true,
+				next: context,
+				consumed: []
+			};
+		},
+		complete(state) {
+			return {
+				success: true,
+				value: state
+			};
+		},
+		getDocFragments(_state, _defaultValue) {
+			return { fragments: [] };
+		}
+	};
+}
+function option(...args) {
+	const lastArg = args.at(-1);
+	const secondLastArg = args.at(-2);
+	let valueParser;
+	let optionNames$1;
+	let options = {};
+	if (isValueParser(lastArg)) {
+		valueParser = lastArg;
+		optionNames$1 = args.slice(0, -1);
+	} else if (typeof lastArg === "object" && lastArg != null) {
+		options = lastArg;
+		if (isValueParser(secondLastArg)) {
+			valueParser = secondLastArg;
+			optionNames$1 = args.slice(0, -2);
+		} else {
+			valueParser = void 0;
+			optionNames$1 = args.slice(0, -1);
+		}
+	} else {
+		optionNames$1 = args;
+		valueParser = void 0;
+	}
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: 10,
+		usage: [valueParser == null ? {
+			type: "optional",
+			terms: [{
+				type: "option",
+				names: optionNames$1
+			}]
+		} : {
+			type: "option",
+			names: optionNames$1,
+			metavar: valueParser.metavar
+		}],
+		initialState: valueParser == null ? {
+			success: true,
+			value: false
+		} : {
+			success: false,
+			error: options.errors?.missing ? typeof options.errors.missing === "function" ? options.errors.missing(optionNames$1) : options.errors.missing : message`Missing option ${optionNames(optionNames$1)}.`
+		},
+		parse(context) {
+			if (context.optionsTerminated) return {
+				success: false,
+				consumed: 0,
+				error: options.errors?.optionsTerminated ?? message`No more options can be parsed.`
+			};
+			else if (context.buffer.length < 1) return {
+				success: false,
+				consumed: 0,
+				error: options.errors?.endOfInput ?? message`Expected an option, but got end of input.`
+			};
+			if (context.buffer[0] === "--") return {
+				success: true,
+				next: {
+					...context,
+					buffer: context.buffer.slice(1),
+					state: context.state,
+					optionsTerminated: true
+				},
+				consumed: context.buffer.slice(0, 1)
+			};
+			if (optionNames$1.includes(context.buffer[0])) {
+				if (context.state.success && (valueParser != null || context.state.value)) return {
+					success: false,
+					consumed: 1,
+					error: options.errors?.duplicate ? typeof options.errors.duplicate === "function" ? options.errors.duplicate(context.buffer[0]) : options.errors.duplicate : message`${context.buffer[0]} cannot be used multiple times.`
+				};
+				if (valueParser == null) return {
+					success: true,
+					next: {
+						...context,
+						state: {
+							success: true,
+							value: true
+						},
+						buffer: context.buffer.slice(1)
+					},
+					consumed: context.buffer.slice(0, 1)
+				};
+				if (context.buffer.length < 2) return {
+					success: false,
+					consumed: 1,
+					error: message`Option ${optionName(context.buffer[0])} requires a value, but got no value.`
+				};
+				const result = valueParser.parse(context.buffer[1]);
+				return {
+					success: true,
+					next: {
+						...context,
+						state: result,
+						buffer: context.buffer.slice(2)
+					},
+					consumed: context.buffer.slice(0, 2)
+				};
+			}
+			const prefixes = optionNames$1.filter((name) => name.startsWith("--") || name.startsWith("/")).map((name) => name.startsWith("/") ? `${name}:` : `${name}=`);
+			for (const prefix of prefixes) {
+				if (!context.buffer[0].startsWith(prefix)) continue;
+				if (context.state.success && (valueParser != null || context.state.value)) return {
+					success: false,
+					consumed: 1,
+					error: options.errors?.duplicate ? typeof options.errors.duplicate === "function" ? options.errors.duplicate(prefix) : options.errors.duplicate : message`${optionName(prefix)} cannot be used multiple times.`
+				};
+				const value = context.buffer[0].slice(prefix.length);
+				if (valueParser == null) return {
+					success: false,
+					consumed: 1,
+					error: options.errors?.unexpectedValue ? typeof options.errors.unexpectedValue === "function" ? options.errors.unexpectedValue(value) : options.errors.unexpectedValue : message`Option ${optionName(prefix)} is a Boolean flag, but got a value: ${value}.`
+				};
+				const result = valueParser.parse(value);
+				return {
+					success: true,
+					next: {
+						...context,
+						state: result,
+						buffer: context.buffer.slice(1)
+					},
+					consumed: context.buffer.slice(0, 1)
+				};
+			}
+			if (valueParser == null) {
+				const shortOptions = optionNames$1.filter((name) => name.match(/^-[^-]$/));
+				for (const shortOption of shortOptions) {
+					if (!context.buffer[0].startsWith(shortOption)) continue;
+					if (context.state.success && (valueParser != null || context.state.value)) return {
+						success: false,
+						consumed: 1,
+						error: options.errors?.duplicate ? typeof options.errors.duplicate === "function" ? options.errors.duplicate(shortOption) : options.errors.duplicate : message`${optionName(shortOption)} cannot be used multiple times.`
+					};
+					return {
+						success: true,
+						next: {
+							...context,
+							state: {
+								success: true,
+								value: true
+							},
+							buffer: [`-${context.buffer[0].slice(2)}`, ...context.buffer.slice(1)]
+						},
+						consumed: [context.buffer[0].slice(0, 2)]
+					};
+				}
+			}
+			return {
+				success: false,
+				consumed: 0,
+				error: message`No matched option for ${optionName(context.buffer[0])}.`
+			};
+		},
+		complete(state) {
+			if (state == null) return valueParser == null ? {
+				success: true,
+				value: false
+			} : {
+				success: false,
+				error: options.errors?.missing ? typeof options.errors.missing === "function" ? options.errors.missing(optionNames$1) : options.errors.missing : message`Missing option ${optionNames(optionNames$1)}.`
+			};
+			if (state.success) return state;
+			return {
+				success: false,
+				error: options.errors?.invalidValue ? typeof options.errors.invalidValue === "function" ? options.errors.invalidValue(state.error) : options.errors.invalidValue : message`${optionNames(optionNames$1)}: ${state.error}`
+			};
+		},
+		getDocFragments(_state, defaultValue) {
+			return {
+				fragments: [{
+					type: "entry",
+					term: {
+						type: "option",
+						names: optionNames$1,
+						metavar: valueParser?.metavar
+					},
+					description: options.description,
+					default: defaultValue != null && valueParser != null ? message`${valueParser.format(defaultValue)}` : void 0
+				}],
+				description: options.description
+			};
+		},
+		[Symbol.for("Deno.customInspect")]() {
+			return `option(${optionNames$1.map((o$1) => JSON.stringify(o$1)).join(", ")})`;
+		}
+	};
+}
+function flag(...args) {
+	const lastArg = args.at(-1);
+	let optionNames$1;
+	let options = {};
+	if (typeof lastArg === "object" && lastArg != null && !Array.isArray(lastArg)) {
+		options = lastArg;
+		optionNames$1 = args.slice(0, -1);
+	} else optionNames$1 = args;
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: 10,
+		usage: [{
+			type: "option",
+			names: optionNames$1
+		}],
+		initialState: void 0,
+		parse(context) {
+			if (context.optionsTerminated) return {
+				success: false,
+				consumed: 0,
+				error: options.errors?.optionsTerminated ?? message`No more options can be parsed.`
+			};
+			else if (context.buffer.length < 1) return {
+				success: false,
+				consumed: 0,
+				error: options.errors?.endOfInput ?? message`Expected an option, but got end of input.`
+			};
+			if (context.buffer[0] === "--") return {
+				success: true,
+				next: {
+					...context,
+					buffer: context.buffer.slice(1),
+					state: context.state,
+					optionsTerminated: true
+				},
+				consumed: context.buffer.slice(0, 1)
+			};
+			if (optionNames$1.includes(context.buffer[0])) {
+				if (context.state?.success) return {
+					success: false,
+					consumed: 1,
+					error: options.errors?.duplicate ? typeof options.errors.duplicate === "function" ? options.errors.duplicate(context.buffer[0]) : options.errors.duplicate : message`${optionName(context.buffer[0])} cannot be used multiple times.`
+				};
+				return {
+					success: true,
+					next: {
+						...context,
+						state: {
+							success: true,
+							value: true
+						},
+						buffer: context.buffer.slice(1)
+					},
+					consumed: context.buffer.slice(0, 1)
+				};
+			}
+			const prefixes = optionNames$1.filter((name) => name.startsWith("--") || name.startsWith("/")).map((name) => name.startsWith("/") ? `${name}:` : `${name}=`);
+			for (const prefix of prefixes) if (context.buffer[0].startsWith(prefix)) {
+				const value = context.buffer[0].slice(prefix.length);
+				return {
+					success: false,
+					consumed: 1,
+					error: message`Flag ${optionName(prefix.slice(0, -1))} does not accept a value, but got: ${value}.`
+				};
+			}
+			const shortOptions = optionNames$1.filter((name) => name.match(/^-[^-]$/));
+			for (const shortOption of shortOptions) {
+				if (!context.buffer[0].startsWith(shortOption)) continue;
+				if (context.state?.success) return {
+					success: false,
+					consumed: 1,
+					error: options.errors?.duplicate ? typeof options.errors.duplicate === "function" ? options.errors.duplicate(shortOption) : options.errors.duplicate : message`${optionName(shortOption)} cannot be used multiple times.`
+				};
+				return {
+					success: true,
+					next: {
+						...context,
+						state: {
+							success: true,
+							value: true
+						},
+						buffer: [`-${context.buffer[0].slice(2)}`, ...context.buffer.slice(1)]
+					},
+					consumed: [context.buffer[0].slice(0, 2)]
+				};
+			}
+			return {
+				success: false,
+				consumed: 0,
+				error: message`No matched option for ${optionName(context.buffer[0])}.`
+			};
+		},
+		complete(state) {
+			if (state == null) return {
+				success: false,
+				error: options.errors?.missing ? typeof options.errors.missing === "function" ? options.errors.missing(optionNames$1) : options.errors.missing : message`Required flag ${optionNames(optionNames$1)} is missing.`
+			};
+			if (state.success) return {
+				success: true,
+				value: true
+			};
+			return {
+				success: false,
+				error: message`${optionNames(optionNames$1)}: ${state.error}`
+			};
+		},
+		getDocFragments(_state, _defaultValue) {
+			return {
+				fragments: [{
+					type: "entry",
+					term: {
+						type: "option",
+						names: optionNames$1
+					},
+					description: options.description
+				}],
+				description: options.description
+			};
+		},
+		[Symbol.for("Deno.customInspect")]() {
+			return `flag(${optionNames$1.map((o$1) => JSON.stringify(o$1)).join(", ")})`;
+		}
+	};
+}
+function argument(valueParser, options = {}) {
+	const optionPattern = /^--?[a-z0-9-]+$/i;
+	const term = {
+		type: "argument",
+		metavar: valueParser.metavar
+	};
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: 5,
+		usage: [term],
+		initialState: void 0,
+		parse(context) {
+			if (context.buffer.length < 1) return {
+				success: false,
+				consumed: 0,
+				error: options.errors?.endOfInput ?? message`Expected an argument, but got end of input.`
+			};
+			let i = 0;
+			let optionsTerminated = context.optionsTerminated;
+			if (!optionsTerminated) {
+				if (context.buffer[i] === "--") {
+					optionsTerminated = true;
+					i++;
+				} else if (context.buffer[i].match(optionPattern)) return {
+					success: false,
+					consumed: i,
+					error: message`Expected an argument, but got an option: ${optionName(context.buffer[i])}.`
+				};
+			}
+			if (context.buffer.length < i + 1) return {
+				success: false,
+				consumed: i,
+				error: message`Expected an argument, but got end of input.`
+			};
+			if (context.state != null) return {
+				success: false,
+				consumed: i,
+				error: options.errors?.multiple ? typeof options.errors.multiple === "function" ? options.errors.multiple(valueParser.metavar) : options.errors.multiple : message`The argument ${metavar(valueParser.metavar)} cannot be used multiple times.`
+			};
+			const result = valueParser.parse(context.buffer[i]);
+			return {
+				success: true,
+				next: {
+					...context,
+					buffer: context.buffer.slice(i + 1),
+					state: result,
+					optionsTerminated
+				},
+				consumed: context.buffer.slice(0, i + 1)
+			};
+		},
+		complete(state) {
+			if (state == null) return {
+				success: false,
+				error: options.errors?.endOfInput ?? message`Expected a ${metavar(valueParser.metavar)}, but too few arguments.`
+			};
+			else if (state.success) return state;
+			return {
+				success: false,
+				error: options.errors?.invalidValue ? typeof options.errors.invalidValue === "function" ? options.errors.invalidValue(state.error) : options.errors.invalidValue : message`${metavar(valueParser.metavar)}: ${state.error}`
+			};
+		},
+		getDocFragments(_state, defaultValue) {
+			return {
+				fragments: [{
+					type: "entry",
+					term,
+					description: options.description,
+					default: defaultValue == null ? void 0 : message`${valueParser.format(defaultValue)}`
+				}],
+				description: options.description
+			};
+		},
+		[Symbol.for("Deno.customInspect")]() {
+			return `argument()`;
+		}
+	};
+}
+function command(name, parser, options = {}) {
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: 15,
+		usage: [{
+			type: "command",
+			name
+		}, ...parser.usage],
+		initialState: void 0,
+		parse(context) {
+			if (context.state === void 0) {
+				if (context.buffer.length < 1 || context.buffer[0] !== name) {
+					const actual = context.buffer.length > 0 ? context.buffer[0] : null;
+					const errorMessage = options.errors?.notMatched ?? message`Expected command ${optionName(name)}, but got ${actual ?? "end of input"}.`;
+					return {
+						success: false,
+						consumed: 0,
+						error: typeof errorMessage === "function" ? errorMessage(name, actual) : errorMessage
+					};
+				}
+				return {
+					success: true,
+					next: {
+						...context,
+						buffer: context.buffer.slice(1),
+						state: ["matched", name]
+					},
+					consumed: context.buffer.slice(0, 1)
+				};
+			} else if (context.state[0] === "matched") {
+				const result = parser.parse({
+					...context,
+					state: parser.initialState
+				});
+				if (result.success) return {
+					success: true,
+					next: {
+						...result.next,
+						state: ["parsing", result.next.state]
+					},
+					consumed: result.consumed
+				};
+				return result;
+			} else if (context.state[0] === "parsing") {
+				const result = parser.parse({
+					...context,
+					state: context.state[1]
+				});
+				if (result.success) return {
+					success: true,
+					next: {
+						...result.next,
+						state: ["parsing", result.next.state]
+					},
+					consumed: result.consumed
+				};
+				return result;
+			}
+			return {
+				success: false,
+				consumed: 0,
+				error: options.errors?.invalidState ?? message`Invalid command state.`
+			};
+		},
+		complete(state) {
+			if (typeof state === "undefined") return {
+				success: false,
+				error: options.errors?.notFound ?? message`Command ${optionName(name)} was not matched.`
+			};
+			else if (state[0] === "matched") return parser.complete(parser.initialState);
+			else if (state[0] === "parsing") return parser.complete(state[1]);
+			return {
+				success: false,
+				error: options.errors?.invalidState ?? message`Invalid command state during completion.`
+			};
+		},
+		getDocFragments(state, defaultValue) {
+			if (state.kind === "unavailable" || typeof state.state === "undefined") return {
+				description: options.description,
+				fragments: [{
+					type: "entry",
+					term: {
+						type: "command",
+						name
+					},
+					description: options.description
+				}]
+			};
+			const innerState = state.state[0] === "parsing" ? {
+				kind: "available",
+				state: state.state[1]
+			} : { kind: "unavailable" };
+			const innerFragments = parser.getDocFragments(innerState, defaultValue);
+			return {
+				...innerFragments,
+				description: innerFragments.description ?? options.description
+			};
+		},
+		[Symbol.for("Deno.customInspect")]() {
+			return `command(${JSON.stringify(name)})`;
+		}
+	};
+}
+function parse(parser, args) {
+	let context = {
+		buffer: args,
+		optionsTerminated: false,
+		state: parser.initialState
+	};
+	do {
+		const result = parser.parse(context);
+		if (!result.success) return {
+			success: false,
+			error: result.error
+		};
+		const previousBuffer = context.buffer;
+		context = result.next;
+		if (context.buffer.length > 0 && context.buffer.length === previousBuffer.length && context.buffer[0] === previousBuffer[0]) return {
+			success: false,
+			error: message`Unexpected option or argument: ${context.buffer[0]}.`
+		};
+	} while (context.buffer.length > 0);
+	const endResult = parser.complete(context.state);
+	return endResult.success ? {
+		success: true,
+		value: endResult.value
+	} : {
+		success: false,
+		error: endResult.error
+	};
+}
+function getDocPage(parser, args = []) {
+	let context = {
+		buffer: args,
+		optionsTerminated: false,
+		state: parser.initialState
+	};
+	do {
+		const result = parser.parse(context);
+		if (!result.success) break;
+		context = result.next;
+	} while (context.buffer.length > 0);
+	const { description, fragments } = parser.getDocFragments({
+		kind: "available",
+		state: context.state
+	}, void 0);
+	const entries = fragments.filter((f$1) => f$1.type === "entry");
+	const sections = [];
+	for (const fragment of fragments) {
+		if (fragment.type !== "section") continue;
+		if (fragment.title == null) entries.push(...fragment.entries);
+		else sections.push(fragment);
+	}
+	if (entries.length > 0) sections.push({ entries });
+	const usage = [...normalizeUsage(parser.usage)];
+	let i = 0;
+	for (const arg of args) {
+		const term = usage[i];
+		if (usage.length > i && term.type === "exclusive") for (const termGroup of term.terms) {
+			const firstTerm = termGroup[0];
+			if (firstTerm?.type !== "command" || firstTerm.name !== arg) continue;
+			usage.splice(i, 1, ...termGroup);
+			break;
+		}
+		i++;
+	}
+	return description == null ? {
+		usage,
+		sections
+	} : {
+		usage,
+		sections,
+		description
+	};
+}
+function createHelpParser(mode) {
+	const helpCommand = command("help", multiple(argument(string({ metavar: "COMMAND" }))), { description: message`Show help information.` });
+	const helpOption = flag("--help", { description: message`Show help information.` });
+	switch (mode) {
+		case "command": return {
+			helpCommand,
+			helpOption: null
+		};
+		case "option": return {
+			helpCommand: null,
+			helpOption
+		};
+		case "both": return {
+			helpCommand,
+			helpOption
+		};
+	}
+}
+function createVersionParser(mode) {
+	const versionCommand = command("version", object({}), { description: message`Show version information.` });
+	const versionOption = flag("--version", { description: message`Show version information.` });
+	switch (mode) {
+		case "command": return {
+			versionCommand,
+			versionOption: null
+		};
+		case "option": return {
+			versionCommand: null,
+			versionOption
+		};
+		case "both": return {
+			versionCommand,
+			versionOption
+		};
+	}
+}
+function combineWithHelpVersion(originalParser, helpParsers, versionParsers) {
+	const parsers = [];
+	if (helpParsers.helpOption) {
+		const lenientHelpParser = {
+			$valueType: [],
+			$stateType: [],
+			priority: 200,
+			usage: helpParsers.helpOption.usage,
+			initialState: null,
+			parse(context) {
+				const { buffer, optionsTerminated } = context;
+				if (optionsTerminated) return {
+					success: false,
+					error: message`Options terminated.`,
+					consumed: 0
+				};
+				let helpFound = false;
+				let helpIndex = -1;
+				let versionIndex = -1;
+				for (let i = 0; i < buffer.length; i++) {
+					if (buffer[i] === "--") break;
+					if (buffer[i] === "--help") {
+						helpFound = true;
+						helpIndex = i;
+					}
+					if (buffer[i] === "--version") versionIndex = i;
+				}
+				if (helpFound && versionIndex > helpIndex) return {
+					success: false,
+					error: message`Version option wins.`,
+					consumed: 0
+				};
+				if (helpFound) {
+					const commands = [];
+					for (let i = 0; i < helpIndex; i++) {
+						const arg = buffer[i];
+						if (!arg.startsWith("-")) commands.push(arg);
+					}
+					return {
+						success: true,
+						next: {
+							...context,
+							buffer: [],
+							state: {
+								help: true,
+								version: false,
+								commands,
+								helpFlag: true
+							}
+						},
+						consumed: buffer.slice(0)
+					};
+				}
+				return {
+					success: false,
+					error: message`Flag ${optionName("--help")} not found.`,
+					consumed: 0
+				};
+			},
+			complete(state) {
+				return {
+					success: true,
+					value: state
+				};
+			},
+			getDocFragments(state) {
+				return helpParsers.helpOption?.getDocFragments(state) ?? { fragments: [] };
+			}
+		};
+		parsers.push(lenientHelpParser);
+	}
+	if (versionParsers.versionOption) {
+		const lenientVersionParser = {
+			$valueType: [],
+			$stateType: [],
+			priority: 200,
+			usage: versionParsers.versionOption.usage,
+			initialState: null,
+			parse(context) {
+				const { buffer, optionsTerminated } = context;
+				if (optionsTerminated) return {
+					success: false,
+					error: message`Options terminated.`,
+					consumed: 0
+				};
+				let versionFound = false;
+				let versionIndex = -1;
+				let helpIndex = -1;
+				for (let i = 0; i < buffer.length; i++) {
+					if (buffer[i] === "--") break;
+					if (buffer[i] === "--version") {
+						versionFound = true;
+						versionIndex = i;
+					}
+					if (buffer[i] === "--help") helpIndex = i;
+				}
+				if (versionFound && helpIndex > versionIndex) return {
+					success: false,
+					error: message`Help option wins.`,
+					consumed: 0
+				};
+				if (versionFound) return {
+					success: true,
+					next: {
+						...context,
+						buffer: [],
+						state: {
+							help: false,
+							version: true,
+							versionFlag: true
+						}
+					},
+					consumed: buffer.slice(0)
+				};
+				return {
+					success: false,
+					error: message`Flag ${optionName("--version")} not found.`,
+					consumed: 0
+				};
+			},
+			complete(state) {
+				return {
+					success: true,
+					value: state
+				};
+			},
+			getDocFragments(state) {
+				return versionParsers.versionOption?.getDocFragments(state) ?? { fragments: [] };
+			}
+		};
+		parsers.push(lenientVersionParser);
+	}
+	if (versionParsers.versionCommand) parsers.push(object({
+		help: constant(false),
+		version: constant(true),
+		result: versionParsers.versionCommand,
+		helpFlag: helpParsers.helpOption ? optional(helpParsers.helpOption) : constant(false)
+	}));
+	if (helpParsers.helpCommand) parsers.push(object({
+		help: constant(true),
+		version: constant(false),
+		commands: helpParsers.helpCommand
+	}));
+	parsers.push(object({
+		help: constant(false),
+		version: constant(false),
+		result: originalParser
+	}));
+	if (parsers.length === 1) return parsers[0];
+	else if (parsers.length === 2) return longestMatch(parsers[0], parsers[1]);
+	else return longestMatch(...parsers);
+}
+function classifyResult(result, args) {
+	if (!result.success) return {
+		type: "error",
+		error: result.error
+	};
+	const value = result.value;
+	if (typeof value === "object" && value != null && "help" in value && "version" in value) {
+		const parsedValue = value;
+		const hasVersionOption = args.includes("--version");
+		const hasVersionCommand = args.length > 0 && args[0] === "version";
+		const hasHelpOption = args.includes("--help");
+		const hasHelpCommand = args.length > 0 && args[0] === "help";
+		if (hasVersionOption && hasHelpOption && !hasVersionCommand && !hasHelpCommand) {}
+		if (hasVersionCommand && hasHelpOption && parsedValue.helpFlag) return {
+			type: "help",
+			commands: ["version"]
+		};
+		if (parsedValue.help && (hasHelpOption || hasHelpCommand)) {
+			let commandContext = [];
+			if (Array.isArray(parsedValue.commands)) commandContext = parsedValue.commands;
+			else if (typeof parsedValue.commands === "object" && parsedValue.commands != null && "length" in parsedValue.commands) commandContext = parsedValue.commands;
+			return {
+				type: "help",
+				commands: commandContext
+			};
+		}
+		if ((hasVersionOption || hasVersionCommand) && (parsedValue.version || parsedValue.versionFlag)) return { type: "version" };
+		return {
+			type: "success",
+			value: parsedValue.result ?? value
+		};
+	}
+	return {
+		type: "success",
+		value
+	};
+}
+function run$1(parser, programName, args, options = {}) {
+	const helpMode = options.help?.mode ?? "option";
+	const onHelp = options.help?.onShow ?? (() => ({}));
+	const versionMode = options.version?.mode ?? "option";
+	const versionValue = options.version?.value ?? "";
+	const onVersion = options.version?.onShow ?? (() => ({}));
+	let { colors, maxWidth, showDefault, aboveError = "usage", onError = () => {
+		throw new RunError("Failed to parse command line arguments.");
+	}, stderr = console.error, stdout = console.log, brief, description, footer } = options;
+	const help = options.help ? helpMode : "none";
+	const version = options.version ? versionMode : "none";
+	const helpParsers = help === "none" ? {
+		helpCommand: null,
+		helpOption: null
+	} : createHelpParser(help);
+	const versionParsers = version === "none" ? {
+		versionCommand: null,
+		versionOption: null
+	} : createVersionParser(version);
+	const augmentedParser = help === "none" && version === "none" ? parser : combineWithHelpVersion(parser, helpParsers, versionParsers);
+	const result = parse(augmentedParser, args);
+	const classified = classifyResult(result, args);
+	switch (classified.type) {
+		case "success": return classified.value;
+		case "version":
+			stdout(versionValue);
+			try {
+				return onVersion(0);
+			} catch {
+				return onVersion();
+			}
+		case "help": {
+			let helpGeneratorParser;
+			const helpAsCommand = help === "command" || help === "both";
+			const versionAsCommand = version === "command" || version === "both";
+			if (helpAsCommand && versionAsCommand) {
+				const tempHelpParsers = createHelpParser(help);
+				const tempVersionParsers = createVersionParser(version);
+				if (tempHelpParsers.helpCommand && tempVersionParsers.versionCommand) helpGeneratorParser = longestMatch(parser, tempHelpParsers.helpCommand, tempVersionParsers.versionCommand);
+				else if (tempHelpParsers.helpCommand) helpGeneratorParser = longestMatch(parser, tempHelpParsers.helpCommand);
+				else if (tempVersionParsers.versionCommand) helpGeneratorParser = longestMatch(parser, tempVersionParsers.versionCommand);
+				else helpGeneratorParser = parser;
+			} else if (helpAsCommand) {
+				const tempHelpParsers = createHelpParser(help);
+				if (tempHelpParsers.helpCommand) helpGeneratorParser = longestMatch(parser, tempHelpParsers.helpCommand);
+				else helpGeneratorParser = parser;
+			} else if (versionAsCommand) {
+				const tempVersionParsers = createVersionParser(version);
+				if (tempVersionParsers.versionCommand) helpGeneratorParser = longestMatch(parser, tempVersionParsers.versionCommand);
+				else helpGeneratorParser = parser;
+			} else helpGeneratorParser = parser;
+			const doc = getDocPage(helpGeneratorParser, classified.commands);
+			if (doc != null) {
+				const augmentedDoc = {
+					...doc,
+					brief: brief ?? doc.brief,
+					description: description ?? doc.description,
+					footer: footer ?? doc.footer
+				};
+				stdout(formatDocPage(programName, augmentedDoc, {
+					colors,
+					maxWidth,
+					showDefault
+				}));
+			}
+			try {
+				return onHelp(0);
+			} catch {
+				return onHelp();
+			}
+		}
+		case "error": break;
+	}
+	if (aboveError === "help") {
+		const doc = getDocPage(args.length < 1 ? augmentedParser : parser, args);
+		if (doc == null) aboveError = "usage";
+		else {
+			const augmentedDoc = {
+				...doc,
+				brief: brief ?? doc.brief,
+				description: description ?? doc.description,
+				footer: footer ?? doc.footer
+			};
+			stderr(formatDocPage(programName, augmentedDoc, {
+				colors,
+				maxWidth,
+				showDefault
+			}));
+		}
+	}
+	if (aboveError === "usage") stderr(`Usage: ${indentLines(formatUsage(programName, augmentedParser.usage, {
+		colors,
+		maxWidth: maxWidth == null ? void 0 : maxWidth - 7,
+		expandCommands: true
+	}), 7)}`);
+	const errorMessage = formatMessage(classified.error, {
+		colors,
+		quotes: !colors
+	});
+	stderr(`Error: ${errorMessage}`);
+	return onError(1);
+}
+var RunError = class extends Error {
+	constructor(message$1) {
+		super(message$1);
+		this.name = "RunError";
+	}
+};
+function indentLines(text$1, indent) {
+	return text$1.split("\n").join("\n" + " ".repeat(indent));
+}
+function run(parser, options = {}) {
+	const { programName = path.basename(process$1.argv[1] || "cli"), args = process$1.argv.slice(2), colors = process$1.stdout.isTTY, maxWidth = process$1.stdout.columns, showDefault, help, version, aboveError = "usage", errorExitCode = 1, brief, description, footer } = options;
+	const helpConfig = help ? {
+		mode: help,
+		onShow: () => process$1.exit(0)
+	} : void 0;
+	const versionConfig = version ? {
+		mode: typeof version === "string" ? "option" : version.mode ?? "option",
+		value: typeof version === "string" ? version : version.value,
+		onShow: () => process$1.exit(0)
+	} : void 0;
+	return run$1(parser, programName, args, {
+		colors,
+		maxWidth,
+		showDefault,
+		help: helpConfig,
+		version: versionConfig,
+		aboveError,
+		brief,
+		description,
+		footer,
+		onError() {
+			return process$1.exit(errorExitCode);
+		}
+	});
+}
+const A = (r) => r !== null && typeof r == "object", a = (r, t) => Object.assign(/* @__PURE__ */ new Error(`[${r}]: ${t}`), { code: r }), _ = "ERR_INVALID_PACKAGE_CONFIG", E$1 = "ERR_INVALID_PACKAGE_TARGET", I = "ERR_PACKAGE_PATH_NOT_EXPORTED", R$1 = /^\d+$/, O$1 = /^(\.{1,2}|node_modules)$/i, w = /\/|\\/;
+var h$1 = ((r) => (r.Export = "exports", r.Import = "imports", r))(h$1 || {});
+const f = (r, t, e, o$1, c) => {
+	if (t == null) return [];
+	if (typeof t == "string") {
+		const [n, ...i] = t.split(w);
+		if (n === ".." || i.some((l) => O$1.test(l))) throw a(E$1, `Invalid "${r}" target "${t}" defined in the package config`);
+		return [c ? t.replace(/\*/g, c) : t];
+	}
+	if (Array.isArray(t)) return t.flatMap((n) => f(r, n, e, o$1, c));
+	if (A(t)) {
+		for (const n of Object.keys(t)) {
+			if (R$1.test(n)) throw a(_, "Cannot contain numeric property keys");
+			if (n === "default" || o$1.includes(n)) return f(r, t[n], e, o$1, c);
+		}
+		return [];
+	}
+	throw a(E$1, `Invalid "${r}" target "${t}"`);
+}, s = "*", m = (r, t) => {
+	const e = r.indexOf(s), o$1 = t.indexOf(s);
+	return e === o$1 ? t.length > r.length : o$1 > e;
+};
+function d(r, t) {
+	if (!t.includes(s) && r.hasOwnProperty(t)) return [t];
+	let e, o$1;
+	for (const c of Object.keys(r)) if (c.includes(s)) {
+		const [n, i, l] = c.split(s);
+		if (l === void 0 && t.startsWith(n) && t.endsWith(i)) {
+			const g = t.slice(n.length, -i.length || void 0);
+			g && (!e || m(e, c)) && (e = c, o$1 = g);
+		}
+	}
+	return [e, o$1];
+}
+const p$1 = (r) => Object.keys(r).reduce((t, e) => {
+	const o$1 = e === "" || e[0] !== ".";
+	if (t === void 0 || t === o$1) return o$1;
+	throw a(_, "\"exports\" cannot contain some keys starting with \".\" and some not");
+}, void 0), u = /^\w+:/, v = (r, t, e) => {
+	if (!r) throw new Error("\"exports\" is required");
+	t = t === "" ? "." : `./${t}`, (typeof r == "string" || Array.isArray(r) || A(r) && p$1(r)) && (r = { ".": r });
+	const [o$1, c] = d(r, t), n = f(h$1.Export, r[o$1], t, e, c);
+	if (n.length === 0) throw a(I, t === "." ? "No \"exports\" main defined" : `Package subpath '${t}' is not defined by "exports"`);
+	for (const i of n) if (!i.startsWith("./") && !u.test(i)) throw a(E$1, `Invalid "exports" target "${i}" defined in the package config`);
+	return n;
+};
+var de = Object.defineProperty;
+var o = (e, t) => de(e, "name", {
+	value: t,
+	configurable: !0
+});
+function E(e) {
+	return e.startsWith("\\\\?\\") ? e : e.replace(/\\/g, "/");
+}
+o(E, "slash");
+const O = o((e) => {
+	const t = fss[e];
+	return (s$1, ...n) => {
+		const l = `${e}:${n.join(":")}`;
+		let i = s$1 == null ? void 0 : s$1.get(l);
+		return i === void 0 && (i = Reflect.apply(t, fss, n), s$1?.set(l, i)), i;
+	};
+}, "cacheFs"), B = O("existsSync"), _e = O("readFileSync"), P = O("statSync"), se = o((e, t, s$1) => {
+	for (;;) {
+		const n = path.posix.join(e, t);
+		if (B(s$1, n)) return n;
+		const l = path.dirname(e);
+		if (l === e) return;
+		e = l;
+	}
+}, "findUp"), z = /^\.{1,2}(\/.*)?$/, G = o((e) => {
+	const t = E(e);
+	return z.test(t) ? t : `./${t}`;
+}, "normalizeRelativePath");
+function je(e, t = !1) {
+	const s$1 = e.length;
+	let n = 0, l = "", i = 0, u$1 = 16, f$1 = 0, r = 0, g = 0, T$1 = 0, b = 0;
+	function _$1(c, k) {
+		let p$2 = 0, F = 0;
+		for (; p$2 < c;) {
+			let j = e.charCodeAt(n);
+			if (j >= 48 && j <= 57) F = F * 16 + j - 48;
+			else if (j >= 65 && j <= 70) F = F * 16 + j - 65 + 10;
+			else if (j >= 97 && j <= 102) F = F * 16 + j - 97 + 10;
+			else break;
+			n++, p$2++;
+		}
+		return p$2 < c && (F = -1), F;
+	}
+	o(_$1, "scanHexDigits");
+	function d$1(c) {
+		n = c, l = "", i = 0, u$1 = 16, b = 0;
+	}
+	o(d$1, "setPosition");
+	function A$1() {
+		let c = n;
+		if (e.charCodeAt(n) === 48) n++;
+		else for (n++; n < e.length && U(e.charCodeAt(n));) n++;
+		if (n < e.length && e.charCodeAt(n) === 46) if (n++, n < e.length && U(e.charCodeAt(n))) for (n++; n < e.length && U(e.charCodeAt(n));) n++;
+		else return b = 3, e.substring(c, n);
+		let k = n;
+		if (n < e.length && (e.charCodeAt(n) === 69 || e.charCodeAt(n) === 101)) if (n++, (n < e.length && e.charCodeAt(n) === 43 || e.charCodeAt(n) === 45) && n++, n < e.length && U(e.charCodeAt(n))) {
+			for (n++; n < e.length && U(e.charCodeAt(n));) n++;
+			k = n;
+		} else b = 3;
+		return e.substring(c, k);
+	}
+	o(A$1, "scanNumber");
+	function w$1() {
+		let c = "", k = n;
+		for (;;) {
+			if (n >= s$1) {
+				c += e.substring(k, n), b = 2;
+				break;
+			}
+			const p$2 = e.charCodeAt(n);
+			if (p$2 === 34) {
+				c += e.substring(k, n), n++;
+				break;
+			}
+			if (p$2 === 92) {
+				if (c += e.substring(k, n), n++, n >= s$1) {
+					b = 2;
+					break;
+				}
+				switch (e.charCodeAt(n++)) {
+					case 34:
+						c += "\"";
+						break;
+					case 92:
+						c += "\\";
+						break;
+					case 47:
+						c += "/";
+						break;
+					case 98:
+						c += "\b";
+						break;
+					case 102:
+						c += "\f";
+						break;
+					case 110:
+						c += `
+`;
+						break;
+					case 114:
+						c += "\r";
+						break;
+					case 116:
+						c += "	";
+						break;
+					case 117:
+						const j = _$1(4);
+						j >= 0 ? c += String.fromCharCode(j) : b = 4;
+						break;
+					default: b = 5;
+				}
+				k = n;
+				continue;
+			}
+			if (p$2 >= 0 && p$2 <= 31) if (x(p$2)) {
+				c += e.substring(k, n), b = 2;
+				break;
+			} else b = 6;
+			n++;
+		}
+		return c;
+	}
+	o(w$1, "scanString");
+	function y() {
+		if (l = "", b = 0, i = n, r = f$1, T$1 = g, n >= s$1) return i = s$1, u$1 = 17;
+		let c = e.charCodeAt(n);
+		if (Q(c)) {
+			do
+				n++, l += String.fromCharCode(c), c = e.charCodeAt(n);
+			while (Q(c));
+			return u$1 = 15;
+		}
+		if (x(c)) return n++, l += String.fromCharCode(c), c === 13 && e.charCodeAt(n) === 10 && (n++, l += `
+`), f$1++, g = n, u$1 = 14;
+		switch (c) {
+			case 123: return n++, u$1 = 1;
+			case 125: return n++, u$1 = 2;
+			case 91: return n++, u$1 = 3;
+			case 93: return n++, u$1 = 4;
+			case 58: return n++, u$1 = 6;
+			case 44: return n++, u$1 = 5;
+			case 34: return n++, l = w$1(), u$1 = 10;
+			case 47:
+				const k = n - 1;
+				if (e.charCodeAt(n + 1) === 47) {
+					for (n += 2; n < s$1 && !x(e.charCodeAt(n));) n++;
+					return l = e.substring(k, n), u$1 = 12;
+				}
+				if (e.charCodeAt(n + 1) === 42) {
+					n += 2;
+					const p$2 = s$1 - 1;
+					let F = !1;
+					for (; n < p$2;) {
+						const j = e.charCodeAt(n);
+						if (j === 42 && e.charCodeAt(n + 1) === 47) {
+							n += 2, F = !0;
+							break;
+						}
+						n++, x(j) && (j === 13 && e.charCodeAt(n) === 10 && n++, f$1++, g = n);
+					}
+					return F || (n++, b = 1), l = e.substring(k, n), u$1 = 13;
+				}
+				return l += String.fromCharCode(c), n++, u$1 = 16;
+			case 45: if (l += String.fromCharCode(c), n++, n === s$1 || !U(e.charCodeAt(n))) return u$1 = 16;
+			case 48:
+			case 49:
+			case 50:
+			case 51:
+			case 52:
+			case 53:
+			case 54:
+			case 55:
+			case 56:
+			case 57: return l += A$1(), u$1 = 11;
+			default:
+				for (; n < s$1 && I$1(c);) n++, c = e.charCodeAt(n);
+				if (i !== n) {
+					switch (l = e.substring(i, n), l) {
+						case "true": return u$1 = 8;
+						case "false": return u$1 = 9;
+						case "null": return u$1 = 7;
+					}
+					return u$1 = 16;
+				}
+				return l += String.fromCharCode(c), n++, u$1 = 16;
+		}
+	}
+	o(y, "scanNext");
+	function I$1(c) {
+		if (Q(c) || x(c)) return !1;
+		switch (c) {
+			case 125:
+			case 93:
+			case 123:
+			case 91:
+			case 34:
+			case 58:
+			case 44:
+			case 47: return !1;
+		}
+		return !0;
+	}
+	o(I$1, "isUnknownContentCharacter");
+	function L() {
+		let c;
+		do
+			c = y();
+		while (c >= 12 && c <= 15);
+		return c;
+	}
+	return o(L, "scanNextNonTrivia"), {
+		setPosition: d$1,
+		getPosition: o(() => n, "getPosition"),
+		scan: t ? L : y,
+		getToken: o(() => u$1, "getToken"),
+		getTokenValue: o(() => l, "getTokenValue"),
+		getTokenOffset: o(() => i, "getTokenOffset"),
+		getTokenLength: o(() => n - i, "getTokenLength"),
+		getTokenStartLine: o(() => r, "getTokenStartLine"),
+		getTokenStartCharacter: o(() => i - T$1, "getTokenStartCharacter"),
+		getTokenError: o(() => b, "getTokenError")
+	};
+}
+o(je, "createScanner");
+function Q(e) {
+	return e === 32 || e === 9;
+}
+o(Q, "isWhiteSpace");
+function x(e) {
+	return e === 10 || e === 13;
+}
+o(x, "isLineBreak");
+function U(e) {
+	return e >= 48 && e <= 57;
+}
+o(U, "isDigit");
+var le;
+(function(e) {
+	e[e.lineFeed = 10] = "lineFeed", e[e.carriageReturn = 13] = "carriageReturn", e[e.space = 32] = "space", e[e._0 = 48] = "_0", e[e._1 = 49] = "_1", e[e._2 = 50] = "_2", e[e._3 = 51] = "_3", e[e._4 = 52] = "_4", e[e._5 = 53] = "_5", e[e._6 = 54] = "_6", e[e._7 = 55] = "_7", e[e._8 = 56] = "_8", e[e._9 = 57] = "_9", e[e.a = 97] = "a", e[e.b = 98] = "b", e[e.c = 99] = "c", e[e.d = 100] = "d", e[e.e = 101] = "e", e[e.f = 102] = "f", e[e.g = 103] = "g", e[e.h = 104] = "h", e[e.i = 105] = "i", e[e.j = 106] = "j", e[e.k = 107] = "k", e[e.l = 108] = "l", e[e.m = 109] = "m", e[e.n = 110] = "n", e[e.o = 111] = "o", e[e.p = 112] = "p", e[e.q = 113] = "q", e[e.r = 114] = "r", e[e.s = 115] = "s", e[e.t = 116] = "t", e[e.u = 117] = "u", e[e.v = 118] = "v", e[e.w = 119] = "w", e[e.x = 120] = "x", e[e.y = 121] = "y", e[e.z = 122] = "z", e[e.A = 65] = "A", e[e.B = 66] = "B", e[e.C = 67] = "C", e[e.D = 68] = "D", e[e.E = 69] = "E", e[e.F = 70] = "F", e[e.G = 71] = "G", e[e.H = 72] = "H", e[e.I = 73] = "I", e[e.J = 74] = "J", e[e.K = 75] = "K", e[e.L = 76] = "L", e[e.M = 77] = "M", e[e.N = 78] = "N", e[e.O = 79] = "O", e[e.P = 80] = "P", e[e.Q = 81] = "Q", e[e.R = 82] = "R", e[e.S = 83] = "S", e[e.T = 84] = "T", e[e.U = 85] = "U", e[e.V = 86] = "V", e[e.W = 87] = "W", e[e.X = 88] = "X", e[e.Y = 89] = "Y", e[e.Z = 90] = "Z", e[e.asterisk = 42] = "asterisk", e[e.backslash = 92] = "backslash", e[e.closeBrace = 125] = "closeBrace", e[e.closeBracket = 93] = "closeBracket", e[e.colon = 58] = "colon", e[e.comma = 44] = "comma", e[e.dot = 46] = "dot", e[e.doubleQuote = 34] = "doubleQuote", e[e.minus = 45] = "minus", e[e.openBrace = 123] = "openBrace", e[e.openBracket = 91] = "openBracket", e[e.plus = 43] = "plus", e[e.slash = 47] = "slash", e[e.formFeed = 12] = "formFeed", e[e.tab = 9] = "tab";
+})(le || (le = {})), new Array(20).fill(0).map((e, t) => " ".repeat(t));
+const h = 200;
+new Array(h).fill(0).map((e, t) => `
+` + " ".repeat(t)), new Array(h).fill(0).map((e, t) => "\r" + " ".repeat(t)), new Array(h).fill(0).map((e, t) => `\r
+` + " ".repeat(t)), new Array(h).fill(0).map((e, t) => `
+` + "	".repeat(t)), new Array(h).fill(0).map((e, t) => "\r" + "	".repeat(t)), new Array(h).fill(0).map((e, t) => `\r
+` + "	".repeat(t));
+var R;
+(function(e) {
+	e.DEFAULT = { allowTrailingComma: !1 };
+})(R || (R = {}));
+function ye(e, t = [], s$1 = R.DEFAULT) {
+	let n = null, l = [];
+	const i = [];
+	function u$1(r) {
+		Array.isArray(l) ? l.push(r) : n !== null && (l[n] = r);
+	}
+	return o(u$1, "onValue"), Fe(e, {
+		onObjectBegin: o(() => {
+			const r = {};
+			u$1(r), i.push(l), l = r, n = null;
+		}, "onObjectBegin"),
+		onObjectProperty: o((r) => {
+			n = r;
+		}, "onObjectProperty"),
+		onObjectEnd: o(() => {
+			l = i.pop();
+		}, "onObjectEnd"),
+		onArrayBegin: o(() => {
+			const r = [];
+			u$1(r), i.push(l), l = r, n = null;
+		}, "onArrayBegin"),
+		onArrayEnd: o(() => {
+			l = i.pop();
+		}, "onArrayEnd"),
+		onLiteralValue: u$1,
+		onError: o((r, g, T$1) => {
+			t.push({
+				error: r,
+				offset: g,
+				length: T$1
+			});
+		}, "onError")
+	}, s$1), l[0];
+}
+o(ye, "parse$1");
+function Fe(e, t, s$1 = R.DEFAULT) {
+	const n = je(e, !1), l = [];
+	function i(v$1) {
+		return v$1 ? () => v$1(n.getTokenOffset(), n.getTokenLength(), n.getTokenStartLine(), n.getTokenStartCharacter()) : () => !0;
+	}
+	o(i, "toNoArgVisit");
+	function u$1(v$1) {
+		return v$1 ? () => v$1(n.getTokenOffset(), n.getTokenLength(), n.getTokenStartLine(), n.getTokenStartCharacter(), () => l.slice()) : () => !0;
+	}
+	o(u$1, "toNoArgVisitWithPath");
+	function f$1(v$1) {
+		return v$1 ? (D) => v$1(D, n.getTokenOffset(), n.getTokenLength(), n.getTokenStartLine(), n.getTokenStartCharacter()) : () => !0;
+	}
+	o(f$1, "toOneArgVisit");
+	function r(v$1) {
+		return v$1 ? (D) => v$1(D, n.getTokenOffset(), n.getTokenLength(), n.getTokenStartLine(), n.getTokenStartCharacter(), () => l.slice()) : () => !0;
+	}
+	o(r, "toOneArgVisitWithPath");
+	const g = u$1(t.onObjectBegin), T$1 = r(t.onObjectProperty), b = i(t.onObjectEnd), _$1 = u$1(t.onArrayBegin), d$1 = i(t.onArrayEnd), A$1 = r(t.onLiteralValue), w$1 = f$1(t.onSeparator), y = i(t.onComment), I$1 = f$1(t.onError), L = s$1 && s$1.disallowComments, c = s$1 && s$1.allowTrailingComma;
+	function k() {
+		for (;;) {
+			const v$1 = n.scan();
+			switch (n.getTokenError()) {
+				case 4:
+					p$2(14);
+					break;
+				case 5:
+					p$2(15);
+					break;
+				case 3:
+					p$2(13);
+					break;
+				case 1:
+					L || p$2(11);
+					break;
+				case 2:
+					p$2(12);
+					break;
+				case 6:
+					p$2(16);
+					break;
+			}
+			switch (v$1) {
+				case 12:
+				case 13:
+					L ? p$2(10) : y();
+					break;
+				case 16:
+					p$2(1);
+					break;
+				case 15:
+				case 14: break;
+				default: return v$1;
+			}
+		}
+	}
+	o(k, "scanNext");
+	function p$2(v$1, D = [], ne = []) {
+		if (I$1(v$1), D.length + ne.length > 0) {
+			let S = n.getToken();
+			for (; S !== 17;) {
+				if (D.indexOf(S) !== -1) {
+					k();
+					break;
+				} else if (ne.indexOf(S) !== -1) break;
+				S = k();
+			}
+		}
+	}
+	o(p$2, "handleError");
+	function F(v$1) {
+		const D = n.getTokenValue();
+		return v$1 ? A$1(D) : (T$1(D), l.push(D)), k(), !0;
+	}
+	o(F, "parseString");
+	function j() {
+		switch (n.getToken()) {
+			case 11:
+				const v$1 = n.getTokenValue();
+				let D = Number(v$1);
+				isNaN(D) && (p$2(2), D = 0), A$1(D);
+				break;
+			case 7:
+				A$1(null);
+				break;
+			case 8:
+				A$1(!0);
+				break;
+			case 9:
+				A$1(!1);
+				break;
+			default: return !1;
+		}
+		return k(), !0;
+	}
+	o(j, "parseLiteral");
+	function a$1() {
+		return n.getToken() !== 10 ? (p$2(3, [], [2, 5]), !1) : (F(!1), n.getToken() === 6 ? (w$1(":"), k(), J() || p$2(4, [], [2, 5])) : p$2(5, [], [2, 5]), l.pop(), !0);
+	}
+	o(a$1, "parseProperty");
+	function N() {
+		g(), k();
+		let v$1 = !1;
+		for (; n.getToken() !== 2 && n.getToken() !== 17;) {
+			if (n.getToken() === 5) {
+				if (v$1 || p$2(4, [], []), w$1(","), k(), n.getToken() === 2 && c) break;
+			} else v$1 && p$2(6, [], []);
+			a$1() || p$2(4, [], [2, 5]), v$1 = !0;
+		}
+		return b(), n.getToken() !== 2 ? p$2(7, [2], []) : k(), !0;
+	}
+	o(N, "parseObject");
+	function be() {
+		_$1(), k();
+		let v$1 = !0, D = !1;
+		for (; n.getToken() !== 4 && n.getToken() !== 17;) {
+			if (n.getToken() === 5) {
+				if (D || p$2(4, [], []), w$1(","), k(), n.getToken() === 4 && c) break;
+			} else D && p$2(6, [], []);
+			v$1 ? (l.push(0), v$1 = !1) : l[l.length - 1]++, J() || p$2(4, [], [4, 5]), D = !0;
+		}
+		return d$1(), v$1 || l.pop(), n.getToken() !== 4 ? p$2(8, [4], []) : k(), !0;
+	}
+	o(be, "parseArray");
+	function J() {
+		switch (n.getToken()) {
+			case 3: return be();
+			case 1: return N();
+			case 10: return F(!0);
+			default: return j();
+		}
+	}
+	return o(J, "parseValue"), k(), n.getToken() === 17 ? s$1.allowEmptyContent ? !0 : (p$2(4, [], []), !1) : J() ? (n.getToken() !== 17 && p$2(9, [], []), !0) : (p$2(4, [], []), !1);
+}
+o(Fe, "visit");
+var ie;
+(function(e) {
+	e[e.None = 0] = "None", e[e.UnexpectedEndOfComment = 1] = "UnexpectedEndOfComment", e[e.UnexpectedEndOfString = 2] = "UnexpectedEndOfString", e[e.UnexpectedEndOfNumber = 3] = "UnexpectedEndOfNumber", e[e.InvalidUnicode = 4] = "InvalidUnicode", e[e.InvalidEscapeCharacter = 5] = "InvalidEscapeCharacter", e[e.InvalidCharacter = 6] = "InvalidCharacter";
+})(ie || (ie = {}));
+var oe;
+(function(e) {
+	e[e.OpenBraceToken = 1] = "OpenBraceToken", e[e.CloseBraceToken = 2] = "CloseBraceToken", e[e.OpenBracketToken = 3] = "OpenBracketToken", e[e.CloseBracketToken = 4] = "CloseBracketToken", e[e.CommaToken = 5] = "CommaToken", e[e.ColonToken = 6] = "ColonToken", e[e.NullKeyword = 7] = "NullKeyword", e[e.TrueKeyword = 8] = "TrueKeyword", e[e.FalseKeyword = 9] = "FalseKeyword", e[e.StringLiteral = 10] = "StringLiteral", e[e.NumericLiteral = 11] = "NumericLiteral", e[e.LineCommentTrivia = 12] = "LineCommentTrivia", e[e.BlockCommentTrivia = 13] = "BlockCommentTrivia", e[e.LineBreakTrivia = 14] = "LineBreakTrivia", e[e.Trivia = 15] = "Trivia", e[e.Unknown = 16] = "Unknown", e[e.EOF = 17] = "EOF";
+})(oe || (oe = {}));
+const De = ye;
+var ue;
+(function(e) {
+	e[e.InvalidSymbol = 1] = "InvalidSymbol", e[e.InvalidNumberFormat = 2] = "InvalidNumberFormat", e[e.PropertyNameExpected = 3] = "PropertyNameExpected", e[e.ValueExpected = 4] = "ValueExpected", e[e.ColonExpected = 5] = "ColonExpected", e[e.CommaExpected = 6] = "CommaExpected", e[e.CloseBraceExpected = 7] = "CloseBraceExpected", e[e.CloseBracketExpected = 8] = "CloseBracketExpected", e[e.EndOfFileExpected = 9] = "EndOfFileExpected", e[e.InvalidCommentToken = 10] = "InvalidCommentToken", e[e.UnexpectedEndOfComment = 11] = "UnexpectedEndOfComment", e[e.UnexpectedEndOfString = 12] = "UnexpectedEndOfString", e[e.UnexpectedEndOfNumber = 13] = "UnexpectedEndOfNumber", e[e.InvalidUnicode = 14] = "InvalidUnicode", e[e.InvalidEscapeCharacter = 15] = "InvalidEscapeCharacter", e[e.InvalidCharacter = 16] = "InvalidCharacter";
+})(ue || (ue = {}));
+const re = o((e, t) => De(_e(t, e, "utf8")), "readJsonc"), H = Symbol("implicitBaseUrl"), $ = "${configDir}", Ee = o(() => {
+	const { findPnpApi: e } = ve;
+	return e && e(process.cwd());
+}, "getPnpApi"), X = o((e, t, s$1, n) => {
+	const l = `resolveFromPackageJsonPath:${e}:${t}:${s$1}`;
+	if (n != null && n.has(l)) return n.get(l);
+	const i = re(e, n);
+	if (!i) return;
+	let u$1 = t || "tsconfig.json";
+	if (!s$1 && i.exports) try {
+		const [f$1] = v(i.exports, t, ["require", "types"]);
+		u$1 = f$1;
+	} catch {
+		return !1;
+	}
+	else !t && i.tsconfig && (u$1 = i.tsconfig);
+	return u$1 = path.join(e, "..", u$1), n?.set(l, u$1), u$1;
+}, "resolveFromPackageJsonPath"), Y = "package.json", Z = "tsconfig.json", Be = o((e, t, s$1) => {
+	let n = e;
+	if (e === ".." && (n = path.join(n, Z)), e[0] === "." && (n = path.resolve(t, n)), path.isAbsolute(n)) {
+		if (B(s$1, n)) {
+			if (P(s$1, n).isFile()) return n;
+		} else if (!n.endsWith(".json")) {
+			const d$1 = `${n}.json`;
+			if (B(s$1, d$1)) return d$1;
+		}
+		return;
+	}
+	const [l, ...i] = e.split("/"), u$1 = l[0] === "@" ? `${l}/${i.shift()}` : l, f$1 = i.join("/"), r = Ee();
+	if (r) {
+		const { resolveRequest: d$1 } = r;
+		try {
+			if (u$1 === e) {
+				const A$1 = d$1(path.join(u$1, Y), t);
+				if (A$1) {
+					const w$1 = X(A$1, f$1, !1, s$1);
+					if (w$1 && B(s$1, w$1)) return w$1;
+				}
+			} else {
+				let A$1;
+				try {
+					A$1 = d$1(e, t, { extensions: [".json"] });
+				} catch {
+					A$1 = d$1(path.join(e, Z), t);
+				}
+				if (A$1) return A$1;
+			}
+		} catch {}
+	}
+	const g = se(path.resolve(t), path.join("node_modules", u$1), s$1);
+	if (!g || !P(s$1, g).isDirectory()) return;
+	const T$1 = path.join(g, Y);
+	if (B(s$1, T$1)) {
+		const d$1 = X(T$1, f$1, !1, s$1);
+		if (d$1 === !1) return;
+		if (d$1 && B(s$1, d$1) && P(s$1, d$1).isFile()) return d$1;
+	}
+	const b = path.join(g, f$1), _$1 = b.endsWith(".json");
+	if (!_$1) {
+		const d$1 = `${b}.json`;
+		if (B(s$1, d$1)) return d$1;
+	}
+	if (B(s$1, b)) {
+		if (P(s$1, b).isDirectory()) {
+			const d$1 = path.join(b, Y);
+			if (B(s$1, d$1)) {
+				const w$1 = X(d$1, "", !0, s$1);
+				if (w$1 && B(s$1, w$1)) return w$1;
+			}
+			const A$1 = path.join(b, Z);
+			if (B(s$1, A$1)) return A$1;
+		} else if (_$1) return b;
+	}
+}, "resolveExtendsPath"), q = o((e, t) => G(path.relative(e, t)), "pathRelative"), fe = [
+	"files",
+	"include",
+	"exclude"
+], Ie = o((e, t, s$1, n) => {
+	const l = Be(e, t, n);
+	if (!l) throw new Error(`File '${e}' not found.`);
+	if (s$1.has(l)) throw new Error(`Circularity detected while resolving configuration: ${l}`);
+	s$1.add(l);
+	const i = path.dirname(l), u$1 = ce(l, n, s$1);
+	delete u$1.references;
+	const { compilerOptions: f$1 } = u$1;
+	if (f$1) {
+		const { baseUrl: r } = f$1;
+		r && !r.startsWith($) && (f$1.baseUrl = E(path.relative(t, path.join(i, r))) || "./");
+		let { outDir: g } = f$1;
+		g && (g.startsWith($) || (g = path.relative(t, path.join(i, g))), f$1.outDir = E(g) || "./");
+	}
+	for (const r of fe) {
+		const g = u$1[r];
+		g && (u$1[r] = g.map((T$1) => T$1.startsWith($) ? T$1 : E(path.relative(t, path.join(i, T$1)))));
+	}
+	return u$1;
+}, "resolveExtends"), Le = ["outDir", "declarationDir"], ce = o((e, t, s$1 = /* @__PURE__ */ new Set()) => {
+	let n;
+	try {
+		n = re(e, t) || {};
+	} catch {
+		throw new Error(`Cannot resolve tsconfig at path: ${e}`);
+	}
+	if (typeof n != "object") throw new SyntaxError(`Failed to parse tsconfig at: ${e}`);
+	const l = path.dirname(e);
+	if (n.compilerOptions) {
+		const { compilerOptions: i } = n;
+		i.paths && !i.baseUrl && (i[H] = l);
+	}
+	if (n.extends) {
+		const i = Array.isArray(n.extends) ? n.extends : [n.extends];
+		delete n.extends;
+		for (const u$1 of i.reverse()) {
+			const f$1 = Ie(u$1, l, new Set(s$1), t), r = {
+				...f$1,
+				...n,
+				compilerOptions: {
+					...f$1.compilerOptions,
+					...n.compilerOptions
+				}
+			};
+			f$1.watchOptions && (r.watchOptions = {
+				...f$1.watchOptions,
+				...n.watchOptions
+			}), n = r;
+		}
+	}
+	if (n.compilerOptions) {
+		const { compilerOptions: i } = n;
+		for (const f$1 of ["baseUrl", "rootDir"]) {
+			const r = i[f$1];
+			if (r && !r.startsWith($)) {
+				const g = path.resolve(l, r);
+				i[f$1] = q(l, g);
+			}
+		}
+		for (const f$1 of Le) {
+			let r = i[f$1];
+			r && (Array.isArray(n.exclude) || (n.exclude = []), n.exclude.includes(r) || n.exclude.push(r), r.startsWith($) || (r = G(r)), i[f$1] = r);
+		}
+	} else n.compilerOptions = {};
+	if (n.include ? (n.include = n.include.map(E), n.files && delete n.files) : n.files && (n.files = n.files.map((i) => i.startsWith($) ? i : G(i))), n.watchOptions) {
+		const { watchOptions: i } = n;
+		i.excludeDirectories && (i.excludeDirectories = i.excludeDirectories.map((u$1) => E(path.resolve(l, u$1))));
+	}
+	return n;
+}, "_parseTsconfig"), W = o((e, t) => {
+	if (e.startsWith($)) return E(path.join(t, e.slice(12)));
+}, "interpolateConfigDir"), $e = [
+	"outDir",
+	"declarationDir",
+	"outFile",
+	"rootDir",
+	"baseUrl",
+	"tsBuildInfoFile"
+], Ue = o((e) => {
+	if (e.strict) for (const N of [
+		"noImplicitAny",
+		"noImplicitThis",
+		"strictNullChecks",
+		"strictFunctionTypes",
+		"strictBindCallApply",
+		"strictPropertyInitialization",
+		"strictBuiltinIteratorReturn",
+		"alwaysStrict",
+		"useUnknownInCatchVariables"
+	]) e[N] === void 0 && (e[N] = !0);
+	if (e.target) {
+		let a$1 = e.target.toLowerCase();
+		a$1 === "es2015" && (a$1 = "es6"), e.target = a$1, a$1 === "esnext" && (e.module ??= "es6", e.useDefineForClassFields ??= !0), (a$1 === "es6" || a$1 === "es2016" || a$1 === "es2017" || a$1 === "es2018" || a$1 === "es2019" || a$1 === "es2020" || a$1 === "es2021" || a$1 === "es2022" || a$1 === "es2023" || a$1 === "es2024") && (e.module ??= "es6"), (a$1 === "es2022" || a$1 === "es2023" || a$1 === "es2024") && (e.useDefineForClassFields ??= !0);
+	}
+	if (e.module) {
+		let a$1 = e.module.toLowerCase();
+		a$1 === "es2015" && (a$1 = "es6"), e.module = a$1, (a$1 === "es6" || a$1 === "es2020" || a$1 === "es2022" || a$1 === "esnext" || a$1 === "none" || a$1 === "system" || a$1 === "umd" || a$1 === "amd") && (e.moduleResolution ??= "classic"), a$1 === "system" && (e.allowSyntheticDefaultImports ??= !0), (a$1 === "node16" || a$1 === "nodenext" || a$1 === "preserve") && (e.esModuleInterop ??= !0, e.allowSyntheticDefaultImports ??= !0), (a$1 === "node16" || a$1 === "nodenext") && (e.moduleDetection ??= "force", e.useDefineForClassFields ??= !0), a$1 === "node16" && (e.target ??= "es2022", e.moduleResolution ??= "node16"), a$1 === "nodenext" && (e.target ??= "esnext", e.moduleResolution ??= "nodenext"), a$1 === "preserve" && (e.moduleResolution ??= "bundler");
+	}
+	if (e.moduleResolution) {
+		let a$1 = e.moduleResolution.toLowerCase();
+		a$1 === "node" && (a$1 = "node10"), e.moduleResolution = a$1, (a$1 === "node16" || a$1 === "nodenext" || a$1 === "bundler") && (e.resolvePackageJsonExports ??= !0, e.resolvePackageJsonImports ??= !0), a$1 === "bundler" && (e.allowSyntheticDefaultImports ??= !0, e.resolveJsonModule ??= !0);
+	}
+	e.esModuleInterop && (e.allowSyntheticDefaultImports ??= !0), e.verbatimModuleSyntax && (e.isolatedModules ??= !0, e.preserveConstEnums ??= !0), e.isolatedModules && (e.preserveConstEnums ??= !0);
+}, "normalizeCompilerOptions"), ae = o((e, t = /* @__PURE__ */ new Map()) => {
+	const s$1 = path.resolve(e), n = ce(s$1, t), l = path.dirname(s$1), { compilerOptions: i } = n;
+	if (i) {
+		for (const f$1 of $e) {
+			const r = i[f$1];
+			if (r) {
+				const g = W(r, l);
+				i[f$1] = g ? q(l, g) : r;
+			}
+		}
+		for (const f$1 of ["rootDirs", "typeRoots"]) {
+			const r = i[f$1];
+			r && (i[f$1] = r.map((g) => {
+				const T$1 = W(g, l);
+				return T$1 ? q(l, T$1) : g;
+			}));
+		}
+		const { paths: u$1 } = i;
+		if (u$1) for (const f$1 of Object.keys(u$1)) u$1[f$1] = u$1[f$1].map((r) => {
+			var g;
+			return (g = W(r, l)) != null ? g : r;
+		});
+		Ue(i);
+	}
+	for (const u$1 of fe) {
+		const f$1 = n[u$1];
+		f$1 && (n[u$1] = f$1.map((r) => {
+			var g;
+			return (g = W(r, l)) != null ? g : r;
+		}));
+	}
+	return n;
+}, "parseTsconfig"), he = o((e = process.cwd(), t = "tsconfig.json", s$1 = /* @__PURE__ */ new Map()) => {
+	const n = se(E(e), t, s$1);
+	if (!n) return null;
+	const l = ae(n, s$1);
+	return {
+		path: n,
+		config: l
+	};
+}, "getTsconfig"), xe = /\*/g, ge = o((e, t) => {
+	const s$1 = e.match(xe);
+	if (s$1 && s$1.length > 1) throw new Error(t);
+}, "assertStarCount"), Ne = o((e) => {
+	if (e.includes("*")) {
+		const [t, s$1] = e.split("*");
+		return {
+			prefix: t,
+			suffix: s$1
+		};
+	}
+	return e;
+}, "parsePattern"), Se = o(({ prefix: e, suffix: t }, s$1) => s$1.startsWith(e) && s$1.endsWith(t), "isPatternMatch"), Pe = o((e, t, s$1) => Object.entries(e).map(([n, l]) => (ge(n, `Pattern '${n}' can have at most one '*' character.`), {
+	pattern: Ne(n),
+	substitutions: l.map((i) => {
+		if (ge(i, `Substitution '${i}' in pattern '${n}' can have at most one '*' character.`), !t && !z.test(i)) throw new Error("Non-relative paths are not allowed when 'baseUrl' is not set. Did you forget a leading './'?");
+		return path.resolve(s$1, i);
+	})
+})), "parsePaths");
+o((e) => {
+	const { compilerOptions: t } = e.config;
+	if (!t) return null;
+	const { baseUrl: s$1, paths: n } = t;
+	if (!s$1 && !n) return null;
+	const l = H in t && t[H], i = path.resolve(path.dirname(e.path), s$1 || l || "."), u$1 = n ? Pe(n, s$1, i) : [];
+	return (f$1) => {
+		if (z.test(f$1)) return [];
+		const r = [];
+		for (const _$1 of u$1) {
+			if (_$1.pattern === f$1) return _$1.substitutions.map(E);
+			typeof _$1.pattern != "string" && r.push(_$1);
+		}
+		let g, T$1 = -1;
+		for (const _$1 of r) Se(_$1.pattern, f$1) && _$1.pattern.prefix.length > T$1 && (T$1 = _$1.pattern.prefix.length, g = _$1);
+		if (!g) return s$1 ? [E(path.join(i, f$1))] : [];
+		const b = f$1.slice(g.pattern.prefix.length, f$1.length - g.pattern.suffix.length);
+		return g.substitutions.map((_$1) => E(_$1.replace("*", b)));
+	};
+}, "createPathsMatcher");
+const pe = o((e) => {
+	let t = "";
+	for (let s$1 = 0; s$1 < e.length; s$1 += 1) {
+		const n = e[s$1], l = n.toUpperCase();
+		t += n === l ? n.toLowerCase() : l;
+	}
+	return t;
+}, "s"), We = 65, Me = 97, Ve = o(() => Math.floor(Math.random() * 26), "m"), Je = o((e) => Array.from({ length: e }, () => String.fromCodePoint(Ve() + (Math.random() > .5 ? We : Me))).join(""), "S"), Oe = o((e = Ae) => {
+	const t = process.execPath;
+	if (e.existsSync(t)) return !e.existsSync(pe(t));
+	const s$1 = `/${Je(10)}`;
+	e.writeFileSync(s$1, "");
+	const n = !e.existsSync(pe(s$1));
+	return e.unlinkSync(s$1), n;
+}, "l"), { join: M } = path.posix, K = {
+	ts: [
+		".ts",
+		".tsx",
+		".d.ts"
+	],
+	cts: [".cts", ".d.cts"],
+	mts: [".mts", ".d.mts"]
+}, ze = o((e) => {
+	const t = [...K.ts], s$1 = [...K.cts], n = [...K.mts];
+	return e != null && e.allowJs && (t.push(".js", ".jsx"), s$1.push(".cjs"), n.push(".mjs")), [
+		...t,
+		...s$1,
+		...n
+	];
+}, "getSupportedExtensions"), Ge = o((e) => {
+	const t = [];
+	if (!e) return t;
+	const { outDir: s$1, declarationDir: n } = e;
+	return s$1 && t.push(s$1), n && t.push(n), t;
+}, "getDefaultExcludeSpec"), me = o((e) => e.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`), "escapeForRegexp"), Qe = [
+	"node_modules",
+	"bower_components",
+	"jspm_packages"
+], C = `(?!(${Qe.join("|")})(/|$))`, He = /(?:^|\/)[^.*?]+$/, ke = "**/*", V = "[^/]", ee = "[^./]", we = process.platform === "win32";
+o(({ config: e, path: t }, s$1 = Oe()) => {
+	if ("extends" in e) throw new Error("tsconfig#extends must be resolved. Use getTsconfig or parseTsconfig to resolve it.");
+	if (!path.isAbsolute(t)) throw new Error("The tsconfig path must be absolute");
+	we && (t = E(t));
+	const n = path.dirname(t), { files: l, include: i, exclude: u$1, compilerOptions: f$1 } = e, r = l == null ? void 0 : l.map((w$1) => M(n, w$1)), g = ze(f$1), T$1 = s$1 ? "" : "i", _$1 = (u$1 || Ge(f$1)).map((w$1) => {
+		const y = M(n, w$1), I$1 = me(y).replaceAll(String.raw`\*\*/`, "(.+/)?").replaceAll(String.raw`\*`, `${V}*`).replaceAll(String.raw`\?`, V);
+		return new RegExp(`^${I$1}($|/)`, T$1);
+	}), d$1 = l || i ? i : [ke], A$1 = d$1 ? d$1.map((w$1) => {
+		let y = M(n, w$1);
+		He.test(y) && (y = M(y, ke));
+		const I$1 = me(y).replaceAll(String.raw`/\*\*`, `(/${C}${ee}${V}*)*?`).replaceAll(/(\/)?\\\*/g, (L, c) => {
+			const k = `(${ee}|(\\.(?!min\\.js$))?)*`;
+			return c ? `/${C}${ee}${k}` : k;
+		}).replaceAll(/(\/)?\\\?/g, (L, c) => {
+			const k = V;
+			return c ? `/${C}${k}` : k;
+		});
+		return new RegExp(`^${I$1}$`, T$1);
+	}) : void 0;
+	return (w$1) => {
+		if (!path.isAbsolute(w$1)) throw new Error("filePath must be absolute");
+		if (we && (w$1 = E(w$1)), r != null && r.includes(w$1)) return e;
+		if (!(!g.some((y) => w$1.endsWith(y)) || _$1.some((y) => y.test(w$1))) && A$1 && A$1.some((y) => y.test(w$1))) return e;
+	};
+}, "createFilesMatcher");
+var import_picocolors = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string$1 = "" + input, index = string$1.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string$1, close, replace, index) + close : open + string$1 + close;
+	};
+	let replaceClose = (string$1, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string$1.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string$1.indexOf(close, cursor);
+		} while (~index);
+		return result + string$1.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f$1 = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f$1("\x1B[0m", "\x1B[0m"),
+			bold: f$1("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f$1("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f$1("\x1B[3m", "\x1B[23m"),
+			underline: f$1("\x1B[4m", "\x1B[24m"),
+			inverse: f$1("\x1B[7m", "\x1B[27m"),
+			hidden: f$1("\x1B[8m", "\x1B[28m"),
+			strikethrough: f$1("\x1B[9m", "\x1B[29m"),
+			black: f$1("\x1B[30m", "\x1B[39m"),
+			red: f$1("\x1B[31m", "\x1B[39m"),
+			green: f$1("\x1B[32m", "\x1B[39m"),
+			yellow: f$1("\x1B[33m", "\x1B[39m"),
+			blue: f$1("\x1B[34m", "\x1B[39m"),
+			magenta: f$1("\x1B[35m", "\x1B[39m"),
+			cyan: f$1("\x1B[36m", "\x1B[39m"),
+			white: f$1("\x1B[37m", "\x1B[39m"),
+			gray: f$1("\x1B[90m", "\x1B[39m"),
+			bgBlack: f$1("\x1B[40m", "\x1B[49m"),
+			bgRed: f$1("\x1B[41m", "\x1B[49m"),
+			bgGreen: f$1("\x1B[42m", "\x1B[49m"),
+			bgYellow: f$1("\x1B[43m", "\x1B[49m"),
+			bgBlue: f$1("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f$1("\x1B[45m", "\x1B[49m"),
+			bgCyan: f$1("\x1B[46m", "\x1B[49m"),
+			bgWhite: f$1("\x1B[47m", "\x1B[49m"),
+			blackBright: f$1("\x1B[90m", "\x1B[39m"),
+			redBright: f$1("\x1B[91m", "\x1B[39m"),
+			greenBright: f$1("\x1B[92m", "\x1B[39m"),
+			yellowBright: f$1("\x1B[93m", "\x1B[39m"),
+			blueBright: f$1("\x1B[94m", "\x1B[39m"),
+			magentaBright: f$1("\x1B[95m", "\x1B[39m"),
+			cyanBright: f$1("\x1B[96m", "\x1B[39m"),
+			whiteBright: f$1("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f$1("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f$1("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f$1("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f$1("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f$1("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f$1("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f$1("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f$1("\x1B[107m", "\x1B[49m")
+		};
+	};
+	module.exports = createColors();
+	module.exports.createColors = createColors;
+})))(), 1);
+function isErr(result) {
+	return result instanceof CtxError;
+}
+function attempt(fn) {
+	const convertUnknownErrorToCtxError = (error) => {
+		const newError = error instanceof Error ? error : new Error(String(error));
+		return new CtxError("", {}, newError);
+	};
+	try {
+		const result = fn();
+		return isPromise(result) ? result.then((value) => value).catch((error) => convertUnknownErrorToCtxError(error)) : result;
+	} catch (error) {
+		return convertUnknownErrorToCtxError(error);
+	}
+}
+function err(message$1, cause) {
+	return cause ? new CtxError(message$1, { cause }) : new CtxError(message$1);
+}
+var CtxError = class CtxError$1 extends Error {
+	context;
+	cause;
+	constructor(message$1, options, errorToConvert) {
+		super();
+		Object.setPrototypeOf(this, new.target.prototype);
+		if (errorToConvert) {
+			this.name = errorToConvert.name;
+			this.message = errorToConvert.message;
+			if (errorToConvert.cause instanceof Error) this.cause = errorToConvert.cause;
+			if (errorToConvert.stack) this.stack = errorToConvert.stack;
+		} else {
+			this.name = "CtxError";
+			this.message = message$1;
+			if (options?.cause) this.cause = options.cause;
+		}
+	}
+	get messageChain() {
+		const messages = [this.message];
+		let currentCause = this.cause;
+		while (currentCause) {
+			const causeMessage = this.#prependErrorNameToMessage(currentCause);
+			messages.push(causeMessage);
+			currentCause = currentCause.cause instanceof Error ? currentCause.cause : void 0;
+		}
+		const filteredMessages = messages.map((msg) => msg.trim()).filter(Boolean);
+		return filteredMessages.length > 0 ? filteredMessages.join(" -> ") : "Unknown error";
+	}
+	#prependErrorNameToMessage(error) {
+		return `${error.name !== "Error" && error.name !== "CtxError" ? `${error.name}: ` : ""}${error.message}`;
+	}
+	get rootStack() {
+		const cleanStack = (stack) => {
+			const stackLines = stack.trim().split("\n");
+			const excludes = [
+				"at new CtxError",
+				"at err",
+				"at attempt"
+			];
+			return stackLines.map((line) => line.trim()).filter((line) => !excludes.some((exclude) => line.startsWith(exclude))).join("\n    ");
+		};
+		const stacks = [this.stack];
+		let currentCause = this.cause;
+		while (currentCause) {
+			stacks.push(currentCause.stack);
+			currentCause = currentCause.cause instanceof Error ? currentCause.cause : void 0;
+		}
+		const rootStack = stacks.map((stack) => stack ? stack.trim() : "").filter(Boolean).at(-1);
+		return rootStack ? cleanStack(rootStack) : "<no stack>";
+	}
+	ctx(context) {
+		this.context = {
+			...this.context,
+			...context
+		};
+		return this;
+	}
+	get(key) {
+		if (this.cause instanceof CtxError$1) {
+			const deepestValue = this.cause.get(key);
+			if (deepestValue !== void 0) return deepestValue;
+		}
+		if (this.context && Object.hasOwn(this.context, key)) return this.context[key];
+	}
+	getAll(key) {
+		const values$1 = [];
+		if (this.context && Object.hasOwn(this.context, key)) values$1.push(this.context[key]);
+		if (this.cause instanceof CtxError$1) values$1.push(...this.cause.getAll(key));
+		return values$1;
+	}
+};
+function isPromise(value) {
+	return value ? typeof value.then === "function" : false;
+}
+const IMPORT_PATTERN = /(?:import|from)\s+['"]([^'"]+)['"]$/gm;
+const FILES_GLOB = "**/*.{ts,tsx,js,jsx,astro}";
+const TRANSFORM_ERRORS = [];
+async function cli() {
+	const options = object({
+		write: option("-w", "--write", { description: message`Write changes to files` }),
+		ignorePatterns: multiple(option("-i", "--ignore", string({ metavar: "PATTERN" }), { description: message`Additional glob patterns for files to ignore` }))
+	});
+	const { write, ignorePatterns } = run(options, {
+		programName: "ts-import-fix",
+		help: "option",
+		showDefault: { prefix: " [default: " }
+	});
+	const exclude = [
+		"node_modules/",
+		"dist/",
+		...ignorePatterns
+	];
+	return {
+		filePaths: await Array.fromAsync(fs.glob(FILES_GLOB, { exclude })),
+		write
+	};
+}
+function getPathsMap() {
+	const tsconfig = he();
+	if (!tsconfig) return err("failed to load tsconfig", void 0);
+	const pathsMap = {};
+	for (let [alias, [aliasDir]] of Object.entries(tsconfig.config.compilerOptions?.paths ?? {})) {
+		if (!alias.endsWith("/*")) continue;
+		if (!aliasDir?.endsWith("/*")) continue;
+		aliasDir = aliasDir.slice(0, -2);
+		alias = alias.slice(0, -2);
+		pathsMap[alias] = aliasDir;
+	}
+	return pathsMap;
+}
+function changeExtension(parsedPath, newExtension) {
+	return {
+		...parsedPath,
+		ext: newExtension,
+		base: ""
+	};
+}
+function transformExtension(filePath) {
+	const pathParts = path.parse(filePath);
+	if (!(pathParts.ext === ".js" || pathParts.ext === "")) return filePath;
+	return path.format(changeExtension(pathParts, ".ts"));
+}
+function transformRelativeImport(filePath, importPath, pathsMap) {
+	const currentDir = path.dirname(filePath);
+	const absoluteImportPath = path.resolve(currentDir, importPath);
+	if (!fss.existsSync(absoluteImportPath)) {
+		TRANSFORM_ERRORS.push(`❌ (${filePath}) skipped transform of '${importPath}': target file does not exist`);
+		return importPath;
+	}
+	for (const [alias, aliasDir] of Object.entries(pathsMap)) {
+		const relativeToAliasDir = path.relative(aliasDir, absoluteImportPath);
+		if (relativeToAliasDir.startsWith("..")) continue;
+		return `${alias}/${relativeToAliasDir}`;
+	}
+	TRANSFORM_ERRORS.push(`❌ (${filePath}) could not find alias for '${importPath}'`);
+}
+async function tsImportFix() {
+	const { filePaths, write } = await cli();
+	const pathsMap = getPathsMap();
+	if (isErr(pathsMap)) return pathsMap;
+	const importFixResult = await attempt(() => {
+		const filePromises = filePaths.map(async (filePath) => {
+			const content = await fs.readFile(filePath, "utf8");
+			const transformedContent = content.replace(IMPORT_PATTERN, (match, importPath) => {
+				const isRelativeImport = importPath.startsWith("./") || importPath.startsWith("../");
+				const isAliasImport = Object.keys(pathsMap).some((alias) => importPath.startsWith(alias));
+				if (!(isRelativeImport || isAliasImport)) return match;
+				let newImportPath = transformExtension(importPath);
+				if (isRelativeImport) newImportPath = transformRelativeImport(filePath, newImportPath, pathsMap) ?? newImportPath;
+				if (newImportPath === importPath) return match;
+				const { ext: originalExt } = path.parse(importPath);
+				const newPathParts = path.parse(newImportPath);
+				const { ext: newExt } = newPathParts;
+				let newImportPathString = newImportPath;
+				if (newExt !== originalExt) newImportPathString = `${path.format(changeExtension(newPathParts, ""))}${import_picocolors.default.greenBright(newExt)}`;
+				console.log(`✅ (${filePath}) '${importPath}' -> ${newImportPathString}`);
+				return match.replace(importPath, newImportPath);
+			});
+			if (transformedContent === content) return;
+			if (write) await fs.writeFile(filePath, transformedContent);
+		});
+		return Promise.all(filePromises);
+	});
+	let exitCode = 0;
+	if (TRANSFORM_ERRORS.length > 0) {
+		console.error(TRANSFORM_ERRORS.join("\n"));
+		exitCode = 1;
+	}
+	if (isErr(importFixResult)) return err("something went wrong when transforming imports", importFixResult);
+	return exitCode;
+}
+async function main() {
+	const result = await tsImportFix();
+	if (isErr(result)) {
+		console.error(import_picocolors.default.redBright(`ts-import-fix: ${result.messageChain}`));
+		return 1;
+	}
+	return result;
+}
+if (import.meta.main) process$1.exitCode = await main();
+export {};