@yamada-ui/cli 2.0.4 → 2.0.5-dev-20251027025837

package/dist/index.js

@@ -801,13 +801,19 @@ const xdgConfigDirectories = (env$2.XDG_CONFIG_DIRS || "/etc/xdg").split(":");
 if (xdgConfig) xdgConfigDirectories.unshift(xdgConfig);
 
 //#endregion
-//#region ../../node_modules/.pnpm/stubborn-fs@1.2.5/node_modules/stubborn-fs/dist/attemptify.js
-const attemptifyAsync = (fn, onError) => {
+//#region ../../node_modules/.pnpm/stubborn-utils@1.0.1/node_modules/stubborn-utils/dist/attemptify_async.js
+const attemptifyAsync = (fn, options) => {
+	const { onError } = options;
 	return function attemptified(...args) {
 		return fn.apply(void 0, args).catch(onError);
 	};
 };
-const attemptifySync = (fn, onError) => {
+var attemptify_async_default = attemptifyAsync;
+
+//#endregion
+//#region ../../node_modules/.pnpm/stubborn-utils@1.0.1/node_modules/stubborn-utils/dist/attemptify_sync.js
+const attemptifySync = (fn, options) => {
+	const { onError } = options;
 	return function attemptified(...args) {
 		try {
 			return fn.apply(void 0, args);
@@ -816,15 +822,55 @@ const attemptifySync = (fn, onError) => {
 		}
 	};
 };
+var attemptify_sync_default = attemptifySync;
 
 //#endregion
-//#region ../../node_modules/.pnpm/stubborn-fs@1.2.5/node_modules/stubborn-fs/dist/constants.js
-const IS_USER_ROOT$1 = process$1.getuid ? !process$1.getuid() : false;
-const LIMIT_FILES_DESCRIPTORS = 1e4;
-const NOOP = () => void 0;
+//#region ../../node_modules/.pnpm/stubborn-utils@1.0.1/node_modules/stubborn-utils/dist/constants.js
+const RETRY_INTERVAL = 250;
 
 //#endregion
-//#region ../../node_modules/.pnpm/stubborn-fs@1.2.5/node_modules/stubborn-fs/dist/handlers.js
+//#region ../../node_modules/.pnpm/stubborn-utils@1.0.1/node_modules/stubborn-utils/dist/retryify_async.js
+const retryifyAsync = (fn, options) => {
+	const { isRetriable } = options;
+	return function retryified(options$1) {
+		const { timeout: timeout$1 } = options$1;
+		const interval = options$1.interval ?? RETRY_INTERVAL;
+		const timestamp = Date.now() + timeout$1;
+		return function attempt(...args) {
+			return fn.apply(void 0, args).catch((error) => {
+				if (!isRetriable(error)) throw error;
+				if (Date.now() >= timestamp) throw error;
+				const delay$1 = Math.round(interval * Math.random());
+				if (delay$1 > 0) return new Promise((resolve) => setTimeout(resolve, delay$1)).then(() => attempt.apply(void 0, args));
+				else return attempt.apply(void 0, args);
+			});
+		};
+	};
+};
+var retryify_async_default = retryifyAsync;
+
+//#endregion
+//#region ../../node_modules/.pnpm/stubborn-utils@1.0.1/node_modules/stubborn-utils/dist/retryify_sync.js
+const retryifySync = (fn, options) => {
+	const { isRetriable } = options;
+	return function retryified(options$1) {
+		const { timeout: timeout$1 } = options$1;
+		const timestamp = Date.now() + timeout$1;
+		return function attempt(...args) {
+			while (true) try {
+				return fn.apply(void 0, args);
+			} catch (error) {
+				if (!isRetriable(error)) throw error;
+				if (Date.now() >= timestamp) throw error;
+				continue;
+			}
+		};
+	};
+};
+var retryify_sync_default = retryifySync;
+
+//#endregion
+//#region ../../node_modules/.pnpm/stubborn-fs@2.0.0/node_modules/stubborn-fs/dist/handlers.js
 const Handlers = {
 	isChangeErrorOk: (error) => {
 		if (!Handlers.isNodeError(error)) return false;
@@ -851,149 +897,70 @@ const Handlers = {
 var handlers_default = Handlers;
 
 //#endregion
-//#region ../../node_modules/.pnpm/stubborn-fs@1.2.5/node_modules/stubborn-fs/dist/retryify_queue.js
-var RetryfyQueue = class {
-	constructor() {
-		this.interval = 25;
-		this.intervalId = void 0;
-		this.limit = LIMIT_FILES_DESCRIPTORS;
-		this.queueActive = /* @__PURE__ */ new Set();
-		this.queueWaiting = /* @__PURE__ */ new Set();
-		this.init = () => {
-			if (this.intervalId) return;
-			this.intervalId = setInterval(this.tick, this.interval);
-		};
-		this.reset = () => {
-			if (!this.intervalId) return;
-			clearInterval(this.intervalId);
-			delete this.intervalId;
-		};
-		this.add = (fn) => {
-			this.queueWaiting.add(fn);
-			if (this.queueActive.size < this.limit / 2) this.tick();
-			else this.init();
-		};
-		this.remove = (fn) => {
-			this.queueWaiting.delete(fn);
-			this.queueActive.delete(fn);
-		};
-		this.schedule = () => {
-			return new Promise((resolve) => {
-				const cleanup = () => this.remove(resolver);
-				const resolver = () => resolve(cleanup);
-				this.add(resolver);
-			});
-		};
-		this.tick = () => {
-			if (this.queueActive.size >= this.limit) return;
-			if (!this.queueWaiting.size) return this.reset();
-			for (const fn of this.queueWaiting) {
-				if (this.queueActive.size >= this.limit) break;
-				this.queueWaiting.delete(fn);
-				this.queueActive.add(fn);
-				fn();
-			}
-		};
-	}
-};
-var retryify_queue_default = new RetryfyQueue();
-
-//#endregion
-//#region ../../node_modules/.pnpm/stubborn-fs@1.2.5/node_modules/stubborn-fs/dist/retryify.js
-const retryifyAsync = (fn, isRetriableError) => {
-	return function retrified(timestamp) {
-		return function attempt(...args) {
-			return retryify_queue_default.schedule().then((cleanup) => {
-				const onResolve = (result) => {
-					cleanup();
-					return result;
-				};
-				const onReject = (error) => {
-					cleanup();
-					if (Date.now() >= timestamp) throw error;
-					if (isRetriableError(error)) {
-						const delay$1 = Math.round(100 * Math.random());
-						return new Promise((resolve) => setTimeout(resolve, delay$1)).then(() => attempt.apply(void 0, args));
-					}
-					throw error;
-				};
-				return fn.apply(void 0, args).then(onResolve, onReject);
-			});
-		};
-	};
-};
-const retryifySync = (fn, isRetriableError) => {
-	return function retrified(timestamp) {
-		return function attempt(...args) {
-			try {
-				return fn.apply(void 0, args);
-			} catch (error) {
-				if (Date.now() > timestamp) throw error;
-				if (isRetriableError(error)) return attempt.apply(void 0, args);
-				throw error;
-			}
-		};
-	};
-};
+//#region ../../node_modules/.pnpm/stubborn-fs@2.0.0/node_modules/stubborn-fs/dist/constants.js
+const ATTEMPTIFY_CHANGE_ERROR_OPTIONS = { onError: handlers_default.onChangeError };
+const ATTEMPTIFY_NOOP_OPTIONS = { onError: () => void 0 };
+const IS_USER_ROOT$1 = process$1.getuid ? !process$1.getuid() : false;
+const RETRYIFY_OPTIONS = { isRetriable: handlers_default.isRetriableError };
 
 //#endregion
-//#region ../../node_modules/.pnpm/stubborn-fs@1.2.5/node_modules/stubborn-fs/dist/index.js
+//#region ../../node_modules/.pnpm/stubborn-fs@2.0.0/node_modules/stubborn-fs/dist/index.js
 const FS = {
 	attempt: {
-		chmod: attemptifyAsync(promisify(fs$1.chmod), handlers_default.onChangeError),
-		chown: attemptifyAsync(promisify(fs$1.chown), handlers_default.onChangeError),
-		close: attemptifyAsync(promisify(fs$1.close), NOOP),
-		fsync: attemptifyAsync(promisify(fs$1.fsync), NOOP),
-		mkdir: attemptifyAsync(promisify(fs$1.mkdir), NOOP),
-		realpath: attemptifyAsync(promisify(fs$1.realpath), NOOP),
-		stat: attemptifyAsync(promisify(fs$1.stat), NOOP),
-		unlink: attemptifyAsync(promisify(fs$1.unlink), NOOP),
-		chmodSync: attemptifySync(fs$1.chmodSync, handlers_default.onChangeError),
-		chownSync: attemptifySync(fs$1.chownSync, handlers_default.onChangeError),
-		closeSync: attemptifySync(fs$1.closeSync, NOOP),
-		existsSync: attemptifySync(fs$1.existsSync, NOOP),
-		fsyncSync: attemptifySync(fs$1.fsync, NOOP),
-		mkdirSync: attemptifySync(fs$1.mkdirSync, NOOP),
-		realpathSync: attemptifySync(fs$1.realpathSync, NOOP),
-		statSync: attemptifySync(fs$1.statSync, NOOP),
-		unlinkSync: attemptifySync(fs$1.unlinkSync, NOOP)
+		chmod: attemptify_async_default(promisify(fs$1.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+		chown: attemptify_async_default(promisify(fs$1.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+		close: attemptify_async_default(promisify(fs$1.close), ATTEMPTIFY_NOOP_OPTIONS),
+		fsync: attemptify_async_default(promisify(fs$1.fsync), ATTEMPTIFY_NOOP_OPTIONS),
+		mkdir: attemptify_async_default(promisify(fs$1.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
+		realpath: attemptify_async_default(promisify(fs$1.realpath), ATTEMPTIFY_NOOP_OPTIONS),
+		stat: attemptify_async_default(promisify(fs$1.stat), ATTEMPTIFY_NOOP_OPTIONS),
+		unlink: attemptify_async_default(promisify(fs$1.unlink), ATTEMPTIFY_NOOP_OPTIONS),
+		chmodSync: attemptify_sync_default(fs$1.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+		chownSync: attemptify_sync_default(fs$1.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+		closeSync: attemptify_sync_default(fs$1.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
+		existsSync: attemptify_sync_default(fs$1.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
+		fsyncSync: attemptify_sync_default(fs$1.fsync, ATTEMPTIFY_NOOP_OPTIONS),
+		mkdirSync: attemptify_sync_default(fs$1.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
+		realpathSync: attemptify_sync_default(fs$1.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
+		statSync: attemptify_sync_default(fs$1.statSync, ATTEMPTIFY_NOOP_OPTIONS),
+		unlinkSync: attemptify_sync_default(fs$1.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
 	},
 	retry: {
-		close: retryifyAsync(promisify(fs$1.close), handlers_default.isRetriableError),
-		fsync: retryifyAsync(promisify(fs$1.fsync), handlers_default.isRetriableError),
-		open: retryifyAsync(promisify(fs$1.open), handlers_default.isRetriableError),
-		readFile: retryifyAsync(promisify(fs$1.readFile), handlers_default.isRetriableError),
-		rename: retryifyAsync(promisify(fs$1.rename), handlers_default.isRetriableError),
-		stat: retryifyAsync(promisify(fs$1.stat), handlers_default.isRetriableError),
-		write: retryifyAsync(promisify(fs$1.write), handlers_default.isRetriableError),
-		writeFile: retryifyAsync(promisify(fs$1.writeFile), handlers_default.isRetriableError),
-		closeSync: retryifySync(fs$1.closeSync, handlers_default.isRetriableError),
-		fsyncSync: retryifySync(fs$1.fsyncSync, handlers_default.isRetriableError),
-		openSync: retryifySync(fs$1.openSync, handlers_default.isRetriableError),
-		readFileSync: retryifySync(fs$1.readFileSync, handlers_default.isRetriableError),
-		renameSync: retryifySync(fs$1.renameSync, handlers_default.isRetriableError),
-		statSync: retryifySync(fs$1.statSync, handlers_default.isRetriableError),
-		writeSync: retryifySync(fs$1.writeSync, handlers_default.isRetriableError),
-		writeFileSync: retryifySync(fs$1.writeFileSync, handlers_default.isRetriableError)
+		close: retryify_async_default(promisify(fs$1.close), RETRYIFY_OPTIONS),
+		fsync: retryify_async_default(promisify(fs$1.fsync), RETRYIFY_OPTIONS),
+		open: retryify_async_default(promisify(fs$1.open), RETRYIFY_OPTIONS),
+		readFile: retryify_async_default(promisify(fs$1.readFile), RETRYIFY_OPTIONS),
+		rename: retryify_async_default(promisify(fs$1.rename), RETRYIFY_OPTIONS),
+		stat: retryify_async_default(promisify(fs$1.stat), RETRYIFY_OPTIONS),
+		write: retryify_async_default(promisify(fs$1.write), RETRYIFY_OPTIONS),
+		writeFile: retryify_async_default(promisify(fs$1.writeFile), RETRYIFY_OPTIONS),
+		closeSync: retryify_sync_default(fs$1.closeSync, RETRYIFY_OPTIONS),
+		fsyncSync: retryify_sync_default(fs$1.fsyncSync, RETRYIFY_OPTIONS),
+		openSync: retryify_sync_default(fs$1.openSync, RETRYIFY_OPTIONS),
+		readFileSync: retryify_sync_default(fs$1.readFileSync, RETRYIFY_OPTIONS),
+		renameSync: retryify_sync_default(fs$1.renameSync, RETRYIFY_OPTIONS),
+		statSync: retryify_sync_default(fs$1.statSync, RETRYIFY_OPTIONS),
+		writeSync: retryify_sync_default(fs$1.writeSync, RETRYIFY_OPTIONS),
+		writeFileSync: retryify_sync_default(fs$1.writeFileSync, RETRYIFY_OPTIONS)
 	}
 };
 var dist_default = FS;
 
 //#endregion
-//#region ../../node_modules/.pnpm/atomically@2.0.3/node_modules/atomically/dist/constants.js
+//#region ../../node_modules/.pnpm/atomically@2.1.0/node_modules/atomically/dist/constants.js
 const DEFAULT_ENCODING = "utf8";
 const DEFAULT_FILE_MODE = 438;
 const DEFAULT_FOLDER_MODE = 511;
 const DEFAULT_WRITE_OPTIONS = {};
-const DEFAULT_USER_UID = os.userInfo().uid;
-const DEFAULT_USER_GID = os.userInfo().gid;
+const DEFAULT_USER_UID = process$1.geteuid ? process$1.geteuid() : -1;
+const DEFAULT_USER_GID = process$1.getegid ? process$1.getegid() : -1;
 const DEFAULT_TIMEOUT_SYNC = 1e3;
 const IS_POSIX = !!process$1.getuid;
 const IS_USER_ROOT = process$1.getuid ? !process$1.getuid() : false;
 const LIMIT_BASENAME_LENGTH = 128;
 
 //#endregion
-//#region ../../node_modules/.pnpm/atomically@2.0.3/node_modules/atomically/dist/utils/lang.js
+//#region ../../node_modules/.pnpm/atomically@2.1.0/node_modules/atomically/dist/utils/lang.js
 const isException = (value) => {
 	return value instanceof Error && "code" in value;
 };
@@ -1058,7 +1025,7 @@ const whenExit = interceptor_default.register;
 var node_default = whenExit;
 
 //#endregion
-//#region ../../node_modules/.pnpm/atomically@2.0.3/node_modules/atomically/dist/utils/temp.js
+//#region ../../node_modules/.pnpm/atomically@2.1.0/node_modules/atomically/dist/utils/temp.js
 const Temp = {
 	store: {},
 	create: (filePath) => {
@@ -1098,10 +1065,10 @@ node_default(Temp.purgeSyncAll);
 var temp_default = Temp;
 
 //#endregion
-//#region ../../node_modules/.pnpm/atomically@2.0.3/node_modules/atomically/dist/index.js
+//#region ../../node_modules/.pnpm/atomically@2.1.0/node_modules/atomically/dist/index.js
 function writeFileSync(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
 	if (isString$1(options)) return writeFileSync(filePath, data, { encoding: options });
-	const timeout$1 = Date.now() + ((options.timeout ?? DEFAULT_TIMEOUT_SYNC) || -1);
+	const retryOptions = { timeout: options.timeout ?? DEFAULT_TIMEOUT_SYNC };
 	let tempDisposer = null;
 	let tempPath = null;
 	let fd = null;
@@ -1130,22 +1097,22 @@ function writeFileSync(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
 				recursive: true
 			});
 		}
-		fd = dist_default.retry.openSync(timeout$1)(tempPath, "w", options.mode || DEFAULT_FILE_MODE);
+		fd = dist_default.retry.openSync(retryOptions)(tempPath, "w", options.mode || DEFAULT_FILE_MODE);
 		if (options.tmpCreated) options.tmpCreated(tempPath);
-		if (isString$1(data)) dist_default.retry.writeSync(timeout$1)(fd, data, 0, options.encoding || DEFAULT_ENCODING);
-		else if (!isUndefined$1(data)) dist_default.retry.writeSync(timeout$1)(fd, data, 0, data.length, 0);
-		if (options.fsync !== false) if (options.fsyncWait !== false) dist_default.retry.fsyncSync(timeout$1)(fd);
+		if (isString$1(data)) dist_default.retry.writeSync(retryOptions)(fd, data, 0, options.encoding || DEFAULT_ENCODING);
+		else if (!isUndefined$1(data)) dist_default.retry.writeSync(retryOptions)(fd, data, 0, data.length, 0);
+		if (options.fsync !== false) if (options.fsyncWait !== false) dist_default.retry.fsyncSync(retryOptions)(fd);
 		else dist_default.attempt.fsync(fd);
-		dist_default.retry.closeSync(timeout$1)(fd);
+		dist_default.retry.closeSync(retryOptions)(fd);
 		fd = null;
 		if (options.chown && (options.chown.uid !== DEFAULT_USER_UID || options.chown.gid !== DEFAULT_USER_GID)) dist_default.attempt.chownSync(tempPath, options.chown.uid, options.chown.gid);
 		if (options.mode && options.mode !== DEFAULT_FILE_MODE) dist_default.attempt.chmodSync(tempPath, options.mode);
 		try {
-			dist_default.retry.renameSync(timeout$1)(tempPath, filePath);
+			dist_default.retry.renameSync(retryOptions)(tempPath, filePath);
 		} catch (error) {
 			if (!isException(error)) throw error;
 			if (error.code !== "ENAMETOOLONG") throw error;
-			dist_default.retry.renameSync(timeout$1)(tempPath, temp_default.truncate(filePath));
+			dist_default.retry.renameSync(retryOptions)(tempPath, temp_default.truncate(filePath));
 		}
 		tempDisposer();
 		tempPath = null;
@@ -1797,7 +1764,7 @@ const chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 //#endregion
-//#region ../../node_modules/.pnpm/ky@1.12.0/node_modules/ky/distribution/errors/HTTPError.js
+//#region ../../node_modules/.pnpm/ky@1.13.0/node_modules/ky/distribution/errors/HTTPError.js
 var HTTPError = class extends Error {
 	response;
 	request;
@@ -1814,7 +1781,28 @@ var HTTPError = class extends Error {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/ky@1.12.0/node_modules/ky/distribution/core/constants.js
+//#region ../../node_modules/.pnpm/ky@1.13.0/node_modules/ky/distribution/errors/NonError.js
+/**
+Wrapper for non-Error values that were thrown.
+
+In JavaScript, any value can be thrown (not just Error instances). This class wraps such values to ensure consistent error handling.
+*/
+var NonError = class extends Error {
+	name = "NonError";
+	value;
+	constructor(value) {
+		let message = "Non-error value was thrown";
+		try {
+			if (typeof value === "string") message = value;
+			else if (value && typeof value === "object" && "message" in value && typeof value.message === "string") message = value.message;
+		} catch {}
+		super(message);
+		this.value = value;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/ky@1.13.0/node_modules/ky/distribution/core/constants.js
 const supportsRequestStreams = (() => {
 	let duplexAccessed = false;
 	let hasContentType = false;
@@ -1872,8 +1860,10 @@ const kyOptionKeys = {
 	throwHttpErrors: true,
 	onDownloadProgress: true,
 	onUploadProgress: true,
-	fetch: true
+	fetch: true,
+	context: true
 };
+const vendorSpecificOptions = { next: true };
 const requestOptionsRegistry = {
 	method: true,
 	headers: true,
@@ -1892,7 +1882,7 @@ const requestOptionsRegistry = {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/ky@1.12.0/node_modules/ky/distribution/utils/body.js
+//#region ../../node_modules/.pnpm/ky@1.13.0/node_modules/ky/distribution/utils/body.js
 const getBodySize = (body) => {
 	if (!body) return 0;
 	if (body instanceof FormData) {
@@ -1954,7 +1944,7 @@ const streamResponse = (response, onDownloadProgress) => {
 		statusText: response.statusText,
 		headers: response.headers
 	});
-	const totalBytes = Number(response.headers.get("content-length")) || 0;
+	const totalBytes = Math.max(0, Number(response.headers.get("content-length")) || 0);
 	return new Response(withProgress(response.body, totalBytes, onDownloadProgress), {
 		status: response.status,
 		statusText: response.statusText,
@@ -1971,11 +1961,11 @@ const streamRequest = (request, onUploadProgress, originalBody) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/ky@1.12.0/node_modules/ky/distribution/utils/is.js
+//#region ../../node_modules/.pnpm/ky@1.13.0/node_modules/ky/distribution/utils/is.js
 const isObject$1 = (value) => value !== null && typeof value === "object";
 
 //#endregion
-//#region ../../node_modules/.pnpm/ky@1.12.0/node_modules/ky/distribution/utils/merge.js
+//#region ../../node_modules/.pnpm/ky@1.13.0/node_modules/ky/distribution/utils/merge.js
 const validateAndMerge = (...sources) => {
 	for (const source of sources) if ((!isObject$1(source) || Array.isArray(source)) && source !== void 0) throw new TypeError("The `options` argument must be an object");
 	return deepMerge({}, ...sources);
@@ -2030,6 +2020,17 @@ const deepMerge = (...sources) => {
 				signals.push(value);
 				continue;
 			}
+			if (key === "context") {
+				if (value !== void 0 && value !== null && (!isObject$1(value) || Array.isArray(value))) throw new TypeError("The `context` option must be an object");
+				returnValue = {
+					...returnValue,
+					context: value === void 0 || value === null ? {} : {
+						...returnValue.context,
+						...value
+					}
+				};
+				continue;
+			}
 			if (key === "searchParams") {
 				if (value === void 0 || value === null) searchParameters = void 0;
 				else searchParameters = searchParameters === void 0 ? value : appendSearchParameters(searchParameters, value);
@@ -2054,11 +2055,12 @@ const deepMerge = (...sources) => {
 	if (signals.length > 0) if (signals.length === 1) returnValue.signal = signals[0];
 	else if (supportsAbortSignal) returnValue.signal = AbortSignal.any(signals);
 	else returnValue.signal = signals.at(-1);
+	if (returnValue.context === void 0) returnValue.context = {};
 	return returnValue;
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/ky@1.12.0/node_modules/ky/distribution/utils/normalize.js
+//#region ../../node_modules/.pnpm/ky@1.13.0/node_modules/ky/distribution/utils/normalize.js
 const normalizeRequestMethod = (input) => requestMethods.includes(input) ? input.toUpperCase() : input;
 const defaultRetryOptions = {
 	limit: 2,
@@ -2086,7 +2088,9 @@ const defaultRetryOptions = {
 	],
 	maxRetryAfter: Number.POSITIVE_INFINITY,
 	backoffLimit: Number.POSITIVE_INFINITY,
-	delay: (attemptCount) => .3 * 2 ** (attemptCount - 1) * 1e3
+	delay: (attemptCount) => .3 * 2 ** (attemptCount - 1) * 1e3,
+	jitter: void 0,
+	retryOnTimeout: false
 };
 const normalizeRetryOptions = (retry$2 = {}) => {
 	if (typeof retry$2 === "number") return {
@@ -2102,7 +2106,7 @@ const normalizeRetryOptions = (retry$2 = {}) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/ky@1.12.0/node_modules/ky/distribution/errors/TimeoutError.js
+//#region ../../node_modules/.pnpm/ky@1.13.0/node_modules/ky/distribution/errors/TimeoutError.js
 var TimeoutError = class extends Error {
 	request;
 	constructor(request) {
@@ -2113,7 +2117,7 @@ var TimeoutError = class extends Error {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/ky@1.12.0/node_modules/ky/distribution/utils/timeout.js
+//#region ../../node_modules/.pnpm/ky@1.13.0/node_modules/ky/distribution/utils/timeout.js
 async function timeout(request, init$1, abortController, options) {
 	return new Promise((resolve, reject) => {
 		const timeoutId = setTimeout(() => {
@@ -2127,7 +2131,7 @@ async function timeout(request, init$1, abortController, options) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/ky@1.12.0/node_modules/ky/distribution/utils/delay.js
+//#region ../../node_modules/.pnpm/ky@1.13.0/node_modules/ky/distribution/utils/delay.js
 async function delay(ms, { signal }) {
 	return new Promise((resolve, reject) => {
 		if (signal) {
@@ -2146,10 +2150,13 @@ async function delay(ms, { signal }) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/ky@1.12.0/node_modules/ky/distribution/utils/options.js
+//#region ../../node_modules/.pnpm/ky@1.13.0/node_modules/ky/distribution/utils/options.js
 const findUnknownOptions = (request, options) => {
 	const unknownOptions = {};
-	for (const key in options) if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && !(key in request)) unknownOptions[key] = options[key];
+	for (const key in options) {
+		if (!Object.hasOwn(options, key)) continue;
+		if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && (!(key in request) || key in vendorSpecificOptions)) unknownOptions[key] = options[key];
+	}
 	return unknownOptions;
 };
 const hasSearchParameters = (search) => {
@@ -2162,78 +2169,78 @@ const hasSearchParameters = (search) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/ky@1.12.0/node_modules/ky/distribution/utils/type-guards.js
+//#region ../../node_modules/.pnpm/ky@1.13.0/node_modules/ky/distribution/utils/type-guards.js
 /**
-* Type guard to check if an error is an HTTPError.
-*
-* @param error - The error to check
-* @returns `true` if the error is an HTTPError, `false` otherwise
-*
-* @example
-* ```
-* import ky, {isHTTPError} from 'ky';
-* try {
-*   const response = await ky.get('/api/data');
-* } catch (error) {
-*   if (isHTTPError(error)) {
-*     console.log('HTTP error status:', error.response.status);
-*   }
-* }
-* ```
+Type guard to check if an error is an HTTPError.
+
+@param error - The error to check
+@returns `true` if the error is an HTTPError, `false` otherwise
+
+@example
+```
+import ky, {isHTTPError} from 'ky';
+try {
+const response = await ky.get('/api/data');
+} catch (error) {
+if (isHTTPError(error)) {
+console.log('HTTP error status:', error.response.status);
+}
+}
+```
 */
 function isHTTPError(error) {
 	return error instanceof HTTPError || error?.name === HTTPError.name;
 }
 /**
-* Type guard to check if an error is a TimeoutError.
-*
-* @param error - The error to check
-* @returns `true` if the error is a TimeoutError, `false` otherwise
-*
-* @example
-* ```
-* import ky, {isTimeoutError} from 'ky';
-* try {
-*   const response = await ky.get('/api/data', { timeout: 1000 });
-* } catch (error) {
-*   if (isTimeoutError(error)) {
-*     console.log('Request timed out:', error.request.url);
-*   }
-* }
-* ```
+Type guard to check if an error is a TimeoutError.
+
+@param error - The error to check
+@returns `true` if the error is a TimeoutError, `false` otherwise
+
+@example
+```
+import ky, {isTimeoutError} from 'ky';
+try {
+const response = await ky.get('/api/data', { timeout: 1000 });
+} catch (error) {
+if (isTimeoutError(error)) {
+console.log('Request timed out:', error.request.url);
+}
+}
+```
 */
 function isTimeoutError(error) {
 	return error instanceof TimeoutError || error?.name === TimeoutError.name;
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/ky@1.12.0/node_modules/ky/distribution/core/Ky.js
+//#region ../../node_modules/.pnpm/ky@1.13.0/node_modules/ky/distribution/core/Ky.js
 var Ky = class Ky {
 	static create(input, options) {
 		const ky$1 = new Ky(input, options);
 		const function_ = async () => {
-			if (typeof ky$1._options.timeout === "number" && ky$1._options.timeout > maxSafeTimeout) throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
+			if (typeof ky$1.#options.timeout === "number" && ky$1.#options.timeout > maxSafeTimeout) throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
 			await Promise.resolve();
-			let response = await ky$1._fetch();
-			for (const hook of ky$1._options.hooks.afterResponse) {
-				const modifiedResponse = await hook(ky$1.request, ky$1.#getNormalizedOptions(), ky$1._decorateResponse(response.clone()), { retryCount: ky$1._retryCount });
+			let response = await ky$1.#fetch();
+			for (const hook of ky$1.#options.hooks.afterResponse) {
+				const modifiedResponse = await hook(ky$1.request, ky$1.#getNormalizedOptions(), ky$1.#decorateResponse(response.clone()), { retryCount: ky$1.#retryCount });
 				if (modifiedResponse instanceof globalThis.Response) response = modifiedResponse;
 			}
-			ky$1._decorateResponse(response);
-			if (!response.ok && ky$1._options.throwHttpErrors) {
+			ky$1.#decorateResponse(response);
+			if (!response.ok && ky$1.#options.throwHttpErrors) {
 				let error = new HTTPError(response, ky$1.request, ky$1.#getNormalizedOptions());
-				for (const hook of ky$1._options.hooks.beforeError) error = await hook(error, { retryCount: ky$1._retryCount });
+				for (const hook of ky$1.#options.hooks.beforeError) error = await hook(error, { retryCount: ky$1.#retryCount });
 				throw error;
 			}
-			if (ky$1._options.onDownloadProgress) {
-				if (typeof ky$1._options.onDownloadProgress !== "function") throw new TypeError("The `onDownloadProgress` option must be a function");
+			if (ky$1.#options.onDownloadProgress) {
+				if (typeof ky$1.#options.onDownloadProgress !== "function") throw new TypeError("The `onDownloadProgress` option must be a function");
 				if (!supportsResponseStreams) throw new Error("Streams are not supported in your environment. `ReadableStream` is missing.");
-				return streamResponse(response.clone(), ky$1._options.onDownloadProgress);
+				return streamResponse(response.clone(), ky$1.#options.onDownloadProgress);
 			}
 			return response;
 		};
-		const result = (ky$1._options.retry.methods.includes(ky$1.request.method.toLowerCase()) ? ky$1._retry(function_) : function_()).finally(async () => {
-			const originalRequest = ky$1._originalRequest;
+		const result = (ky$1.#options.retry.methods.includes(ky$1.request.method.toLowerCase()) ? ky$1.#retry(function_) : function_()).finally(async () => {
+			const originalRequest = ky$1.#originalRequest;
 			const cleanupPromises = [];
 			if (originalRequest && !originalRequest.bodyUsed) cleanupPromises.push(originalRequest.body?.cancel());
 			if (!ky$1.request.bodyUsed) cleanupPromises.push(ky$1.request.body?.cancel());
@@ -2261,116 +2268,150 @@ var Ky = class Ky {
 		return searchParams;
 	}
 	request;
-	abortController;
-	_retryCount = 0;
-	_input;
-	_options;
-	_originalRequest;
+	#abortController;
+	#retryCount = 0;
+	#input;
+	#options;
+	#originalRequest;
+	#userProvidedAbortSignal;
 	#cachedNormalizedOptions;
 	constructor(input, options = {}) {
-		this._input = input;
-		this._options = {
+		this.#input = input;
+		this.#options = {
 			...options,
-			headers: mergeHeaders(this._input.headers, options.headers),
+			headers: mergeHeaders(this.#input.headers, options.headers),
 			hooks: mergeHooks({
 				beforeRequest: [],
 				beforeRetry: [],
 				beforeError: [],
 				afterResponse: []
 			}, options.hooks),
-			method: normalizeRequestMethod(options.method ?? this._input.method ?? "GET"),
+			method: normalizeRequestMethod(options.method ?? this.#input.method ?? "GET"),
 			prefixUrl: String(options.prefixUrl || ""),
 			retry: normalizeRetryOptions(options.retry),
 			throwHttpErrors: options.throwHttpErrors !== false,
 			timeout: options.timeout ?? 1e4,
-			fetch: options.fetch ?? globalThis.fetch.bind(globalThis)
+			fetch: options.fetch ?? globalThis.fetch.bind(globalThis),
+			context: options.context ?? {}
 		};
-		if (typeof this._input !== "string" && !(this._input instanceof URL || this._input instanceof globalThis.Request)) throw new TypeError("`input` must be a string, URL, or Request");
-		if (this._options.prefixUrl && typeof this._input === "string") {
-			if (this._input.startsWith("/")) throw new Error("`input` must not begin with a slash when using `prefixUrl`");
-			if (!this._options.prefixUrl.endsWith("/")) this._options.prefixUrl += "/";
-			this._input = this._options.prefixUrl + this._input;
+		if (typeof this.#input !== "string" && !(this.#input instanceof URL || this.#input instanceof globalThis.Request)) throw new TypeError("`input` must be a string, URL, or Request");
+		if (this.#options.prefixUrl && typeof this.#input === "string") {
+			if (this.#input.startsWith("/")) throw new Error("`input` must not begin with a slash when using `prefixUrl`");
+			if (!this.#options.prefixUrl.endsWith("/")) this.#options.prefixUrl += "/";
+			this.#input = this.#options.prefixUrl + this.#input;
 		}
 		if (supportsAbortController && supportsAbortSignal) {
-			const originalSignal = this._options.signal ?? this._input.signal;
-			this.abortController = new globalThis.AbortController();
-			this._options.signal = originalSignal ? AbortSignal.any([originalSignal, this.abortController.signal]) : this.abortController.signal;
+			this.#userProvidedAbortSignal = this.#options.signal ?? this.#input.signal;
+			this.#abortController = new globalThis.AbortController();
+			this.#options.signal = this.#userProvidedAbortSignal ? AbortSignal.any([this.#userProvidedAbortSignal, this.#abortController.signal]) : this.#abortController.signal;
 		}
-		if (supportsRequestStreams) this._options.duplex = "half";
-		if (this._options.json !== void 0) {
-			this._options.body = this._options.stringifyJson?.(this._options.json) ?? JSON.stringify(this._options.json);
-			this._options.headers.set("content-type", this._options.headers.get("content-type") ?? "application/json");
+		if (supportsRequestStreams) this.#options.duplex = "half";
+		if (this.#options.json !== void 0) {
+			this.#options.body = this.#options.stringifyJson?.(this.#options.json) ?? JSON.stringify(this.#options.json);
+			this.#options.headers.set("content-type", this.#options.headers.get("content-type") ?? "application/json");
 		}
 		const userProvidedContentType = options.headers && new globalThis.Headers(options.headers).has("content-type");
-		if (this._input instanceof globalThis.Request && (supportsFormData && this._options.body instanceof globalThis.FormData || this._options.body instanceof URLSearchParams) && !userProvidedContentType) this._options.headers.delete("content-type");
-		this.request = new globalThis.Request(this._input, this._options);
-		if (hasSearchParameters(this._options.searchParams)) {
-			const searchParams = "?" + (typeof this._options.searchParams === "string" ? this._options.searchParams.replace(/^\?/, "") : new URLSearchParams(Ky.#normalizeSearchParams(this._options.searchParams)).toString());
+		if (this.#input instanceof globalThis.Request && (supportsFormData && this.#options.body instanceof globalThis.FormData || this.#options.body instanceof URLSearchParams) && !userProvidedContentType) this.#options.headers.delete("content-type");
+		this.request = new globalThis.Request(this.#input, this.#options);
+		if (hasSearchParameters(this.#options.searchParams)) {
+			const searchParams = "?" + (typeof this.#options.searchParams === "string" ? this.#options.searchParams.replace(/^\?/, "") : new URLSearchParams(Ky.#normalizeSearchParams(this.#options.searchParams)).toString());
 			const url$2 = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
-			this.request = new globalThis.Request(new globalThis.Request(url$2, { ...this.request }), this._options);
+			this.request = new globalThis.Request(new globalThis.Request(url$2, { ...this.request }), this.#options);
 		}
-		if (this._options.onUploadProgress) {
-			if (typeof this._options.onUploadProgress !== "function") throw new TypeError("The `onUploadProgress` option must be a function");
+		if (this.#options.onUploadProgress) {
+			if (typeof this.#options.onUploadProgress !== "function") throw new TypeError("The `onUploadProgress` option must be a function");
 			if (!supportsRequestStreams) throw new Error("Request streams are not supported in your environment. The `duplex` option for `Request` is not available.");
-			if (this.request.body) this.request = streamRequest(this.request, this._options.onUploadProgress, this._options.body);
+			if (this.request.body) this.request = streamRequest(this.request, this.#options.onUploadProgress, this.#options.body);
+		}
+	}
+	#calculateDelay() {
+		const retryDelay = this.#options.retry.delay(this.#retryCount);
+		let jitteredDelay = retryDelay;
+		if (this.#options.retry.jitter === true) jitteredDelay = Math.random() * retryDelay;
+		else if (typeof this.#options.retry.jitter === "function") {
+			jitteredDelay = this.#options.retry.jitter(retryDelay);
+			if (!Number.isFinite(jitteredDelay) || jitteredDelay < 0) jitteredDelay = retryDelay;
+		}
+		return Math.min(this.#options.retry.backoffLimit, jitteredDelay);
+	}
+	async #calculateRetryDelay(error) {
+		this.#retryCount++;
+		if (this.#retryCount > this.#options.retry.limit) throw error;
+		const errorObject = error instanceof Error ? error : new NonError(error);
+		if (this.#options.retry.shouldRetry !== void 0) {
+			const result = await this.#options.retry.shouldRetry({
+				error: errorObject,
+				retryCount: this.#retryCount
+			});
+			if (result === false) throw error;
+			if (result === true) return this.#calculateDelay();
 		}
-	}
-	_calculateRetryDelay(error) {
-		this._retryCount++;
-		if (this._retryCount > this._options.retry.limit || isTimeoutError(error)) throw error;
+		if (isTimeoutError(error) && !this.#options.retry.retryOnTimeout) throw error;
 		if (isHTTPError(error)) {
-			if (!this._options.retry.statusCodes.includes(error.response.status)) throw error;
-			const retryAfter = error.response.headers.get("Retry-After") ?? error.response.headers.get("RateLimit-Reset") ?? error.response.headers.get("X-RateLimit-Reset") ?? error.response.headers.get("X-Rate-Limit-Reset");
-			if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
+			if (!this.#options.retry.statusCodes.includes(error.response.status)) throw error;
+			const retryAfter = error.response.headers.get("Retry-After") ?? error.response.headers.get("RateLimit-Reset") ?? error.response.headers.get("X-RateLimit-Retry-After") ?? error.response.headers.get("X-RateLimit-Reset") ?? error.response.headers.get("X-Rate-Limit-Reset");
+			if (retryAfter && this.#options.retry.afterStatusCodes.includes(error.response.status)) {
 				let after = Number(retryAfter) * 1e3;
 				if (Number.isNaN(after)) after = Date.parse(retryAfter) - Date.now();
 				else if (after >= Date.parse("2024-01-01")) after -= Date.now();
-				const max = this._options.retry.maxRetryAfter ?? after;
+				const max = this.#options.retry.maxRetryAfter ?? after;
 				return after < max ? after : max;
 			}
 			if (error.response.status === 413) throw error;
 		}
-		const retryDelay = this._options.retry.delay(this._retryCount);
-		return Math.min(this._options.retry.backoffLimit, retryDelay);
+		return this.#calculateDelay();
 	}
-	_decorateResponse(response) {
-		if (this._options.parseJson) response.json = async () => this._options.parseJson(await response.text());
+	#decorateResponse(response) {
+		if (this.#options.parseJson) response.json = async () => this.#options.parseJson(await response.text());
 		return response;
 	}
-	async _retry(function_) {
+	async #retry(function_) {
 		try {
 			return await function_();
 		} catch (error) {
-			const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
-			if (this._retryCount < 1) throw error;
-			await delay(ms, { signal: this._options.signal });
-			for (const hook of this._options.hooks.beforeRetry) if (await hook({
-				request: this.request,
-				options: this.#getNormalizedOptions(),
-				error,
-				retryCount: this._retryCount
-			}) === stop) return;
-			return this._retry(function_);
-		}
-	}
-	async _fetch() {
-		for (const hook of this._options.hooks.beforeRequest) {
-			const result = await hook(this.request, this.#getNormalizedOptions(), { retryCount: this._retryCount });
+			const ms = Math.min(await this.#calculateRetryDelay(error), maxSafeTimeout);
+			if (this.#retryCount < 1) throw error;
+			await delay(ms, this.#userProvidedAbortSignal ? { signal: this.#userProvidedAbortSignal } : {});
+			for (const hook of this.#options.hooks.beforeRetry) {
+				const hookResult = await hook({
+					request: this.request,
+					options: this.#getNormalizedOptions(),
+					error,
+					retryCount: this.#retryCount
+				});
+				if (hookResult instanceof globalThis.Request) {
+					this.request = hookResult;
+					break;
+				}
+				if (hookResult instanceof globalThis.Response) return hookResult;
+				if (hookResult === stop) return;
+			}
+			return this.#retry(function_);
+		}
+	}
+	async #fetch() {
+		if (this.#abortController?.signal.aborted) {
+			this.#abortController = new globalThis.AbortController();
+			this.#options.signal = this.#userProvidedAbortSignal ? AbortSignal.any([this.#userProvidedAbortSignal, this.#abortController.signal]) : this.#abortController.signal;
+			this.request = new globalThis.Request(this.request, { signal: this.#options.signal });
+		}
+		for (const hook of this.#options.hooks.beforeRequest) {
+			const result = await hook(this.request, this.#getNormalizedOptions(), { retryCount: this.#retryCount });
 			if (result instanceof Request) {
 				this.request = result;
 				break;
 			}
 			if (result instanceof Response) return result;
 		}
-		const nonRequestOptions = findUnknownOptions(this.request, this._options);
-		this._originalRequest = this.request;
-		this.request = this._originalRequest.clone();
-		if (this._options.timeout === false) return this._options.fetch(this._originalRequest, nonRequestOptions);
-		return timeout(this._originalRequest, nonRequestOptions, this.abortController, this._options);
+		const nonRequestOptions = findUnknownOptions(this.request, this.#options);
+		this.#originalRequest = this.request;
+		this.request = this.#originalRequest.clone();
+		if (this.#options.timeout === false) return this.#options.fetch(this.#originalRequest, nonRequestOptions);
+		return timeout(this.#originalRequest, nonRequestOptions, this.#abortController, this.#options);
 	}
 	#getNormalizedOptions() {
 		if (!this.#cachedNormalizedOptions) {
-			const { hooks,...normalizedOptions } = this._options;
+			const { hooks,...normalizedOptions } = this.#options;
 			this.#cachedNormalizedOptions = Object.freeze(normalizedOptions);
 		}
 		return this.#cachedNormalizedOptions;
@@ -2378,7 +2419,7 @@ var Ky = class Ky {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/ky@1.12.0/node_modules/ky/distribution/index.js
+//#region ../../node_modules/.pnpm/ky@1.13.0/node_modules/ky/distribution/index.js
 const createInstance = (defaults$1) => {
 	const ky$1 = (input, options) => Ky.create(input, validateAndMerge(defaults$1, options));
 	for (const method of requestMethods) ky$1[method] = (input, options) => Ky.create(input, validateAndMerge(defaults$1, options, { method }));
@@ -3709,9 +3750,9 @@ var require_dist$1 = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@pnp
 }) });
 
 //#endregion
-//#region ../../node_modules/.pnpm/tsdown@0.15.9_typescript@5.9.3/node_modules/tsdown/esm-shims.js
+//#region ../../node_modules/.pnpm/tsdown@0.15.10_typescript@5.9.3/node_modules/tsdown/esm-shims.js
 var getFilename, getDirname, __dirname$2;
-var init_esm_shims = __esm({ "../../node_modules/.pnpm/tsdown@0.15.9_typescript@5.9.3/node_modules/tsdown/esm-shims.js": (() => {
+var init_esm_shims = __esm({ "../../node_modules/.pnpm/tsdown@0.15.10_typescript@5.9.3/node_modules/tsdown/esm-shims.js": (() => {
 	getFilename = () => fileURLToPath(import.meta.url);
 	getDirname = () => path.dirname(getFilename());
 	__dirname$2 = /* @__PURE__ */ getDirname();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@yamada-ui/cli",
   "type": "module",
-  "version": "2.0.4",
+  "version": "2.0.5-dev-20251027025837",
   "description": "The official CLI for Yamada UI projects",
   "keywords": [
     "theme",
@@ -57,7 +57,7 @@
     "sucrase": "^3.35.0",
     "validate-npm-package-name": "^6.0.2",
     "yamljs": "^0.3.0",
-    "@yamada-ui/utils": "2.0.3"
+    "@yamada-ui/utils": "2.0.4-dev-20251027025837"
   },
   "devDependencies": {
     "@types/prompts": "^2.4.9",