@mtkruto/browser 0.6.1 → 0.119.1

package/esm/client/2_file_manager.js

@@ -1,18 +1,6 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _FileManager_instances, _a, _FileManager_c, _FileManager_Lupload, _FileManager_UPLOAD_MAX_CHUNK_SIZE, _FileManager_DOWNLOAD_MAX_CHUNK_SIZE, _FileManager_BIG_FILE_THRESHOLD, _FileManager_UPLOAD_REQUEST_PER_CONNECTION, _FileManager_uploadStream, _FileManager_uploadBuffer, _FileManager_handleError, _FileManager_getFileContents, _FileManager_CUSTOM_EMOJI_TTL;
 /**
  * MTKruto - Cross-runtime JavaScript library for building Telegram clients
- * Copyright (C) 2023-2024 Roj <https://roj.im/>
+ * Copyright (C) 2023-2026 Roj <https://roj.im/>
  *
  * This file is part of MTKruto.
  *
@@ -29,145 +17,376 @@ var _FileManager_instances, _a, _FileManager_c, _FileManager_Lupload, _FileManag
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-import * as dntShim from "../_dnt.shims.js";
-import { AssertionError, basename, extension, extname, isAbsolute, toFileUrl, unreachable } from "../0_deps.js";
+var _a;
+import { AssertionError, basename, delay, extension, extname, isAbsolute, join, MINUTE, SECOND, toFileUrl, unreachable } from "../0_deps.js";
 import { InputError } from "../0_errors.js";
-import { drop, getLogger, getRandomId, iterateReadableStream, kilobyte, megabyte, minute, mod, PartStream, second } from "../1_utilities.js";
-import { as, is } from "../2_tl.js";
+import { getLogger, getRandomId, iterateReadableStream, kilobyte, megabyte, mod, PartStream } from "../1_utilities.js";
+import { Api } from "../2_tl.js";
+import { TimeTooBig, TimeTooSmall } from "../3_errors.js";
+import { getDc } from "../3_transport.js";
 import { constructSticker, deserializeFileId, FileType, PhotoSourceType, serializeFileId, toUniqueFileId } from "../3_types.js";
-import { STICKER_SET_NAME_TTL } from "../4_constants.js";
+import { DOWNLOAD_MAX_CHUNK_SIZE, STICKER_SET_NAME_TTL } from "../4_constants.js";
+import { FloodWait, StickersetInvalid } from "../4_errors.js";
+import { UPLOAD_REQUEST_PER_CONNECTION } from "./0_utilities.js";
 export class FileManager {
+    #c;
+    #Lupload;
+    static #UPLOAD_MAX_CHUNK_SIZE = 512 * kilobyte;
+    static #BIG_FILE_THRESHOLD = 10 * megabyte;
     constructor(c) {
-        _FileManager_instances.add(this);
-        _FileManager_c.set(this, void 0);
-        _FileManager_Lupload.set(this, void 0);
-        __classPrivateFieldSet(this, _FileManager_c, c, "f");
+        this.#c = c;
         const L = getLogger("FileManager").client(c.id);
-        __classPrivateFieldSet(this, _FileManager_Lupload, L.branch("upload"), "f");
+        this.#Lupload = L.branch("upload");
+    }
+    #progressIds = new Set();
+    getProgressId() {
+        let id;
+        do {
+            id = getRandomId();
+        } while (id === 0n || this.#progressIds.has(id));
+        this.#progressIds.add(id);
+        return Promise.resolve(String(id));
     }
     async upload(file, params, checkName, allowStream = true) {
-        let { size, name, contents } = await __classPrivateFieldGet(_a, _a, "m", _FileManager_getFileContents).call(_a, file, params, allowStream);
+        if (params?.progressId !== undefined && !this.#progressIds.has(BigInt(params.progressId))) {
+            throw new InputError("Invalid progressId.");
+        }
+        if (params?.progressId !== undefined) {
+            this.#progressIds.delete(BigInt(params.progressId));
+        }
+        let { size, name, contents } = await _a.#getFileContents(file, params, allowStream);
         if (checkName) {
             name = checkName(name);
         }
-        if (size == 0 || size < -1) {
+        if (size === 0 || size < -1) {
             throw new InputError("Invalid file size.");
         }
-        const chunkSize = params?.chunkSize ?? __classPrivateFieldGet(_a, _a, "f", _FileManager_UPLOAD_MAX_CHUNK_SIZE);
-        _a.validateChunkSize(chunkSize, __classPrivateFieldGet(_a, _a, "f", _FileManager_UPLOAD_MAX_CHUNK_SIZE));
-        const fileId = getRandomId();
-        const isBig = contents instanceof Uint8Array ? contents.length > __classPrivateFieldGet(_a, _a, "f", _FileManager_BIG_FILE_THRESHOLD) : true;
-        const poolSize = contents instanceof Uint8Array ? isBig ? 3 : 1 : 3;
-        const pool = __classPrivateFieldGet(this, _FileManager_c, "f").getCdnConnectionPool(poolSize);
+        const poolSize = await this.#c.getUploadPoolSize();
+        const chunkSize = params?.chunkSize ?? _a.#UPLOAD_MAX_CHUNK_SIZE;
+        _a.validateChunkSize(chunkSize, _a.#UPLOAD_MAX_CHUNK_SIZE);
+        const mustTrackProgress = params?.progressId !== undefined;
+        const fileId = params?.progressId !== undefined ? BigInt(params.progressId) : getRandomId();
+        const isBig = contents instanceof Uint8Array ? contents.length > _a.#BIG_FILE_THRESHOLD : true;
         const whatIsUploaded = contents instanceof Uint8Array ? (isBig ? "big file" : "file") + " of size " + size : "stream";
-        __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug("uploading " + whatIsUploaded + " with chunk size of " + chunkSize + " and pool size of " + poolSize + " and file ID of " + fileId);
-        params?.signal?.addEventListener("abort", () => drop(pool.disconnect()));
-        await pool.connect();
+        this.#Lupload.debug("uploading " + whatIsUploaded + " with chunk size of " + chunkSize + " and pool size of " + poolSize + " and file ID of " + fileId);
         let result;
-        try {
-            if (contents instanceof Uint8Array) {
-                result = await __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_uploadBuffer).call(this, contents, fileId, chunkSize, params?.signal, pool);
-            }
-            else {
-                result = await __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_uploadStream).call(this, contents, fileId, chunkSize, params?.signal, pool);
-            }
+        if (contents instanceof Uint8Array) {
+            result = await this.#uploadBuffer(contents, fileId, mustTrackProgress, chunkSize, poolSize, params?.signal);
         }
-        finally {
-            drop(pool.disconnect());
+        else {
+            result = await this.#uploadStream(contents, fileId, mustTrackProgress, chunkSize, poolSize, params?.signal);
         }
-        __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug(`[${fileId}] uploaded ` + result.parts + " part(s)");
-        if (result.small) {
+        this.#Lupload.debug(`[${fileId}] uploaded ` + result.parts + " part(s)");
+        if (checkName) {
+            name = checkName(name, result.firstPart);
+        }
+        if (result.isSmall) {
             return { _: "inputFile", id: fileId, name, parts: result.parts, md5_checksum: "" };
         }
         else {
             return { _: "inputFileBig", id: fileId, name, parts: result.parts };
         }
     }
+    async #uploadStream(stream, fileId, mustTrackProgress, chunkSize, poolSize, signal) {
+        let part;
+        let promises = new Array();
+        let ms = 0.05;
+        let uploaded = 0;
+        let firstPart;
+        for await (part of iterateReadableStream(stream.pipeThrough(new PartStream(chunkSize)))) {
+            if (!part.isSmall && part.part > 0) {
+                await delay(ms);
+                ms = Math.max(ms * .8, 0.003);
+            }
+            if (!firstPart) {
+                firstPart = part.bytes;
+            }
+            promises.push(this.#uploadPart(fileId, part.totalParts, !part.isSmall, part.part, part.bytes, signal).then(() => {
+                if (mustTrackProgress) {
+                    uploaded += part.bytes.length;
+                    this.#c.handleUpdate({
+                        uploadProgress: {
+                            id: String(fileId),
+                            uploaded,
+                            total: 0,
+                        },
+                    });
+                }
+            }));
+            if (promises.length === poolSize * UPLOAD_REQUEST_PER_CONNECTION) {
+                await Promise.all(promises);
+                promises = [];
+            }
+        }
+        await Promise.all(promises);
+        return { isSmall: part.isSmall, parts: part.totalParts, firstPart };
+    }
+    async #uploadBuffer(buffer, fileId, mustTrackProgress, chunkSize, poolSize, signal) {
+        const isBig = buffer.byteLength > _a.#BIG_FILE_THRESHOLD;
+        const partCount = Math.ceil(buffer.byteLength / chunkSize);
+        let promises = new Array();
+        let started = false;
+        let ms = 0.05;
+        let uploaded = 0;
+        let firstPart;
+        main: for (let part = 0; part < partCount;) {
+            for (let i = 0; i < poolSize; ++i) {
+                for (let i = 0; i < UPLOAD_REQUEST_PER_CONNECTION; ++i) {
+                    const start = part * chunkSize;
+                    const end = start + chunkSize;
+                    const bytes = buffer.subarray(start, end);
+                    if (!bytes.length) {
+                        break main;
+                    }
+                    if (!started) {
+                        started = true;
+                    }
+                    else if (isBig && part > 0) {
+                        await delay(ms);
+                        ms = Math.max(ms * .8, 0.003);
+                    }
+                    if (!firstPart) {
+                        firstPart = bytes;
+                    }
+                    promises.push(this.#uploadPart(fileId, partCount, isBig, part++, bytes, signal).then(() => {
+                        if (mustTrackProgress) {
+                            uploaded += bytes.length;
+                            this.#c.handleUpdate({
+                                uploadProgress: {
+                                    id: String(fileId),
+                                    uploaded,
+                                    total: buffer.length,
+                                },
+                            });
+                        }
+                    }));
+                    if (promises.length === poolSize * UPLOAD_REQUEST_PER_CONNECTION) {
+                        await Promise.all(promises);
+                        promises = [];
+                    }
+                }
+            }
+            await Promise.all(promises);
+            promises = [];
+        }
+        await Promise.all(promises);
+        return { isSmall: !isBig, parts: partCount, firstPart };
+    }
+    async #uploadPart(fileId, partCount, isBig, index, bytes, signal) {
+        let retryIn = 1;
+        let errorCount = 0;
+        while (true) {
+            try {
+                signal?.throwIfAborted();
+                this.#Lupload.debug(`[${fileId}] uploading part ` + (index + 1));
+                if (isBig) {
+                    await this.#c.invoke({ _: "upload.saveBigFilePart", file_id: fileId, file_part: index, bytes, file_total_parts: partCount }, { type: "upload" });
+                }
+                else {
+                    await this.#c.invoke({ _: "upload.saveFilePart", file_id: fileId, bytes, file_part: index }, { type: "upload" });
+                }
+                this.#Lupload.debug(`[${fileId}] uploaded part ` + (index + 1));
+                break;
+            }
+            catch (err) {
+                signal?.throwIfAborted();
+                this.#Lupload.debug(`[${fileId}] failed to upload part ` + (index + 1));
+                ++errorCount;
+                if (errorCount > 20) {
+                    retryIn = 0;
+                    errorCount = 20;
+                }
+                await this.#handleError(err, retryIn, `[${fileId}-${index + 1}]`);
+                retryIn += 2;
+                if (retryIn > 11) {
+                    retryIn = 11;
+                }
+            }
+        }
+    }
+    async #handleError(err, retryIn, logPrefix) {
+        if (err instanceof TimeTooBig || err instanceof TimeTooSmall) {
+            throw err;
+        }
+        else if (err instanceof FloodWait) {
+            this.#Lupload.warning(`${logPrefix} retrying in ${err.seconds} seconds:`, err);
+            await delay(err.seconds * SECOND);
+        }
+        else if (retryIn > 0) {
+            this.#Lupload.warning(`${logPrefix} retrying in ${retryIn} seconds:`, err);
+            await delay(retryIn * SECOND);
+        }
+        else {
+            throw err;
+        }
+    }
+    static async #getFileContents(source, params, allowStream) {
+        let name = params?.fileName?.trim() || "file";
+        let contents;
+        let size = -1;
+        if (source instanceof Uint8Array) {
+            contents = source;
+            size = source.byteLength;
+        }
+        else if (source instanceof ReadableStream) {
+            if (!allowStream) {
+                throw new InputError("Streamed upload not allowed.");
+            }
+            contents = source;
+        }
+        else if (typeof source === "object" && source !== null && (Symbol.iterator in source || Symbol.asyncIterator in source)) {
+            if (!allowStream) {
+                throw new InputError("Streamed upload not allowed.");
+            }
+            contents = new ReadableStream({
+                pull: Symbol.asyncIterator in source
+                    ? async (controller) => {
+                        const { value, done } = await source.next();
+                        done ? controller.close() : controller.enqueue(value);
+                    }
+                    : (controller) => {
+                        const { value, done } = source.next();
+                        done ? controller.close() : controller.enqueue(value);
+                    },
+            });
+        }
+        else {
+            let url;
+            try {
+                url = new URL(source).toString();
+            }
+            catch {
+                let path_;
+                if (typeof source === "string") {
+                    if (isAbsolute(source)) {
+                        path_ = source;
+                    }
+                    else {
+                        // @ts-ignore: lib
+                        path_ = join(Deno.cwd(), source);
+                    }
+                    url = toFileUrl(path_).toString();
+                    name = basename(path_);
+                }
+                else {
+                    unreachable();
+                }
+            }
+            const response = await fetch(url);
+            if (response.body === null) {
+                throw new InputError("Invalid response");
+            }
+            if (name === "file") {
+                const contentType = response.headers.get("content-type")?.split(";")[0].trim();
+                if (contentType) {
+                    name += extension(contentType);
+                }
+                else {
+                    const maybeFileName = new URL(response.url).pathname.split("/")
+                        .filter((v) => v)
+                        .slice(-1)[0]
+                        .trim();
+                    if (maybeFileName) {
+                        name += extension(extname(maybeFileName));
+                    }
+                }
+            }
+            const contentLength = Number(response.headers.get("content-length"));
+            if (contentLength && !isNaN(contentLength)) {
+                size = contentLength;
+            }
+            if (allowStream) {
+                contents = response.body;
+            }
+            else {
+                contents = new Uint8Array(await response.arrayBuffer());
+            }
+        }
+        return { size: params?.fileSize ? params.fileSize : size, name, contents };
+    }
     async *downloadInner(location, dcId, params) {
         const signal = params?.signal;
         signal?.throwIfAborted();
         const id = "id" in location ? location.id : "photo_id" in location ? location.photo_id : null;
-        if (id != null && __classPrivateFieldGet(this, _FileManager_c, "f").storage.supportsFiles) {
-            const file = await __classPrivateFieldGet(this, _FileManager_c, "f").storage.getFile(id);
-            const partOffset = file == null ? 0 : params?.offset ? Math.ceil(10 / file[1]) - 1 : 0;
-            if (file != null && file[0] > 0) {
-                yield* __classPrivateFieldGet(this, _FileManager_c, "f").storage.iterFileParts(id, file[0], partOffset, signal);
+        if (id !== null && this.#c.storage.supportsFiles) {
+            const file = await this.#c.storage.getFile(id);
+            const partOffset = file === null ? 0 : params?.offset ? Math.ceil(10 / file[1]) - 1 : 0;
+            if (file !== null && file[0] > 0) {
+                yield* this.#c.storage.iterFileParts(id, file[0], partOffset, signal);
                 return;
             }
         }
-        const chunkSize = params?.chunkSize ?? __classPrivateFieldGet(_a, _a, "f", _FileManager_DOWNLOAD_MAX_CHUNK_SIZE);
-        _a.validateChunkSize(chunkSize, __classPrivateFieldGet(_a, _a, "f", _FileManager_DOWNLOAD_MAX_CHUNK_SIZE));
+        const chunkSize = params?.chunkSize ?? DOWNLOAD_MAX_CHUNK_SIZE;
+        _a.validateChunkSize(chunkSize, DOWNLOAD_MAX_CHUNK_SIZE);
         if (params?.offset !== undefined) {
             _a.validateOffset(params.offset);
         }
-        const connection = __classPrivateFieldGet(this, _FileManager_c, "f").getCdnConnection(dcId);
-        await connection.connect();
+        const dc = getDc(dcId);
         signal?.throwIfAborted();
         const limit = chunkSize;
         let offset = params?.offset ? BigInt(params.offset) : 0n;
         let part = 0;
-        try {
-            while (true) {
+        let ms = 0.05;
+        while (true) {
+            signal?.throwIfAborted();
+            let retryIn = 1;
+            let errorCount = 0;
+            try {
+                const file = await this.#c.invoke({ _: "upload.getFile", location, offset, limit }, { dc, type: "download" });
                 signal?.throwIfAborted();
-                let retryIn = 1;
-                let errorCount = 0;
-                try {
-                    const file = await connection.invoke({ _: "upload.getFile", location, offset, limit });
-                    signal?.throwIfAborted();
-                    if (is("upload.file", file)) {
-                        yield file.bytes;
-                        if (id != null) {
-                            await __classPrivateFieldGet(this, _FileManager_c, "f").storage.saveFilePart(id, part, file.bytes);
+                if (Api.is("upload.file", file)) {
+                    yield file.bytes;
+                    if (id !== null) {
+                        await this.#c.storage.saveFilePart(id, part, file.bytes);
+                        signal?.throwIfAborted();
+                    }
+                    ++part;
+                    if (file.bytes.length < limit) {
+                        if (id !== null) {
+                            await this.#c.storage.setFilePartCount(id, part + 1, chunkSize);
                             signal?.throwIfAborted();
                         }
-                        ++part;
-                        if (file.bytes.length < limit) {
-                            if (id != null) {
-                                await __classPrivateFieldGet(this, _FileManager_c, "f").storage.setFilePartCount(id, part + 1, chunkSize);
-                                signal?.throwIfAborted();
-                            }
-                            break;
-                        }
-                        else {
-                            offset += BigInt(file.bytes.length);
-                        }
+                        break;
                     }
                     else {
-                        unreachable();
+                        offset += BigInt(file.bytes.length);
                     }
                 }
-                catch (err) {
-                    if (typeof err === "object" && err instanceof AssertionError) {
-                        throw err;
-                    }
-                    ++errorCount;
-                    if (errorCount > 20) {
-                        retryIn = 0;
-                    }
-                    await __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_handleError).call(this, err, retryIn, `[${id}-${part + 1}]`);
-                    signal?.throwIfAborted();
-                    retryIn += 2;
-                    if (retryIn > 11) {
-                        retryIn = 11;
-                    }
+                else {
+                    unreachable();
+                }
+                await delay(ms);
+                ms = Math.max(ms * .8, 0.003);
+            }
+            catch (err) {
+                if (typeof err === "object" && err instanceof AssertionError) {
+                    throw err;
+                }
+                ++errorCount;
+                if (errorCount > 20) {
+                    retryIn = 0;
+                    errorCount = 0;
+                }
+                await this.#handleError(err, retryIn, `[${id}-${part + 1}]`);
+                signal?.throwIfAborted();
+                retryIn += 2;
+                if (retryIn > 11) {
+                    retryIn = 11;
                 }
             }
-        }
-        finally {
-            drop(connection.disconnect());
         }
     }
     static validateChunkSize(chunkSize, max) {
         if (chunkSize <= 0) {
             throw new InputError("chunkSize must be bigger than zero.");
         }
-        if (chunkSize % 1 != 0) {
+        if (chunkSize % 1 !== 0) {
             throw new InputError("chunkSize must be a whole number.");
         }
         if (chunkSize > max) {
             throw new InputError("chunkSize is too big.");
         }
-        if (mod(chunkSize, 1024) != 0) {
+        if (mod(chunkSize, 1024) !== 0) {
             throw new InputError("chunkSize must be divisible by 1024.");
         }
     }
@@ -175,35 +394,49 @@ export class FileManager {
         if (offset < 0) {
             throw new InputError("offset must not be smaller than zero.");
         }
-        if (offset % 1 != 0) {
+        if (offset % 1 !== 0) {
             throw new InputError("offset must be a whole number.");
         }
-        if (mod(offset, 1024) != 0) {
+        if (mod(offset, 1024) !== 0) {
             throw new InputError("offset must be divisible by 1024.");
         }
     }
     async *download(fileId, params) {
         const fileId_ = deserializeFileId(fileId);
-        if (fileId_.location.type == "photo") {
+        if (fileId_.location.type === "photo") {
             switch (fileId_.type) {
                 case FileType.ProfilePhoto: {
-                    if (fileId_.location.source.type != PhotoSourceType.ChatPhotoBig && fileId_.location.source.type != PhotoSourceType.ChatPhotoSmall) {
+                    if (fileId_.location.source.type !== PhotoSourceType.ChatPhotoBig && fileId_.location.source.type !== PhotoSourceType.ChatPhotoSmall) {
                         unreachable();
                     }
-                    const big = fileId_.location.source.type == PhotoSourceType.ChatPhotoBig;
-                    const peer = await __classPrivateFieldGet(this, _FileManager_c, "f").getInputPeer(Number(fileId_.location.source.chatId));
+                    const big = fileId_.location.source.type === PhotoSourceType.ChatPhotoBig;
+                    const peer = await this.#c.getInputPeer(Number(fileId_.location.source.chatId));
                     const location = { _: "inputPeerPhotoFileLocation", big: big ? true : undefined, peer, photo_id: fileId_.location.id };
                     yield* this.downloadInner(location, fileId_.dcId, params);
                     break;
                 }
                 case FileType.Photo: {
-                    const location = {
-                        _: "inputPhotoFileLocation",
-                        id: fileId_.location.id,
-                        access_hash: fileId_.location.accessHash,
-                        file_reference: fileId_.fileReference ?? new Uint8Array(),
-                        thumb_size: "thumbnailType" in fileId_.location.source ? String.fromCharCode(fileId_.location.source.thumbnailType) : "",
-                    };
+                    let location;
+                    if (fileId_.location.source.type === PhotoSourceType.StickerSetThumbnailVersion) {
+                        location = {
+                            _: "inputStickerSetThumb",
+                            stickerset: {
+                                _: "inputStickerSetID",
+                                id: fileId_.location.source.stickerSetId,
+                                access_hash: fileId_.location.source.stickerSetAccessHash,
+                            },
+                            thumb_version: fileId_.location.source.version,
+                        };
+                    }
+                    else {
+                        location = {
+                            _: "inputPhotoFileLocation",
+                            id: fileId_.location.id,
+                            access_hash: fileId_.location.accessHash,
+                            file_reference: fileId_.fileReference ?? new Uint8Array(),
+                            thumb_size: "thumbnailType" in fileId_.location.source ? String.fromCharCode(fileId_.location.source.thumbnailType) : "",
+                        };
+                    }
                     yield* this.downloadInner(location, fileId_.dcId, params);
                     break;
                 }
@@ -220,7 +453,7 @@ export class FileManager {
                 }
             }
         }
-        else if (fileId_.location.type == "common") {
+        else if (fileId_.location.type === "common") {
             const location = {
                 _: "inputDocumentFileLocation",
                 id: fileId_.location.id,
@@ -235,17 +468,28 @@ export class FileManager {
         }
     }
     async getStickerSetName(inputStickerSet, hash = 0) {
-        const maybeStickerSetName = await __classPrivateFieldGet(this, _FileManager_c, "f").messageStorage.getStickerSetName(inputStickerSet.id, inputStickerSet.access_hash);
-        if (maybeStickerSetName != null && Date.now() - maybeStickerSetName[1].getTime() < STICKER_SET_NAME_TTL) {
+        const maybeStickerSetName = await this.#c.messageStorage.getStickerSetName(inputStickerSet.id, inputStickerSet.access_hash);
+        if (maybeStickerSetName !== null && Date.now() - maybeStickerSetName[1].getTime() < STICKER_SET_NAME_TTL) {
             return maybeStickerSetName[0];
         }
         else {
-            const stickerSet = await __classPrivateFieldGet(this, _FileManager_c, "f").invoke({ _: "messages.getStickerSet", stickerset: inputStickerSet, hash });
-            const name = as("messages.stickerSet", stickerSet).set.short_name;
-            await __classPrivateFieldGet(this, _FileManager_c, "f").messageStorage.updateStickerSetName(inputStickerSet.id, inputStickerSet.access_hash, name);
-            return name;
+            try {
+                const stickerSet = await this.#c.invoke({ _: "messages.getStickerSet", stickerset: inputStickerSet, hash });
+                const name = Api.as("messages.stickerSet", stickerSet).set.short_name;
+                await this.#c.messageStorage.updateStickerSetName(inputStickerSet.id, inputStickerSet.access_hash, name);
+                return name;
+            }
+            catch (err) {
+                if (err instanceof StickersetInvalid) {
+                    return undefined;
+                }
+                else {
+                    throw err;
+                }
+            }
         }
     }
+    static #CUSTOM_EMOJI_TTL = 30 * MINUTE;
     async getCustomEmojiStickers(id) {
         id = Array.isArray(id) ? id : [id];
         if (!id.length) {
@@ -254,8 +498,8 @@ export class FileManager {
         const stickers = new Array();
         let shouldFetch = false;
         for (const id_ of id) {
-            const maybeDocument = await __classPrivateFieldGet(this, _FileManager_c, "f").messageStorage.getCustomEmojiDocument(BigInt(id_));
-            if (maybeDocument != null && Date.now() - maybeDocument[1].getTime() <= __classPrivateFieldGet(_a, _a, "f", _FileManager_CUSTOM_EMOJI_TTL)) {
+            const maybeDocument = await this.#c.messageStorage.getCustomEmojiDocument(BigInt(id_));
+            if (maybeDocument !== null && Date.now() - maybeDocument[1].getTime() <= _a.#CUSTOM_EMOJI_TTL) {
                 const document_ = maybeDocument[0];
                 const fileId_ = {
                     type: FileType.Document,
@@ -276,9 +520,9 @@ export class FileManager {
         if (!shouldFetch) {
             return stickers;
         }
-        const documents_ = (await __classPrivateFieldGet(this, _FileManager_c, "f").invoke({ _: "messages.getCustomEmojiDocuments", document_id: id.map(BigInt) })).map((v) => as("document", v));
+        const documents_ = (await this.#c.invoke({ _: "messages.getCustomEmojiDocuments", document_id: id.map(BigInt) })).map((v) => Api.as("document", v));
         for (const [i, document_] of documents_.entries()) {
-            await __classPrivateFieldGet(this, _FileManager_c, "f").messageStorage.setCustomEmojiDocument(document_.id, document_);
+            await this.#c.messageStorage.setCustomEmojiDocument(document_.id, document_);
             const fileId_ = {
                 type: FileType.Document,
                 dcId: document_.dc_id,
@@ -293,210 +537,4 @@ export class FileManager {
         return stickers;
     }
 }
-_a = FileManager, _FileManager_c = new WeakMap(), _FileManager_Lupload = new WeakMap(), _FileManager_instances = new WeakSet(), _FileManager_uploadStream = async function _FileManager_uploadStream(stream, fileId, chunkSize, signal, pool) {
-    let part;
-    let promises = new Array();
-    let invoke = pool.invoke();
-    let apiPromiseCount = 0;
-    for await (part of iterateReadableStream(stream.pipeThrough(new PartStream(chunkSize)))) {
-        promises.push((async () => {
-            let retryIn = 1;
-            let errorCount = 0;
-            while (true) {
-                try {
-                    signal?.throwIfAborted();
-                    __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug(`[${fileId}] uploading part ` + (part.part + 1));
-                    if (part.small) {
-                        await invoke({ _: "upload.saveFilePart", file_id: fileId, bytes: part.bytes, file_part: part.part });
-                    }
-                    else {
-                        await invoke({ _: "upload.saveBigFilePart", file_id: fileId, file_part: part.part, bytes: part.bytes, file_total_parts: part.totalParts });
-                    }
-                    __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug(`[${fileId}] uploaded part ` + (part.part + 1));
-                    break;
-                }
-                catch (err) {
-                    signal?.throwIfAborted();
-                    __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug(`[${fileId}] failed to upload part ` + (part.part + 1));
-                    ++errorCount;
-                    if (errorCount > 20) {
-                        retryIn = 0;
-                    }
-                    await __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_handleError).call(this, err, retryIn, `[${fileId}-${part.part + 1}]`);
-                    retryIn += 2;
-                    if (retryIn > 11) {
-                        retryIn = 11;
-                    }
-                }
-            }
-        })());
-        if (++apiPromiseCount >= __classPrivateFieldGet(_a, _a, "f", _FileManager_UPLOAD_REQUEST_PER_CONNECTION)) {
-            invoke = pool.invoke();
-            apiPromiseCount = 0;
-        }
-        if (promises.length == pool.size * __classPrivateFieldGet(_a, _a, "f", _FileManager_UPLOAD_REQUEST_PER_CONNECTION)) {
-            await Promise.all(promises);
-            promises = [];
-        }
-    }
-    await Promise.all(promises);
-    return { small: part.small, parts: part.totalParts };
-}, _FileManager_uploadBuffer = async function _FileManager_uploadBuffer(buffer, fileId, chunkSize, signal, pool) {
-    const isBig = buffer.byteLength > __classPrivateFieldGet(_a, _a, "f", _FileManager_BIG_FILE_THRESHOLD);
-    const partCount = Math.ceil(buffer.byteLength / chunkSize);
-    let promises = new Array();
-    let started = false;
-    let delay = 0.05;
-    main: for (let part = 0; part < partCount;) {
-        for (let i = 0; i < pool.size; ++i) {
-            const invoke = pool.invoke();
-            for (let i = 0; i < __classPrivateFieldGet(_a, _a, "f", _FileManager_UPLOAD_REQUEST_PER_CONNECTION); ++i) {
-                const start = part * chunkSize;
-                const end = start + chunkSize;
-                const bytes = buffer.subarray(start, end);
-                if (!bytes.length) {
-                    break main;
-                }
-                const thisPart = part++; // `thisPart` must be used instead of `part` in the promise body
-                if (!started) {
-                    started = true;
-                }
-                else if (isBig) {
-                    await new Promise((r) => setTimeout(r, delay));
-                    delay = Math.max(delay * .8, 0.003);
-                }
-                promises.push((async () => {
-                    let retryIn = 1;
-                    let errorCount = 0;
-                    while (true) {
-                        try {
-                            signal?.throwIfAborted();
-                            __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug(`[${fileId}] uploading part ` + (thisPart + 1));
-                            if (isBig) {
-                                await invoke({ _: "upload.saveBigFilePart", file_id: fileId, file_part: thisPart, bytes, file_total_parts: partCount });
-                            }
-                            else {
-                                await invoke({ _: "upload.saveFilePart", file_id: fileId, bytes, file_part: thisPart });
-                            }
-                            __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug(`[${fileId}] uploaded part ` + (thisPart + 1) + " / " + partCount);
-                            break;
-                        }
-                        catch (err) {
-                            signal?.throwIfAborted();
-                            __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug(`[${fileId}] failed to upload part ` + (thisPart + 1) + " / " + partCount, err);
-                            ++errorCount;
-                            if (errorCount > 20) {
-                                retryIn = 0;
-                            }
-                            await __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_handleError).call(this, err, retryIn, `[${fileId}-${thisPart + 1}]`);
-                            retryIn += 2;
-                            if (retryIn > 11) {
-                                retryIn = 11;
-                            }
-                        }
-                    }
-                })());
-            }
-        }
-        await Promise.all(promises);
-        promises = [];
-    }
-    await Promise.all(promises);
-    return { small: !isBig, parts: partCount };
-}, _FileManager_handleError = async function _FileManager_handleError(err, retryIn, logPrefix) {
-    if (retryIn > 0) {
-        __classPrivateFieldGet(this, _FileManager_Lupload, "f").warning(`${logPrefix} retrying in ${retryIn} seconds`);
-        await new Promise((r) => setTimeout(r, retryIn * second));
-    }
-    else {
-        throw err;
-    }
-}, _FileManager_getFileContents = async function _FileManager_getFileContents(source, params, allowStream) {
-    let name = params?.fileName?.trim() || "file";
-    let contents;
-    let size = -1;
-    if (source instanceof Uint8Array) {
-        contents = source;
-        size = source.byteLength;
-    }
-    else if (source instanceof ReadableStream) {
-        if (!allowStream) {
-            throw new InputError("Streamed upload not allowed.");
-        }
-        contents = source;
-    }
-    else if (typeof source === "object" && source != null && (Symbol.iterator in source || Symbol.asyncIterator in source)) {
-        if (!allowStream) {
-            throw new InputError("Streamed upload not allowed.");
-        }
-        contents = new ReadableStream({
-            pull: Symbol.asyncIterator in source
-                ? async (controller) => {
-                    const { value, done } = await source.next();
-                    done ? controller.close() : controller.enqueue(value);
-                }
-                : (controller) => {
-                    const { value, done } = source.next();
-                    done ? controller.close() : controller.enqueue(value);
-                },
-        });
-    }
-    else {
-        let url;
-        try {
-            url = new URL(source).toString();
-        }
-        catch {
-            let path_;
-            if (typeof source === "string") {
-                if (isAbsolute(source)) {
-                    path_ = source;
-                }
-                else {
-                    // @ts-ignore: lib
-                    path_ = join(dntShim.Deno.cwd(), source);
-                }
-                url = toFileUrl(path_).toString();
-                name = basename(path_);
-            }
-            else {
-                unreachable();
-            }
-        }
-        const response = await fetch(url);
-        if (response.body == null) {
-            throw new InputError("Invalid response");
-        }
-        if (name == "file") {
-            const contentType = response.headers.get("content-type")?.split(";")[0].trim();
-            if (contentType) {
-                name += extension(contentType);
-            }
-            else {
-                const maybeFileName = new URL(response.url).pathname.split("/")
-                    .filter((v) => v)
-                    .slice(-1)[0]
-                    .trim();
-                if (maybeFileName) {
-                    name += extension(extname(maybeFileName));
-                }
-            }
-        }
-        const contentLength = Number(response.headers.get("content-length"));
-        if (!isNaN(contentLength)) {
-            size = contentLength;
-        }
-        if (allowStream) {
-            contents = response.body;
-        }
-        else {
-            contents = new Uint8Array(await response.arrayBuffer());
-        }
-    }
-    return { size: params?.fileSize ? params.fileSize : size, name, contents };
-};
-_FileManager_UPLOAD_MAX_CHUNK_SIZE = { value: 512 * kilobyte };
-_FileManager_DOWNLOAD_MAX_CHUNK_SIZE = { value: 1 * megabyte };
-_FileManager_BIG_FILE_THRESHOLD = { value: 10 * megabyte };
-_FileManager_UPLOAD_REQUEST_PER_CONNECTION = { value: 2 };
-_FileManager_CUSTOM_EMOJI_TTL = { value: 30 * minute };
+_a = FileManager;