@mtkruto/node 0.1.100 → 0.1.102

package/esm/client/4_client.js

@@ -1,10 +1,10 @@
 import { debug, gunzip, Mutex } from "../0_deps.js";
-import { bigIntFromBuffer, drop, getRandomBigInt, getRandomId, mustPrompt, mustPromptOneOf, Queue, sha1, UNREACHABLE } from "../1_utilities.js";
+import { bigIntFromBuffer, drop, getRandomBigInt, getRandomId, mod, mustPrompt, mustPromptOneOf, Queue, sha1, UNREACHABLE } from "../1_utilities.js";
 import { as, functions, getChannelChatId, Message_, MessageContainer, peerToChatId, RPCResult, TLError, TLReader, types } from "../2_tl.js";
 import { StorageMemory } from "../3_storage.js";
 import { botCommandScopeToTlObject, constructCallbackQuery, constructInlineQuery, constructMessage, constructUser, FileID, FileType, inlineQueryResultToTlObject, messageEntityToTlObject, replyMarkupToTlObject, ThumbnailSource } from "../3_types.js";
 import { ACK_THRESHOLD, APP_VERSION, CHANNEL_DIFFERENCE_LIMIT_BOT, CHANNEL_DIFFERENCE_LIMIT_USER, DEVICE_MODEL, LANG_CODE, LANG_PACK, LAYER, MAX_CHANNEL_ID, MAX_CHAT_ID, STICKER_SET_NAME_TTL, SYSTEM_LANG_CODE, SYSTEM_VERSION, USERNAME_TTL, ZERO_CHANNEL_ID } from "../4_constants.js";
-import { AuthKeyUnregistered, Migrate, PasswordHashInvalid, PhoneNumberInvalid, SessionPasswordNeeded, upgradeInstance } from "../4_errors.js";
+import { AuthKeyUnregistered, FloodWait, Migrate, PasswordHashInvalid, PhoneNumberInvalid, SessionPasswordNeeded, upgradeInstance } from "../4_errors.js";
 import { parseHtml } from "./0_html.js";
 import { decryptMessage, encryptMessage, getMessageId } from "./0_message.js";
 import { checkPassword } from "./0_password.js";
@@ -17,11 +17,14 @@ const dGap = debug("Client/recoverUpdateGap");
 const dGapC = debug("Client/recoverChannelUpdateGap");
 const dAuth = debug("Client/authorize");
 const dRecv = debug("Client/receiveLoop");
+const dUpload = debug("Client/upload");
 export const getEntity = Symbol();
 export const getStickerSetName = Symbol();
 export const handleMigrationError = Symbol();
 export const getMessageWithReply = Symbol();
 export const restartAuth = Symbol();
+export class ConnectionError extends Error {
+}
 export class Client extends ClientAbstract {
     /**
      * Constructs the client.
@@ -30,14 +33,8 @@ export class Client extends ClientAbstract {
      * @param apiId App's API ID from [my.telegram.org](https://my.telegram.org/apps). Defaults to 0 (unset).
      * @param apiHash App's API hash from [my.telegram.org/apps](https://my.telegram.org/apps). Defaults to empty string (unset).
      */
-    constructor(storage = new StorageMemory(), apiId = 0, apiHash = "", params) {
+    constructor(storage, apiId = 0, apiHash = "", params) {
         super(params);
-        Object.defineProperty(this, "storage", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: storage
-        });
         Object.defineProperty(this, "apiId", {
             enumerable: true,
             configurable: true,
@@ -86,6 +83,18 @@ export class Client extends ClientAbstract {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "errorHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "storage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "parseMode", {
             enumerable: true,
             configurable: true,
@@ -189,6 +198,12 @@ export class Client extends ClientAbstract {
             writable: true,
             value: null
         });
+        Object.defineProperty(this, "pingLoopStarted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "autoStarted", {
             enumerable: true,
             configurable: true,
@@ -228,6 +243,7 @@ export class Client extends ClientAbstract {
             writable: true,
             value: skip
         });
+        this.storage = storage ?? new StorageMemory();
         this.parseMode = params?.parseMode ?? null;
         this.appVersion = params?.appVersion ?? APP_VERSION;
         this.deviceModel = params?.deviceModel ?? DEVICE_MODEL;
@@ -237,6 +253,7 @@ export class Client extends ClientAbstract {
         this.systemVersion = params?.systemVersion ?? SYSTEM_VERSION;
         this.publicKeys = params?.publicKeys;
         this.autoStart = params?.autoStart ?? true;
+        this.errorHandler = params?.errorHandler;
     }
     propagateConnectionState(connectionState) {
         return this.handle({ connectionState }, resolve);
@@ -306,7 +323,6 @@ export class Client extends ClientAbstract {
             }
             d("encrypted client connected");
             drop(this.receiveLoop());
-            drop(this.pingLoop());
         }
         finally {
             release();
@@ -548,7 +564,7 @@ export class Client extends ClientAbstract {
     }
     async receiveLoop() {
         if (!this.auth || !this.transport) {
-            throw new Error("Not connected");
+            throw new ConnectionError("Not connected");
         }
         while (this.connected) {
             try {
@@ -576,6 +592,9 @@ export class Client extends ClientAbstract {
                     if (body instanceof types._TypeUpdates || body instanceof types._TypeUpdate) {
                         this.processUpdatesQueue.add(() => this.processUpdates(body));
                     }
+                    else if (body instanceof types.NewSessionCreated) {
+                        this.state.salt = body.serverSalt;
+                    }
                     else if (message.body instanceof RPCResult) {
                         let result = message.body.result;
                         if (result instanceof types.GZIPPacked) {
@@ -639,10 +658,18 @@ export class Client extends ClientAbstract {
                     drop(this.recoverUpdateGap("deserialize"));
                 }
                 else {
-                    throw err;
+                    dRecv("uncaught error: %o", err);
                 }
             }
         }
+        if (!this.connected) {
+            for (const { reject } of this.promises.values()) {
+                reject(new ConnectionError("Connection was closed"));
+            }
+        }
+        else {
+            UNREACHABLE();
+        }
     }
     async pingLoop() {
         while (this.connected) {
@@ -661,41 +688,61 @@ export class Client extends ClientAbstract {
                 await this.start();
             }
             else {
-                throw new Error("Not connected");
+                throw new ConnectionError("Not connected");
             }
         }
         if (!this.auth || !this.transport) {
             UNREACHABLE();
         }
-        let seqNo = this.state.seqNo * 2;
-        if (!(function_ instanceof functions.Ping) && !(function_ instanceof types.MsgsAck)) {
-            seqNo++;
-            this.state.seqNo++;
-        }
-        const messageId = this.lastMsgId = getMessageId(this.lastMsgId);
-        const message = new Message_(messageId, seqNo, function_);
-        await this.transport.transport.send(await encryptMessage(message, this.auth.key, this.auth.id, this.state.salt, this.sessionId));
-        d("invoked %s", function_.constructor.name);
-        if (noWait) {
-            return;
-        }
-        let result;
-        try {
-            result = await new Promise((resolve, reject) => {
-                this.promises.set(message.id, { resolve, reject });
-            });
-        }
-        catch (err) {
-            if (err instanceof AuthKeyUnregistered) {
-                await this.propagateAuthorizationState(false);
+        let n = 1;
+        while (true) {
+            try {
+                let seqNo = this.state.seqNo * 2;
+                if (!(function_ instanceof functions.Ping) && !(function_ instanceof types.MsgsAck)) {
+                    seqNo++;
+                    this.state.seqNo++;
+                }
+                const messageId = this.lastMsgId = getMessageId(this.lastMsgId);
+                const message = new Message_(messageId, seqNo, function_);
+                await this.transport.transport.send(await encryptMessage(message, this.auth.key, this.auth.id, this.state.salt, this.sessionId));
+                d("invoked %s", function_.constructor.name);
+                if (noWait) {
+                    return;
+                }
+                let result;
+                try {
+                    result = await new Promise((resolve, reject) => {
+                        this.promises.set(message.id, { resolve, reject });
+                    });
+                }
+                catch (err) {
+                    if (err instanceof AuthKeyUnregistered) {
+                        await this.propagateAuthorizationState(false);
+                    }
+                    throw err;
+                }
+                if (result instanceof types.BadServerSalt) {
+                    return await this.invoke(function_);
+                }
+                else {
+                    if (!this.pingLoopStarted) {
+                        drop(this.pingLoop());
+                        this.pingLoopStarted = true;
+                    }
+                    return result;
+                }
+            }
+            catch (err) {
+                if (this.errorHandler === undefined) {
+                    throw err;
+                }
+                if (this.errorHandler !== undefined && await this.errorHandler(err, function_, n++)) {
+                    continue;
+                }
+                else {
+                    throw err;
+                }
             }
-            throw err;
-        }
-        if (result instanceof types.BadServerSalt) {
-            return await this.invoke(function_);
-        }
-        else {
-            return result;
         }
     }
     /**
@@ -1152,10 +1199,10 @@ export class Client extends ClientAbstract {
         const messages = new Array();
         if (updates instanceof types.Updates) {
             for (const update of updates.updates) {
-                if (update instanceof types.UpdateNewMessage) {
+                if (update instanceof types.UpdateNewMessage || update instanceof types.UpdateEditMessage) {
                     messages.push(await constructMessage(update.message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this)));
                 }
-                else if (update instanceof types.UpdateNewChannelMessage) {
+                else if (update instanceof types.UpdateNewChannelMessage || update instanceof types.UpdateEditChannelMessage) {
                     messages.push(await constructMessage(update.message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this)));
                 }
             }
@@ -1236,7 +1283,7 @@ export class Client extends ClientAbstract {
      */
     async editMessageText(chatId, messageId, text, params) {
         const [message, entities] = this.parseText(text, params);
-        await this.invoke(new functions.MessagesEditMessage({
+        const result = await this.invoke(new functions.MessagesEditMessage({
             id: messageId,
             peer: await this.getInputPeer(chatId),
             entities,
@@ -1244,6 +1291,8 @@ export class Client extends ClientAbstract {
             noWebpage: params?.disableWebPagePreview ? true : undefined,
             replyMarkup: await this.constructReplyMarkup(params),
         }));
+        const message_ = await this.updatesToMessages(chatId, result).then((v) => v[0]);
+        return Client.assertMsgHas(message_, "text");
     }
     async getMessagesInner(chatId_, messageIds) {
         const peer = await this.getInputPeer(chatId_);
@@ -1305,29 +1354,30 @@ export class Client extends ClientAbstract {
         const messages = await this.getMessages(chatId, [messageId]);
         return messages[0] ?? null;
     }
-    async *downloadInner(location, dcId) {
-        let client = null;
-        if (dcId != undefined && dcId != this.dcId) {
-            const exportedAuth = await this.invoke(new functions.AuthExportAuthorization({ dcId }));
-            client = new Client(new StorageMemory(), this.apiId, this.apiHash, {
-                transportProvider: this.transportProvider,
-                appVersion: this.appVersion,
-                deviceModel: this.deviceModel,
-                langCode: this.langCode,
-                langPack: this.langPack,
-                systemLangCode: this.systemLangCode,
-                systemVersion: this.systemVersion,
-                cdn: true,
-            });
-            let dc = String(dcId);
-            if (this.dcId < 0) {
-                dc += "-test";
-            }
-            await client.setDc(dc);
-            await client.connect();
-            await client.authorize(exportedAuth);
-        }
-        const limit = 1024 * 1024;
+    async *downloadInner(location, dcId, params) {
+        const chunkSize = params?.chunkSize ?? 1024 * 1024;
+        if (mod(chunkSize, 1024) != 0) {
+            throw new Error("chunkSize must be divisible by 1024");
+        }
+        const exportedAuth = await this.invoke(new functions.AuthExportAuthorization({ dcId }));
+        const client = new Client(new StorageMemory(), this.apiId, this.apiHash, {
+            transportProvider: this.transportProvider,
+            appVersion: this.appVersion,
+            deviceModel: this.deviceModel,
+            langCode: this.langCode,
+            langPack: this.langPack,
+            systemLangCode: this.systemLangCode,
+            systemVersion: this.systemVersion,
+            cdn: true,
+        });
+        let dc = String(dcId);
+        if (this.dcId < 0) {
+            dc += "-test";
+        }
+        await client.setDc(dc);
+        await client.connect();
+        await client.authorize(exportedAuth);
+        const limit = chunkSize;
         let offset = 0n;
         while (true) {
             const file = await (client ?? this).invoke(new functions.UploadGetFile({ location, offset, limit }));
@@ -1350,14 +1400,14 @@ export class Client extends ClientAbstract {
      *
      * @param fileId The identifier of the file to download.
      */
-    async download(fileId) {
+    async download(fileId, params) {
         const fileId_ = FileID.decode(fileId);
         switch (fileId_.fileType) {
             case FileType.ChatPhoto: {
                 const big = fileId_.params.thumbnailSource == ThumbnailSource.ChatPhotoBig;
                 const peer = await this.getInputPeer(fileId_.params.chatId);
                 const location = new types.InputPeerPhotoFileLocation({ big: big ? true : undefined, peer, photoId: fileId_.params.mediaId });
-                return this.downloadInner(location);
+                return this.downloadInner(location, fileId_.dcId, params);
             }
             case FileType.Photo: {
                 if (fileId_.params.mediaId == undefined || fileId_.params.accessHash == undefined || fileId_.params.fileReference == undefined || fileId_.params.thumbnailSize == undefined) {
@@ -1369,7 +1419,7 @@ export class Client extends ClientAbstract {
                     fileReference: fileId_.params.fileReference,
                     thumbSize: fileId_.params.thumbnailSize,
                 });
-                return this.downloadInner(location);
+                return this.downloadInner(location, fileId_.dcId, params);
             }
             default:
                 UNREACHABLE();
@@ -1607,17 +1657,107 @@ export class Client extends ClientAbstract {
         }
         await this.invoke(new functions.MessagesSetTyping({ peer: await this.getInputPeer(chatId), action, topMsgId: messageThreadId }));
     }
+    /**
+     * Upload a file.
+     *
+     * @param contents The contents of the file.
+     */
+    async upload(contents, params) {
+        const isBig = contents.length > 1048576; // 10 MB
+        const chunkSize = params?.chunkSize ?? 512 * 1024;
+        if (mod(chunkSize, 1024) != 0) {
+            throw new Error("chunkSize must be divisible by 1024");
+        }
+        const signal = params?.signal;
+        dUpload("uploading " + (isBig ? "big " : "") + "file of size " + contents.length + " with chunk size of " + chunkSize);
+        const fileId = getRandomId();
+        const name = params?.fileName ?? fileId.toString();
+        const client = new Client(this.storage, this.apiId, this.apiHash, {
+            transportProvider: this.transportProvider,
+            appVersion: this.appVersion,
+            deviceModel: this.deviceModel,
+            langCode: this.langCode,
+            langPack: this.langPack,
+            systemLangCode: this.systemLangCode,
+            systemVersion: this.systemVersion,
+            cdn: true,
+            initialDc: this.initialDc,
+            autoStart: false,
+        });
+        signal?.addEventListener("abort", () => drop(client.disconnect()));
+        client.state.salt = this.state.salt;
+        await client.connect();
+        let part = 0;
+        const partCount = Math.ceil(contents.length / chunkSize);
+        try {
+            main: for (; part < partCount; part++) {
+                chunk: while (true) {
+                    try {
+                        const start = part * chunkSize;
+                        const end = start + chunkSize;
+                        const bytes = contents.slice(start, end);
+                        if (bytes.length == 0) {
+                            continue main;
+                        }
+                        if (isBig) {
+                            await client.invoke(new functions.UploadSaveBigFilePart({ fileId, filePart: part, bytes, fileTotalParts: partCount }));
+                        }
+                        else {
+                            await client.invoke(new functions.UploadSaveFilePart({ fileId, bytes, filePart: part }));
+                        }
+                        dUpload((part + 1) + " out of " + partCount + " chunks have been uploaded so far");
+                        break chunk;
+                    }
+                    catch (err) {
+                        if (signal?.aborted) {
+                            break main;
+                        }
+                        if (err instanceof FloodWait) {
+                            dUpload("got a flood wait of " + err.seconds + " seconds");
+                            await new Promise((r) => setTimeout(r, err.seconds * 1000));
+                        }
+                        else if (err instanceof ConnectionError) {
+                            while (true) {
+                                try {
+                                    await new Promise((r) => setTimeout(r, 3000));
+                                    await client.connect();
+                                }
+                                catch {
+                                    if (signal?.aborted) {
+                                        break main;
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            throw err;
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            drop(client.disconnect());
+        }
+        dUpload("uploaded all " + partCount + " chunk(s)");
+        if (isBig) {
+            return new types.InputFileBig({ id: fileId, parts: contents.length / chunkSize, name });
+        }
+        else {
+            return new types.InputFile({ id: fileId, name, parts: part, md5Checksum: "" });
+        }
+    }
     async setMyCommands(commands, params) {
         await this.invoke(new functions.BotsSetBotCommands({
             commands: commands.map((v) => new types.BotCommand(v)),
             langCode: params?.languageCode ?? "",
-            scope: await botCommandScopeToTlObject(params?.scope ?? { type: "default" }, this.getInputPeer.bind(this)), // TODO: use params.scope
+            scope: await botCommandScopeToTlObject(params?.scope ?? { type: "default" }, this.getInputPeer.bind(this)),
         }));
     }
     async getMyCommands(params) {
         const commands_ = await this.invoke(new functions.BotsGetBotCommands({
             langCode: params?.languageCode ?? "",
-            scope: await botCommandScopeToTlObject(params?.scope ?? { type: "default" }, this.getInputPeer.bind(this)), // TODO: use params.scope
+            scope: await botCommandScopeToTlObject(params?.scope ?? { type: "default" }, this.getInputPeer.bind(this)),
         }));
         return commands_.map((v) => ({ command: v.command, description: v.description }));
     }
@@ -1679,4 +1819,52 @@ export class Client extends ClientAbstract {
             }
         }, handler);
     }
+    async setMyInfo(info) {
+        await this.invoke(new functions.BotsSetBotInfo({ bot: new types.InputUserSelf(), ...info }));
+    }
+    /**
+     * Use this method to change the bot's description, which is shown in the chat with the bot if the chat is empty.
+     */
+    async setMyDescription({ description, languageCode }) {
+        await this.assertBot("setMyDescription");
+        await this.setMyInfo({ description, langCode: languageCode ?? "" });
+    }
+    /**
+     * Use this method to change the bot's name.
+     */
+    async setMyName({ name, languageCode }) {
+        await this.assertBot("setMyName");
+        await this.setMyInfo({ name, langCode: languageCode ?? "" });
+    }
+    /**
+     * Use this method to change the bot's short description, which is shown on the bot's profile page and is sent together with the link when users share the bot.
+     */
+    async setMyShortDescription({ shortDescription: about, languageCode }) {
+        await this.assertBot("setMyShortDescription");
+        await this.setMyInfo({ about, langCode: languageCode ?? "" });
+    }
+    getMyInfo(languageCode) {
+        return this.invoke(new functions.BotsGetBotInfo({ bot: new types.InputUserSelf(), langCode: languageCode ?? "" }));
+    }
+    /**
+     * Use this method to get the current bot description for the given user language.
+     */
+    async getMyDescription(languageCode) {
+        await this.assertBot("getMyDescription");
+        return await this.getMyInfo(languageCode).then((v) => v.description);
+    }
+    /**
+     * Use this method to get the current bot name for the given user language.
+     */
+    async getMyName(languageCode) {
+        await this.assertBot("getMyName");
+        return await this.getMyInfo(languageCode).then((v) => v.description);
+    }
+    /**
+     * Use this method to get the current bot short description for the given user language.
+     */
+    async getMyShortDescription(languageCode) {
+        await this.assertBot("getMyShortDescription");
+        return await this.getMyInfo(languageCode).then((v) => v.about);
+    }
 }

package/esm/connection/1_connection_web_socket.js

@@ -81,7 +81,7 @@ export class ConnectionWebSocket extends ConnectionUnframed {
                 this.buffer.push(byte);
             }
             if (this.nextResolve != null && this.buffer.length >= this.nextResolve[0]) {
-                this.nextResolve[1]();
+                this.nextResolve[1].resolve();
                 this.nextResolve = null;
             }
             release();
@@ -136,7 +136,7 @@ export class ConnectionWebSocket extends ConnectionUnframed {
         const release = await this.rMutex.acquire();
         try {
             if (this.buffer.length < p.length) {
-                await new Promise((r) => this.nextResolve = [p.length, r]);
+                await new Promise((resolve, reject) => this.nextResolve = [p.length, { resolve, reject }]);
             }
             p.set(this.buffer.splice(0, p.length));
         }
@@ -161,5 +161,8 @@ export class ConnectionWebSocket extends ConnectionUnframed {
             throw new Error("Connection not open");
         }
         this.webSocket.close(1000, "method");
+        if (this.nextResolve != null) {
+            this.nextResolve[1].reject(new Error("Connection not open"));
+        }
     }
 }

package/esm/deps/deno.land/{std@0.201.0 → std@0.204.0}/assert/_diff.js

@@ -239,14 +239,21 @@ export function diffstr(A, B) {
         }
     }
     // Compute word-diff
-    const aLines = added.length < removed.length ? added : removed;
-    const bLines = aLines === removed ? added : removed;
+    const hasMoreRemovedLines = added.length < removed.length;
+    const aLines = hasMoreRemovedLines ? added : removed;
+    const bLines = hasMoreRemovedLines ? removed : added;
     for (const a of aLines) {
         let tokens = [], b;
         // Search another diff line with at least one common token
         while (bLines.length) {
             b = bLines.shift();
-            tokens = diff(tokenize(a.value, { wordDiff: true }), tokenize(b?.value ?? "", { wordDiff: true }));
+            const tokenized = [
+                tokenize(a.value, { wordDiff: true }),
+                tokenize(b?.value ?? "", { wordDiff: true }),
+            ];
+            if (hasMoreRemovedLines)
+                tokenized.reverse();
+            tokens = diff(tokenized[0], tokenized[1]);
             if (tokens.some(({ type, value }) => type === DiffType.common && value.trim().length)) {
                 break;
             }

package/esm/deps/deno.land/{std@0.201.0 → std@0.204.0}/assert/assert_false.js

@@ -1,5 +1,6 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 import { AssertionError } from "./assertion_error.js";
+/** Make an assertion, error will be thrown if `expr` have truthy value. */
 export function assertFalse(expr, msg = "") {
     if (expr) {
         throw new AssertionError(msg);

package/esm/deps/deno.land/std@0.204.0/encoding/_util.d.ts

@@ -0,0 +1 @@
+export declare function validateBinaryLike(source: unknown): Uint8Array;

package/esm/deps/deno.land/std@0.204.0/encoding/_util.js

@@ -0,0 +1,26 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const encoder = new TextEncoder();
+function getTypeName(value) {
+    const type = typeof value;
+    if (type !== "object") {
+        return type;
+    }
+    else if (value === null) {
+        return "null";
+    }
+    else {
+        return value?.constructor?.name ?? "object";
+    }
+}
+export function validateBinaryLike(source) {
+    if (typeof source === "string") {
+        return encoder.encode(source);
+    }
+    else if (source instanceof Uint8Array) {
+        return source;
+    }
+    else if (source instanceof ArrayBuffer) {
+        return new Uint8Array(source);
+    }
+    throw new TypeError(`The input must be a Uint8Array, a string, or an ArrayBuffer. Received a value of the type ${getTypeName(source)}.`);
+}

package/esm/deps/deno.land/std@0.204.0/encoding/base64.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @deprecated (will be removed in 0.210.0) Use a `encodeBase64` instead.
+ *
+ * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
+ * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ * @param data
+ */
+export declare const encode: typeof encodeBase64;
+/**
+ * @deprecated (will be removed in 0.210.0) Use a `decodeBase64` instead.
+ *
+ * Decodes a given RFC4648 base64 encoded string
+ * @param b64
+ */
+export declare const decode: typeof decodeBase64;
+/**
+ * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ */
+export declare function encodeBase64(data: ArrayBuffer | Uint8Array | string): string;
+/**
+ * Decodes a given RFC4648 base64 encoded string
+ */
+export declare function decodeBase64(b64: string): Uint8Array;