itd-api 0.1.0 → 0.2.0

package/dist/multi-storage-D1keK2Op.cjs

@@ -0,0 +1,930 @@
+const require_storage = require("./storage-ycBqLBRB.cjs");
+//#region node_modules/set-cookie-parser/lib/set-cookie.js
+var defaultParseOptions = {
+	decodeValues: true,
+	map: false,
+	silent: false,
+	split: "auto"
+};
+function isForbiddenKey(key) {
+	return typeof key !== "string" || key in {};
+}
+function createNullObj() {
+	return Object.create(null);
+}
+function isNonEmptyString(str) {
+	return typeof str === "string" && !!str.trim();
+}
+function parseString(setCookieValue, options) {
+	var parts = setCookieValue.split(";").filter(isNonEmptyString);
+	var nameValuePairStr = parts.shift();
+	if (!nameValuePairStr) return null;
+	var parsed = parseNameValuePair(nameValuePairStr);
+	var name = parsed.name;
+	var value = parsed.value;
+	options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+	if (isForbiddenKey(name)) return null;
+	try {
+		value = options.decodeValues ? decodeURIComponent(value) : value;
+	} catch (e) {
+		console.error("set-cookie-parser: failed to decode cookie value. Set options.decodeValues=false to disable decoding.", e);
+	}
+	var cookie = createNullObj();
+	cookie.name = name;
+	cookie.value = value;
+	parts.forEach(function(part) {
+		var sides = part.split("=");
+		var key = sides.shift().trim().toLowerCase();
+		if (isForbiddenKey(key)) return;
+		var value = sides.join("=").trim();
+		if (key === "expires") cookie.expires = new Date(value);
+		else if (key === "max-age") {
+			var n = parseInt(value, 10);
+			if (!Number.isNaN(n)) cookie.maxAge = n;
+		} else if (key === "secure") cookie.secure = true;
+		else if (key === "httponly") cookie.httpOnly = true;
+		else if (key === "samesite") cookie.sameSite = value;
+		else if (key === "partitioned") cookie.partitioned = true;
+		else if (key) cookie[key] = value;
+	});
+	return cookie;
+}
+function parseNameValuePair(nameValuePairStr) {
+	var name = "";
+	var value = "";
+	var nameValueArr = nameValuePairStr.split("=");
+	if (nameValueArr.length > 1) {
+		name = nameValueArr.shift();
+		value = nameValueArr.join("=");
+	} else value = nameValuePairStr;
+	return {
+		name,
+		value
+	};
+}
+function parseSetCookie(input, options) {
+	options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+	if (!input) if (!options.map) return [];
+	else return createNullObj();
+	if (input.headers) if (typeof input.headers.getSetCookie === "function") input = input.headers.getSetCookie();
+	else if (input.headers["set-cookie"]) input = input.headers["set-cookie"];
+	else {
+		var sch = input.headers[Object.keys(input.headers).find(function(key) {
+			return key.toLowerCase() === "set-cookie";
+		})];
+		if (!sch && input.headers.cookie && !options.silent) console.warn("Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning.");
+		input = sch;
+	}
+	var split = options.split;
+	var isArray = Array.isArray(input);
+	if (split === "auto") split = !isArray;
+	if (!isArray) input = [input];
+	input = input.filter(isNonEmptyString);
+	if (split) input = input.map(splitCookiesString).flat();
+	if (!options.map) return input.map(function(str) {
+		return parseString(str, options);
+	}).filter(Boolean);
+	else {
+		var cookies = createNullObj();
+		return input.reduce(function(cookies, str) {
+			var cookie = parseString(str, options);
+			if (cookie && !isForbiddenKey(cookie.name)) cookies[cookie.name] = cookie;
+			return cookies;
+		}, cookies);
+	}
+}
+function splitCookiesString(cookiesString) {
+	if (Array.isArray(cookiesString)) return cookiesString;
+	if (typeof cookiesString !== "string") return [];
+	var cookiesStrings = [];
+	var pos = 0;
+	var start;
+	var ch;
+	var lastComma;
+	var nextStart;
+	var cookiesSeparatorFound;
+	function skipWhitespace() {
+		while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) pos += 1;
+		return pos < cookiesString.length;
+	}
+	function notSpecialChar() {
+		ch = cookiesString.charAt(pos);
+		return ch !== "=" && ch !== ";" && ch !== ",";
+	}
+	while (pos < cookiesString.length) {
+		start = pos;
+		cookiesSeparatorFound = false;
+		while (skipWhitespace()) {
+			ch = cookiesString.charAt(pos);
+			if (ch === ",") {
+				lastComma = pos;
+				pos += 1;
+				skipWhitespace();
+				nextStart = pos;
+				while (pos < cookiesString.length && notSpecialChar()) pos += 1;
+				if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+					cookiesSeparatorFound = true;
+					pos = nextStart;
+					cookiesStrings.push(cookiesString.substring(start, lastComma));
+					start = pos;
+				} else pos = lastComma + 1;
+			} else pos += 1;
+		}
+		if (!cookiesSeparatorFound || pos >= cookiesString.length) cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+	}
+	return cookiesStrings;
+}
+parseSetCookie.parseSetCookie = parseSetCookie;
+parseSetCookie.parse = parseSetCookie;
+parseSetCookie.parseString = parseString;
+parseSetCookie.splitCookiesString = splitCookiesString;
+//#endregion
+//#region src/core/cookies.ts
+/** Имя cookie-флага «есть refresh-сессия». Ставится сайтом итд.com рядом с refresh-токеном. */
+const AUTH_FLAG_COOKIE = "is_auth";
+/**
+* Имя cookie с refresh-токеном.
+*
+* `POST /api/v1/auth/refresh` читает токен **только отсюда** — тело запроса сервер игнорирует.
+* Cookie помечена `HttpOnly`, поэтому в браузере её не прочитать и не выставить; вне браузера
+* она проходит через jar, и туда же кладётся токен, переданный строкой.
+*/
+const REFRESH_COOKIE = "refresh_token";
+/** Путь, которым сервер ограничивает {@link REFRESH_COOKIE}. */
+const REFRESH_COOKIE_PATH = "/api/v1/auth";
+/** Разделитель origin и содержимого cookie при сериализации. В origin пробелов не бывает. */
+const SERIALIZED_SEPARATOR = " ";
+function originOf(url) {
+	try {
+		return new URL(url).origin;
+	} catch {
+		return "";
+	}
+}
+/** Дата в миллисекунды. Некорректная дата считается отсутствующей, а не `NaN`. */
+function toTimestamp(date) {
+	if (!date) return void 0;
+	const time = date.getTime();
+	return Number.isFinite(time) ? time : void 0;
+}
+function pathOf(url) {
+	try {
+		return new URL(url).pathname || "/";
+	} catch {
+		return "/";
+	}
+}
+/**
+* Подходит ли путь cookie запросу.
+*
+* Правило из RFC 6265: путь cookie должен быть префиксом пути запроса, причём граница
+* должна проходить по сегменту — `/api` не подходит запросу `/apiary`.
+*/
+function pathMatches(cookiePath, requestPath) {
+	if (cookiePath === "/" || cookiePath === requestPath) return true;
+	if (!requestPath.startsWith(cookiePath)) return false;
+	return cookiePath.endsWith("/") || requestPath[cookiePath.length] === "/";
+}
+/**
+* Минимальное хранилище cookie для сред без своего.
+*
+* Refresh-токен итд.com приходит в `Set-Cookie`, а `fetch` вне браузера cookie не хранит —
+* без jar сессию не продлить. В браузере и React Native не используется: там cookie ведёт
+* сама среда.
+*
+* Реализована практическая часть RFC 6265: origin, путь, срок жизни, флаг `Secure`.
+* Доменные cookie для поддоменов намеренно не поддерживаются — API работает с одного хоста.
+*/
+var CookieJar = class {
+	#byOrigin = /* @__PURE__ */ new Map();
+	/**
+	* Забирает `Set-Cookie` из ответа.
+	*
+	* Использует `Headers.getSetCookie()`, где он есть (Node 20+, undici). В остальных средах
+	* заголовки склеены в одну строку, и её нельзя резать по запятой напрямую: запятая есть
+	* внутри `Expires=Wed, 09 Jun 2027 …`. Разделением занимается `set-cookie-parser`.
+	*/
+	setFromResponse(url, response) {
+		const headers = response.headers;
+		const raw = typeof headers.getSetCookie === "function" ? headers.getSetCookie() : splitCookiesString(headers.get("set-cookie") ?? "");
+		if (raw.length > 0) this.setFromStrings(url, raw);
+	}
+	/**
+	* Кладёт cookie напрямую, минуя `Set-Cookie`.
+	*
+	* Нужно ровно в одном случае: пользователь передал refresh-токен строкой, а сервер читает
+	* его только из cookie. Значение не кодируется — оно уходит в заголовок как есть.
+	*/
+	set(url, name, value, path = "/") {
+		this.setFromStrings(url, [`${name}=${value}; Path=${path}`]);
+	}
+	/** Сохраняет cookie из готовых строк `Set-Cookie`. */
+	setFromStrings(url, setCookieStrings) {
+		const origin = originOf(url);
+		if (!origin) return;
+		const jar = this.#byOrigin.get(origin) ?? /* @__PURE__ */ new Map();
+		for (const parsed of parseSetCookie(setCookieStrings)) {
+			const expires = toTimestamp(parsed.expires);
+			const expiresAt = (typeof parsed.maxAge === "number" && Number.isFinite(parsed.maxAge) ? Date.now() + parsed.maxAge * 1e3 : void 0) ?? expires;
+			if (expiresAt !== void 0 && expiresAt <= Date.now()) {
+				jar.delete(parsed.name);
+				continue;
+			}
+			jar.set(parsed.name, {
+				name: parsed.name,
+				value: parsed.value,
+				path: parsed.path ?? "/",
+				expires: expiresAt,
+				secure: parsed.secure ?? false
+			});
+		}
+		this.#byOrigin.set(origin, jar);
+	}
+	/**
+	* Собирает значение заголовка `Cookie` для запроса.
+	*
+	* @returns строка вида `a=1; b=2` либо `undefined`, если подходящих cookie нет
+	*/
+	getHeader(url) {
+		const cookies = this.#matching(url);
+		if (cookies.length === 0) return void 0;
+		return cookies.map((cookie) => `${cookie.name}=${cookie.value}`).join("; ");
+	}
+	/**
+	* Значение действующей cookie.
+	*
+	* Нужно, чтобы забрать обновлённый refresh-токен: сервер ротирует его при каждом
+	* продлении сессии, и сохранять надо именно новое значение.
+	*
+	* @param url если указан, учитываются origin, путь и флаг `Secure`
+	*/
+	getValue(name, url) {
+		if (url) return this.#matching(url).find((cookie) => cookie.name === name)?.value;
+		const now = Date.now();
+		for (const jar of this.#byOrigin.values()) {
+			const cookie = jar.get(name);
+			if (cookie && (cookie.expires === void 0 || cookie.expires > now)) return cookie.value;
+		}
+	}
+	/**
+	* Есть ли действующая cookie с таким именем.
+	*
+	* Используется для проверки флага {@link AUTH_FLAG_COOKIE} перед запросом обновления
+	* токена: у анонима refresh-сессии нет, и дёргать API незачем.
+	*/
+	has(name, url) {
+		if (url) return this.#matching(url).some((cookie) => cookie.name === name);
+		const now = Date.now();
+		for (const jar of this.#byOrigin.values()) {
+			const cookie = jar.get(name);
+			if (cookie && (cookie.expires === void 0 || cookie.expires > now)) return true;
+		}
+		return false;
+	}
+	/** Сохраняет содержимое jar для записи в {@link TokenStorage}. */
+	serialize() {
+		const result = [];
+		const now = Date.now();
+		for (const [origin, jar] of this.#byOrigin) for (const cookie of jar.values()) {
+			if (cookie.expires !== void 0 && cookie.expires <= now) continue;
+			const parts = [`${cookie.name}=${cookie.value}`, `Path=${cookie.path}`];
+			if (cookie.expires !== void 0) parts.push(`Expires=${new Date(cookie.expires).toUTCString()}`);
+			if (cookie.secure) parts.push("Secure");
+			result.push(`${origin}${SERIALIZED_SEPARATOR}${parts.join("; ")}`);
+		}
+		return result;
+	}
+	/** Восстанавливает jar из результата {@link serialize}. Некорректные записи молча пропускаются. */
+	deserialize(entries) {
+		if (!entries) return;
+		for (const entry of entries) {
+			const separatorAt = entry.indexOf(SERIALIZED_SEPARATOR);
+			if (separatorAt <= 0) continue;
+			const origin = entry.slice(0, separatorAt);
+			const setCookie = entry.slice(separatorAt + 1);
+			if (!originOf(origin)) continue;
+			this.setFromStrings(origin, [setCookie]);
+		}
+	}
+	/** Удаляет все cookie. */
+	clear() {
+		this.#byOrigin.clear();
+	}
+	/** Действующие cookie, подходящие запросу: тот же origin, подходящий путь, не истёкшие. */
+	#matching(url) {
+		const origin = originOf(url);
+		const jar = this.#byOrigin.get(origin);
+		if (!jar) return [];
+		const isSecureRequest = origin.startsWith("https:");
+		const requestPath = pathOf(url);
+		const now = Date.now();
+		const result = [];
+		for (const cookie of jar.values()) {
+			if (cookie.expires !== void 0 && cookie.expires <= now) {
+				jar.delete(cookie.name);
+				continue;
+			}
+			if (cookie.secure && !isSecureRequest) continue;
+			if (!pathMatches(cookie.path, requestPath)) continue;
+			result.push(cookie);
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/core/attachments.ts
+/** Способ передачи содержимого вложения. */
+const FileTransferMode = Object.freeze({
+	/** Сначала получить файл целиком, затем отправить его как `Blob`. */
+	Buffer: "buffer",
+	/** Передавать данные по мере чтения, не собирая файл целиком в памяти. */
+	Stream: "stream"
+});
+/** Размер очереди потокового вложения по умолчанию — 4 МиБ. */
+const DEFAULT_FILE_STREAM_BUFFER_BYTES = 4 * 1024 * 1024;
+/** Предел размера файла, скачиваемого по адресу, — 100 МиБ. */
+const DEFAULT_URL_FILE_MAX_BYTES = 100 * 1024 * 1024;
+/** Потоки, на которые уже наложены счётчик размера и backpressure. */
+const BOUNDED_FILE_STREAMS = /* @__PURE__ */ new WeakSet();
+/** Проверяет числовую границу до обращения к источнику. */
+function optionalBytes(value, name) {
+	if (value === void 0) return void 0;
+	if (!Number.isFinite(value) || value < 0 || !Number.isInteger(value)) throw new require_storage.ItdConfigError(`${name} должен быть неотрицательным целым числом, получено: ${value}`);
+	return value;
+}
+/** Проверяет и дополняет настройки потока. @internal */
+function resolveFileStreamOptions(options, defaultMaxBytes) {
+	const mode = options.mode ?? FileTransferMode.Buffer;
+	if (mode !== FileTransferMode.Buffer && mode !== FileTransferMode.Stream) throw new require_storage.ItdConfigError(`mode вложения должен быть 'buffer' или 'stream', получено: ${mode}`);
+	if (mode === FileTransferMode.Stream && typeof ReadableStream === "undefined") throw new require_storage.ItdConfigError("эта среда не поддерживает ReadableStream; используйте mode: 'buffer'");
+	const maxBytes = optionalBytes(options.maxBytes ?? defaultMaxBytes, "maxBytes");
+	const streamBufferBytes = optionalBytes(options.streamBufferBytes ?? 4194304, "streamBufferBytes") ?? 4194304;
+	if (streamBufferBytes === 0) throw new require_storage.ItdConfigError("streamBufferBytes должен быть больше нуля");
+	return {
+		mode,
+		maxBytes,
+		streamBufferBytes
+	};
+}
+/** Убирает параметры MIME и приводит его к форме для сравнения. */
+function normalizeMimeType(contentType) {
+	return contentType?.split(";", 1)[0]?.trim().toLowerCase() || void 0;
+}
+/** Достаёт имя файла из пути URL. */
+function filenameFromUrl(url) {
+	const last = url.pathname.split("/").pop();
+	if (!last) return void 0;
+	try {
+		return decodeURIComponent(last) || void 0;
+	} catch {
+		return last;
+	}
+}
+/** Создаёт ошибку превышения размера. */
+function tooLarge(url, limit, actual) {
+	return new require_storage.ItdFileError(`файл${url ? ` по адресу ${url}` : ""} больше предела в ${limit} байт: ${actual}`, {
+		reason: require_storage.ItdFileErrorReason.TooLarge,
+		...url ? { url } : {},
+		limit,
+		actual
+	});
+}
+/** Проверяет объявленный размер и возвращает его, если заголовок корректен. */
+function declaredSize(response, maxBytes, url) {
+	const header = response.headers.get("content-length");
+	if (header === null) return void 0;
+	const size = Number(header);
+	if (!Number.isFinite(size) || size < 0 || !Number.isInteger(size)) return void 0;
+	if (maxBytes !== void 0 && size > maxBytes) throw tooLarge(url, maxBytes, size);
+	return size;
+}
+/** Получает HTTP-ответ источника и проверяет его статус. */
+async function fetchFile(target, options, context) {
+	let requested;
+	try {
+		requested = new URL(target);
+	} catch {
+		throw new require_storage.ItdConfigError(`«${target}» не разбирается как адрес`);
+	}
+	if (requested.protocol !== "http:" && requested.protocol !== "https:") throw new require_storage.ItdConfigError(`вложение по адресу поддерживает только http и https, получено: ${requested.protocol}`);
+	let response;
+	try {
+		response = await context.fetch(requested, { ...context.signal ? { signal: context.signal } : {} });
+	} catch (error) {
+		if (context.signal?.aborted || error instanceof Error && error.name === "AbortError") throw error;
+		throw new require_storage.ItdFileError(`не удалось получить файл по адресу ${requested.href}`, {
+			reason: require_storage.ItdFileErrorReason.Network,
+			url: requested.href,
+			retryable: true,
+			cause: error
+		});
+	}
+	const finalUrl = response.url ? new URL(response.url) : requested;
+	if (!response.ok) {
+		await response.body?.cancel().catch(() => {});
+		throw new require_storage.ItdFileError(`источник ${finalUrl.href} ответил статусом ${response.status}`, {
+			reason: require_storage.ItdFileErrorReason.Http,
+			url: finalUrl.href,
+			status: response.status,
+			retryable: response.status === 408 || response.status === 429 || response.status >= 500
+		});
+	}
+	const { maxBytes } = resolveFileStreamOptions(options, DEFAULT_URL_FILE_MAX_BYTES);
+	let size;
+	try {
+		size = declaredSize(response, maxBytes, finalUrl.href);
+	} catch (error) {
+		await response.body?.cancel().catch(() => {});
+		throw error;
+	}
+	return {
+		response,
+		url: finalUrl,
+		size
+	};
+}
+/** Приводит произвольный чанк потока к байтам. */
+function asBytes(value) {
+	return value instanceof Uint8Array ? value : new Uint8Array(value);
+}
+function isReadableByteStream(value) {
+	return typeof ReadableStream !== "undefined" && value instanceof ReadableStream;
+}
+/**
+* Ограничивает размер и очередь потока. Отмена результирующего потока отменяет исходный.
+*
+* @internal
+*/
+function boundedFileStream(source, options = {}) {
+	const maxBytes = optionalBytes(options.maxBytes, "maxBytes");
+	const streamBufferBytes = optionalBytes(options.streamBufferBytes ?? 4194304, "streamBufferBytes") ?? 4194304;
+	if (streamBufferBytes === 0) throw new require_storage.ItdConfigError("streamBufferBytes должен быть больше нуля");
+	const reader = source.getReader();
+	let total = 0;
+	let finished = false;
+	let abortListener;
+	const cleanup = () => {
+		if (abortListener) options.signal?.removeEventListener("abort", abortListener);
+		abortListener = void 0;
+	};
+	const stream = new ReadableStream({
+		start(controller) {
+			if (!options.signal) return;
+			abortListener = () => {
+				finished = true;
+				reader.cancel(options.signal?.reason).catch(() => {});
+				controller.error(options.signal?.reason ?? new DOMException("Aborted", "AbortError"));
+				cleanup();
+			};
+			if (options.signal.aborted) abortListener();
+			else options.signal.addEventListener("abort", abortListener, { once: true });
+		},
+		async pull(controller) {
+			if (finished) return;
+			try {
+				const next = await reader.read();
+				if (finished) return;
+				if (next.done) {
+					finished = true;
+					cleanup();
+					controller.close();
+					return;
+				}
+				const chunk = asBytes(next.value);
+				total += chunk.byteLength;
+				if (maxBytes !== void 0 && total > maxBytes) {
+					finished = true;
+					await reader.cancel().catch(() => {});
+					cleanup();
+					controller.error(tooLarge(options.url, maxBytes, total));
+					return;
+				}
+				controller.enqueue(chunk);
+			} catch (error) {
+				finished = true;
+				cleanup();
+				if (error instanceof require_storage.ItdFileError) {
+					controller.error(error);
+					return;
+				}
+				controller.error(new require_storage.ItdFileError("не удалось прочитать поток вложения", {
+					reason: require_storage.ItdFileErrorReason.Read,
+					...options.url ? { url: options.url } : {},
+					retryable: options.retryableRead ?? false,
+					cause: error
+				}));
+			}
+		},
+		async cancel(reason) {
+			finished = true;
+			cleanup();
+			await reader.cancel(reason).catch(() => {});
+		}
+	}, {
+		highWaterMark: streamBufferBytes,
+		size: (chunk) => chunk.byteLength
+	});
+	BOUNDED_FILE_STREAMS.add(stream);
+	return stream;
+}
+/** Наложены ли на поток ограничения библиотеки. @internal */
+function isBoundedFileStream(stream) {
+	return BOUNDED_FILE_STREAMS.has(stream);
+}
+/** Читает ответ с контролем размера до создания итогового `Blob`. */
+async function responseBlob(response, url, maxBytes, streamBufferBytes, signal) {
+	if (!response.body) {
+		const blob = await response.blob();
+		if (maxBytes !== void 0 && blob.size > maxBytes) throw tooLarge(url, maxBytes, blob.size);
+		return blob;
+	}
+	const chunks = [];
+	const reader = boundedFileStream(response.body, {
+		...maxBytes !== void 0 ? { maxBytes } : {},
+		streamBufferBytes,
+		...signal ? { signal } : {},
+		url,
+		retryableRead: true
+	}).getReader();
+	try {
+		for (;;) {
+			const next = await reader.read();
+			if (next.done) break;
+			chunks.push(next.value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return new Blob(chunks.map((chunk) => Uint8Array.from(chunk).buffer));
+}
+/** Скачивает файл целиком с ограничением размера. @internal */
+async function downloadFile(target, options, context) {
+	const resolved = resolveFileStreamOptions(options, DEFAULT_URL_FILE_MAX_BYTES);
+	const { response, url } = await fetchFile(target, options, context);
+	const blob = await responseBlob(response, url.href, resolved.maxBytes, resolved.streamBufferBytes, context.signal);
+	const contentType = normalizeMimeType(options.contentType ?? response.headers.get("content-type") ?? void 0);
+	const filename = options.filename ?? filenameFromUrl(url);
+	return {
+		file: new Blob([blob], { type: contentType ?? "" }),
+		...filename ? { filename } : {},
+		...contentType ? { contentType } : {}
+	};
+}
+/** Открывает HTTP-ответ как ограниченный поток. @internal */
+async function openUrlFile(target, options, context) {
+	const resolved = resolveFileStreamOptions(options, DEFAULT_URL_FILE_MAX_BYTES);
+	const { response, url, size } = await fetchFile(target, options, context);
+	if (!response.body) throw new require_storage.ItdFileError(`источник ${url.href} не предоставил потоковое тело`, {
+		reason: require_storage.ItdFileErrorReason.StreamUnavailable,
+		url: url.href
+	});
+	const stream = boundedFileStream(response.body, {
+		...resolved.maxBytes !== void 0 ? { maxBytes: resolved.maxBytes } : {},
+		streamBufferBytes: resolved.streamBufferBytes,
+		...context.signal ? { signal: context.signal } : {},
+		url: url.href,
+		retryableRead: true
+	});
+	const filename = options.filename ?? filenameFromUrl(url);
+	const contentType = normalizeMimeType(options.contentType ?? response.headers.get("content-type") ?? void 0);
+	return {
+		stream,
+		...filename ? { filename } : {},
+		...contentType ? { contentType } : {},
+		...size !== void 0 ? { size } : {},
+		close: () => stream.cancel().catch(() => {})
+	};
+}
+function fromUrl(url, options = {}) {
+	if (resolveFileStreamOptions(options, 104857600).mode === FileTransferMode.Stream) return { open: (context) => openUrlFile(url, options, context) };
+	return { load: (context) => downloadFile(url, options, context) };
+}
+/**
+* Создаёт повторяемый пользовательский поток.
+*
+* Фабрика вызывается заново для каждой попытки; возвращать один и тот же поток нельзя.
+*/
+function fromStream(factory, options = {}) {
+	const resolved = resolveFileStreamOptions({
+		...options,
+		mode: FileTransferMode.Stream
+	}, void 0);
+	optionalBytes(options.size, "size");
+	return { open: async (context) => {
+		let opened;
+		try {
+			opened = await factory(context);
+		} catch (error) {
+			if (error instanceof require_storage.ItdFileError || error instanceof require_storage.ItdConfigError || context.signal?.aborted) throw error;
+			throw new require_storage.ItdFileError("не удалось открыть поток вложения", {
+				reason: require_storage.ItdFileErrorReason.Read,
+				retryable: true,
+				cause: error
+			});
+		}
+		const content = isReadableByteStream(opened) ? { stream: opened } : opened;
+		if (!content || !isReadableByteStream(content.stream)) throw new require_storage.ItdConfigError("fromStream должен вернуть ReadableStream или { stream }");
+		const size = options.size ?? content.size;
+		optionalBytes(size, "size");
+		if (resolved.maxBytes !== void 0 && size !== void 0 && size > resolved.maxBytes) {
+			await content.close?.();
+			throw tooLarge(void 0, resolved.maxBytes, size);
+		}
+		return {
+			stream: boundedFileStream(content.stream, {
+				...resolved.maxBytes !== void 0 ? { maxBytes: resolved.maxBytes } : {},
+				streamBufferBytes: resolved.streamBufferBytes,
+				...context.signal ? { signal: context.signal } : {},
+				retryableRead: true
+			}),
+			...options.filename ?? content.filename ? { filename: options.filename ?? content.filename } : {},
+			...normalizeMimeType(options.contentType ?? content.contentType) ? { contentType: normalizeMimeType(options.contentType ?? content.contentType) } : {},
+			...size !== void 0 ? { size } : {},
+			...content.close ? { close: content.close } : {}
+		};
+	} };
+}
+//#endregion
+//#region src/core/multi-storage.ts
+/**
+* Срез мультихранилища как обычное {@link TokenStorage} — в таком виде его получает
+* отдельный `ItdClient`, который про соседние аккаунты ничего не знает.
+*/
+function scopedTokenStorage(storage, account) {
+	return {
+		get: () => storage.get(account),
+		set: (session) => storage.set(account, session),
+		clear: () => storage.clear(account)
+	};
+}
+/**
+* Можно ли восстановить авторизованный аккаунт из записи.
+*
+* Один `deviceId` не считается сессией: он намеренно переживает выход, но не позволяет
+* выполнить ни одного авторизованного запроса.
+*
+* @internal
+*/
+function isRestorableSession(session) {
+	if (!session) return false;
+	if (session.accessToken || session.refreshToken) return true;
+	const jar = new CookieJar();
+	jar.deserialize(session.cookies);
+	return jar.has(AUTH_FLAG_COOKIE);
+}
+/** @internal */
+function controlledTokenStorage(storage, account) {
+	let revoked = false;
+	const pending = /* @__PURE__ */ new Set();
+	const mutate = (operation) => {
+		if (revoked) return Promise.resolve();
+		const promise = Promise.resolve().then(operation);
+		pending.add(promise);
+		promise.then(() => pending.delete(promise), () => pending.delete(promise));
+		return promise;
+	};
+	return {
+		storage: {
+			get: () => revoked ? null : storage.get(account),
+			set: (session) => mutate(() => storage.set(account, session)),
+			clear: () => mutate(() => storage.clear(account))
+		},
+		revoke() {
+			revoked = true;
+		},
+		async drain() {
+			await Promise.all([...pending]);
+		}
+	};
+}
+/**
+* Мультихранилище в памяти процесса — вариант по умолчанию.
+*
+* Сессии теряются при перезапуске. Для долгоживущих ботов возьмите `FileMultiTokenStorage`
+* из `itd-api/node` либо соберите своё через {@link createMultiTokenStorage}.
+*/
+var MemoryMultiTokenStorage = class {
+	#sessions = /* @__PURE__ */ new Map();
+	constructor(initial) {
+		for (const [account, session] of Object.entries(initial ?? {})) this.#sessions.set(account, require_storage.copySession(session));
+	}
+	get(account) {
+		const session = this.#sessions.get(account);
+		return session ? require_storage.copySession(session) : null;
+	}
+	set(account, session) {
+		this.#sessions.set(account, require_storage.copySession(session));
+	}
+	clear(account) {
+		this.#sessions.delete(account);
+	}
+	accounts() {
+		return [...this.#sessions.keys()];
+	}
+};
+/**
+* Собирает {@link MultiTokenStorage} из четырёх функций — когда заводить класс избыточно.
+* Аналог `createTokenStorage` для нескольких аккаунтов.
+*/
+function createMultiTokenStorage(handlers) {
+	return handlers;
+}
+/** Создаёт запись без прототипа: имена `__proto__` и `constructor` остаются обычными ключами. */
+function emptySessionRecord() {
+	return Object.create(null);
+}
+/** Копирует внешний снимок в запись без унаследованных свойств. */
+function normalizeSessionRecord(record) {
+	const normalized = emptySessionRecord();
+	for (const [account, session] of Object.entries(record ?? {})) normalized[account] = require_storage.copySession(session);
+	return normalized;
+}
+/**
+* Мультихранилище поверх источника, который читается и пишется целиком.
+*
+* Решает главную проблему такого способа хранения — **гонку «прочитать, изменить,
+* записать»**: десять аккаунтов пишут в одну запись, и наивная реализация теряла бы
+* чужие сессии. Источник читается один раз, дальше слепок живёт в памяти, а записи
+* выстраиваются в цепочку и идут по очереди.
+*
+* Внутри процесса этого достаточно. Несколько процессов, пишущих в одну запись,
+* по-прежнему затирают друг друга — как и несколько экземпляров этого адаптера,
+* направленных на один источник в одном процессе.
+*/
+function createRecordMultiStorage(source) {
+	/** Слепок записи. `undefined` — источник ещё не читался. */
+	let snapshot;
+	/** Общий промис чтения: параллельные вызовы на холодном старте читают источник один раз. */
+	let loading = null;
+	/** Цепочка записей. Ошибка одной не останавливает следующие. */
+	let writing = Promise.resolve();
+	const load = async () => {
+		if (snapshot !== void 0) return snapshot;
+		loading ??= source.read().then((value) => {
+			snapshot = normalizeSessionRecord(value);
+			return snapshot;
+		}).finally(() => {
+			loading = null;
+		});
+		return loading;
+	};
+	const flush = () => {
+		const current = normalizeSessionRecord(snapshot ?? null);
+		const operation = async () => {
+			if (source.remove && Object.keys(current).length === 0) await source.remove();
+			else await source.write(current);
+		};
+		writing = writing.then(operation, operation);
+		return writing;
+	};
+	return {
+		async get(account) {
+			const current = await load();
+			const session = Object.hasOwn(current, account) ? current[account] : void 0;
+			return session ? require_storage.copySession(session) : null;
+		},
+		async set(account, session) {
+			const current = await load();
+			current[account] = require_storage.copySession(session);
+			await flush();
+		},
+		async clear(account) {
+			const current = await load();
+			if (!Object.hasOwn(current, account)) return;
+			delete current[account];
+			await flush();
+		},
+		async accounts() {
+			return Object.keys(await load());
+		}
+	};
+}
+//#endregion
+Object.defineProperty(exports, "AUTH_FLAG_COOKIE", {
+	enumerable: true,
+	get: function() {
+		return AUTH_FLAG_COOKIE;
+	}
+});
+Object.defineProperty(exports, "CookieJar", {
+	enumerable: true,
+	get: function() {
+		return CookieJar;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_FILE_STREAM_BUFFER_BYTES", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_FILE_STREAM_BUFFER_BYTES;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_URL_FILE_MAX_BYTES", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_URL_FILE_MAX_BYTES;
+	}
+});
+Object.defineProperty(exports, "FileTransferMode", {
+	enumerable: true,
+	get: function() {
+		return FileTransferMode;
+	}
+});
+Object.defineProperty(exports, "MemoryMultiTokenStorage", {
+	enumerable: true,
+	get: function() {
+		return MemoryMultiTokenStorage;
+	}
+});
+Object.defineProperty(exports, "REFRESH_COOKIE", {
+	enumerable: true,
+	get: function() {
+		return REFRESH_COOKIE;
+	}
+});
+Object.defineProperty(exports, "REFRESH_COOKIE_PATH", {
+	enumerable: true,
+	get: function() {
+		return REFRESH_COOKIE_PATH;
+	}
+});
+Object.defineProperty(exports, "boundedFileStream", {
+	enumerable: true,
+	get: function() {
+		return boundedFileStream;
+	}
+});
+Object.defineProperty(exports, "controlledTokenStorage", {
+	enumerable: true,
+	get: function() {
+		return controlledTokenStorage;
+	}
+});
+Object.defineProperty(exports, "createMultiTokenStorage", {
+	enumerable: true,
+	get: function() {
+		return createMultiTokenStorage;
+	}
+});
+Object.defineProperty(exports, "createRecordMultiStorage", {
+	enumerable: true,
+	get: function() {
+		return createRecordMultiStorage;
+	}
+});
+Object.defineProperty(exports, "downloadFile", {
+	enumerable: true,
+	get: function() {
+		return downloadFile;
+	}
+});
+Object.defineProperty(exports, "fromStream", {
+	enumerable: true,
+	get: function() {
+		return fromStream;
+	}
+});
+Object.defineProperty(exports, "fromUrl", {
+	enumerable: true,
+	get: function() {
+		return fromUrl;
+	}
+});
+Object.defineProperty(exports, "isBoundedFileStream", {
+	enumerable: true,
+	get: function() {
+		return isBoundedFileStream;
+	}
+});
+Object.defineProperty(exports, "isRestorableSession", {
+	enumerable: true,
+	get: function() {
+		return isRestorableSession;
+	}
+});
+Object.defineProperty(exports, "normalizeMimeType", {
+	enumerable: true,
+	get: function() {
+		return normalizeMimeType;
+	}
+});
+Object.defineProperty(exports, "openUrlFile", {
+	enumerable: true,
+	get: function() {
+		return openUrlFile;
+	}
+});
+Object.defineProperty(exports, "resolveFileStreamOptions", {
+	enumerable: true,
+	get: function() {
+		return resolveFileStreamOptions;
+	}
+});
+Object.defineProperty(exports, "scopedTokenStorage", {
+	enumerable: true,
+	get: function() {
+		return scopedTokenStorage;
+	}
+});
+
+//# sourceMappingURL=multi-storage-D1keK2Op.cjs.map