sv 0.11.2 → 0.11.3

package/dist/bin.mjs

@@ -1,1834 +1,43 @@
 #!/usr/bin/env node
 import { i as __toESM } from "./chunk-BjMGrMj9.mjs";
-import { O as dist, T as resolveCommand, a as installOption, b as getPackageJson, c as Option, d as up$1, f as from, g as commonFilePaths, i as installDependencies, k as getSharedFiles, l as program, m as templates, n as addPnpmBuildDependencies, o as packageManagerPrompt, p as create$1, r as getUserAgent, s as Command, t as AGENT_NAMES, v as formatFiles, w as detect, y as getHighlighter } from "./package-manager-CySZrSUa.mjs";
-import { $ as ze, G as J, H as De, J as Ue, K as Ke, O as create$2, Q as ke, U as Fe, W as Ge, Y as We, Z as et, _ as createDefault, a as toFragment, at as parseSvelte, dt as require_picocolors, et as Vu, it as parseScript, k as overrideProperties, lt as walk, o as isVersionUnsupportedBelow, q as T, r as ensureScript, rt as parseJson, x as addDefault } from "./core-D715tamU.mjs";
-import { a as setupAddons, n as officialAddons, o as createWorkspace, r as applyAddons, t as getAddonDetails } from "./official-P5OKi7QM.mjs";
-import fs, { existsSync } from "node:fs";
-import path, { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { exec, execSync } from "node:child_process";
+import { f as program, l as from, r as getUserAgent, u as Command } from "./package-manager-DkCPtZM1.mjs";
+import { Et as require_picocolors, ft as resolveCommand } from "./utils-DjBRIDJG.mjs";
+import { a as helpConfig, i as forwardExitCode, n as add, o as name, r as create, s as version } from "./add-BWQarWDB.mjs";
 import process from "node:process";
-import { promisify } from "node:util";
-import { createGunzip } from "node:zlib";
-import { pipeline } from "node:stream/promises";
+import { execSync } from "node:child_process";
 
-//#region package.json
-var name = "sv";
-var version = "0.11.2";
-
-//#endregion
-//#region lib/addons/_config/community.ts
-/** EVALUATED AT BUILD TIME */
-const communityAddonIds = ["unocss", "unplugin-icons"];
-async function getCommunityAddon(name$1) {
-	const { default: details } = await import(`../../../community-addons/${name$1}.ts`);
-	return details;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/empathic@2.0.0/node_modules/empathic/package.mjs
-/**
-* Find the closest "package.json" file while walking parent directories.
-* @returns The absolute path to a "package.json", if found.
-*/
-function up(options$1) {
-	return up$1("package.json", options$1);
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/valibot@1.2.0_typescript@5.9.3/node_modules/valibot/dist/index.mjs
-var import_picocolors$3 = /* @__PURE__ */ __toESM(require_picocolors(), 1);
-let store$4;
-/**
-* Returns the global configuration.
-*
-* @param config The config to merge.
-*
-* @returns The configuration.
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function getGlobalConfig(config$1) {
-	return {
-		lang: config$1?.lang ?? store$4?.lang,
-		message: config$1?.message,
-		abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
-		abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
-	};
-}
-let store$3;
-/**
-* Returns a global error message.
-*
-* @param lang The language of the message.
-*
-* @returns The error message.
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function getGlobalMessage(lang) {
-	return store$3?.get(lang);
-}
-let store$2;
-/**
-* Returns a schema error message.
-*
-* @param lang The language of the message.
-*
-* @returns The error message.
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function getSchemaMessage(lang) {
-	return store$2?.get(lang);
-}
-let store$1;
-/**
-* Returns a specific error message.
-*
-* @param reference The identifier reference.
-* @param lang The language of the message.
-*
-* @returns The error message.
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function getSpecificMessage(reference, lang) {
-	return store$1?.get(reference)?.get(lang);
-}
-/**
-* Stringifies an unknown input to a literal or type string.
-*
-* @param input The unknown input.
-*
-* @returns A literal or type string.
-*
-* @internal
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function _stringify(input) {
-	const type = typeof input;
-	if (type === "string") return `"${input}"`;
-	if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
-	if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
-	return type;
-}
-/**
-* Adds an issue to the dataset.
-*
-* @param context The issue context.
-* @param label The issue label.
-* @param dataset The input dataset.
-* @param config The configuration.
-* @param other The optional props.
-*
-* @internal
-*/
-function _addIssue(context, label, dataset, config$1, other) {
-	const input = other && "input" in other ? other.input : dataset.value;
-	const expected = other?.expected ?? context.expects ?? null;
-	const received = other?.received ?? /* @__PURE__ */ _stringify(input);
-	const issue = {
-		kind: context.kind,
-		type: context.type,
-		input,
-		expected,
-		received,
-		message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
-		requirement: context.requirement,
-		path: other?.path,
-		issues: other?.issues,
-		lang: config$1.lang,
-		abortEarly: config$1.abortEarly,
-		abortPipeEarly: config$1.abortPipeEarly
-	};
-	const isSchema = context.kind === "schema";
-	const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
-	if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
-	if (isSchema) dataset.typed = false;
-	if (dataset.issues) dataset.issues.push(issue);
-	else dataset.issues = [issue];
-}
-/**
-* Returns the Standard Schema properties.
-*
-* @param context The schema context.
-*
-* @returns The Standard Schema properties.
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function _getStandardProps(context) {
-	return {
-		version: 1,
-		vendor: "valibot",
-		validate(value$1) {
-			return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
-		}
-	};
-}
-/**
-* Disallows inherited object properties and prevents object prototype
-* pollution by disallowing certain keys.
-*
-* @param object The object to check.
-* @param key The key to check.
-*
-* @returns Whether the key is allowed.
-*
-* @internal
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function _isValidObjectKey(object$1, key) {
-	return Object.hasOwn(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
-}
-/**
-* Joins multiple `expects` values with the given separator.
-*
-* @param values The `expects` values.
-* @param separator The separator.
-*
-* @returns The joined `expects` property.
-*
-* @internal
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function _joinExpects(values$1, separator) {
-	const list = [...new Set(values$1)];
-	if (list.length > 1) return `(${list.join(` ${separator} `)})`;
-	return list[0] ?? "never";
-}
-/**
-* A Valibot error with useful information.
-*/
-var ValiError = class extends Error {
-	/**
-	* Creates a Valibot error with useful information.
-	*
-	* @param issues The error issues.
-	*/
-	constructor(issues) {
-		super(issues[0].message);
-		this.name = "ValiError";
-		this.issues = issues;
-	}
-};
-/**
-* Creates a custom transformation action.
-*
-* @param operation The transformation operation.
-*
-* @returns A transform action.
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function transform(operation) {
-	return {
-		kind: "transformation",
-		type: "transform",
-		reference: transform,
-		async: false,
-		operation,
-		"~run"(dataset) {
-			dataset.value = this.operation(dataset.value);
-			return dataset;
-		}
-	};
-}
-/**
-* Returns the fallback value of the schema.
-*
-* @param schema The schema to get it from.
-* @param dataset The output dataset if available.
-* @param config The config if available.
-*
-* @returns The fallback value.
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function getFallback(schema, dataset, config$1) {
-	return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
-}
-/**
-* Returns the default value of the schema.
-*
-* @param schema The schema to get it from.
-* @param dataset The input dataset if available.
-* @param config The config if available.
-*
-* @returns The default value.
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function getDefault(schema, dataset, config$1) {
-	return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
-}
-/* @__NO_SIDE_EFFECTS__ */
-function array(item, message$1) {
-	return {
-		kind: "schema",
-		type: "array",
-		reference: array,
-		expects: "Array",
-		async: false,
-		item,
-		message: message$1,
-		get "~standard"() {
-			return /* @__PURE__ */ _getStandardProps(this);
-		},
-		"~run"(dataset, config$1) {
-			const input = dataset.value;
-			if (Array.isArray(input)) {
-				dataset.typed = true;
-				dataset.value = [];
-				for (let key = 0; key < input.length; key++) {
-					const value$1 = input[key];
-					const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
-					if (itemDataset.issues) {
-						const pathItem = {
-							type: "array",
-							origin: "value",
-							input,
-							key,
-							value: value$1
-						};
-						for (const issue of itemDataset.issues) {
-							if (issue.path) issue.path.unshift(pathItem);
-							else issue.path = [pathItem];
-							dataset.issues?.push(issue);
-						}
-						if (!dataset.issues) dataset.issues = itemDataset.issues;
-						if (config$1.abortEarly) {
-							dataset.typed = false;
-							break;
-						}
-					}
-					if (!itemDataset.typed) dataset.typed = false;
-					dataset.value.push(itemDataset.value);
-				}
-			} else _addIssue(this, "type", dataset, config$1);
-			return dataset;
-		}
-	};
-}
-/* @__NO_SIDE_EFFECTS__ */
-function boolean(message$1) {
-	return {
-		kind: "schema",
-		type: "boolean",
-		reference: boolean,
-		expects: "boolean",
-		async: false,
-		message: message$1,
-		get "~standard"() {
-			return /* @__PURE__ */ _getStandardProps(this);
-		},
-		"~run"(dataset, config$1) {
-			if (typeof dataset.value === "boolean") dataset.typed = true;
-			else _addIssue(this, "type", dataset, config$1);
-			return dataset;
-		}
-	};
-}
-/* @__NO_SIDE_EFFECTS__ */
-function optional(wrapped, default_) {
-	return {
-		kind: "schema",
-		type: "optional",
-		reference: optional,
-		expects: `(${wrapped.expects} | undefined)`,
-		async: false,
-		wrapped,
-		default: default_,
-		get "~standard"() {
-			return /* @__PURE__ */ _getStandardProps(this);
-		},
-		"~run"(dataset, config$1) {
-			if (dataset.value === void 0) {
-				if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
-				if (dataset.value === void 0) {
-					dataset.typed = true;
-					return dataset;
-				}
-			}
-			return this.wrapped["~run"](dataset, config$1);
-		}
-	};
-}
-/* @__NO_SIDE_EFFECTS__ */
-function picklist(options$1, message$1) {
-	return {
-		kind: "schema",
-		type: "picklist",
-		reference: picklist,
-		expects: /* @__PURE__ */ _joinExpects(options$1.map(_stringify), "|"),
-		async: false,
-		options: options$1,
-		message: message$1,
-		get "~standard"() {
-			return /* @__PURE__ */ _getStandardProps(this);
-		},
-		"~run"(dataset, config$1) {
-			if (this.options.includes(dataset.value)) dataset.typed = true;
-			else _addIssue(this, "type", dataset, config$1);
-			return dataset;
-		}
-	};
-}
-/* @__NO_SIDE_EFFECTS__ */
-function record(key, value$1, message$1) {
-	return {
-		kind: "schema",
-		type: "record",
-		reference: record,
-		expects: "Object",
-		async: false,
-		key,
-		value: value$1,
-		message: message$1,
-		get "~standard"() {
-			return /* @__PURE__ */ _getStandardProps(this);
-		},
-		"~run"(dataset, config$1) {
-			const input = dataset.value;
-			if (input && typeof input === "object") {
-				dataset.typed = true;
-				dataset.value = {};
-				for (const entryKey in input) if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
-					const entryValue = input[entryKey];
-					const keyDataset = this.key["~run"]({ value: entryKey }, config$1);
-					if (keyDataset.issues) {
-						const pathItem = {
-							type: "object",
-							origin: "key",
-							input,
-							key: entryKey,
-							value: entryValue
-						};
-						for (const issue of keyDataset.issues) {
-							issue.path = [pathItem];
-							dataset.issues?.push(issue);
-						}
-						if (!dataset.issues) dataset.issues = keyDataset.issues;
-						if (config$1.abortEarly) {
-							dataset.typed = false;
-							break;
-						}
-					}
-					const valueDataset = this.value["~run"]({ value: entryValue }, config$1);
-					if (valueDataset.issues) {
-						const pathItem = {
-							type: "object",
-							origin: "value",
-							input,
-							key: entryKey,
-							value: entryValue
-						};
-						for (const issue of valueDataset.issues) {
-							if (issue.path) issue.path.unshift(pathItem);
-							else issue.path = [pathItem];
-							dataset.issues?.push(issue);
-						}
-						if (!dataset.issues) dataset.issues = valueDataset.issues;
-						if (config$1.abortEarly) {
-							dataset.typed = false;
-							break;
-						}
-					}
-					if (!keyDataset.typed || !valueDataset.typed) dataset.typed = false;
-					if (keyDataset.typed) dataset.value[keyDataset.value] = valueDataset.value;
-				}
-			} else _addIssue(this, "type", dataset, config$1);
-			return dataset;
-		}
-	};
-}
-/* @__NO_SIDE_EFFECTS__ */
-function strictObject(entries$1, message$1) {
-	return {
-		kind: "schema",
-		type: "strict_object",
-		reference: strictObject,
-		expects: "Object",
-		async: false,
-		entries: entries$1,
-		message: message$1,
-		get "~standard"() {
-			return /* @__PURE__ */ _getStandardProps(this);
-		},
-		"~run"(dataset, config$1) {
-			const input = dataset.value;
-			if (input && typeof input === "object") {
-				dataset.typed = true;
-				dataset.value = {};
-				for (const key in this.entries) {
-					const valueSchema = this.entries[key];
-					if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
-						const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
-						const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
-						if (valueDataset.issues) {
-							const pathItem = {
-								type: "object",
-								origin: "value",
-								input,
-								key,
-								value: value$1
-							};
-							for (const issue of valueDataset.issues) {
-								if (issue.path) issue.path.unshift(pathItem);
-								else issue.path = [pathItem];
-								dataset.issues?.push(issue);
-							}
-							if (!dataset.issues) dataset.issues = valueDataset.issues;
-							if (config$1.abortEarly) {
-								dataset.typed = false;
-								break;
-							}
-						}
-						if (!valueDataset.typed) dataset.typed = false;
-						dataset.value[key] = valueDataset.value;
-					} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
-					else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
-						_addIssue(this, "key", dataset, config$1, {
-							input: void 0,
-							expected: `"${key}"`,
-							path: [{
-								type: "object",
-								origin: "key",
-								input,
-								key,
-								value: input[key]
-							}]
-						});
-						if (config$1.abortEarly) break;
-					}
-				}
-				if (!dataset.issues || !config$1.abortEarly) {
-					for (const key in input) if (!(key in this.entries)) {
-						_addIssue(this, "key", dataset, config$1, {
-							input: key,
-							expected: "never",
-							path: [{
-								type: "object",
-								origin: "key",
-								input,
-								key,
-								value: input[key]
-							}]
-						});
-						break;
-					}
-				}
-			} else _addIssue(this, "type", dataset, config$1);
-			return dataset;
-		}
-	};
-}
-/* @__NO_SIDE_EFFECTS__ */
-function string(message$1) {
-	return {
-		kind: "schema",
-		type: "string",
-		reference: string,
-		expects: "string",
-		async: false,
-		message: message$1,
-		get "~standard"() {
-			return /* @__PURE__ */ _getStandardProps(this);
-		},
-		"~run"(dataset, config$1) {
-			if (typeof dataset.value === "string") dataset.typed = true;
-			else _addIssue(this, "type", dataset, config$1);
-			return dataset;
-		}
-	};
-}
-/**
-* Returns the sub issues of the provided datasets for the union issue.
-*
-* @param datasets The datasets.
-*
-* @returns The sub issues.
-*
-* @internal
-*/
-/* @__NO_SIDE_EFFECTS__ */
-function _subIssues(datasets) {
-	let issues;
-	if (datasets) for (const dataset of datasets) if (issues) issues.push(...dataset.issues);
-	else issues = dataset.issues;
-	return issues;
-}
-/* @__NO_SIDE_EFFECTS__ */
-function union(options$1, message$1) {
-	return {
-		kind: "schema",
-		type: "union",
-		reference: union,
-		expects: /* @__PURE__ */ _joinExpects(options$1.map((option) => option.expects), "|"),
-		async: false,
-		options: options$1,
-		message: message$1,
-		get "~standard"() {
-			return /* @__PURE__ */ _getStandardProps(this);
-		},
-		"~run"(dataset, config$1) {
-			let validDataset;
-			let typedDatasets;
-			let untypedDatasets;
-			for (const schema of this.options) {
-				const optionDataset = schema["~run"]({ value: dataset.value }, config$1);
-				if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
-				else typedDatasets = [optionDataset];
-				else {
-					validDataset = optionDataset;
-					break;
-				}
-				else if (untypedDatasets) untypedDatasets.push(optionDataset);
-				else untypedDatasets = [optionDataset];
-			}
-			if (validDataset) return validDataset;
-			if (typedDatasets) {
-				if (typedDatasets.length === 1) return typedDatasets[0];
-				_addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
-				dataset.typed = true;
-			} else if (untypedDatasets?.length === 1) return untypedDatasets[0];
-			else _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
-			return dataset;
-		}
-	};
-}
-/**
-* Parses an unknown input based on a schema.
-*
-* @param schema The schema to be used.
-* @param input The input to be parsed.
-* @param config The parse configuration.
-*
-* @returns The parsed input.
-*/
-function parse(schema, input, config$1) {
-	const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
-	if (dataset.issues) throw new ValiError(dataset.issues);
-	return dataset.value;
-}
-/* @__NO_SIDE_EFFECTS__ */
-function pipe(...pipe$1) {
-	return {
-		...pipe$1[0],
-		pipe: pipe$1,
-		get "~standard"() {
-			return /* @__PURE__ */ _getStandardProps(this);
-		},
-		"~run"(dataset, config$1) {
-			for (const item of pipe$1) if (item.kind !== "metadata") {
-				if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
-					dataset.typed = false;
-					break;
-				}
-				if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly) dataset = item["~run"](dataset, config$1);
-			}
-			return dataset;
-		}
-	};
-}
-
-//#endregion
-//#region lib/cli/utils/errors.ts
-var UnsupportedError = class extends Error {
-	constructor(reasons) {
-		super();
-		this.name = "Unsupported Environment";
-		this.reasons = [];
-		this.reasons = reasons;
-	}
-};
-
-//#endregion
-//#region lib/cli/utils/common.ts
-const NO_PREFIX = "--no-";
-let options = [];
-function getLongFlag(flags) {
-	return flags.split(",").map((f) => f.trim()).find((f) => f.startsWith("--"));
-}
-const helpConfig = {
-	argumentDescription: formatDescription,
-	optionDescription: formatDescription,
-	visibleOptions(cmd) {
-		options = cmd.options;
-		const visible = cmd.options.filter((o) => !o.hidden);
-		const show = [];
-		for (const option of visible) {
-			const flag = getLongFlag(option.flags);
-			if (flag?.startsWith(NO_PREFIX)) {
-				const stripped = flag.slice(5);
-				if (visible.some((o) => getLongFlag(o.flags)?.startsWith(`--${stripped}`))) continue;
-			}
-			show.push(option);
-		}
-		return show;
-	},
-	optionTerm(option) {
-		const longFlag = getLongFlag(option.flags);
-		const flag = longFlag?.split(" ").at(0);
-		if (!flag || !longFlag) return option.flags;
-		const noVariant = `--no-${flag.slice(2)}`;
-		if (options.some((o) => getLongFlag(o.flags) === noVariant)) return `--[no-]${longFlag.slice(2)}`;
-		return option.flags;
-	},
-	styleTitle: (str) => import_picocolors$3.default.underline(str),
-	styleCommandText: (str) => import_picocolors$3.default.red(str),
-	styleDescriptionText: (str) => import_picocolors$3.default.gray(str),
-	styleOptionText: (str) => import_picocolors$3.default.white(str),
-	styleArgumentText: (str) => import_picocolors$3.default.white(str),
-	styleSubcommandText: (str) => import_picocolors$3.default.red(str)
-};
-function formatDescription(arg) {
-	let output = arg.description;
-	if (arg.defaultValue !== void 0 && String(arg.defaultValue)) output += import_picocolors$3.default.dim(` (default: ${JSON.stringify(arg.defaultValue)})`);
-	if (arg.argChoices !== void 0 && String(arg.argChoices)) output += import_picocolors$3.default.dim(` (choices: ${arg.argChoices.join(", ")})`);
-	return output;
-}
-async function runCommand(action) {
-	try {
-		Ge(`Welcome to the Svelte CLI! ${import_picocolors$3.default.gray(`(v${version})`)}`);
-		const minimumVersion = "18.3.0";
-		if (isVersionUnsupportedBelow(process.versions.node, minimumVersion)) T.warn(`You are using Node.js ${import_picocolors$3.default.red(process.versions.node)}, please upgrade to Node.js ${import_picocolors$3.default.green(minimumVersion)} or higher.`);
-		await action();
-		Fe("You're all set!");
-	} catch (e) {
-		if (e instanceof UnsupportedError) {
-			const padding = getPadding(e.reasons.map((r) => r.id));
-			const message = e.reasons.map((r) => `  ${r.id.padEnd(padding)}  ${import_picocolors$3.default.red(r.reason)}`).join("\n");
-			T.error(`${e.name}\n\n${message}`);
-			T.message();
-		} else if (e instanceof Error) {
-			T.error(e.stack ?? String(e));
-			T.message();
-		}
-		De("Operation failed.");
-	}
-}
-function getPadding(lines) {
-	const lengths = lines.map((s) => s.length);
-	return Math.max(...lengths);
-}
-function forwardExitCode(error) {
-	if (error && typeof error === "object" && "status" in error && typeof error.status === "number") process.exit(error.status);
-	else process.exit(1);
-}
-function parseAddonOptions(optionFlags) {
-	if (optionFlags === void 0 || optionFlags === "") return;
-	const options$1 = optionFlags.split("+");
-	const malformed = options$1.filter((option) => !/.+:.*/.test(option));
-	if (malformed.length > 0) {
-		const message = `Malformed arguments: The following add-on options: ${malformed.map((o) => `'${o}'`).join(", ")} are missing their option name or value (e.g. 'addon=option1:value1+option2:value2').`;
-		throw new Error(message);
-	}
-	return options$1;
-}
-function logArgs(agent, command, args, lastArgs = []) {
-	const allArgs = [
-		"sv",
-		command,
-		...args
-	];
-	if (agent === null || agent === void 0) allArgs.push("--no-install");
-	else allArgs.push("--install", agent);
-	const res = resolveCommand(agent ?? "npm", "execute", [...allArgs, ...lastArgs]);
-	T.message(import_picocolors$3.default.dim([res.command, ...res.args].join(" ")));
-}
-function errorAndExit(message) {
-	T.error(message);
-	De("Operation failed.");
-	process.exit(1);
-}
-
-//#endregion
-//#region lib/cli/add/verifiers.ts
-function verifyCleanWorkingDirectory(cwd$1, gitCheck) {
-	const verifications = [];
-	if (gitCheck) verifications.push({
-		name: "clean working directory",
-		run: async () => {
-			try {
-				const { stdout: stdout$1 } = await promisify(exec)("git status --short", { cwd: cwd$1 });
-				if (stdout$1) return {
-					success: false,
-					message: "Found modified files"
-				};
-				return {
-					success: true,
-					message: void 0
-				};
-			} catch {
-				return {
-					success: true,
-					message: "Not a git repository"
-				};
-			}
-		}
-	});
-	return verifications;
-}
-function verifyUnsupportedAddons(addons, addonSetupResult) {
-	const verifications = [];
-	verifications.push({
-		name: "unsupported add-ons",
-		run: () => {
-			const reasons = addons.flatMap((a) => addonSetupResult[a.id].unsupported.map((reason) => ({
-				id: a.id,
-				reason
-			})));
-			if (reasons.length === 0) return {
-				success: true,
-				message: void 0
-			};
-			throw new UnsupportedError(reasons);
-		}
-	});
-	return verifications;
-}
-
-//#endregion
-//#region lib/cli/add/fetch-packages.ts
-const NODE_MODULES = fileURLToPath(new URL("../node_modules", import.meta.url));
-const REGISTRY = "https://registry.npmjs.org";
-const Directive = {
-	file: "file:",
-	npm: "npm:"
-};
-function verifyPackage(pkg, specifier) {
-	const deps = {
-		...pkg.dependencies,
-		...pkg.peerDependencies
-	};
-	if (!deps["sv"]) throw new Error(`Invalid add-on package specified: '${specifier}' is missing a dependency on 'sv' in its 'package.json'`);
-	for (const dep of Object.keys(deps)) {
-		if (dep === "sv") continue;
-		throw new Error(`Invalid add-on package detected: '${specifier}'\nCommunity addons should not have any external 'dependencies' besides 'sv'. Consider bundling your dependencies if they are necessary`);
-	}
-}
-/**
-* Downloads and installs the package into the `node_modules` of `sv`.
-* @returns the details of the downloaded addon
-*/
-async function downloadPackage(options$1) {
-	const { pkg } = options$1;
-	if (options$1.path) {
-		const dest = path.join(NODE_MODULES, pkg.name.split("/").join(path.sep));
-		if (fs.existsSync(dest)) fs.rmSync(dest);
-		const dir = path.dirname(dest);
-		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-		fs.symlinkSync(options$1.path, dest);
-		const { default: details$1 } = await import(pkg.name);
-		return details$1;
-	}
-	const tarballUrl = pkg.dist.tarball;
-	const data = await fetch(tarballUrl);
-	if (!data.body) throw new Error(`Unexpected response: '${tarballUrl}' responded with no body`);
-	await pipeline(data.body, createGunzip());
-	const { default: details } = await import(pkg.name);
-	return details;
-}
-async function getPackageJSON({ cwd: cwd$1, packageName }) {
-	let npm = packageName;
-	if (packageName.startsWith(Directive.file)) {
-		const pkgPath = path.resolve(cwd$1, packageName.slice(Directive.file.length));
-		const pkgJSONPath = path.resolve(pkgPath, "package.json");
-		const json = fs.readFileSync(pkgJSONPath, "utf8");
-		const pkg$1 = JSON.parse(json);
-		verifyPackage(pkg$1, packageName);
-		return {
-			path: pkgPath,
-			pkg: pkg$1,
-			repo: pkgPath
-		};
-	}
-	if (packageName.startsWith(Directive.npm)) npm = packageName.slice(Directive.npm.length);
-	const pkg = await fetchPackageJSON(npm);
-	verifyPackage(pkg, packageName);
-	return {
-		pkg,
-		repo: pkg.repository?.url ?? `https://www.npmjs.com/package/${npm}`
-	};
-}
-async function fetchPackageJSON(packageName) {
-	let pkgName = packageName;
-	let scope = "";
-	if (packageName.startsWith("@")) {
-		const [org, name$2] = pkgName.split("/", 2);
-		scope = `${org}/`;
-		pkgName = name$2;
-	}
-	const [name$1, tag = "latest"] = pkgName.split("@");
-	const pkgUrl = `${REGISTRY}/${scope + name$1}/${tag}`;
-	const resp = await fetch(pkgUrl);
-	if (resp.status === 404) throw new Error(`Package '${packageName}' doesn't exist in the registry: '${pkgUrl}'`);
-	if (resp.status < 200 && resp.status >= 300) throw new Error(`Failed to fetch '${pkgUrl}' - GET ${resp.status}`);
-	return await resp.json();
-}
-
-//#endregion
-//#region lib/cli/add/index.ts
-var import_picocolors$2 = /* @__PURE__ */ __toESM(require_picocolors(), 1);
-const officialAddons$1 = Object.values(officialAddons);
-const aliases = officialAddons$1.map((c) => c.alias).filter((v) => v !== void 0);
-const addonOptions = getAddonOptionFlags();
-const communityDetails = [];
-const AddonsSchema = array(string());
-const OptionsSchema$1 = strictObject({
-	cwd: string(),
-	install: union([boolean(), picklist(AGENT_NAMES)]),
-	gitCheck: boolean(),
-	community: optional(union([AddonsSchema, boolean()])),
-	addons: record(string(), optional(array(string())))
-});
-const defaultPkgPath = up();
-const defaultCwd = defaultPkgPath ? path.dirname(defaultPkgPath) : void 0;
-const add = new Command("add").description("applies specified add-ons into a project").argument("[add-on...]", `add-ons to install`, (value, previous = []) => addonArgsHandler(previous, value)).option("-C, --cwd <path>", "path to working directory", defaultCwd).option("--no-git-check", "even if some files are dirty, no prompt will be shown").option("--no-install", "skip installing dependencies").addOption(installOption).configureHelp({
-	...helpConfig,
-	formatHelp(cmd, helper) {
-		const termWidth = helper.padWidth(cmd, helper);
-		const helpWidth = helper.helpWidth ?? 80;
-		function callFormatItem(term, description) {
-			return helper.formatItem(term, termWidth, description, helper);
-		}
-		let output = [`${helper.styleTitle("Usage:")} ${helper.styleUsage(helper.commandUsage(cmd))}`, ""];
-		const commandDescription = helper.commandDescription(cmd);
-		if (commandDescription.length > 0) output = output.concat([helper.boxWrap(helper.styleCommandDescription(commandDescription), helpWidth), ""]);
-		const argumentList = helper.visibleArguments(cmd).map((argument) => {
-			return callFormatItem(helper.styleArgumentTerm(helper.argumentTerm(argument)), helper.styleArgumentDescription(helper.argumentDescription(argument)));
-		});
-		if (argumentList.length > 0) output = output.concat([
-			helper.styleTitle("Arguments:"),
-			...argumentList,
-			""
-		]);
-		const addonList = addonOptions.map((option) => {
-			const description = option.choices;
-			return callFormatItem(helper.styleArgumentTerm(option.id), helper.styleArgumentDescription(description));
-		});
-		if (addonList.length > 0) output = output.concat([
-			helper.styleTitle("Add-On Options:"),
-			...addonList,
-			""
-		]);
-		const optionList = helper.visibleOptions(cmd).map((option) => {
-			return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
-		});
-		if (optionList.length > 0) output = output.concat([
-			helper.styleTitle("Options:"),
-			...optionList,
-			""
-		]);
-		if (helper.showGlobalOptions) {
-			const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
-				return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
-			});
-			if (globalOptionList.length > 0) output = output.concat([
-				helper.styleTitle("Global Options:"),
-				...globalOptionList,
-				""
-			]);
-		}
-		const commandList = helper.visibleCommands(cmd).map((cmd$1) => {
-			return callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(cmd$1)), helper.styleSubcommandDescription(helper.subcommandDescription(cmd$1)));
-		});
-		if (commandList.length > 0) output = output.concat([
-			helper.styleTitle("Commands:"),
-			...commandList,
-			""
-		]);
-		return output.join("\n");
-	}
-}).action(async (addonArgs, opts) => {
-	if (opts.cwd === void 0) errorAndExit("Invalid workspace: Please verify that you are inside of a Svelte project. You can also specify the working directory with `--cwd <path>`");
-	else if (!fs.existsSync(path.resolve(opts.cwd, "package.json"))) errorAndExit(`Invalid workspace: Path '${path.resolve(opts.cwd)}' is not a valid workspace.`);
-	const selectedAddonArgs = sanitizeAddons(addonArgs);
-	const options$1 = parse(OptionsSchema$1, {
-		...opts,
-		addons: {}
-	});
-	selectedAddonArgs.forEach((addon) => options$1.addons[addon.id] = addon.options);
-	const workspace = await createWorkspace({ cwd: options$1.cwd });
-	runCommand(async () => {
-		const { answersCommunity, answersOfficial, selectedAddons } = await promptAddonQuestions({
-			options: options$1,
-			selectedAddonIds: selectedAddonArgs.map(({ id }) => id),
-			workspace
-		});
-		const { nextSteps } = await runAddonsApply({
-			answersOfficial,
-			answersCommunity,
-			options: options$1,
-			selectedAddons,
-			workspace,
-			fromCommand: "add"
-		});
-		if (nextSteps.length > 0) Ke(nextSteps.join("\n"), "Next steps", { format: (line) => line });
-	});
+//#region lib/cli/check.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+const check = new Command("check").description("a CLI for checking your Svelte code").allowUnknownOption(true).allowExcessArguments(true).option("-C, --cwd <path>", "path to working directory", process.cwd()).configureHelp({ formatHelp() {
+	runCheck(process.cwd(), ["--help"]);
+	return "";
+} }).action((options, check$1) => {
+	const cwd$1 = options.cwd;
+	const args = check$1.args;
+	runCheck(cwd$1, args);
 });
-async function promptAddonQuestions({ options: options$1, selectedAddonIds, workspace }) {
-	const selectedOfficialAddons = [];
-	selectedAddonIds.map((id) => {
-		if (officialAddons$1.find((a) => a.id === id)) selectedOfficialAddons.push(getAddonDetails(id));
-	});
-	const emptyAnswersReducer = (acc, id) => {
-		acc[id] = {};
-		return acc;
-	};
-	const answersOfficial = selectedOfficialAddons.map(({ id }) => id).reduce(emptyAnswersReducer, {});
-	for (const addonOption of addonOptions) {
-		const addonId = addonOption.id;
-		const specifiedOptions = options$1.addons[addonId];
-		if (!specifiedOptions) continue;
-		const details = getAddonDetails(addonId);
-		if (!selectedOfficialAddons.find((d) => d === details)) selectedOfficialAddons.push(details);
-		answersOfficial[addonId] ??= {};
-		const optionEntries = Object.entries(details.options);
-		const specifiedOptionsObject = Object.fromEntries(specifiedOptions.map((option) => option.split(":", 2)));
-		for (const option of specifiedOptions) {
-			const [optionId, optionValue] = option.split(":", 2);
-			const optionEntry = optionEntries.find(([id, question$1]) => {
-				if (id === optionId) return true;
-				if (question$1.group === optionId) {
-					if (question$1.type === "select") {
-						if (!question$1.options.some((opt) => opt.value === optionValue)) return false;
-					} else if (question$1.type === "multiselect") {
-						if (!(optionValue === "none" ? [] : optionValue.split(",")).every((val) => question$1.options.some((opt) => opt.value === val.trim()))) return false;
-					}
-					if (question$1.condition) return question$1.condition(specifiedOptionsObject);
-					return true;
-				}
-				return false;
-			});
-			if (!optionEntry) {
-				const { choices } = getOptionChoices(details);
-				errorAndExit(`Invalid '${addonId}' add-on option: '${option}'\nAvailable options: ${choices.join(", ")}`);
-				throw new Error();
-			}
-			const [questionId, question] = optionEntry;
-			if (question.type === "multiselect" && questionId === optionId) {
-				const invalidValues = (optionValue === "none" || optionValue === "" ? [] : optionValue.split(",")).filter((val) => !question.options.some((opt) => opt.value === val.trim()));
-				if (invalidValues.length > 0) {
-					const validValues = question.options.map((opt) => opt.value).join(", ");
-					errorAndExit(`Invalid '${addonId}' add-on option: '${option}'\nInvalid values: ${invalidValues.join(", ")}\nAvailable values: ${validValues}`);
-				}
-			}
-			let existingOption = answersOfficial[addonId][questionId];
-			if (existingOption !== void 0) {
-				if (typeof existingOption === "boolean") existingOption = existingOption ? "yes" : "no";
-				errorAndExit(`Conflicting '${addonId}' option: '${option}' conflicts with '${questionId}:${existingOption}'`);
-			}
-			if (question.type === "boolean") answersOfficial[addonId][questionId] = optionValue === "yes";
-			else if (question.type === "number") answersOfficial[addonId][questionId] = Number(optionValue);
-			else if (question.type === "multiselect") if (optionValue === "none" || optionValue === "") answersOfficial[addonId][questionId] = [];
-			else answersOfficial[addonId][questionId] = optionValue.split(",").map((v) => v.trim());
-			else answersOfficial[addonId][questionId] = optionValue;
-		}
-		for (const [id, question] of Object.entries(details.options)) if (question.condition?.(answersOfficial[addonId]) !== false) answersOfficial[addonId][id] ??= question.default;
-		else if (answersOfficial[addonId][id] !== void 0) throw new Error(`Incompatible '${addonId}' option specified: '${answersOfficial[addonId][id]}'`);
-	}
-	if (options$1.community === true) {
-		const promptOptions = (await Promise.all(communityAddonIds.map(async (id) => await getCommunityAddon(id)))).map((addon) => ({
-			value: addon.id,
-			label: addon.id,
-			hint: "https://www.npmjs.com/package/" + addon.id
-		}));
-		const selected = await Ue({
-			message: "Which community tools would you like to add to your project?",
-			options: promptOptions,
-			required: false
-		});
-		if (Vu(selected)) {
-			De("Operation cancelled.");
-			process.exit(1);
-		} else if (selected.length === 0) {
-			De("No add-ons selected. Exiting.");
-			process.exit(1);
-		}
-		options$1.community = selected;
-	}
-	const selectedCommunityAddons = [];
-	const answersCommunity = selectedCommunityAddons.map(({ id }) => id).reduce(emptyAnswersReducer, {});
-	if (Array.isArray(options$1.community) && options$1.community.length > 0) selectedCommunityAddons.push(...await resolveCommunityAddons(options$1.cwd, options$1.community));
-	const selectedAddons = [...selectedOfficialAddons.map((addon) => ({
-		type: "official",
-		addon
-	})), ...selectedCommunityAddons.map((addon) => ({
-		type: "community",
-		addon
-	}))];
-	const addonSetupResults = setupAddons(selectedAddons.length ? selectedAddons.map(({ addon }) => addon) : officialAddons$1, workspace);
-	if (selectedAddons.length === 0) {
-		const allSetupResults = setupAddons(officialAddons$1, workspace);
-		const addonOptions$1 = officialAddons$1.filter(({ id }) => allSetupResults[id].unsupported.length === 0).map(({ id, homepage, shortDescription }) => ({
-			label: id,
-			value: id,
-			hint: `${shortDescription} - ${homepage}`
-		}));
-		const selected = await Ue({
-			message: `What would you like to add to your project? ${import_picocolors$2.default.dim("(use arrow keys / space bar)")}`,
-			options: addonOptions$1,
-			required: false
-		});
-		if (Vu(selected)) {
-			De("Operation cancelled.");
-			process.exit(1);
-		}
-		for (const id of selected) {
-			const addon = getAddonDetails(id);
-			selectedAddons.push({
-				type: "official",
-				addon
-			});
-		}
-	}
-	for (const { addon } of selectedAddons) {
-		const missingDependencies = addonSetupResults[addon.id].dependsOn.filter((depId) => !selectedAddons.some((a) => a.addon.id === depId));
-		for (const depId of missingDependencies) {
-			const dependency = officialAddons$1.find((a) => a.id === depId);
-			if (!dependency) throw new Error(`'${addon.id}' depends on an invalid add-on: '${depId}'`);
-			if (await ke({ message: `The ${import_picocolors$2.default.bold(import_picocolors$2.default.cyan(addon.id))} add-on requires ${import_picocolors$2.default.bold(import_picocolors$2.default.cyan(depId))} to also be setup. ${import_picocolors$2.default.green("Include it?")}` }) !== true) {
-				De("Operation cancelled.");
-				process.exit(1);
-			}
-			selectedAddons.push({
-				type: "official",
-				addon: dependency
-			});
-		}
-	}
-	const addons = selectedAddons.map(({ addon }) => addon);
-	const verifications = [...verifyCleanWorkingDirectory(options$1.cwd, options$1.gitCheck), ...verifyUnsupportedAddons(addons, addonSetupResults)];
-	const fails = [];
-	for (const verification of verifications) {
-		const { message, success } = await verification.run();
-		if (!success) fails.push({
-			name: verification.name,
-			message
-		});
-	}
-	if (fails.length > 0) {
-		const message = fails.map(({ name: name$1, message: message$1 }) => import_picocolors$2.default.yellow(`${name$1} (${message$1})`)).join("\n- ");
-		Ke(`- ${message}`, "Verifications not met", { format: (line) => line });
-		const force = await ke({
-			message: "Verifications failed. Do you wish to continue?",
-			initialValue: false
-		});
-		if (Vu(force) || !force) {
-			De("Operation cancelled.");
-			process.exit(1);
-		}
-	}
-	for (const { addon, type } of selectedAddons) {
-		const addonId = addon.id;
-		const questionPrefix = selectedAddons.length > 1 ? `${addon.id}: ` : "";
-		let values = {};
-		if (type === "official") {
-			answersOfficial[addonId] ??= {};
-			values = answersOfficial[addonId];
-		}
-		if (type === "community") {
-			answersCommunity[addonId] ??= {};
-			values = answersCommunity[addonId];
-		}
-		for (const [questionId, question] of Object.entries(addon.options)) {
-			if (question.condition?.(values) === false || values[questionId] !== void 0) continue;
-			let answer;
-			const message = questionPrefix + question.question;
-			if (question.type === "boolean") answer = await ke({
-				message,
-				initialValue: question.default
-			});
-			if (question.type === "select") answer = await ze({
-				message,
-				initialValue: question.default,
-				options: question.options
-			});
-			if (question.type === "multiselect") answer = await Ue({
-				message,
-				initialValues: question.default,
-				required: question.required,
-				options: question.options
-			});
-			if (question.type === "string" || question.type === "number") {
-				answer = await et({
-					message,
-					initialValue: question.default.toString(),
-					placeholder: question.placeholder,
-					validate: question.validate
-				});
-				if (question.type === "number") answer = Number(answer);
-			}
-			if (Vu(answer)) {
-				De("Operation cancelled.");
-				process.exit(1);
-			}
-			values[questionId] = answer;
-		}
-	}
-	return {
-		selectedAddons,
-		answersOfficial,
-		answersCommunity
-	};
-}
-async function runAddonsApply({ answersOfficial, answersCommunity, options: options$1, selectedAddons, addonSetupResults, workspace, fromCommand }) {
-	if (!addonSetupResults) addonSetupResults = setupAddons(selectedAddons.length ? selectedAddons.map(({ addon }) => addon) : officialAddons$1, workspace);
-	if (selectedAddons.length === 0) return {
-		nextSteps: [],
-		argsFormattedAddons: [],
-		filesToFormat: []
-	};
-	const officialDetails = Object.keys(answersOfficial).map((id) => getAddonDetails(id));
-	const commDetails = Object.keys(answersCommunity).map((id) => communityDetails.find((a) => a.id === id));
-	const details = officialDetails.concat(commDetails);
-	const addonMap = Object.assign({}, ...details.map((a) => ({ [a.id]: a })));
-	const { filesToFormat, pnpmBuildDependencies, status } = await applyAddons({
-		workspace,
-		addonSetupResults,
-		addons: addonMap,
-		options: answersOfficial
-	});
-	const addonSuccess = [];
-	for (const [addonId, info] of Object.entries(status)) if (info === "success") addonSuccess.push(addonId);
-	else {
-		T.warn(`Canceled ${addonId}: ${info.join(", ")}`);
-		selectedAddons = selectedAddons.filter((a) => a.addon.id !== addonId);
-	}
-	if (addonSuccess.length === 0) {
-		De("All selected add-ons were canceled.");
+function runCheck(cwd$1, args) {
+	const pm = getUserAgent() ?? "npm";
+	if (!from(cwd$1, "svelte-check", true)) {
+		const cmd = resolveCommand(pm, "add", ["-D", "svelte-check"]);
+		console.error(`'svelte-check' is not installed locally. Install it with: ${import_picocolors.default.bold(`${cmd.command} ${cmd.args.join(" ")}`)}`);
 		process.exit(1);
-	} else {
-		const highlighter$1 = getHighlighter();
-		T.success(`Successfully setup add-ons: ${addonSuccess.map((c) => highlighter$1.addon(c)).join(", ")}`);
-	}
-	const packageManager = options$1.install === false ? null : options$1.install === true ? await packageManagerPrompt(options$1.cwd) : options$1.install;
-	await addPnpmBuildDependencies(workspace.cwd, packageManager, ["esbuild", ...pnpmBuildDependencies]);
-	const argsFormattedAddons = [];
-	for (const { addon, type } of selectedAddons) {
-		const addonId = addon.id;
-		const answers = type === "official" ? answersOfficial[addonId] : answersCommunity[addonId];
-		if (!answers) continue;
-		const addonDetails = type === "official" ? getAddonDetails(addonId) : addon;
-		const optionParts = [];
-		for (const [optionId, value] of Object.entries(answers)) {
-			if (value === void 0) continue;
-			const question = addonDetails.options[optionId];
-			if (!question) continue;
-			let formattedValue;
-			if (question.type === "boolean") formattedValue = value ? "yes" : "no";
-			else if (question.type === "number") formattedValue = String(value);
-			else if (question.type === "multiselect") if (Array.isArray(value)) if (value.length === 0) formattedValue = "none";
-			else formattedValue = value.join(",");
-			else formattedValue = String(value);
-			else formattedValue = String(value);
-			optionParts.push(`${optionId}:${formattedValue}`);
-		}
-		if (optionParts.length > 0) argsFormattedAddons.push(`${addonId}="${optionParts.join("+")}"`);
-		else argsFormattedAddons.push(addonId);
-	}
-	if (fromCommand === "add") logArgs(packageManager, "add", argsFormattedAddons);
-	if (packageManager) {
-		workspace.packageManager = packageManager;
-		await installDependencies(packageManager, options$1.cwd);
-		await formatFiles({
-			packageManager,
-			cwd: options$1.cwd,
-			filesToFormat
-		});
 	}
-	const highlighter = getHighlighter();
-	return {
-		nextSteps: selectedAddons.map(({ addon }) => {
-			if (!addon.nextSteps) return;
-			const addonOptions$1 = answersOfficial[addon.id];
-			const addonNextSteps = addon.nextSteps({
-				...workspace,
-				options: addonOptions$1,
-				highlighter
-			});
-			if (addonNextSteps.length === 0) return;
-			let addonMessage = `${import_picocolors$2.default.green(addon.id)}:\n`;
-			addonMessage += `  - ${addonNextSteps.join("\n  - ")}`;
-			return addonMessage;
-		}).filter((msg) => msg !== void 0),
-		argsFormattedAddons,
-		filesToFormat
-	};
-}
-/**
-* Sanitizes the add-on arguments by checking for invalid add-ons and transforming aliases.
-* @param addonArgs The add-on arguments to sanitize.
-* @returns The sanitized add-on arguments.
-*/
-function sanitizeAddons(addonArgs) {
-	const officialAddonIds = officialAddons$1.map((addon) => addon.id);
-	const invalidAddons = addonArgs.filter(({ id }) => !officialAddonIds.includes(id) && !aliases.includes(id)).map(({ id }) => id);
-	if (invalidAddons.length > 0) errorAndExit(`Invalid add-ons specified: ${invalidAddons.join(", ")}`);
-	return transformAliases(addonArgs);
-}
-/**
-* Handles passed add-on arguments, accumulating them into an array of {@link AddonArgs}.
-*/
-function addonArgsHandler(acc, current) {
-	const [addonId, optionFlags] = current.split("=", 2);
-	if (acc.find(({ id }) => id === addonId)) errorAndExit(`Malformed arguments: Add-on '${addonId}' is repeated multiple times.`);
 	try {
-		const options$1 = parseAddonOptions(optionFlags);
-		acc.push({
-			id: addonId,
-			options: options$1
+		const cmd = resolveCommand(pm, "execute-local", ["svelte-check", ...args]);
+		execSync(`${cmd.command} ${cmd.args.join(" ")}`, {
+			stdio: "inherit",
+			cwd: cwd$1
 		});
 	} catch (error) {
-		if (error instanceof Error) errorAndExit(error.message);
-		console.error(error);
-		process.exit(1);
-	}
-	return acc;
-}
-/**
-* Dedupes and transforms aliases into their respective addon id
-*/
-function transformAliases(addons) {
-	const set = /* @__PURE__ */ new Map();
-	for (const addon of addons) if (aliases.includes(addon.id)) {
-		const officialAddon = officialAddons$1.find((a) => a.alias === addon.id);
-		set.set(officialAddon.id, {
-			id: officialAddon.id,
-			options: addon.options
-		});
-	} else set.set(addon.id, addon);
-	return Array.from(set.values());
-}
-function getAddonOptionFlags() {
-	const options$1 = [];
-	for (const addon of officialAddons$1) {
-		const id = addon.id;
-		const details = getAddonDetails(id);
-		if (Object.values(details.options).length === 0) continue;
-		const { defaults, groups } = getOptionChoices(details);
-		const choices = Object.entries(groups).map(([group, choices$1]) => `${import_picocolors$2.default.dim(`${group}:`)} ${choices$1.join(", ")}`).join("\n");
-		const preset = defaults.join(", ") || "none";
-		options$1.push({
-			id,
-			choices,
-			preset
-		});
-	}
-	return options$1;
-}
-function getOptionChoices(details) {
-	const choices = [];
-	const defaults = [];
-	const groups = {};
-	const options$1 = {};
-	for (const [id, question] of Object.entries(details.options)) {
-		let values = [];
-		const applyDefault = question.condition?.(options$1) !== false;
-		if (question.type === "boolean") {
-			values = ["yes", `no`];
-			if (applyDefault) {
-				options$1[id] = question.default;
-				defaults.push(question.default ? values[0] : values[1]);
-			}
-		}
-		if (question.type === "select") {
-			values = question.options.map((o) => o.value);
-			if (applyDefault) {
-				options$1[id] = question.default;
-				defaults.push(question.default);
-			}
-		}
-		if (question.type === "multiselect") {
-			values = question.options.map((o) => o.value);
-			if (applyDefault) {
-				options$1[id] = question.default;
-				defaults.push(...question.default);
-			}
-		}
-		if (question.type === "string" || question.type === "number") {
-			values = ["<user-input>"];
-			if (applyDefault) {
-				options$1[id] = question.default;
-				defaults.push(question.default.toString());
-			}
-		}
-		choices.push(...values);
-		const groupId = question.group ?? id;
-		groups[groupId] ??= [];
-		groups[groupId].push(...values);
-	}
-	return {
-		choices,
-		defaults,
-		groups
-	};
-}
-async function resolveCommunityAddons(cwd$1, community) {
-	const selectedAddons = [];
-	const addons = community.map((id) => {
-		if (Object.values(Directive).some((directive) => id.startsWith(directive))) return id;
-		if (!communityAddonIds.includes(id)) throw new Error(`Invalid community add-on specified: '${id}'\nAvailable options: ${communityAddonIds.join(", ")}`);
-		return id;
-	});
-	const { start, stop } = J();
-	try {
-		start("Resolving community add-on packages");
-		const pkgs = await Promise.all(addons.map(async (id) => {
-			return await getPackageJSON({
-				cwd: cwd$1,
-				packageName: id
-			});
-		}));
-		stop("Resolved community add-on packages");
-		T.warn("The Svelte maintainers have not reviewed community add-ons for malicious code. Use at your discretion.");
-		const paddingName = getPadding(pkgs.map(({ pkg }) => pkg.name));
-		const paddingVersion = getPadding(pkgs.map(({ pkg }) => `(v${pkg.version})`));
-		const packageInfos = pkgs.map(({ pkg, repo: _repo }) => {
-			return `${import_picocolors$2.default.yellowBright(pkg.name.padEnd(paddingName))} ${import_picocolors$2.default.dim(`(v${pkg.version})`.padEnd(paddingVersion))} ${import_picocolors$2.default.dim(`(${_repo})`)}`;
-		});
-		T.message(packageInfos.join("\n"));
-		if (await ke({ message: "Would you like to continue?" }) !== true) {
-			De("Operation cancelled.");
-			process.exit(1);
-		}
-		start("Downloading community add-on packages");
-		const details = await Promise.all(pkgs.map(async (opts) => downloadPackage(opts)));
-		for (const addon of details) {
-			communityDetails.push(addon);
-			selectedAddons.push(addon);
-		}
-		stop("Downloaded community add-on packages");
-	} catch (err) {
-		stop("Failed to resolve community add-on packages", 1);
-		throw err;
-	}
-	return selectedAddons;
-}
-
-//#endregion
-//#region lib/create/playground.ts
-function validatePlaygroundUrl(link) {
-	try {
-		const url = new URL(link);
-		if (url.hostname !== "svelte.dev" || !url.pathname.startsWith("/playground/")) return false;
-		const { playgroundId, hash } = parsePlaygroundUrl(link);
-		return playgroundId !== void 0 || hash !== void 0;
-	} catch {
-		return false;
-	}
-}
-function parsePlaygroundUrl(link) {
-	const url = new URL(link);
-	const [, playgroundId] = url.pathname.match(/\/playground\/([^/]+)/) || [];
-	return {
-		playgroundId,
-		hash: url.hash !== "" ? url.hash.slice(1) : void 0,
-		svelteVersion: url.searchParams.get("version") || void 0
-	};
-}
-async function downloadPlaygroundData({ playgroundId, hash, svelteVersion }) {
-	let data = [];
-	if (hash) data = JSON.parse(await decodeAndDecompressText(hash));
-	else data = await (await fetch(`https://svelte.dev/playground/api/${playgroundId}.json`)).json();
-	const files = data.components !== void 0 ? data.components : data.files;
-	return {
-		name: data.name,
-		files: files.map((file) => {
-			return {
-				name: file.name + (file.type !== "file" ? `.${file.type}` : ""),
-				content: file.source || file.contents
-			};
-		}),
-		svelteVersion
-	};
-}
-async function decodeAndDecompressText(input) {
-	const decoded = atob(input.replaceAll("-", "+").replaceAll("_", "/"));
-	const u8 = new Uint8Array(decoded.length);
-	for (let i = 0; i < decoded.length; i++) u8[i] = decoded.charCodeAt(i);
-	const stream = new Blob([u8]).stream().pipeThrough(new DecompressionStream("gzip"));
-	return new Response(stream).text();
-}
-/**
-* @returns A Map of packages with it's name as the key, and it's version as the value.
-*/
-function detectPlaygroundDependencies(files) {
-	const packages = /* @__PURE__ */ new Map();
-	const excludedPrefixes = [
-		"$",
-		"node:",
-		"svelte",
-		"@sveltejs/"
-	];
-	for (const file of files) {
-		let ast;
-		if (file.name.endsWith(".svelte")) {
-			const { ast: svelteAst } = parseSvelte(file.content);
-			ast = ensureScript(svelteAst);
-		} else if (file.name.endsWith(".js") || file.name.endsWith(".ts")) ast = parseScript(file.content).ast;
-		if (!ast) continue;
-		ast.body.filter((node) => node.type === "ImportDeclaration").map((node) => node.source.value).filter((importPath) => !importPath.startsWith("./") && !importPath.startsWith("/")).filter((importPath) => !excludedPrefixes.some((prefix) => importPath.startsWith(prefix))).map(extractPackageInfo).forEach(({ pkgName, version: version$1 }) => packages.set(pkgName, version$1));
-	}
-	return packages;
-}
-/**
-* Extracts a package's name and it's versions from a provided import path.
-*
-* Handles imports with or without subpaths (e.g. `pkg-name/subpath`, `@org/pkg-name/subpath`)
-* as well as specified versions (e.g. pkg-name@1.2.3).
-*/
-function extractPackageInfo(importPath) {
-	let pkgName = "";
-	if (importPath.startsWith("@")) {
-		const [org, pkg, _subpath] = importPath.split("/", 3);
-		pkgName = `${org}/${pkg}`;
-	}
-	if (!pkgName) [pkgName] = importPath.split("/", 2);
-	const version$1 = extractPackageVersion(pkgName);
-	if (version$1 !== "latest") pkgName = pkgName.replace(`@${version$1}`, "");
-	return {
-		pkgName,
-		version: version$1
-	};
-}
-function extractPackageVersion(pkgName) {
-	let version$1 = "latest";
-	if (pkgName.includes("@", 1)) [, version$1] = pkgName.split("@");
-	return version$1;
-}
-function setupPlaygroundProject(url, playground, cwd$1, installDependencies$1) {
-	const mainFile = playground.files.find((file) => file.name === "App.svelte");
-	if (!mainFile) throw new Error("Failed to find `App.svelte` entrypoint.");
-	const dependencies = detectPlaygroundDependencies(playground.files);
-	for (const file of playground.files) {
-		for (const [pkg, version$1] of dependencies) if (version$1 !== "latest") file.content = file.content.replaceAll(`${pkg}@${version$1}`, pkg);
-		const filePath$1 = path.join(cwd$1, "src", "lib", "playground", file.name);
-		fs.mkdirSync(path.dirname(filePath$1), { recursive: true });
-		fs.writeFileSync(filePath$1, file.content, "utf8");
-	}
-	{
-		const playgroundFiles = getSharedFiles().filter((file) => file.include.includes("playground"));
-		for (const file of playgroundFiles) {
-			let contentToWrite = file.contents;
-			if (file.name === "src/lib/PlaygroundLayout.svelte") {
-				const { ast: ast$1, generateCode: generateCode$1 } = parseSvelte(file.contents);
-				walk(ensureScript(ast$1), null, { Literal(node) {
-					if (node.value === "$sv-title-$sv") {
-						node.value = playground.name;
-						node.raw = void 0;
-					} else if (node.value === "$sv-url-$sv") {
-						node.value = url;
-						node.raw = void 0;
-					}
-				} });
-				contentToWrite = generateCode$1();
-			}
-			fs.writeFileSync(path.join(cwd$1, file.name), contentToWrite, "utf-8");
-		}
-	}
-	const filePath = path.join(cwd$1, "src/routes/+page.svelte");
-	const { ast, generateCode } = parseSvelte(fs.readFileSync(filePath, "utf-8"));
-	const scriptAst = ensureScript(ast);
-	addDefault(scriptAst, {
-		as: "App",
-		from: `$lib/playground/${mainFile.name}`
-	});
-	addDefault(scriptAst, {
-		as: "PlaygroundLayout",
-		from: `$lib/PlaygroundLayout.svelte`
-	});
-	ast.fragment.nodes.push(...toFragment(`<PlaygroundLayout>
-	<App />
-</PlaygroundLayout>`));
-	const newContent = generateCode();
-	fs.writeFileSync(filePath, newContent, "utf-8");
-	const pkgPath = path.join(cwd$1, commonFilePaths.packageJson);
-	const pkgJson = parseJson(fs.readFileSync(pkgPath, "utf-8"));
-	let updatePackageJson = false;
-	if (installDependencies$1 && dependencies.size >= 0) {
-		updatePackageJson = true;
-		pkgJson.data.dependencies ??= {};
-		for (const [dep, version$1] of dependencies) pkgJson.data.dependencies[dep] = version$1;
-	}
-	let experimentalAsyncNeeded = true;
-	const addExperimentalAsync = () => {
-		const svelteConfigPath = path.join(cwd$1, commonFilePaths.svelteConfig);
-		const { ast: ast$1, generateCode: generateCode$1 } = parseScript(fs.readFileSync(svelteConfigPath, "utf-8"));
-		const { value: config } = createDefault(ast$1, { fallback: create$2({}) });
-		overrideProperties(config, { compilerOptions: { experimental: { async: true } } });
-		fs.writeFileSync(svelteConfigPath, generateCode$1(), "utf-8");
-	};
-	if (playground.svelteVersion) {
-		updatePackageJson = true;
-		const match = /^(pr|commit|branch)-(.+)/.exec(playground.svelteVersion);
-		const version$1 = match ? `https://pkg.pr.new/svelte@${match[2]}` : `${playground.svelteVersion}`;
-		pkgJson.data.devDependencies["svelte"] = version$1;
-		if (!version$1.includes("pkg.pr.new")) {
-			if (isVersionUnsupportedBelow(version$1, "5.36")) experimentalAsyncNeeded = false;
-		}
-	}
-	if (experimentalAsyncNeeded) addExperimentalAsync();
-	if (updatePackageJson) fs.writeFileSync(pkgPath, pkgJson.generateCode(), "utf-8");
-}
-
-//#endregion
-//#region lib/cli/create.ts
-var import_picocolors$1 = /* @__PURE__ */ __toESM(require_picocolors(), 1);
-const langs = ["ts", "jsdoc"];
-const langMap = {
-	ts: "typescript",
-	jsdoc: "checkjs",
-	false: "none"
-};
-const templateChoices = templates.map((t) => t.name);
-const langOption = new Option("--types <lang>", "add type checking").choices(langs);
-const templateOption = new Option("--template <type>", "template to scaffold").choices(templateChoices);
-const noAddonsOption = new Option("--no-add-ons", "do not prompt to add add-ons").conflicts("add");
-const addOption = new Option("--add <addon...>", "add-on to include").default([]);
-const ProjectPathSchema = optional(string());
-const OptionsSchema = strictObject({
-	types: pipe(optional(union([picklist(langs), boolean()])), transform((lang) => langMap[String(lang)])),
-	addOns: boolean(),
-	add: array(string()),
-	install: union([boolean(), picklist(AGENT_NAMES)]),
-	template: optional(picklist(templateChoices)),
-	fromPlayground: optional(string()),
-	dirCheck: boolean()
-});
-const create = new Command("create").description("scaffolds a new SvelteKit project").argument("[path]", "where the project will be created").addOption(templateOption).addOption(langOption).option("--no-types").addOption(noAddonsOption).addOption(addOption).option("--no-install", "skip installing dependencies").option("--from-playground <url>", "create a project from the svelte playground").option("--no-dir-check", "even if the folder is not empty, no prompt will be shown").addOption(installOption).configureHelp(helpConfig).action((projectPath, opts) => {
-	const cwd$1 = parse(ProjectPathSchema, projectPath);
-	const options$1 = parse(OptionsSchema, opts);
-	if (options$1.fromPlayground && !validatePlaygroundUrl(options$1.fromPlayground)) {
-		console.error(import_picocolors$1.default.red(`Error: Invalid playground URL: ${options$1.fromPlayground}`));
-		process.exit(1);
-	}
-	runCommand(async () => {
-		const { directory, addOnNextSteps, packageManager } = await createProject(cwd$1, options$1);
-		const highlight = (str) => import_picocolors$1.default.bold(import_picocolors$1.default.cyan(str));
-		let i = 1;
-		const initialSteps = ["📁 Project steps", ""];
-		const relative = path.relative(process.cwd(), directory);
-		const pm = packageManager ?? (await detect({ cwd: directory }))?.name ?? getUserAgent() ?? "npm";
-		if (relative !== "") {
-			const pathHasSpaces = relative.includes(" ");
-			initialSteps.push(`  ${i++}: ${highlight(`cd ${pathHasSpaces ? `"${relative}"` : relative}`)}`);
-		}
-		if (!packageManager) {
-			const { args: args$1, command: command$1 } = resolveCommand(pm, "install", []);
-			initialSteps.push(`  ${i++}: ${highlight(`${command$1} ${args$1.join(" ")}`)}`);
-		}
-		const { args, command } = resolveCommand(pm, "run", ["dev", "--open"]);
-		const pmRunCmd = `${command} ${args.join(" ")}`;
-		const steps = [
-			...initialSteps,
-			`  ${i++}: ${highlight(pmRunCmd)}`,
-			"",
-			`To close the dev server, hit ${highlight("Ctrl-C")}`
-		];
-		if (addOnNextSteps.length > 0) {
-			steps.push("", "🧩 Add-on steps", "");
-			for (const step of addOnNextSteps) {
-				const indented = step.replaceAll("  -", "    -");
-				steps.push(`  ${indented}`);
-			}
-		}
-		steps.push("", `Stuck? Visit us at ${import_picocolors$1.default.cyan("https://svelte.dev/chat")}`);
-		Ke(steps.join("\n"), "What's next?", { format: (line) => line });
-	});
-}).showHelpAfterError(true);
-async function createProject(cwd$1, options$1) {
-	if (options$1.fromPlayground) T.warn("The Svelte maintainers have not reviewed playgrounds for malicious code. Use at your discretion.");
-	const { directory, template, language } = await We({
-		directory: () => {
-			const defaultPath = "./";
-			if (cwd$1) return Promise.resolve(cwd$1);
-			return et({
-				message: "Where would you like your project to be created?",
-				placeholder: `  (hit Enter to use '${defaultPath}')`,
-				defaultValue: defaultPath
-			});
-		},
-		force: async ({ results: { directory: directory$1 } }) => {
-			if (!options$1.dirCheck) return;
-			if (!fs.existsSync(directory$1)) return;
-			if (!fs.readdirSync(directory$1).some((file) => !file.startsWith(".git"))) return;
-			const force = await ke({
-				message: "Directory not empty. Continue?",
-				initialValue: false
-			});
-			if (Vu(force) || !force) {
-				De("Exiting.");
-				process.exit(0);
-			}
-		},
-		template: () => {
-			if (options$1.template) return Promise.resolve(options$1.template);
-			if (options$1.fromPlayground) return Promise.resolve("minimal");
-			return ze({
-				message: "Which template would you like?",
-				initialValue: "minimal",
-				options: templates.map((t) => ({
-					label: t.title,
-					value: t.name,
-					hint: t.description
-				}))
-			});
-		},
-		language: () => {
-			if (options$1.types) return Promise.resolve(options$1.types);
-			return ze({
-				message: "Add type checking with TypeScript?",
-				initialValue: "typescript",
-				options: [
-					{
-						label: "Yes, using TypeScript syntax",
-						value: "typescript"
-					},
-					{
-						label: "Yes, using JavaScript with JSDoc comments",
-						value: "checkjs"
-					},
-					{
-						label: "No",
-						value: "none"
-					}
-				]
-			});
-		}
-	}, { onCancel: () => {
-		De("Operation cancelled.");
-		process.exit(0);
-	} });
-	const projectPath = path.resolve(directory);
-	const projectName = path.basename(projectPath);
-	let selectedAddons = [];
-	let answersOfficial = {};
-	let answersCommunity = {};
-	let sanitizedAddonsMap = {};
-	const workspace = await createVirtualWorkspace({
-		cwd: projectPath,
-		template,
-		type: language
-	});
-	if (options$1.addOns || options$1.add.length > 0) {
-		sanitizedAddonsMap = sanitizeAddons(options$1.add.reduce(addonArgsHandler, [])).reduce((acc, curr) => {
-			acc[curr.id] = curr.options;
-			return acc;
-		}, {});
-		const result = await promptAddonQuestions({
-			options: {
-				cwd: projectPath,
-				install: false,
-				gitCheck: false,
-				community: [],
-				addons: sanitizedAddonsMap
-			},
-			selectedAddonIds: Object.keys(sanitizedAddonsMap),
-			workspace
-		});
-		selectedAddons = result.selectedAddons;
-		answersOfficial = result.answersOfficial;
-		answersCommunity = result.answersCommunity;
-	}
-	create$1(projectPath, {
-		name: projectName,
-		template,
-		types: language
-	});
-	if (options$1.fromPlayground) await createProjectFromPlayground(options$1.fromPlayground, projectPath);
-	T.success("Project created");
-	let addOnNextSteps = [];
-	let argsFormattedAddons = [];
-	let addOnFilesToFormat = [];
-	if (options$1.addOns || options$1.add.length > 0) {
-		const { nextSteps, argsFormattedAddons: argsFormatted$1, filesToFormat } = await runAddonsApply({
-			answersOfficial,
-			answersCommunity,
-			options: {
-				cwd: projectPath,
-				install: false,
-				gitCheck: false,
-				community: [],
-				addons: sanitizedAddonsMap
-			},
-			selectedAddons,
-			addonSetupResults: void 0,
-			workspace,
-			fromCommand: "create"
-		});
-		argsFormattedAddons = argsFormatted$1;
-		addOnFilesToFormat = filesToFormat;
-		addOnNextSteps = nextSteps;
-	}
-	const packageManager = options$1.install === false ? null : options$1.install === true ? await packageManagerPrompt(projectPath) : options$1.install;
-	const argsFormatted = [];
-	argsFormatted.push("--template", template);
-	if (language === "typescript") argsFormatted.push("--types", "ts");
-	else if (language === "checkjs") argsFormatted.push("--types", "jsdoc");
-	else if (language === "none") argsFormatted.push("--no-types");
-	if (argsFormattedAddons.length > 0) argsFormatted.push("--add", ...argsFormattedAddons);
-	logArgs(packageManager, "create", argsFormatted, [directory]);
-	await addPnpmBuildDependencies(projectPath, packageManager, ["esbuild"]);
-	if (packageManager) {
-		await installDependencies(packageManager, projectPath);
-		await formatFiles({
-			packageManager,
-			cwd: projectPath,
-			filesToFormat: addOnFilesToFormat
-		});
-	}
-	return {
-		directory: projectPath,
-		addOnNextSteps,
-		packageManager
-	};
-}
-async function createProjectFromPlayground(url, cwd$1) {
-	const playground = await downloadPlaygroundData(parsePlaygroundUrl(url));
-	const dependencies = detectPlaygroundDependencies(playground.files);
-	setupPlaygroundProject(url, playground, cwd$1, await confirmExternalDependencies(Array.from(dependencies.keys())));
-}
-async function confirmExternalDependencies(dependencies) {
-	if (dependencies.length === 0) return false;
-	const dependencyList = dependencies.map(import_picocolors$1.default.yellowBright).join(", ");
-	T.warn(`The following external dependencies were found in the playground:\n\n${dependencyList}`);
-	const installDeps = await ke({
-		message: "Do you want to install these external dependencies?",
-		initialValue: false
-	});
-	if (Vu(installDeps)) {
-		De("Operation cancelled.");
-		process.exit(0);
+		forwardExitCode(error);
 	}
-	return installDeps;
-}
-async function createVirtualWorkspace({ cwd: cwd$1, template, type }) {
-	const override = { dependencies: {} };
-	if (template === "minimal" || template === "demo" || template === "library") override.kit = {
-		routesDirectory: "src/routes",
-		libDirectory: "src/lib"
-	};
-	const { data: packageJson } = getPackageJson(dist(`templates/${template}`));
-	override.dependencies = {
-		...packageJson.devDependencies,
-		...packageJson.dependencies,
-		...override.dependencies
-	};
-	const tentativeWorkspace = await createWorkspace({
-		cwd: cwd$1,
-		override
-	});
-	return {
-		...tentativeWorkspace,
-		typescript: type === "typescript",
-		files: {
-			...tentativeWorkspace.files,
-			viteConfig: type === "typescript" ? commonFilePaths.viteConfigTS : commonFilePaths.viteConfig,
-			svelteConfig: commonFilePaths.svelteConfig
-		}
-	};
 }
 
 //#endregion
 //#region lib/cli/migrate.ts
-const migrate = new Command("migrate").description("a CLI for migrating Svelte(Kit) codebases").argument("[migration]", "migration to run").option("-C, --cwd <path>", "path to working directory", process.cwd()).action((migration, options$1) => {
-	runMigrate(options$1.cwd, [migration]);
+const migrate = new Command("migrate").description("a CLI for migrating Svelte(Kit) codebases").argument("[migration]", "migration to run").option("-C, --cwd <path>", "path to working directory", process.cwd()).action((migration, options) => {
+	runMigrate(options.cwd, [migration]);
 });
 function runMigrate(cwd$1, args) {
 	const pm = getUserAgent() ?? "npm";
@@ -1845,35 +54,6 @@ function runMigrate(cwd$1, args) {
 	}
 }
 
-//#endregion
-//#region lib/cli/check.ts
-var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
-const check = new Command("check").description("a CLI for checking your Svelte code").allowUnknownOption(true).allowExcessArguments(true).option("-C, --cwd <path>", "path to working directory", process.cwd()).configureHelp({ formatHelp() {
-	runCheck(process.cwd(), ["--help"]);
-	return "";
-} }).action((options$1, check$1) => {
-	const cwd$1 = options$1.cwd;
-	const args = check$1.args;
-	runCheck(cwd$1, args);
-});
-function runCheck(cwd$1, args) {
-	const pm = getUserAgent() ?? "npm";
-	if (!from(cwd$1, "svelte-check", true)) {
-		const cmd = resolveCommand(pm, "add", ["-D", "svelte-check"]);
-		console.error(`'svelte-check' is not installed locally. Install it with: ${import_picocolors.default.bold(`${cmd.command} ${cmd.args.join(" ")}`)}`);
-		process.exit(1);
-	}
-	try {
-		const cmd = resolveCommand(pm, "execute-local", ["svelte-check", ...args]);
-		execSync(`${cmd.command} ${cmd.args.join(" ")}`, {
-			stdio: "inherit",
-			cwd: cwd$1
-		});
-	} catch (error) {
-		forwardExitCode(error);
-	}
-}
-
 //#endregion
 //#region bin.ts
 console.log();