azot 5.0.0-alpha.12 → 5.0.0-alpha.13

package/dist/context-AYnteC1j.cjs

@@ -0,0 +1,2267 @@
+const require_chunk = require('./chunk-BmvPcxpV.cjs');
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_os = require("node:os");
+node_os = require_chunk.__toESM(node_os);
+let node_timers_promises = require("node:timers/promises");
+let _inquirer_prompts = require("@inquirer/prompts");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_chunk.__toESM(node_fs_promises);
+let _logtape_logtape = require("@logtape/logtape");
+let _logtape_file = require("@logtape/file");
+let _logtape_pretty = require("@logtape/pretty");
+let node_process = require("node:process");
+let node_events = require("node:events");
+node_events = require_chunk.__toESM(node_events);
+require("urlpattern-polyfill");
+let node_readline_promises = require("node:readline/promises");
+let impit = require("impit");
+let undici = require("undici");
+let metavm = require("metavm");
+metavm = require_chunk.__toESM(metavm);
+let node_child_process = require("node:child_process");
+require("picocolors");
+require("nanospinner");
+let conf = require("conf");
+conf = require_chunk.__toESM(conf);
+
+//#region ../../apps/desktop/package.json
+var name = "azot-desktop";
+var version$1 = "5.0.0-alpha.41";
+var productName = "Azot";
+var package_default = {
+	name,
+	version: version$1,
+	description: "A powerful, extensible app for downloading videos",
+	keywords: ["downloader"],
+	homepage: "https://azot.mov",
+	author: "Vitaly Gashkov <vitalygashkov@vk.com>",
+	repository: {
+		"type": "git",
+		"url": "https://github.com/azot-labs/azot.git"
+	},
+	funding: [{
+		"type": "individual",
+		"url": "https://t.me/tribute/app?startapp=dqW2"
+	}],
+	files: ["out"],
+	os: [
+		"darwin",
+		"linux",
+		"win32"
+	],
+	main: "./out/main.js",
+	scripts: {
+		"start": "tsx --env-file .env ./src/main/cli.ts",
+		"preview": "electron-vite preview --config vite.desktop.config.mjs",
+		"dev": "electron-vite dev --config vite.desktop.config.mjs --watch",
+		"cli": "pnpm run bundle:extensions && bun run ./src/main/cli.ts --env-file .env",
+		"test": "vitest",
+		"coverage": "vitest run --coverage",
+		"bundle:extensions": "node ./scripts/bundle-extensions.mjs",
+		"bundle:cli": "pnpm run bundle:extensions && node ./scripts/bundle-cli.mjs",
+		"bundle": "pnpm run bundle:extensions && electron-vite build --config vite.cli.config.mjs && electron-vite build --config vite.desktop.config.mjs",
+		"prebuild": "pnpm -C ../../packages/api build",
+		"build:cli": "pnpm -C ../../packages/molnia build && pnpm run bundle:cli && bun build --compile ./out/cli.mjs --minify --outfile ./release/azot",
+		"build": "pnpm run bundle && electron-builder build --config electron-builder.config.js",
+		"build:mac": "pnpm run bundle && electron-builder build --mac --arm64 --config electron-builder.config.js",
+		"build:mac:intel": "pnpm run bundle && electron-builder build --mac --x64 --config electron-builder.config.js",
+		"build:win": "pnpm run bundle && electron-builder build --win --config electron-builder.config.js",
+		"build:linux": "pnpm run bundle && electron-builder build --linux --config electron-builder.config.js",
+		"publish:desktop": "pnpm run bundle && electron-builder build --publish always --config electron-builder.config.js",
+		"typecheck": "pnpm run typecheck:node && pnpm run typecheck:web",
+		"typecheck:node": "tsc --noEmit -p tsconfig.node.json --composite false",
+		"typecheck:web": "vue-tsc --noEmit -p tsconfig.web.json --composite false",
+		"lint": "../../node_modules/.bin/oxlint -c ../../.oxlintrc.json .",
+		"lint:fix": "../../node_modules/.bin/oxlint -c ../../.oxlintrc.json --fix .",
+		"fmt": "../../node_modules/.bin/oxfmt -c ../../.oxfmtrc.json .",
+		"fmt:check": "../../node_modules/.bin/oxfmt -c ../../.oxfmtrc.json --check ."
+	},
+	dependencies: {
+		"@electron-toolkit/preload": "^3.0.2",
+		"@electron-toolkit/utils": "^4.0.0",
+		"@gitbeaker/rest": "^43.8.0",
+		"@inquirer/prompts": "^8.2.1",
+		"@logtape/file": "^2.0.2",
+		"@logtape/logtape": "^2.0.2",
+		"@logtape/pretty": "^2.0.2",
+		"@tanstack/query-core": "^5.90.20",
+		"@tribute-tg/better-auth": "^2.1.8",
+		"azot": "workspace:*",
+		"better-auth": "^1.4.18",
+		"bytenode": "^1.5.7",
+		"conf": "^15.1.0",
+		"cookie": "^1.1.1",
+		"cross-spawn": "^7.0.6",
+		"dasha": "4.0.0-alpha.11",
+		"electron-squirrel-startup": "^1.0.1",
+		"electron-updater": "^6.8.3",
+		"impit": "^0.9.2",
+		"ky": "^1.14.3",
+		"mediabunny": "^1.34.4",
+		"metavm": "^1.4.5",
+		"molnia": "workspace:*",
+		"nanospinner": "^1.2.2",
+		"okova": "^0.10.5",
+		"open": "^11.0.0",
+		"p-queue": "^9.1.0",
+		"picocolors": "^1.1.1",
+		"posthog-js": "^1.342.1",
+		"semver": "^7.7.4",
+		"telegram-better-auth": "^0.0.8",
+		"undici": "^7.22.0",
+		"urlpattern-polyfill": "^10.1.0",
+		"yargs": "^18.0.0",
+		"yauzl": "^3.2.0",
+		"zod": "^4.3.6"
+	},
+	devDependencies: {
+		"@electron-toolkit/tsconfig": "^2.0.0",
+		"@iconify/vue": "^5.0.0",
+		"@intlify/unplugin-vue-i18n": "^11.0.7",
+		"@tailwindcss/vite": "^4.2.0",
+		"@tanstack/vue-query": "^5.92.9",
+		"@types/node": "^25.3.0",
+		"@types/semver": "^7.7.1",
+		"@types/wicg-file-system-access": "^2023.10.7",
+		"@types/yargs": "^17.0.35",
+		"@vee-validate/zod": "^4.15.1",
+		"@vitejs/plugin-vue": "^6.0.4",
+		"@vueuse/core": "^14.2.1",
+		"class-variance-authority": "^0.7.1",
+		"clsx": "^2.1.1",
+		"dotenv": "^17.3.1",
+		"electron": "39.5.1",
+		"electron-builder": "^26.8.1",
+		"electron-vite": "^5.0.0",
+		"esbuild": "^0.27.3",
+		"execa": "^9.6.0",
+		"lucide-vue-next": "^0.575.0",
+		"non.geist": "^1.0.4",
+		"pinia": "^3.0.4",
+		"postcss": "^8.5.6",
+		"reka-ui": "^2.8.2",
+		"rolldown": "^1.0.0-rc.5",
+		"sass": "^1.97.3",
+		"tailwind-merge": "^3.5.0",
+		"tailwindcss": "^4.2.0",
+		"tailwindcss-animate": "^1.0.7",
+		"tsdown": "^0.20.3",
+		"tsx": "^4.21.0",
+		"typescript": "^5.9.3",
+		"vee-validate": "^4.15.1",
+		"vite": "^7.3.1",
+		"vite-plugin-static-copy": "^3.1.2",
+		"vitest": "^4.0.18",
+		"vue": "^3.5.28",
+		"vue-i18n": "^11.2.8",
+		"vue-sonner": "^2.0.9",
+		"vue-tsc": "^3.2.5"
+	},
+	peerDependencies: { "vitest": ">=3.2.0" },
+	engines: { "node": ">=22" },
+	productName,
+	readmeFilename: "README.md"
+};
+
+//#endregion
+//#region ../../apps/desktop/src/main/config.ts
+const isPkg = "pkg" in process && process.pkg !== void 0;
+const isElectron = !!process.versions.electron && false;
+const isCLI = !isElectron;
+const fullVersion = `v${version$1} ${node_process.platform}-${node_process.arch} node-${node_process.version}`;
+const shortVersion = `v${version$1}`;
+const APP_NAME = name.split("/")[0]?.split("-")[0]?.replace("@", "");
+const APP_TITLE = productName;
+const OS_TITLE_MAP = {
+	darwin: "macOS",
+	win32: "Windows",
+	linux: "Linux"
+};
+const OS_TITLE = OS_TITLE_MAP[process.platform];
+
+//#endregion
+//#region ../../apps/desktop/src/main/path.ts
+const resolveDir = (input) => {
+	const dir = typeof input === "string" ? input : input[OS_TITLE];
+	if (!(0, node_fs.existsSync)(dir)) (0, node_fs.mkdirSync)(dir, { recursive: true });
+	return dir;
+};
+const HOME_DIR = (0, node_os.homedir)();
+const TEMP_DIR = (0, node_os.tmpdir)();
+const DATA_DIR = resolveDir({
+	Windows: process.env.APPDATA || (0, node_path.join)(HOME_DIR, "AppData", "Roaming"),
+	macOS: (0, node_path.join)(HOME_DIR, "Library", "Application Support"),
+	Linux: process.env.XDG_DATA_HOME || (0, node_path.join)(HOME_DIR, ".local", "share")
+});
+const CONFIG_DIR = resolveDir({
+	Windows: process.env.APPDATA || (0, node_path.join)(HOME_DIR, "AppData", "Roaming"),
+	macOS: (0, node_path.join)(HOME_DIR, "Library", "Application Support"),
+	Linux: process.env.XDG_CONFIG_HOME || (0, node_path.join)(HOME_DIR, ".config")
+});
+const CACHE_DIR = resolveDir({
+	Windows: process.env.LOCALAPPDATA || (0, node_path.join)(HOME_DIR, "AppData", "Local"),
+	macOS: (0, node_path.join)(HOME_DIR, "Library", "Caches"),
+	Linux: process.env.XDG_CACHE_HOME || (0, node_path.join)(HOME_DIR, ".cache")
+});
+const DOWNLOAD_DIR = resolveDir({
+	Windows: (0, node_path.join)(HOME_DIR, "Downloads"),
+	macOS: (0, node_path.join)(HOME_DIR, "Downloads"),
+	Linux: process.env.XDG_DOWNLOAD_DIR || (0, node_path.join)(HOME_DIR, "Downloads")
+});
+const APP_DATA_DIR = resolveDir({
+	Windows: (0, node_path.join)(DATA_DIR, APP_TITLE),
+	macOS: (0, node_path.join)(DATA_DIR, APP_TITLE),
+	Linux: (0, node_path.join)(DATA_DIR, APP_TITLE.toLowerCase())
+});
+const APP_CONFIG_DIR = resolveDir({
+	Windows: (0, node_path.join)(CONFIG_DIR, APP_TITLE),
+	macOS: (0, node_path.join)(CONFIG_DIR, APP_TITLE),
+	Linux: (0, node_path.join)(CONFIG_DIR, APP_TITLE.toLowerCase())
+});
+const APP_LOG_DIR = resolveDir({
+	Windows: (0, node_path.join)(CONFIG_DIR, APP_TITLE, "logs"),
+	macOS: (0, node_path.join)(HOME_DIR, "Library", "Logs", APP_TITLE),
+	Linux: (0, node_path.join)(CONFIG_DIR, APP_TITLE.toLowerCase(), "logs")
+});
+const APP_TEMP_DIR = (0, node_path.join)(TEMP_DIR, APP_TITLE.toLowerCase());
+const EXTENSIONS_DIR = resolveDir((0, node_path.join)(APP_DATA_DIR, "extensions"));
+const EXTENSIONS_SOURCES_DIR = resolveDir((0, node_path.join)(EXTENSIONS_DIR, "installed"));
+const EXTENSIONS_DATA_DIR = resolveDir((0, node_path.join)(EXTENSIONS_DIR, "work"));
+const EXTENSIONS_INDEX_PATH = resolveDir((0, node_path.join)(EXTENSIONS_DIR, "index.json"));
+const SETTINGS_PATH = (0, node_path.join)(APP_CONFIG_DIR, "settings.json");
+
+//#endregion
+//#region ../../apps/desktop/src/main/core/logger.ts
+const isDev = process.argv.includes("-d") || process.argv.includes("--debug") || process.env.NODE_ENV_ELECTRON_VITE === "development" || !!process.env.ELECTRON_CLI_ARGS;
+const getLogFileName = () => {
+	return `Azot_${(/* @__PURE__ */ new Date()).toISOString().split(".")[0].replace("T", "_").replaceAll("-", "").replaceAll(":", "")}.log`;
+};
+const getLogFilePath = () => (0, node_path.join)(APP_LOG_DIR, getLogFileName());
+(0, _logtape_logtape.configureSync)({
+	sinks: {
+		console: (0, _logtape_logtape.withFilter)((0, _logtape_logtape.getConsoleSink)({ formatter: (0, _logtape_pretty.getPrettyFormatter)({
+			timestamp: "time",
+			messageColor: null,
+			messageStyle: null,
+			levelStyle: null,
+			icons: false,
+			colors: true,
+			level: "FULL",
+			categoryWidth: 0,
+			categoryStyle: null,
+			categoryTruncate: "end",
+			wordWrap: true
+		}) }), isDev ? "debug" : "info"),
+		file: (0, _logtape_file.getFileSink)(getLogFilePath(), { flushInterval: 0 })
+	},
+	loggers: [{
+		category: [],
+		lowestLevel: "trace",
+		sinks: ["console", "file"]
+	}, {
+		category: ["logtape", "meta"],
+		lowestLevel: "error",
+		sinks: ["console"]
+	}]
+});
+const logger = (0, _logtape_logtape.getLogger)([]);
+
+//#endregion
+//#region ../../apps/desktop/src/main/core/feedback.ts
+var Feedback = class Feedback extends node_events.EventEmitter {
+	static requestEventName = "feedback";
+	static responseEventName = "feedback:response";
+	#queue = Promise.resolve();
+	async ask(request) {
+		const run = () => new Promise((resolve) => {
+			this.once(Feedback.responseEventName, (response) => {
+				resolve(response);
+			});
+			this.emit(Feedback.requestEventName, request);
+		});
+		const next = this.#queue.then(run, run);
+		this.#queue = next.then(() => void 0, () => void 0);
+		return next;
+	}
+	listen(listener) {
+		this.addListener(Feedback.requestEventName, async (request) => {
+			const answer = await listener(request);
+			this.emit(Feedback.responseEventName, answer);
+		});
+	}
+};
+const feedback = new Feedback();
+
+//#endregion
+//#region ../../apps/desktop/src/main/core/utils.ts
+const sanitizeString = (text) => {
+	const forbidden = [
+		"}",
+		"{",
+		"%",
+		">",
+		"<",
+		"^",
+		";",
+		"`",
+		"$",
+		"\"",
+		"@",
+		"="
+	];
+	let result = text;
+	for (const i in forbidden) result = result.replaceAll("/", "_").replaceAll(forbidden[i], "");
+	return result;
+};
+const execUrlPatterns = (url, patterns, baseUrls) => {
+	const pathname = {};
+	const search = {};
+	for (const baseUrl of baseUrls) for (const path of patterns) {
+		const patternResult = new URLPattern(path, baseUrl).exec(url);
+		if (patternResult) {
+			Object.assign(pathname, patternResult.pathname.groups);
+			Object.assign(search, patternResult.search.groups);
+		}
+	}
+	return {
+		pathname,
+		search
+	};
+};
+const extendEpisodes = (episodesBySeasons = /* @__PURE__ */ new Map()) => {
+	const has = (episode, season) => {
+		for (const s of episodesBySeasons.keys()) for (const e of episodesBySeasons.get(s) || []) {
+			const seasonEmpty = season === void 0 || isNaN(season);
+			const episodeEmpty = episode === void 0 || isNaN(episode);
+			let hasMatch = false;
+			if (episodeEmpty) hasMatch = s === season;
+			else hasMatch = (seasonEmpty ? isNaN(s) : s === season) && e === episode;
+			if (hasMatch) return true;
+		}
+		return false;
+	};
+	const set = (episode, season) => {
+		const s = season || NaN;
+		const e = episode || NaN;
+		if (episodesBySeasons.has(s)) episodesBySeasons.get(s)?.add(e);
+		else episodesBySeasons.set(s, new Set([e]));
+	};
+	const getAllEpisodeNumbers = () => Array.from(episodesBySeasons.values()).flatMap((value) => Array.from(value));
+	const seasonsCount = episodesBySeasons.size;
+	const episodes = getAllEpisodeNumbers();
+	const episodesCount = episodes.length;
+	const getMin = () => Math.min(...episodes);
+	const getMax = () => Math.max(...episodes);
+	return {
+		items: episodesBySeasons,
+		has,
+		set,
+		getMin,
+		getMax,
+		seasonsCount,
+		episodesCount
+	};
+};
+const dateTimeFormatter = new Intl.DateTimeFormat("en-US", {
+	year: "numeric",
+	month: "2-digit",
+	day: "2-digit",
+	hour: "2-digit",
+	minute: "2-digit",
+	second: "2-digit",
+	hour12: false
+});
+const timeFormatter = new Intl.DateTimeFormat("en-US", {
+	hour: "2-digit",
+	minute: "2-digit",
+	second: "2-digit",
+	hour12: false
+});
+
+//#endregion
+//#region ../../apps/desktop/src/main/core/prompt.ts
+var Prompt = class Prompt extends node_events.EventEmitter {
+	static requestEventName = "form";
+	static responseEventName = "form:response";
+	title;
+	#queue = Promise.resolve();
+	constructor(defaults = {}) {
+		super();
+		this.title = defaults.title;
+		if (isCLI) this.listen(async (form) => {
+			const readline = (0, node_readline_promises.createInterface)({
+				input: node_process.stdin,
+				output: node_process.stdout
+			});
+			const { title, description, fields, ...restFields } = form;
+			const response = {};
+			for (const [field, { label, type }] of Object.entries(fields || restFields)) {
+				const isBooleanQuestion = type === "confirm";
+				const formattedMessage = [
+					title,
+					description,
+					label
+				].filter(Boolean).join(". ") + (isBooleanQuestion ? " (y/n)" : "") + ": ";
+				response[field] = await Promise.race([readline.question(formattedMessage), (0, node_timers_promises.setTimeout)(TIMEOUT, "")]);
+			}
+			readline.close();
+			return response;
+		});
+	}
+	async ask(request) {
+		const run = () => new Promise((resolve) => {
+			this.once(Prompt.responseEventName, (response) => {
+				resolve(response);
+			});
+			this.emit(Prompt.requestEventName, request);
+		});
+		const next = this.#queue.then(run, run);
+		this.#queue = next.then(() => void 0, () => void 0);
+		return next;
+	}
+	listen(listener) {
+		this.addListener(Prompt.requestEventName, async (request) => {
+			const answer = await listener(request);
+			this.emit(Prompt.responseEventName, answer);
+		});
+	}
+};
+const prompt = new Prompt();
+const input = async (message, options) => {
+	const fields = options?.fields ?? { answer: { label: message } };
+	return await prompt.ask({
+		title: options?.title,
+		description: message,
+		fields
+	});
+};
+const TIMEOUT = 12e4;
+
+//#endregion
+//#region ../../node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/errors/HTTPError.js
+var HTTPError = class extends Error {
+	response;
+	request;
+	options;
+	constructor(response, request, options) {
+		const status = `${response.status || response.status === 0 ? response.status : ""} ${response.statusText ?? ""}`.trim();
+		const reason = status ? `status code ${status}` : "an unknown error";
+		super(`Request failed with ${reason}: ${request.method} ${request.url}`);
+		this.name = "HTTPError";
+		this.response = response;
+		this.request = request;
+		this.options = options;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/ky@1.14.3/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.14.3/node_modules/ky/distribution/errors/ForceRetryError.js
+/**
+Internal error used to signal a forced retry from afterResponse hooks.
+This is thrown when a user returns ky.retry() from an afterResponse hook.
+*/
+var ForceRetryError = class extends Error {
+	name = "ForceRetryError";
+	customDelay;
+	code;
+	customRequest;
+	constructor(options) {
+		const cause = options?.cause ? options.cause instanceof Error ? options.cause : new NonError(options.cause) : void 0;
+		super(options?.code ? `Forced retry: ${options.code}` : "Forced retry", cause ? { cause } : void 0);
+		this.customDelay = options?.delay;
+		this.code = options?.code;
+		this.customRequest = options?.request;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/core/constants.js
+const supportsRequestStreams = (() => {
+	let duplexAccessed = false;
+	let hasContentType = false;
+	const supportsReadableStream = typeof globalThis.ReadableStream === "function";
+	const supportsRequest = typeof globalThis.Request === "function";
+	if (supportsReadableStream && supportsRequest) try {
+		hasContentType = new globalThis.Request("https://empty.invalid", {
+			body: new globalThis.ReadableStream(),
+			method: "POST",
+			get duplex() {
+				duplexAccessed = true;
+				return "half";
+			}
+		}).headers.has("Content-Type");
+	} catch (error) {
+		if (error instanceof Error && error.message === "unsupported BodyInit type") return false;
+		throw error;
+	}
+	return duplexAccessed && !hasContentType;
+})();
+const supportsAbortController = typeof globalThis.AbortController === "function";
+const supportsAbortSignal = typeof globalThis.AbortSignal === "function" && typeof globalThis.AbortSignal.any === "function";
+const supportsResponseStreams = typeof globalThis.ReadableStream === "function";
+const supportsFormData = typeof globalThis.FormData === "function";
+const requestMethods = [
+	"get",
+	"post",
+	"put",
+	"patch",
+	"head",
+	"delete"
+];
+const validate = () => void 0;
+validate();
+const responseTypes = {
+	json: "application/json",
+	text: "text/*",
+	formData: "multipart/form-data",
+	arrayBuffer: "*/*",
+	blob: "*/*",
+	bytes: "*/*"
+};
+const maxSafeTimeout = 2147483647;
+const usualFormBoundarySize = new TextEncoder().encode("------WebKitFormBoundaryaxpyiPgbbPti10Rw").length;
+const stop = Symbol("stop");
+/**
+Marker returned by ky.retry() to signal a forced retry from afterResponse hooks.
+*/
+var RetryMarker = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+};
+/**
+Force a retry from an `afterResponse` hook.
+
+This allows you to retry a request based on the response content, even if the response has a successful status code. The retry will respect the `retry.limit` option and skip the `shouldRetry` check. The forced retry is observable in `beforeRetry` hooks, where the error will be a `ForceRetryError`.
+
+@param options - Optional configuration for the retry.
+
+@example
+```
+import ky, {isForceRetryError} from 'ky';
+
+const api = ky.extend({
+hooks: {
+afterResponse: [
+async (request, options, response) => {
+// Retry based on response body content
+if (response.status === 200) {
+const data = await response.clone().json();
+
+// Simple retry with default delay
+if (data.error?.code === 'TEMPORARY_ERROR') {
+return ky.retry();
+}
+
+// Retry with custom delay from API response
+if (data.error?.code === 'RATE_LIMIT') {
+return ky.retry({
+delay: data.error.retryAfter * 1000,
+code: 'RATE_LIMIT'
+});
+}
+
+// Retry with a modified request (e.g., fallback endpoint)
+if (data.error?.code === 'FALLBACK_TO_BACKUP') {
+return ky.retry({
+request: new Request('https://backup-api.com/endpoint', {
+method: request.method,
+headers: request.headers,
+}),
+code: 'BACKUP_ENDPOINT'
+});
+}
+
+// Retry with refreshed authentication
+if (data.error?.code === 'TOKEN_REFRESH' && data.newToken) {
+return ky.retry({
+request: new Request(request, {
+headers: {
+...Object.fromEntries(request.headers),
+'Authorization': `Bearer ${data.newToken}`
+}
+}),
+code: 'TOKEN_REFRESHED'
+});
+}
+
+// Retry with cause to preserve error chain
+try {
+validateResponse(data);
+} catch (error) {
+return ky.retry({
+code: 'VALIDATION_FAILED',
+cause: error
+});
+}
+}
+}
+],
+beforeRetry: [
+({error, retryCount}) => {
+// Observable in beforeRetry hooks
+if (isForceRetryError(error)) {
+console.log(`Forced retry #${retryCount}: ${error.message}`);
+// Example output: "Forced retry #1: Forced retry: RATE_LIMIT"
+}
+}
+]
+}
+});
+
+const response = await api.get('https://example.com/api');
+```
+*/
+const retry = (options) => new RetryMarker(options);
+const kyOptionKeys = {
+	json: true,
+	parseJson: true,
+	stringifyJson: true,
+	searchParams: true,
+	prefixUrl: true,
+	retry: true,
+	timeout: true,
+	hooks: true,
+	throwHttpErrors: true,
+	onDownloadProgress: true,
+	onUploadProgress: true,
+	fetch: true,
+	context: true
+};
+const vendorSpecificOptions = { next: true };
+const requestOptionsRegistry = {
+	method: true,
+	headers: true,
+	body: true,
+	mode: true,
+	credentials: true,
+	cache: true,
+	redirect: true,
+	referrer: true,
+	referrerPolicy: true,
+	integrity: true,
+	keepalive: true,
+	signal: true,
+	window: true,
+	duplex: true
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/body.js
+const getBodySize = (body) => {
+	if (!body) return 0;
+	if (body instanceof FormData) {
+		let size = 0;
+		for (const [key, value] of body) {
+			size += usualFormBoundarySize;
+			size += new TextEncoder().encode(`Content-Disposition: form-data; name="${key}"`).length;
+			size += typeof value === "string" ? new TextEncoder().encode(value).length : value.size;
+		}
+		return size;
+	}
+	if (body instanceof Blob) return body.size;
+	if (body instanceof ArrayBuffer) return body.byteLength;
+	if (typeof body === "string") return new TextEncoder().encode(body).length;
+	if (body instanceof URLSearchParams) return new TextEncoder().encode(body.toString()).length;
+	if ("byteLength" in body) return body.byteLength;
+	if (typeof body === "object" && body !== null) try {
+		const jsonString = JSON.stringify(body);
+		return new TextEncoder().encode(jsonString).length;
+	} catch {
+		return 0;
+	}
+	return 0;
+};
+const withProgress = (stream, totalBytes, onProgress) => {
+	let previousChunk;
+	let transferredBytes = 0;
+	return stream.pipeThrough(new TransformStream({
+		transform(currentChunk, controller) {
+			controller.enqueue(currentChunk);
+			if (previousChunk) {
+				transferredBytes += previousChunk.byteLength;
+				let percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
+				if (percent >= 1) percent = 1 - Number.EPSILON;
+				onProgress?.({
+					percent,
+					totalBytes: Math.max(totalBytes, transferredBytes),
+					transferredBytes
+				}, previousChunk);
+			}
+			previousChunk = currentChunk;
+		},
+		flush() {
+			if (previousChunk) {
+				transferredBytes += previousChunk.byteLength;
+				onProgress?.({
+					percent: 1,
+					totalBytes: Math.max(totalBytes, transferredBytes),
+					transferredBytes
+				}, previousChunk);
+			}
+		}
+	}));
+};
+const streamResponse = (response, onDownloadProgress) => {
+	if (!response.body) return response;
+	if (response.status === 204) return new Response(null, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+	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,
+		headers: response.headers
+	});
+};
+const streamRequest = (request, onUploadProgress, originalBody) => {
+	if (!request.body) return request;
+	const totalBytes = getBodySize(originalBody ?? request.body);
+	return new Request(request, {
+		duplex: "half",
+		body: withProgress(request.body, totalBytes, onUploadProgress)
+	});
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/is.js
+const isObject = (value) => value !== null && typeof value === "object";
+
+//#endregion
+//#region ../../node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/merge.js
+const validateAndMerge = (...sources) => {
+	for (const source of sources) if ((!isObject(source) || Array.isArray(source)) && source !== void 0) throw new TypeError("The `options` argument must be an object");
+	return deepMerge({}, ...sources);
+};
+const mergeHeaders = (source1 = {}, source2 = {}) => {
+	const result = new globalThis.Headers(source1);
+	const isHeadersInstance = source2 instanceof globalThis.Headers;
+	const source = new globalThis.Headers(source2);
+	for (const [key, value] of source.entries()) if (isHeadersInstance && value === "undefined" || value === void 0) result.delete(key);
+	else result.set(key, value);
+	return result;
+};
+function newHookValue(original, incoming, property) {
+	return Object.hasOwn(incoming, property) && incoming[property] === void 0 ? [] : deepMerge(original[property] ?? [], incoming[property] ?? []);
+}
+const mergeHooks = (original = {}, incoming = {}) => ({
+	beforeRequest: newHookValue(original, incoming, "beforeRequest"),
+	beforeRetry: newHookValue(original, incoming, "beforeRetry"),
+	afterResponse: newHookValue(original, incoming, "afterResponse"),
+	beforeError: newHookValue(original, incoming, "beforeError")
+});
+const appendSearchParameters = (target, source) => {
+	const result = new URLSearchParams();
+	for (const input of [target, source]) {
+		if (input === void 0) continue;
+		if (input instanceof URLSearchParams) for (const [key, value] of input.entries()) result.append(key, value);
+		else if (Array.isArray(input)) for (const pair of input) {
+			if (!Array.isArray(pair) || pair.length !== 2) throw new TypeError("Array search parameters must be provided in [[key, value], ...] format");
+			result.append(String(pair[0]), String(pair[1]));
+		}
+		else if (isObject(input)) {
+			for (const [key, value] of Object.entries(input)) if (value !== void 0) result.append(key, String(value));
+		} else {
+			const parameters = new URLSearchParams(input);
+			for (const [key, value] of parameters.entries()) result.append(key, value);
+		}
+	}
+	return result;
+};
+const deepMerge = (...sources) => {
+	let returnValue = {};
+	let headers = {};
+	let hooks = {};
+	let searchParameters;
+	const signals = [];
+	for (const source of sources) if (Array.isArray(source)) {
+		if (!Array.isArray(returnValue)) returnValue = [];
+		returnValue = [...returnValue, ...source];
+	} else if (isObject(source)) {
+		for (let [key, value] of Object.entries(source)) {
+			if (key === "signal" && value instanceof globalThis.AbortSignal) {
+				signals.push(value);
+				continue;
+			}
+			if (key === "context") {
+				if (value !== void 0 && value !== null && (!isObject(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);
+				continue;
+			}
+			if (isObject(value) && key in returnValue) value = deepMerge(returnValue[key], value);
+			returnValue = {
+				...returnValue,
+				[key]: value
+			};
+		}
+		if (isObject(source.hooks)) {
+			hooks = mergeHooks(hooks, source.hooks);
+			returnValue.hooks = hooks;
+		}
+		if (isObject(source.headers)) {
+			headers = mergeHeaders(headers, source.headers);
+			returnValue.headers = headers;
+		}
+	}
+	if (searchParameters !== void 0) returnValue.searchParams = searchParameters;
+	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);
+	return returnValue;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/normalize.js
+const normalizeRequestMethod = (input) => requestMethods.includes(input) ? input.toUpperCase() : input;
+const defaultRetryOptions = {
+	limit: 2,
+	methods: [
+		"get",
+		"put",
+		"head",
+		"delete",
+		"options",
+		"trace"
+	],
+	statusCodes: [
+		408,
+		413,
+		429,
+		500,
+		502,
+		503,
+		504
+	],
+	afterStatusCodes: [
+		413,
+		429,
+		503
+	],
+	maxRetryAfter: Number.POSITIVE_INFINITY,
+	backoffLimit: Number.POSITIVE_INFINITY,
+	delay: (attemptCount) => .3 * 2 ** (attemptCount - 1) * 1e3,
+	jitter: void 0,
+	retryOnTimeout: false
+};
+const normalizeRetryOptions = (retry = {}) => {
+	if (typeof retry === "number") return {
+		...defaultRetryOptions,
+		limit: retry
+	};
+	if (retry.methods && !Array.isArray(retry.methods)) throw new Error("retry.methods must be an array");
+	retry.methods &&= retry.methods.map((method) => method.toLowerCase());
+	if (retry.statusCodes && !Array.isArray(retry.statusCodes)) throw new Error("retry.statusCodes must be an array");
+	const normalizedRetry = Object.fromEntries(Object.entries(retry).filter(([, value]) => value !== void 0));
+	return {
+		...defaultRetryOptions,
+		...normalizedRetry
+	};
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/errors/TimeoutError.js
+var TimeoutError = class extends Error {
+	request;
+	constructor(request) {
+		super(`Request timed out: ${request.method} ${request.url}`);
+		this.name = "TimeoutError";
+		this.request = request;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/timeout.js
+async function timeout(request, init, abortController, options) {
+	return new Promise((resolve, reject) => {
+		const timeoutId = setTimeout(() => {
+			if (abortController) abortController.abort();
+			reject(new TimeoutError(request));
+		}, options.timeout);
+		options.fetch(request, init).then(resolve).catch(reject).then(() => {
+			clearTimeout(timeoutId);
+		});
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/delay.js
+async function delay(ms, { signal }) {
+	return new Promise((resolve, reject) => {
+		if (signal) {
+			signal.throwIfAborted();
+			signal.addEventListener("abort", abortHandler, { once: true });
+		}
+		function abortHandler() {
+			clearTimeout(timeoutId);
+			reject(signal.reason);
+		}
+		const timeoutId = setTimeout(() => {
+			signal?.removeEventListener("abort", abortHandler);
+			resolve();
+		}, ms);
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/options.js
+const findUnknownOptions = (request, options) => {
+	const unknownOptions = {};
+	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) => {
+	if (search === void 0) return false;
+	if (Array.isArray(search)) return search.length > 0;
+	if (search instanceof URLSearchParams) return search.size > 0;
+	if (typeof search === "object") return Object.keys(search).length > 0;
+	if (typeof search === "string") return search.trim().length > 0;
+	return Boolean(search);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/ky@1.14.3/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);
+}
+}
+```
+*/
+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);
+}
+}
+```
+*/
+function isTimeoutError(error) {
+	return error instanceof TimeoutError || error?.name === TimeoutError.name;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/core/Ky.js
+var Ky = class Ky {
+	static create(input, options) {
+		const ky = new Ky(input, options);
+		const function_ = async () => {
+			if (typeof ky.#options.timeout === "number" && ky.#options.timeout > maxSafeTimeout) throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
+			await Promise.resolve();
+			let response = await ky.#fetch();
+			for (const hook of ky.#options.hooks.afterResponse) {
+				const clonedResponse = ky.#decorateResponse(response.clone());
+				let modifiedResponse;
+				try {
+					modifiedResponse = await hook(ky.request, ky.#getNormalizedOptions(), clonedResponse, { retryCount: ky.#retryCount });
+				} catch (error) {
+					ky.#cancelResponseBody(clonedResponse);
+					ky.#cancelResponseBody(response);
+					throw error;
+				}
+				if (modifiedResponse instanceof RetryMarker) {
+					ky.#cancelResponseBody(clonedResponse);
+					ky.#cancelResponseBody(response);
+					throw new ForceRetryError(modifiedResponse.options);
+				}
+				const nextResponse = modifiedResponse instanceof globalThis.Response ? modifiedResponse : response;
+				if (clonedResponse !== nextResponse) ky.#cancelResponseBody(clonedResponse);
+				if (response !== nextResponse) ky.#cancelResponseBody(response);
+				response = nextResponse;
+			}
+			ky.#decorateResponse(response);
+			if (!response.ok && (typeof ky.#options.throwHttpErrors === "function" ? ky.#options.throwHttpErrors(response.status) : ky.#options.throwHttpErrors)) {
+				let error = new HTTPError(response, ky.request, ky.#getNormalizedOptions());
+				for (const hook of ky.#options.hooks.beforeError) error = await hook(error, { retryCount: ky.#retryCount });
+				throw error;
+			}
+			if (ky.#options.onDownloadProgress) {
+				if (typeof ky.#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.");
+				const progressResponse = response.clone();
+				ky.#cancelResponseBody(response);
+				return streamResponse(progressResponse, ky.#options.onDownloadProgress);
+			}
+			return response;
+		};
+		const result = ky.#retry(function_).finally(() => {
+			const originalRequest = ky.#originalRequest;
+			ky.#cancelBody(originalRequest?.body ?? void 0);
+			ky.#cancelBody(ky.request.body ?? void 0);
+		});
+		for (const [type, mimeType] of Object.entries(responseTypes)) {
+			if (type === "bytes" && typeof globalThis.Response?.prototype?.bytes !== "function") continue;
+			result[type] = async () => {
+				ky.request.headers.set("accept", ky.request.headers.get("accept") || mimeType);
+				const response = await result;
+				if (type === "json") {
+					if (response.status === 204) return "";
+					const text = await response.text();
+					if (text === "") return "";
+					if (options.parseJson) return options.parseJson(text);
+					return JSON.parse(text);
+				}
+				return response[type]();
+			};
+		}
+		return result;
+	}
+	static #normalizeSearchParams(searchParams) {
+		if (searchParams && typeof searchParams === "object" && !Array.isArray(searchParams) && !(searchParams instanceof URLSearchParams)) return Object.fromEntries(Object.entries(searchParams).filter(([, value]) => value !== void 0));
+		return searchParams;
+	}
+	request;
+	#abortController;
+	#retryCount = 0;
+	#input;
+	#options;
+	#originalRequest;
+	#userProvidedAbortSignal;
+	#cachedNormalizedOptions;
+	constructor(input, options = {}) {
+		this.#input = input;
+		this.#options = {
+			...options,
+			headers: mergeHeaders(this.#input.headers, options.headers),
+			hooks: mergeHooks({
+				beforeRequest: [],
+				beforeRetry: [],
+				beforeError: [],
+				afterResponse: []
+			}, options.hooks),
+			method: normalizeRequestMethod(options.method ?? this.#input.method ?? "GET"),
+			prefixUrl: String(options.prefixUrl || ""),
+			retry: normalizeRetryOptions(options.retry),
+			throwHttpErrors: options.throwHttpErrors ?? true,
+			timeout: options.timeout ?? 1e4,
+			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 (supportsAbortController && supportsAbortSignal) {
+			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");
+		}
+		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());
+			const url = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
+			this.request = new globalThis.Request(url, this.#options);
+		}
+		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.");
+			this.request = this.#wrapRequestWithUploadProgress(this.request, this.#options.body ?? void 0);
+		}
+	}
+	#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;
+		}
+		const backoffLimit = this.#options.retry.backoffLimit ?? Number.POSITIVE_INFINITY;
+		return Math.min(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 (errorObject instanceof ForceRetryError) return errorObject.customDelay ?? this.#calculateDelay();
+		if (!this.#options.retry.methods.includes(this.request.method.toLowerCase())) throw 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();
+		}
+		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-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;
+				return after < max ? after : max;
+			}
+			if (error.response.status === 413) throw error;
+		}
+		return this.#calculateDelay();
+	}
+	#decorateResponse(response) {
+		if (this.#options.parseJson) response.json = async () => this.#options.parseJson(await response.text());
+		return response;
+	}
+	#cancelBody(body) {
+		if (!body) return;
+		body.cancel().catch(() => void 0);
+	}
+	#cancelResponseBody(response) {
+		this.#cancelBody(response.body ?? void 0);
+	}
+	async #retry(function_) {
+		try {
+			return await function_();
+		} catch (error) {
+			const ms = Math.min(await this.#calculateRetryDelay(error), maxSafeTimeout);
+			if (this.#retryCount < 1) throw error;
+			await delay(ms, this.#userProvidedAbortSignal ? { signal: this.#userProvidedAbortSignal } : {});
+			if (error instanceof ForceRetryError && error.customRequest) {
+				const managedRequest = this.#options.signal ? new globalThis.Request(error.customRequest, { signal: this.#options.signal }) : new globalThis.Request(error.customRequest);
+				this.#assignRequest(managedRequest);
+			}
+			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.#assignRequest(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 Response) return result;
+			if (result instanceof globalThis.Request) {
+				this.#assignRequest(result);
+				break;
+			}
+		}
+		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;
+			this.#cachedNormalizedOptions = Object.freeze(normalizedOptions);
+		}
+		return this.#cachedNormalizedOptions;
+	}
+	#assignRequest(request) {
+		this.#cachedNormalizedOptions = void 0;
+		this.request = this.#wrapRequestWithUploadProgress(request);
+	}
+	#wrapRequestWithUploadProgress(request, originalBody) {
+		if (!this.#options.onUploadProgress || !request.body) return request;
+		return streamRequest(request, this.#options.onUploadProgress, originalBody ?? this.#options.body ?? void 0);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/index.js
+/*! MIT License © Sindre Sorhus */
+const createInstance = (defaults) => {
+	const ky = (input, options) => Ky.create(input, validateAndMerge(defaults, options));
+	for (const method of requestMethods) ky[method] = (input, options) => Ky.create(input, validateAndMerge(defaults, options, { method }));
+	ky.create = (newDefaults) => createInstance(validateAndMerge(newDefaults));
+	ky.extend = (newDefaults) => {
+		if (typeof newDefaults === "function") newDefaults = newDefaults(defaults ?? {});
+		return createInstance(validateAndMerge(defaults, newDefaults));
+	};
+	ky.stop = stop;
+	ky.retry = retry;
+	return ky;
+};
+const ky$1 = createInstance();
+
+//#endregion
+//#region ../../node_modules/.pnpm/cookie@1.1.1/node_modules/cookie/dist/index.js
+var require_dist = /* @__PURE__ */ require_chunk.__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.stringifySetCookie = stringifySetCookie;
+	exports.serialize = stringifySetCookie;
+	exports.parseSetCookie = parseSetCookie;
+	exports.stringifySetCookie = stringifySetCookie;
+	exports.serialize = stringifySetCookie;
+	/**
+	* RegExp to match cookie-name in RFC 6265 sec 4.1.1
+	* This refers out to the obsoleted definition of token in RFC 2616 sec 2.2
+	* which has been replaced by the token definition in RFC 7230 appendix B.
+	*
+	* cookie-name       = token
+	* token             = 1*tchar
+	* tchar             = "!" / "#" / "$" / "%" / "&" / "'" /
+	*                     "*" / "+" / "-" / "." / "^" / "_" /
+	*                     "`" / "|" / "~" / DIGIT / ALPHA
+	*
+	* Note: Allowing more characters - https://github.com/jshttp/cookie/issues/191
+	* Allow same range as cookie value, except `=`, which delimits end of name.
+	*/
+	const cookieNameRegExp = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/;
+	/**
+	* RegExp to match cookie-value in RFC 6265 sec 4.1.1
+	*
+	* cookie-value      = *cookie-octet / ( DQUOTE *cookie-octet DQUOTE )
+	* cookie-octet      = %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E
+	*                     ; US-ASCII characters excluding CTLs,
+	*                     ; whitespace DQUOTE, comma, semicolon,
+	*                     ; and backslash
+	*
+	* Allowing more characters: https://github.com/jshttp/cookie/issues/191
+	* Comma, backslash, and DQUOTE are not part of the parsing algorithm.
+	*/
+	const cookieValueRegExp = /^[\u0021-\u003A\u003C-\u007E]*$/;
+	/**
+	* RegExp to match domain-value in RFC 6265 sec 4.1.1
+	*
+	* domain-value      = <subdomain>
+	*                     ; defined in [RFC1034], Section 3.5, as
+	*                     ; enhanced by [RFC1123], Section 2.1
+	* <subdomain>       = <label> | <subdomain> "." <label>
+	* <label>           = <let-dig> [ [ <ldh-str> ] <let-dig> ]
+	*                     Labels must be 63 characters or less.
+	*                     'let-dig' not 'letter' in the first char, per RFC1123
+	* <ldh-str>         = <let-dig-hyp> | <let-dig-hyp> <ldh-str>
+	* <let-dig-hyp>     = <let-dig> | "-"
+	* <let-dig>         = <letter> | <digit>
+	* <letter>          = any one of the 52 alphabetic characters A through Z in
+	*                     upper case and a through z in lower case
+	* <digit>           = any one of the ten digits 0 through 9
+	*
+	* Keep support for leading dot: https://github.com/jshttp/cookie/issues/173
+	*
+	* > (Note that a leading %x2E ("."), if present, is ignored even though that
+	* character is not permitted, but a trailing %x2E ("."), if present, will
+	* cause the user agent to ignore the attribute.)
+	*/
+	const domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
+	/**
+	* RegExp to match path-value in RFC 6265 sec 4.1.1
+	*
+	* path-value        = <any CHAR except CTLs or ";">
+	* CHAR              = %x01-7F
+	*                     ; defined in RFC 5234 appendix B.1
+	*/
+	const pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
+	/**
+	* RegExp to match max-age-value in RFC 6265 sec 5.6.2
+	*/
+	const maxAgeRegExp = /^-?\d+$/;
+	const __toString = Object.prototype.toString;
+	function stringifySetCookie(_name, _val, _opts) {
+		const cookie = typeof _name === "object" ? _name : {
+			..._opts,
+			name: _name,
+			value: String(_val)
+		};
+		const enc = (typeof _val === "object" ? _val : _opts)?.encode || encodeURIComponent;
+		if (!cookieNameRegExp.test(cookie.name)) throw new TypeError(`argument name is invalid: ${cookie.name}`);
+		const value = cookie.value ? enc(cookie.value) : "";
+		if (!cookieValueRegExp.test(value)) throw new TypeError(`argument val is invalid: ${cookie.value}`);
+		let str = cookie.name + "=" + value;
+		if (cookie.maxAge !== void 0) {
+			if (!Number.isInteger(cookie.maxAge)) throw new TypeError(`option maxAge is invalid: ${cookie.maxAge}`);
+			str += "; Max-Age=" + cookie.maxAge;
+		}
+		if (cookie.domain) {
+			if (!domainValueRegExp.test(cookie.domain)) throw new TypeError(`option domain is invalid: ${cookie.domain}`);
+			str += "; Domain=" + cookie.domain;
+		}
+		if (cookie.path) {
+			if (!pathValueRegExp.test(cookie.path)) throw new TypeError(`option path is invalid: ${cookie.path}`);
+			str += "; Path=" + cookie.path;
+		}
+		if (cookie.expires) {
+			if (!isDate(cookie.expires) || !Number.isFinite(cookie.expires.valueOf())) throw new TypeError(`option expires is invalid: ${cookie.expires}`);
+			str += "; Expires=" + cookie.expires.toUTCString();
+		}
+		if (cookie.httpOnly) str += "; HttpOnly";
+		if (cookie.secure) str += "; Secure";
+		if (cookie.partitioned) str += "; Partitioned";
+		if (cookie.priority) switch (typeof cookie.priority === "string" ? cookie.priority.toLowerCase() : void 0) {
+			case "low":
+				str += "; Priority=Low";
+				break;
+			case "medium":
+				str += "; Priority=Medium";
+				break;
+			case "high":
+				str += "; Priority=High";
+				break;
+			default: throw new TypeError(`option priority is invalid: ${cookie.priority}`);
+		}
+		if (cookie.sameSite) switch (typeof cookie.sameSite === "string" ? cookie.sameSite.toLowerCase() : cookie.sameSite) {
+			case true:
+			case "strict":
+				str += "; SameSite=Strict";
+				break;
+			case "lax":
+				str += "; SameSite=Lax";
+				break;
+			case "none":
+				str += "; SameSite=None";
+				break;
+			default: throw new TypeError(`option sameSite is invalid: ${cookie.sameSite}`);
+		}
+		return str;
+	}
+	/**
+	* Deserialize a `Set-Cookie` header into an object.
+	*
+	* deserialize('foo=bar; httpOnly')
+	*   => { name: 'foo', value: 'bar', httpOnly: true }
+	*/
+	function parseSetCookie(str, options) {
+		const dec = options?.decode || decode;
+		const len = str.length;
+		const endIdx = endIndex(str, 0, len);
+		const eqIdx = eqIndex(str, 0, endIdx);
+		const setCookie = eqIdx === -1 ? {
+			name: "",
+			value: dec(valueSlice(str, 0, endIdx))
+		} : {
+			name: valueSlice(str, 0, eqIdx),
+			value: dec(valueSlice(str, eqIdx + 1, endIdx))
+		};
+		let index = endIdx + 1;
+		while (index < len) {
+			const endIdx = endIndex(str, index, len);
+			const eqIdx = eqIndex(str, index, endIdx);
+			const attr = eqIdx === -1 ? valueSlice(str, index, endIdx) : valueSlice(str, index, eqIdx);
+			const val = eqIdx === -1 ? void 0 : valueSlice(str, eqIdx + 1, endIdx);
+			switch (attr.toLowerCase()) {
+				case "httponly":
+					setCookie.httpOnly = true;
+					break;
+				case "secure":
+					setCookie.secure = true;
+					break;
+				case "partitioned":
+					setCookie.partitioned = true;
+					break;
+				case "domain":
+					setCookie.domain = val;
+					break;
+				case "path":
+					setCookie.path = val;
+					break;
+				case "max-age":
+					if (val && maxAgeRegExp.test(val)) setCookie.maxAge = Number(val);
+					break;
+				case "expires":
+					if (!val) break;
+					const date = new Date(val);
+					if (Number.isFinite(date.valueOf())) setCookie.expires = date;
+					break;
+				case "priority":
+					if (!val) break;
+					const priority = val.toLowerCase();
+					if (priority === "low" || priority === "medium" || priority === "high") setCookie.priority = priority;
+					break;
+				case "samesite":
+					if (!val) break;
+					const sameSite = val.toLowerCase();
+					if (sameSite === "lax" || sameSite === "strict" || sameSite === "none") setCookie.sameSite = sameSite;
+					break;
+			}
+			index = endIdx + 1;
+		}
+		return setCookie;
+	}
+	/**
+	* Find the `;` character between `min` and `len` in str.
+	*/
+	function endIndex(str, min, len) {
+		const index = str.indexOf(";", min);
+		return index === -1 ? len : index;
+	}
+	/**
+	* Find the `=` character between `min` and `max` in str.
+	*/
+	function eqIndex(str, min, max) {
+		const index = str.indexOf("=", min);
+		return index < max ? index : -1;
+	}
+	/**
+	* Slice out a value between startPod to max.
+	*/
+	function valueSlice(str, min, max) {
+		let start = min;
+		let end = max;
+		do {
+			const code = str.charCodeAt(start);
+			if (code !== 32 && code !== 9) break;
+		} while (++start < end);
+		while (end > start) {
+			const code = str.charCodeAt(end - 1);
+			if (code !== 32 && code !== 9) break;
+			end--;
+		}
+		return str.slice(start, end);
+	}
+	/**
+	* URL-decode string value. Optimized to skip native call when no %.
+	*/
+	function decode(str) {
+		if (str.indexOf("%") === -1) return str;
+		try {
+			return decodeURIComponent(str);
+		} catch (e) {
+			return str;
+		}
+	}
+	/**
+	* Determine if value is a Date.
+	*/
+	function isDate(val) {
+		return __toString.call(val) === "[object Date]";
+	}
+}));
+
+//#endregion
+//#region ../../apps/desktop/src/main/core/cookie-store.ts
+var import_dist = require_dist();
+const parseSetCookieList = (setCookieList) => {
+	const cookies = [];
+	for (const setCookieString of setCookieList) try {
+		const setCookie = (0, import_dist.parseSetCookie)(setCookieString);
+		const cookie = {
+			...setCookie,
+			expires: setCookie.expires instanceof Date ? setCookie.expires.getTime() : setCookie.expires,
+			sameSite: typeof setCookie.sameSite === "boolean" ? "strict" : setCookie.sameSite
+		};
+		cookies.push(cookie);
+	} catch (e) {
+		logger.debug(e);
+	}
+	return cookies;
+};
+const importCookies = async (cookiesTxtPath) => {
+	const text = await (0, node_fs_promises.readFile)(cookiesTxtPath, "utf8").catch(() => "");
+	if (!text) return [];
+	const rows = text.split(node_os.EOL).flatMap((line) => line.split("\n")).filter((line) => !!line.trim() && !line.startsWith("# ")).map((line) => line.split("	"));
+	const cookies = [];
+	for (const row of rows) {
+		const [domain, _includeSubdomains, path, secure, expires, name, value] = row;
+		cookies.push({
+			name,
+			value,
+			expires: Number(expires),
+			maxAge: void 0,
+			domain: domain.replace("#HttpOnly_", ""),
+			path,
+			secure: secure === "TRUE",
+			httpOnly: void 0,
+			sameSite: void 0
+		});
+	}
+	return cookies;
+};
+var CookieStore = class {
+	#data = {};
+	#cookies;
+	#storagePath;
+	#hasBeenRead = false;
+	static parse(setCookieList) {
+		return parseSetCookieList(setCookieList);
+	}
+	constructor({ storagePath } = {}) {
+		this.#storagePath = storagePath;
+		this.#cookies = [];
+	}
+	async import(cookiesTxtPath) {
+		if ((await (0, node_fs_promises.stat)(cookiesTxtPath).catch(() => null))?.isFile()) {
+			this.#cookies = await importCookies(cookiesTxtPath);
+			await (0, node_fs_promises.rm)(cookiesTxtPath, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	async #read() {
+		if (!this.#storagePath || this.#hasBeenRead) return;
+		if ((await (0, node_fs_promises.stat)(this.#storagePath).catch(() => null))?.isFile()) {
+			const data = await (0, node_fs_promises.readFile)(this.#storagePath, "utf8");
+			this.#data = data ? JSON.parse(data) : {};
+			this.#cookies = "cookies" in this.#data ? this.#data.cookies : [];
+		}
+		this.#hasBeenRead = true;
+	}
+	async #write() {
+		if (!this.#storagePath) return;
+		const data = JSON.stringify({
+			...this.#data,
+			cookies: this.#cookies
+		}, null, 2);
+		await (0, node_fs_promises.writeFile)(this.#storagePath, data, "utf8");
+	}
+	async get(cookie) {
+		await this.#read();
+		const name = typeof cookie === "string" ? cookie : cookie.name;
+		return this.#cookies.find((c) => c.name === name) ?? null;
+	}
+	async getAll(cookie) {
+		await this.#read();
+		if (!cookie) return this.#cookies;
+		const name = typeof cookie === "string" ? cookie : cookie.name;
+		return this.#cookies.filter((c) => c.name === name) ?? null;
+	}
+	async set(cookie) {
+		await this.#read();
+		this.#cookies = this.#cookies.filter((c) => !(c.name === cookie.name && c.domain === cookie.domain));
+		this.#cookies.push(cookie);
+		await this.#write();
+	}
+	async delete(cookie) {
+		await this.#read();
+		if (!cookie) this.#cookies = [];
+		else {
+			const name = typeof cookie === "string" ? cookie : cookie.name;
+			this.#cookies = this.#cookies.filter((c) => c.name !== name);
+		}
+		await this.#write();
+	}
+	toString() {
+		return this.#cookies.map((cookie) => `${cookie.name}=${cookie.value}`).join("; ");
+	}
+};
+
+//#endregion
+//#region ../../apps/desktop/src/main/core/http-client.ts
+const ky = ky$1.default ?? ky$1;
+const hasUserAgent = (headers) => {
+	if (!headers) return false;
+	if (headers instanceof Headers) return headers.has("User-Agent");
+	if (typeof headers === "object" && headers !== null) return "User-Agent" in headers || "user-agent" in headers;
+	return false;
+};
+const getInputUrl = (input) => {
+	if (input instanceof URL) return input;
+	if (input instanceof Request) return new URL(input.url);
+	return new URL(input);
+};
+var HttpClient = class {
+	cookieStore;
+	headers;
+	#client;
+	#chrome;
+	constructor(options = {}) {
+		this.headers = new Headers();
+		this.configure(options);
+	}
+	configure({ maxRetries = 3, proxyUrl, allowH2 = true, cookieStore } = {}) {
+		this.cookieStore = cookieStore ?? this.cookieStore ?? new CookieStore();
+		const agent = proxyUrl ? new undici.ProxyAgent({
+			uri: proxyUrl,
+			allowH2
+		}) : new undici.Agent({ allowH2 });
+		const defaultOptions = { retry: maxRetries };
+		this.#client = ky.create({
+			dispatcher: agent,
+			proxy: proxyUrl,
+			...defaultOptions
+		});
+		const impit$1 = new impit.Impit({
+			browser: "chrome",
+			proxyUrl,
+			ignoreTlsErrors: true,
+			followRedirects: true
+		});
+		this.#chrome = ky.create({
+			fetch: impit$1.fetch.bind(impit$1),
+			...defaultOptions
+		});
+	}
+	async fetch(input, init = {}) {
+		const headers = this.appendHeaders(init?.headers);
+		const cookies = await this.cookieStore.getAll();
+		const filteredCookies = cookies.filter((c) => !c.domain || getInputUrl(input).hostname.includes(c.domain));
+		for (const cookie of cookies) {
+			if (filteredCookies.find((c) => c.name === cookie.name)) continue;
+			if (!cookie.domain) filteredCookies.push(cookie);
+		}
+		const cookieHeaderValue = filteredCookies.map((cookie) => `${cookie.name}=${cookie.value}`).join("; ");
+		if (!headers.has("cookie")) headers.set("cookie", cookieHeaderValue);
+		else if (!headers.get("cookie")) headers.delete("cookie");
+		const fetchFn = (hasUserAgent(init?.headers) ? this.#client : this.#chrome)[init?.method?.toLowerCase() ?? "get"];
+		const response = await fetchFn(input, {
+			...init,
+			headers
+		});
+		const setCookie = response.headers.getSetCookie();
+		if (setCookie) await this.setCookies(setCookie);
+		return response;
+	}
+	async setCookies(setCookie) {
+		const newCookies = [];
+		if (typeof setCookie === "string") {
+			const [newCookie] = parseSetCookieList([setCookie]);
+			if (newCookie) newCookies.push(newCookie);
+		} else if (Array.isArray(setCookie) && typeof setCookie.at(0) === "string") {
+			const cookies = parseSetCookieList(setCookie);
+			newCookies.push(...cookies);
+		} else if (Array.isArray(setCookie) && typeof setCookie[0] !== "string") newCookies.push(...setCookie);
+		if (!newCookies || !newCookies?.length) return;
+		for (const cookie of newCookies) await this.cookieStore.set(cookie);
+	}
+	appendHeaders(headers) {
+		const newHeaders = new Headers(this.headers);
+		for (const [name, value] of Object.entries(headers ?? {})) newHeaders.set(name, value);
+		return newHeaders;
+	}
+	setHeader(name, value) {
+		this.headers.set(name, value);
+	}
+	removeHeader(name) {
+		this.headers.delete(name);
+	}
+};
+const httpClient = new HttpClient();
+
+//#endregion
+//#region ../../apps/desktop/src/main/core/loader.ts
+const { COMMON_CONTEXT } = metavm.default;
+const create = (src, name = "Eval", options) => {
+	try {
+		return metavm.default.createScript(name, src, options);
+	} catch (e) {
+		console.debug(e);
+		console.debug(src);
+		console.error(`Syntax Error: ${e.message}`);
+		return null;
+	}
+};
+
+//#endregion
+//#region ../../apps/desktop/src/main/cli/utils.ts
+const getRandomElements = (array, count = 1) => {
+	if (Array.isArray(array) || typeof array === "string") {
+		const elements = [];
+		for (let i = 1; i <= count; i++) elements.push(array[Math.floor(Math.random() * array.length)]);
+		return elements;
+	} else return [];
+};
+
+//#endregion
+//#region ../../apps/desktop/src/main/core/storage.ts
+const createConf = (partialOptions) => {
+	return new ("default" in conf.default ? conf.default.default : conf.default)(partialOptions);
+};
+var FileStorage = class {
+	#store;
+	constructor(filePath) {
+		this.#store = createConf({
+			cwd: (0, node_path.dirname)(filePath),
+			configName: (0, node_path.basename)(filePath, ".json")
+		});
+	}
+	get length() {
+		return Object.keys(this.#store.store).length;
+	}
+	clear() {
+		this.#store.clear();
+	}
+	getItem(key) {
+		return this.#store.get(key) ?? null;
+	}
+	key(index) {
+		return Object.keys(this.#store.store).at(index) ?? null;
+	}
+	removeItem(key) {
+		this.#store.delete(key);
+	}
+	setItem(key, value) {
+		this.#store.set(key, value);
+	}
+};
+
+//#endregion
+//#region ../../apps/desktop/src/main/errors.ts
+const errors = new node_events.default();
+
+//#endregion
+//#region ../../apps/desktop/src/main/extensions/context.ts
+const isPromptCancelError = (error) => {
+	if (!error || typeof error !== "object") return false;
+	const name = "name" in error ? String(error.name) : "";
+	return name === "ExitPromptError" || name === "AbortPromptError";
+};
+const capitalize = (text) => text[0].toUpperCase() + text.slice(1);
+const parseBoolean = (value, fallback = false) => {
+	if (typeof value === "boolean") return value;
+	if (typeof value !== "string") return fallback;
+	const normalized = value.trim().toLowerCase();
+	if ([
+		"1",
+		"true",
+		"yes",
+		"y",
+		"on"
+	].includes(normalized)) return true;
+	if ([
+		"0",
+		"false",
+		"no",
+		"n",
+		"off"
+	].includes(normalized)) return false;
+	return fallback;
+};
+const parseNumber = (value, fallback = 0) => {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value !== "string") return fallback;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : fallback;
+};
+const getEmptyFieldValue = (field) => {
+	switch (field.type) {
+		case "checkbox": return parseBoolean(field.defaultValue, false);
+		case "number": return parseNumber(field.defaultValue, 0);
+		default: return field.defaultValue ?? "";
+	}
+};
+const coerceFieldValue = (field, value) => {
+	switch (field.type) {
+		case "checkbox": return parseBoolean(value, parseBoolean(field.defaultValue, false));
+		case "number": return parseNumber(value, parseNumber(field.defaultValue, 0));
+		default:
+			if (typeof value === "string") return value;
+			if (value === void 0 || value === null) return field.defaultValue ?? "";
+			return String(value);
+	}
+};
+const createEmptyAskResult = (form) => {
+	const entries = Object.entries(form).map(([name, field]) => [name, getEmptyFieldValue(field)]);
+	return Object.fromEntries(entries);
+};
+const coerceAskResult = (form, values) => {
+	const entries = Object.entries(form).map(([name, field]) => [name, coerceFieldValue(field, values[name])]);
+	return Object.fromEntries(entries);
+};
+const runAction = async (action) => {
+	if (!action?.onAction) return;
+	await action.onAction();
+};
+const openExternalLink = async (url) => {
+	if (isCLI) {
+		const { default: open } = await Promise.resolve().then(() => require("./open-C0aYOBn3.cjs"));
+		await open(url);
+		return;
+	}
+	const { shell } = await import("electron");
+	await shell.openExternal(url);
+};
+const openWindow = (url, _target, _features) => {
+	const href = typeof url === "string" ? url : url?.toString();
+	if (!href?.trim()) return null;
+	openExternalLink(href).catch((error) => {
+		logger.error(`Failed to open URL: ${href}`);
+		logger.debug(error instanceof Error ? error.message : String(error));
+	});
+	return null;
+};
+const chooseActionWithSelect = async (message, actions) => {
+	if (!actions.length) return "dismiss";
+	try {
+		return await (0, _inquirer_prompts.select)({
+			message,
+			loop: false,
+			choices: actions.map((entry) => ({
+				name: entry.action.title,
+				value: entry.kind
+			}))
+		});
+	} catch (error) {
+		if (isPromptCancelError(error)) return "dismiss";
+		throw error;
+	}
+};
+const getOS = () => {
+	switch (node_os.default.type()) {
+		case "Darwin": return "macOS";
+		case "Windows_NT": return "Windows";
+		default: return "Linux";
+	}
+};
+Object.defineProperties(Uint8Array.prototype, {
+	toBase64: {
+		value: function() {
+			return Buffer.from(this).toString("base64");
+		},
+		writable: true,
+		configurable: true
+	},
+	toHex: {
+		value: function() {
+			return Buffer.from(this).toString("hex");
+		},
+		writable: true,
+		configurable: true
+	}
+});
+Object.defineProperties(Uint8Array, {
+	fromBase64: {
+		value: function(base64String) {
+			return new Uint8Array(Buffer.from(base64String, "base64"));
+		},
+		writable: true,
+		configurable: true
+	},
+	fromHex: {
+		value: function(hexString) {
+			return new Uint8Array(Buffer.from(hexString, "hex"));
+		},
+		writable: true,
+		configurable: true
+	}
+});
+const macOSVersionMap = new Map([
+	[24, ["Sequoia", "15"]],
+	[23, ["Sonoma", "14"]],
+	[22, ["Ventura", "13"]],
+	[21, ["Monterey", "12"]],
+	[20, ["Big Sur", "11"]],
+	[19, ["Catalina", "10.15"]],
+	[18, ["Mojave", "10.14"]],
+	[17, ["High Sierra", "10.13"]],
+	[16, ["Sierra", "10.12"]],
+	[15, ["El Capitan", "10.11"]],
+	[14, ["Yosemite", "10.10"]],
+	[13, ["Mavericks", "10.9"]],
+	[12, ["Mountain Lion", "10.8"]],
+	[11, ["Lion", "10.7"]],
+	[10, ["Snow Leopard", "10.6"]],
+	[9, ["Leopard", "10.5"]],
+	[8, ["Tiger", "10.4"]],
+	[7, ["Panther", "10.3"]],
+	[6, ["Jaguar", "10.2"]],
+	[5, ["Puma", "10.1"]]
+]);
+const macosRelease = () => {
+	const releaseN = Number(node_os.default.release().split(".")[0]);
+	const [name, version] = macOSVersionMap.get(releaseN) || ["Unknown", ""];
+	return {
+		name,
+		version
+	};
+};
+const getOSVersion = () => {
+	switch (getOS()) {
+		case "macOS": return macosRelease().version;
+		case "Windows": return node_os.default.release();
+		case "Linux": return node_os.default.release();
+	}
+};
+const createUserAgentData = () => {
+	const brands = [{
+		brand: "Azot",
+		version: package_default.version.split(".").slice(0, 2).join(".")
+	}, {
+		brand: "Node.js",
+		version: process.version.replace("v", "").split(".").slice(0, 1).join(".")
+	}];
+	return {
+		mobile: false,
+		platform: getOS(),
+		brands,
+		getHighEntropyValues: async (hints) => {
+			const values = {
+				mobile: false,
+				platform: getOS(),
+				brands
+			};
+			if (hints.includes("architecture")) values.architecture = node_os.default.arch();
+			if (hints.includes("platform")) values.platform = getOS();
+			if (hints.includes("platformVersion")) values.platformVersion = getOSVersion();
+			if (hints.includes("fullVersionList")) values.fullVersionList = [{
+				brand: "Azot",
+				version: package_default.version
+			}, {
+				brand: "Node.js",
+				version: process.version
+			}];
+			return values;
+		}
+	};
+};
+const createContext = ({ name = "extension", dir = process.cwd(), title } = {}) => {
+	const workDir = resolveDir((0, node_path.join)(dir, name));
+	const localStorage = new FileStorage((0, node_path.join)(workDir, `storage.json`));
+	const cookieStore = new CookieStore({ storagePath: (0, node_path.join)(workDir, `cookies.json`) });
+	const http = new HttpClient({ cookieStore });
+	const between = (text, from, to) => text.split(from)[1]?.split(to)[0]?.trim();
+	const common = {
+		sanitizeString,
+		execUrlPatterns,
+		extendEpisodes,
+		between,
+		getRandomElements
+	};
+	const defaultTitle = title ? capitalize(title) : void 0;
+	const resolveTitle = (nextTitle) => nextTitle || defaultTitle;
+	const requestPrompt = async (request) => {
+		if (!request.title) request.title = defaultTitle;
+		return await prompt.ask(request);
+	};
+	const notify = async (message, options = {}) => {
+		const titleText = resolveTitle(options.title) ?? "Azot";
+		const actions = [options.primaryAction ? {
+			kind: "primary",
+			action: options.primaryAction
+		} : null, options.secondaryAction ? {
+			kind: "secondary",
+			action: options.secondaryAction
+		} : null].filter(Boolean);
+		if (isCLI) {
+			if (!actions.length) return logger.info(message);
+			const selected = await chooseActionWithSelect(message, actions);
+			if (selected === "primary") await runAction(options.primaryAction);
+			if (selected === "secondary") await runAction(options.secondaryAction);
+			return;
+		}
+		const selected = (await feedback.ask({
+			variant: "notify",
+			title: titleText,
+			message,
+			style: options.style,
+			primaryAction: options.primaryAction ? {
+				title: options.primaryAction.title,
+				style: options.primaryAction.style
+			} : void 0,
+			secondaryAction: options.secondaryAction ? {
+				title: options.secondaryAction.title,
+				style: options.secondaryAction.style
+			} : void 0
+		})).action ?? "dismiss";
+		if (selected === "primary") await runAction(options.primaryAction);
+		if (selected === "secondary") await runAction(options.secondaryAction);
+	};
+	const confirm = async (message, options = {}) => {
+		const titleText = resolveTitle(options.title) ?? "Azot";
+		const hasCustomActions = !!options.primaryAction || !!options.secondaryAction;
+		const primaryAction = options.primaryAction ?? { title: "OK" };
+		const secondaryAction = options.secondaryAction ?? {
+			title: "Cancel",
+			style: "cancel"
+		};
+		if (isCLI) {
+			if (hasCustomActions) {
+				const selected = await chooseActionWithSelect(message, [{
+					kind: "primary",
+					action: primaryAction
+				}, {
+					kind: "secondary",
+					action: secondaryAction
+				}]);
+				if (selected === "primary") {
+					await runAction(primaryAction);
+					return true;
+				}
+				if (selected === "secondary") await runAction(secondaryAction);
+				return false;
+			}
+			try {
+				const accepted = await (0, _inquirer_prompts.confirm)({
+					message,
+					default: true
+				});
+				if (accepted) await runAction(options.primaryAction);
+				else await runAction(options.secondaryAction);
+				return accepted;
+			} catch (error) {
+				if (isPromptCancelError(error)) return false;
+				throw error;
+			}
+		}
+		const result = await feedback.ask({
+			variant: "confirm",
+			title: titleText,
+			message,
+			style: options.style,
+			primaryAction: {
+				title: primaryAction.title,
+				style: primaryAction.style
+			},
+			secondaryAction: {
+				title: secondaryAction.title,
+				style: secondaryAction.style
+			}
+		});
+		const isPrimary = result.action === "primary";
+		if (isPrimary) await runAction(primaryAction);
+		else if (result.action === "secondary") await runAction(secondaryAction);
+		return isPrimary;
+	};
+	const askFeedback = async (message, options) => {
+		const emptyResult = createEmptyAskResult(options.form);
+		const formEntries = Object.entries(options.form);
+		const hasActions = !!options.primaryAction || !!options.secondaryAction;
+		const primaryAction = options.primaryAction ?? { title: "Submit" };
+		const secondaryAction = options.secondaryAction ?? {
+			title: "Cancel",
+			style: "cancel"
+		};
+		if (isCLI) {
+			const values = {};
+			try {
+				for (const [name, field] of formEntries) {
+					const fieldMessage = [field.title || name, field.description].filter(Boolean).join(" - ");
+					if (field.type === "checkbox") {
+						values[name] = await (0, _inquirer_prompts.confirm)({
+							message: fieldMessage,
+							default: parseBoolean(field.defaultValue, false)
+						});
+						continue;
+					}
+					if (field.type === "number") {
+						const fallback = parseNumber(field.defaultValue, NaN);
+						values[name] = await (0, _inquirer_prompts.number)({
+							message: fieldMessage,
+							default: Number.isFinite(fallback) ? fallback : void 0,
+							validate: (value) => {
+								if (value === void 0 || Number.isNaN(value)) return field.required ? "This field is required" : true;
+								return true;
+							}
+						});
+						continue;
+					}
+					if (field.type === "password") {
+						values[name] = await (0, _inquirer_prompts.password)({
+							message: fieldMessage,
+							validate: field.required ? (value) => String(value ?? "").trim() ? true : "This field is required" : void 0
+						});
+						continue;
+					}
+					values[name] = await (0, _inquirer_prompts.input)({
+						message: fieldMessage,
+						default: field.defaultValue,
+						validate: field.required ? (value) => String(value ?? "").trim() ? true : "This field is required" : void 0
+					});
+				}
+			} catch (error) {
+				if (isPromptCancelError(error)) return emptyResult;
+				throw error;
+			}
+			if (!hasActions) return coerceAskResult(options.form, values);
+			const selectedAction = await chooseActionWithSelect(message, [{
+				kind: "primary",
+				action: primaryAction
+			}, {
+				kind: "secondary",
+				action: secondaryAction
+			}]);
+			if (selectedAction === "primary") {
+				await runAction(primaryAction);
+				return coerceAskResult(options.form, values);
+			}
+			if (selectedAction === "secondary") await runAction(secondaryAction);
+			return emptyResult;
+		}
+		const promptFields = Object.fromEntries(formEntries.map(([fieldName, field]) => [fieldName, {
+			type: field.type,
+			label: field.title || fieldName,
+			description: field.description,
+			placeholder: field.placeholder,
+			defaultValue: field.defaultValue,
+			value: field.defaultValue,
+			required: field.required,
+			autoFocus: field.autoFocus
+		}]));
+		const promptResponse = await requestPrompt({
+			title: resolveTitle(options.title),
+			description: message,
+			fields: promptFields,
+			actions: hasActions ? {
+				primaryAction: {
+					title: primaryAction.title,
+					style: primaryAction.style
+				},
+				secondaryAction: {
+					title: secondaryAction.title,
+					style: secondaryAction.style
+				}
+			} : void 0
+		});
+		const action = promptResponse.__action ?? "primary";
+		const values = { ...promptResponse };
+		delete values.__action;
+		if (action === "primary") {
+			await runAction(options.primaryAction);
+			return coerceAskResult(options.form, values);
+		}
+		if (action === "secondary") await runAction(options.secondaryAction);
+		return emptyResult;
+	};
+	const Azot = {
+		defineExtension: (extension) => extension,
+		version: package_default.version,
+		sleep: node_timers_promises.setTimeout,
+		sanitizeString,
+		execUrlPatterns,
+		extendEpisodes,
+		between,
+		getRandomElements,
+		utils: common,
+		prompt: requestPrompt,
+		input,
+		notify,
+		confirm,
+		ask: askFeedback
+	};
+	class Document {
+		get cookie() {
+			return cookieStore.toString();
+		}
+	}
+	const window = {
+		fetch: http.fetch.bind(http),
+		Response,
+		Request,
+		Headers,
+		AbortController,
+		AbortSignal,
+		URL,
+		URLSearchParams,
+		URLPattern,
+		open: openWindow,
+		Blob,
+		structuredClone,
+		btoa,
+		atob,
+		TextEncoder,
+		TextDecoder,
+		Uint8Array,
+		crypto,
+		console: {
+			log: console.log,
+			info: logger.info.bind(logger),
+			warn: logger.warn.bind(logger),
+			error: (...args) => {
+				const message = String(args[0] ?? "Unknown error");
+				errors.emit("error", { message });
+				logger.error(message);
+			},
+			trace: logger.trace.bind(logger),
+			debug: logger.debug.bind(logger)
+		},
+		Event,
+		EventTarget,
+		localStorage,
+		cookieStore,
+		document: new Document(),
+		eval: (x) => create(x)?.exports,
+		navigator: {
+			appName: "Azot",
+			appVersion: package_default.version,
+			platform: process.platform,
+			userAgent: `Azot/${package_default.version}`,
+			userAgentData: createUserAgentData()
+		}
+	};
+	return {
+		http,
+		question: prompt,
+		common,
+		Streamyx: Azot,
+		Azot,
+		window,
+		...window
+	};
+};
+
+//#endregion
+Object.defineProperty(exports, 'createContext', {
+  enumerable: true,
+  get: function () {
+    return createContext;
+  }
+});