@mtkruto/browser 0.119.0 → 0.120.0

package/esm/client/2_file_manager.js

@@ -17,18 +17,7 @@
  * 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/>.
  */
-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;
+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 { getLogger, getRandomId, iterateReadableStream, kilobyte, megabyte, mod, PartStream } from "../1_utilities.js";
@@ -40,53 +29,54 @@ 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);
-        _FileManager_progressIds.set(this, new Set());
-        __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 || __classPrivateFieldGet(this, _FileManager_progressIds, "f").has(id));
-        __classPrivateFieldGet(this, _FileManager_progressIds, "f").add(id);
+        } while (id === 0n || this.#progressIds.has(id));
+        this.#progressIds.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))) {
+        if (params?.progressId !== undefined && !this.#progressIds.has(BigInt(params.progressId))) {
             throw new InputError("Invalid progressId.");
         }
         if (params?.progressId !== undefined) {
-            __classPrivateFieldGet(this, _FileManager_progressIds, "f").delete(BigInt(params.progressId));
+            this.#progressIds.delete(BigInt(params.progressId));
         }
-        let { size, name, contents } = await __classPrivateFieldGet(_a, _a, "m", _FileManager_getFileContents).call(_a, file, params, allowStream);
+        let { size, name, contents } = await _a.#getFileContents(file, params, allowStream);
         if (checkName) {
             name = checkName(name);
         }
         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 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 > __classPrivateFieldGet(_a, _a, "f", _FileManager_BIG_FILE_THRESHOLD) : true;
+        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);
+        this.#Lupload.debug("uploading " + whatIsUploaded + " with chunk size of " + chunkSize + " and pool size of " + poolSize + " and file ID of " + fileId);
         let result;
         if (contents instanceof Uint8Array) {
-            result = await __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_uploadBuffer).call(this, contents, fileId, mustTrackProgress, chunkSize, poolSize, params?.signal);
+            result = await this.#uploadBuffer(contents, fileId, mustTrackProgress, chunkSize, poolSize, params?.signal);
         }
         else {
-            result = await __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_uploadStream).call(this, contents, fileId, mustTrackProgress, chunkSize, poolSize, params?.signal);
+            result = await this.#uploadStream(contents, fileId, mustTrackProgress, chunkSize, poolSize, params?.signal);
         }
-        __classPrivateFieldGet(this, _FileManager_Lupload, "f").debug(`[${fileId}] uploaded ` + result.parts + " part(s)");
+        this.#Lupload.debug(`[${fileId}] uploaded ` + result.parts + " part(s)");
         if (checkName) {
             name = checkName(name, result.firstPart);
         }
@@ -97,15 +87,232 @@ export class FileManager {
             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);
+        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* __classPrivateFieldGet(this, _FileManager_c, "f").storage.iterFileParts(id, file[0], partOffset, signal);
+                yield* this.#c.storage.iterFileParts(id, file[0], partOffset, signal);
                 return;
             }
         }
@@ -125,18 +332,18 @@ export class FileManager {
             let retryIn = 1;
             let errorCount = 0;
             try {
-                const file = await __classPrivateFieldGet(this, _FileManager_c, "f").invoke({ _: "upload.getFile", location, offset, limit }, { dc, type: "download" });
+                const file = await this.#c.invoke({ _: "upload.getFile", location, offset, limit }, { dc, type: "download" });
                 signal?.throwIfAborted();
                 if (Api.is("upload.file", file)) {
                     yield file.bytes;
                     if (id !== null) {
-                        await __classPrivateFieldGet(this, _FileManager_c, "f").storage.saveFilePart(id, part, file.bytes);
+                        await this.#c.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);
+                            await this.#c.storage.setFilePartCount(id, part + 1, chunkSize);
                             signal?.throwIfAborted();
                         }
                         break;
@@ -160,7 +367,7 @@ export class FileManager {
                     retryIn = 0;
                     errorCount = 0;
                 }
-                await __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_handleError).call(this, err, retryIn, `[${id}-${part + 1}]`);
+                await this.#handleError(err, retryIn, `[${id}-${part + 1}]`);
                 signal?.throwIfAborted();
                 retryIn += 2;
                 if (retryIn > 11) {
@@ -203,7 +410,7 @@ export class FileManager {
                         unreachable();
                     }
                     const big = fileId_.location.source.type === PhotoSourceType.ChatPhotoBig;
-                    const peer = await __classPrivateFieldGet(this, _FileManager_c, "f").getInputPeer(Number(fileId_.location.source.chatId));
+                    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;
@@ -261,15 +468,15 @@ export class FileManager {
         }
     }
     async getStickerSetName(inputStickerSet, hash = 0) {
-        const maybeStickerSetName = await __classPrivateFieldGet(this, _FileManager_c, "f").messageStorage.getStickerSetName(inputStickerSet.id, inputStickerSet.access_hash);
+        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 {
             try {
-                const stickerSet = await __classPrivateFieldGet(this, _FileManager_c, "f").invoke({ _: "messages.getStickerSet", stickerset: inputStickerSet, hash });
+                const stickerSet = await this.#c.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);
+                await this.#c.messageStorage.updateStickerSetName(inputStickerSet.id, inputStickerSet.access_hash, name);
                 return name;
             }
             catch (err) {
@@ -282,6 +489,7 @@ export class FileManager {
             }
         }
     }
+    static #CUSTOM_EMOJI_TTL = 30 * MINUTE;
     async getCustomEmojiStickers(id) {
         id = Array.isArray(id) ? id : [id];
         if (!id.length) {
@@ -290,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,
@@ -312,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) => Api.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,
@@ -329,219 +537,4 @@ export class FileManager {
         return stickers;
     }
 }
-_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 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(__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 (promises.length === poolSize * UPLOAD_REQUEST_PER_CONNECTION) {
-            await Promise.all(promises);
-            promises = [];
-        }
-    }
-    await Promise.all(promises);
-    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 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(__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 { 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 (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;
-    }
-}, _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(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 };
-};
-_FileManager_UPLOAD_MAX_CHUNK_SIZE = { value: 512 * kilobyte };
-_FileManager_BIG_FILE_THRESHOLD = { value: 10 * megabyte };
-_FileManager_CUSTOM_EMOJI_TTL = { value: 30 * MINUTE };
+_a = FileManager;