@mtkruto/browser 0.6.0 → 0.119.0

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,54 +17,80 @@ 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, extension, path, unreachable } from "../0_deps.js";
+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_BIG_FILE_THRESHOLD, _FileManager_progressIds, _FileManager_uploadStream, _FileManager_uploadBuffer, _FileManager_uploadPart, _FileManager_handleError, _FileManager_getFileContents, _FileManager_CUSTOM_EMOJI_TTL;
+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 {
     constructor(c) {
         _FileManager_instances.add(this);
         _FileManager_c.set(this, void 0);
         _FileManager_Lupload.set(this, void 0);
+        _FileManager_progressIds.set(this, new Set());
         __classPrivateFieldSet(this, _FileManager_c, c, "f");
         const L = getLogger("FileManager").client(c.id);
         __classPrivateFieldSet(this, _FileManager_Lupload, L.branch("upload"), "f");
     }
+    getProgressId() {
+        let id;
+        do {
+            id = getRandomId();
+        } while (id === 0n || __classPrivateFieldGet(this, _FileManager_progressIds, "f").has(id));
+        __classPrivateFieldGet(this, _FileManager_progressIds, "f").add(id);
+        return Promise.resolve(String(id));
+    }
     async upload(file, params, checkName, allowStream = true) {
+        if (params?.progressId !== undefined && !__classPrivateFieldGet(this, _FileManager_progressIds, "f").has(BigInt(params.progressId))) {
+            throw new InputError("Invalid progressId.");
+        }
+        if (params?.progressId !== undefined) {
+            __classPrivateFieldGet(this, _FileManager_progressIds, "f").delete(BigInt(params.progressId));
+        }
         let { size, name, contents } = await __classPrivateFieldGet(_a, _a, "m", _FileManager_getFileContents).call(_a, 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 poolSize = await __classPrivateFieldGet(this, _FileManager_c, "f").getUploadPoolSize();
         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 mustTrackProgress = params?.progressId !== undefined;
+        const fileId = params?.progressId !== undefined ? BigInt(params.progressId) : 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 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();
         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 __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_uploadBuffer).call(this, contents, fileId, mustTrackProgress, chunkSize, poolSize, params?.signal);
         }
-        finally {
-            drop(pool.disconnect());
+        else {
+            result = await __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_uploadStream).call(this, contents, fileId, mustTrackProgress, chunkSize, poolSize, params?.signal);
         }
         __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug(`[${fileId}] uploaded ` + result.parts + " part(s)");
-        if (result.small) {
+        if (checkName) {
+            name = checkName(name, result.firstPart);
+        }
+        if (result.isSmall) {
             return { _: "inputFile", id: fileId, name, parts: result.parts, md5_checksum: "" };
         }
         else {
@@ -87,87 +101,85 @@ export class FileManager {
         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) {
+        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) {
+            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);
                 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 __classPrivateFieldGet(this, _FileManager_c, "f").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 __classPrivateFieldGet(this, _FileManager_c, "f").storage.saveFilePart(id, part, file.bytes);
+                        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();
                         }
-                        ++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 __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_handleError).call(this, 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 +187,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 big = fileId_.location.source.type === PhotoSourceType.ChatPhotoBig;
                     const peer = await __classPrivateFieldGet(this, _FileManager_c, "f").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 +246,7 @@ export class FileManager {
                 }
             }
         }
-        else if (fileId_.location.type == "common") {
+        else if (fileId_.location.type === "common") {
             const location = {
                 _: "inputDocumentFileLocation",
                 id: fileId_.location.id,
@@ -236,14 +262,24 @@ 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) {
+        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 __classPrivateFieldGet(this, _FileManager_c, "f").invoke({ _: "messages.getStickerSet", stickerset: inputStickerSet, hash });
+                const name = Api.as("messages.stickerSet", stickerSet).set.short_name;
+                await __classPrivateFieldGet(this, _FileManager_c, "f").messageStorage.updateStickerSetName(inputStickerSet.id, inputStickerSet.access_hash, name);
+                return name;
+            }
+            catch (err) {
+                if (err instanceof StickersetInvalid) {
+                    return undefined;
+                }
+                else {
+                    throw err;
+                }
+            }
         }
     }
     async getCustomEmojiStickers(id) {
@@ -255,7 +291,7 @@ export class FileManager {
         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)) {
+            if (maybeDocument !== null && Date.now() - maybeDocument[1].getTime() <= __classPrivateFieldGet(_a, _a, "f", _FileManager_CUSTOM_EMOJI_TTL)) {
                 const document_ = maybeDocument[0];
                 const fileId_ = {
                     type: FileType.Document,
@@ -276,7 +312,7 @@ 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 __classPrivateFieldGet(this, _FileManager_c, "f").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_);
             const fileId_ = {
@@ -293,120 +329,131 @@ 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) {
+_a = FileManager, _FileManager_c = new WeakMap(), _FileManager_Lupload = new WeakMap(), _FileManager_progressIds = new WeakMap(), _FileManager_instances = new WeakSet(), _FileManager_uploadStream = async function _FileManager_uploadStream(stream, fileId, mustTrackProgress, chunkSize, poolSize, signal) {
     let part;
     let promises = new Array();
-    let invoke = pool.invoke();
-    let apiPromiseCount = 0;
+    let ms = 0.05;
+    let uploaded = 0;
+    let firstPart;
     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 (!part.isSmall && part.part > 0) {
+            await delay(ms);
+            ms = Math.max(ms * .8, 0.003);
+        }
+        if (!firstPart) {
+            firstPart = part.bytes;
+        }
+        promises.push(__classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_uploadPart).call(this, fileId, part.totalParts, !part.isSmall, part.part, part.bytes, signal).then(() => {
+            if (mustTrackProgress) {
+                uploaded += part.bytes.length;
+                __classPrivateFieldGet(this, _FileManager_c, "f").handleUpdate({
+                    uploadProgress: {
+                        id: String(fileId),
+                        uploaded,
+                        total: 0,
+                    },
+                });
             }
-        })());
-        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)) {
+        }));
+        if (promises.length === poolSize * 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) {
+    return { isSmall: part.isSmall, parts: part.totalParts, firstPart };
+}, _FileManager_uploadBuffer = async function _FileManager_uploadBuffer(buffer, fileId, mustTrackProgress, chunkSize, poolSize, signal) {
     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;
+    let ms = 0.05;
+    let uploaded = 0;
+    let firstPart;
     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) {
+        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;
                 }
-                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);
+                else if (isBig && part > 0) {
+                    await delay(ms);
+                    ms = Math.max(ms * .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;
-                            }
-                        }
+                if (!firstPart) {
+                    firstPart = bytes;
+                }
+                promises.push(__classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_uploadPart).call(this, fileId, partCount, isBig, part++, bytes, signal).then(() => {
+                    if (mustTrackProgress) {
+                        uploaded += bytes.length;
+                        __classPrivateFieldGet(this, _FileManager_c, "f").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 { small: !isBig, parts: partCount };
+    return { isSmall: !isBig, parts: partCount, firstPart };
+}, _FileManager_uploadPart = async function _FileManager_uploadPart(fileId, partCount, isBig, index, bytes, signal) {
+    let retryIn = 1;
+    let errorCount = 0;
+    while (true) {
+        try {
+            signal?.throwIfAborted();
+            __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug(`[${fileId}] uploading part ` + (index + 1));
+            if (isBig) {
+                await __classPrivateFieldGet(this, _FileManager_c, "f").invoke({ _: "upload.saveBigFilePart", file_id: fileId, file_part: index, bytes, file_total_parts: partCount }, { type: "upload" });
+            }
+            else {
+                await __classPrivateFieldGet(this, _FileManager_c, "f").invoke({ _: "upload.saveFilePart", file_id: fileId, bytes, file_part: index }, { type: "upload" });
+            }
+            __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug(`[${fileId}] uploaded part ` + (index + 1));
+            break;
+        }
+        catch (err) {
+            signal?.throwIfAborted();
+            __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug(`[${fileId}] failed to upload part ` + (index + 1));
+            ++errorCount;
+            if (errorCount > 20) {
+                retryIn = 0;
+                errorCount = 20;
+            }
+            await __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_handleError).call(this, err, retryIn, `[${fileId}-${index + 1}]`);
+            retryIn += 2;
+            if (retryIn > 11) {
+                retryIn = 11;
+            }
+        }
+    }
 }, _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));
+    if (err instanceof TimeTooBig || err instanceof TimeTooSmall) {
+        throw err;
+    }
+    else if (err instanceof FloodWait) {
+        __classPrivateFieldGet(this, _FileManager_Lupload, "f").warning(`${logPrefix} retrying in ${err.seconds} seconds:`, err);
+        await delay(err.seconds * SECOND);
+    }
+    else if (retryIn > 0) {
+        __classPrivateFieldGet(this, _FileManager_Lupload, "f").warning(`${logPrefix} retrying in ${retryIn} seconds:`, err);
+        await delay(retryIn * SECOND);
     }
     else {
         throw err;
@@ -425,7 +472,7 @@ _a = FileManager, _FileManager_c = new WeakMap(), _FileManager_Lupload = new Wea
         }
         contents = source;
     }
-    else if (typeof source === "object" && source != null && (Symbol.iterator in source || Symbol.asyncIterator in 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.");
         }
@@ -449,25 +496,25 @@ _a = FileManager, _FileManager_c = new WeakMap(), _FileManager_Lupload = new Wea
         catch {
             let path_;
             if (typeof source === "string") {
-                if (path.isAbsolute(source)) {
+                if (isAbsolute(source)) {
                     path_ = source;
                 }
                 else {
                     // @ts-ignore: lib
-                    path_ = path.join(dntShim.Deno.cwd(), source);
+                    path_ = join(Deno.cwd(), source);
                 }
-                url = path.toFileUrl(path_).toString();
-                name = path.basename(path_);
+                url = toFileUrl(path_).toString();
+                name = basename(path_);
             }
             else {
                 unreachable();
             }
         }
         const response = await fetch(url);
-        if (response.body == null) {
+        if (response.body === null) {
             throw new InputError("Invalid response");
         }
-        if (name == "file") {
+        if (name === "file") {
             const contentType = response.headers.get("content-type")?.split(";")[0].trim();
             if (contentType) {
                 name += extension(contentType);
@@ -478,12 +525,12 @@ _a = FileManager, _FileManager_c = new WeakMap(), _FileManager_Lupload = new Wea
                     .slice(-1)[0]
                     .trim();
                 if (maybeFileName) {
-                    name += extension(path.extname(maybeFileName));
+                    name += extension(extname(maybeFileName));
                 }
             }
         }
         const contentLength = Number(response.headers.get("content-length"));
-        if (!isNaN(contentLength)) {
+        if (contentLength && !isNaN(contentLength)) {
             size = contentLength;
         }
         if (allowStream) {
@@ -496,7 +543,5 @@ _a = FileManager, _FileManager_c = new WeakMap(), _FileManager_Lupload = new Wea
     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 };
+_FileManager_CUSTOM_EMOJI_TTL = { value: 30 * MINUTE };