@mtkruto/node 0.0.822 → 0.0.824

package/esm/client/client.d.ts

@@ -2,7 +2,7 @@ import { MaybePromise } from "../types.js";
 import * as types from "../tl/2_types.js";
 import * as functions from "../tl/3_functions.js";
 import { ClientAbstract } from "./client_abstract.js";
-import { Session } from "../session/session.js";
+import { Storage } from "../storage/storage.js";
 import { DC, TransportProvider } from "../transport/transport_provider.js";
 export declare const restartAuth: unique symbol;
 export interface AuthorizeUserParams<S = string> {
@@ -42,9 +42,10 @@ export interface ClientParams {
     systemVersion?: string;
 }
 export declare class Client extends ClientAbstract {
-    readonly session: Session;
+    readonly storage: Storage;
     readonly apiId: number;
     readonly apiHash: string;
+    private auth;
     private sessionId;
     private state;
     private promises;
@@ -59,20 +60,21 @@ export declare class Client extends ClientAbstract {
     /**
      * Constructs the client.
      *
-     * @param session The session provider to use. Defaults to in-memory session.
+     * @param storage The storage provider to use. Defaults to memory storage.
      * @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). Default to empty string (unset).
      * @param params Other parameters.
      */
-    constructor(session?: Session, apiId?: number, apiHash?: string, params?: ClientParams);
-    private shouldLoadSession;
+    constructor(storage?: Storage, apiId?: number, apiHash?: string, params?: ClientParams);
+    private storageInited;
     /**
      * Sets the DC and resets the auth key stored in the session provider
      * if the stored DC was not the same as the `dc` parameter.
      *
      * @param dc The DC to change to.
      */
-    setDc(dc: DC): void;
+    setDc(dc: DC): Promise<void>;
+    private setAuth;
     /**
      * Loads the session if `setDc` was not called, initializes and connnects
      * a `ClientPlain` to generate auth key if there was none, and connects the client.
@@ -111,4 +113,8 @@ export declare class Client extends ClientAbstract {
      * Alias for `invoke` with its second parameter being `true`.
      */
     send<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<void>;
+    private processChats;
+    private processUsers;
+    private processUpdates;
+    getInputPeer(id: string | number): Promise<types.InputPeerChat | types.InputPeerUser | types.InputPeerChannel>;
 }

package/esm/client/client.js

@@ -1,8 +1,9 @@
 import { gunzip } from "../deps.js";
-import { ackThreshold, DEFAULT_APP_VERSION, DEFAULT_DEVICE_MODEL, DEFAULT_LANG_CODE, DEFAULT_LANG_PACK, DEFAULT_SYSTEM_LANG_CODE, DEFAULT_SYSTEM_VERSION, LAYER } from "../constants.js";
-import { getRandomBigInt } from "../utilities/0_bigint.js";
+import { ackThreshold, DEFAULT_APP_VERSION, DEFAULT_DEVICE_MODEL, DEFAULT_INITIAL_DC, DEFAULT_LANG_CODE, DEFAULT_LANG_PACK, DEFAULT_SYSTEM_LANG_CODE, DEFAULT_SYSTEM_VERSION, LAYER, MAX_CHANNEL_ID, MAX_CHAT_ID, USERNAME_TTL, ZERO_CHANNEL_ID } from "../constants.js";
+import { bigIntFromBuffer, getRandomBigInt } from "../utilities/0_bigint.js";
 import { decryptMessage, encryptMessage, getMessageId } from "../utilities/1_message.js";
 import { checkPassword } from "../utilities/1_password.js";
+import { as } from "../tl/1_tl_object.js";
 import * as types from "../tl/2_types.js";
 import * as functions from "../tl/3_functions.js";
 import { TLReader } from "../tl/3_tl_reader.js";
@@ -11,24 +12,25 @@ import { Message } from "../tl/5_message.js";
 import { MessageContainer } from "../tl/6_message_container.js";
 import { ClientAbstract } from "./client_abstract.js";
 import { ClientPlain } from "./client_plain.js";
-import { SessionMemory } from "../session/session_memory.js";
+import { StorageMemory } from "../storage/storage_memory.js";
+import { sha1 } from "../utilities/0_hash.js";
 export const restartAuth = Symbol();
 export class Client extends ClientAbstract {
     /**
      * Constructs the client.
      *
-     * @param session The session provider to use. Defaults to in-memory session.
+     * @param storage The storage provider to use. Defaults to memory storage.
      * @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). Default to empty string (unset).
      * @param params Other parameters.
      */
-    constructor(session = new SessionMemory(), apiId = 0, apiHash = "", params) {
+    constructor(storage = new StorageMemory(), apiId = 0, apiHash = "", params) {
         super(params?.transportProvider);
-        Object.defineProperty(this, "session", {
+        Object.defineProperty(this, "storage", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: session
+            value: storage
         });
         Object.defineProperty(this, "apiId", {
             enumerable: true,
@@ -42,6 +44,12 @@ export class Client extends ClientAbstract {
             writable: true,
             value: apiHash
         });
+        Object.defineProperty(this, "auth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
         Object.defineProperty(this, "sessionId", {
             enumerable: true,
             configurable: true,
@@ -108,11 +116,11 @@ export class Client extends ClientAbstract {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "shouldLoadSession", {
+        Object.defineProperty(this, "storageInited", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: true
+            value: false
         });
         this.appVersion = params?.appVersion ?? DEFAULT_APP_VERSION;
         this.deviceModel = params?.deviceModel ?? DEFAULT_DEVICE_MODEL;
@@ -127,42 +135,57 @@ export class Client extends ClientAbstract {
      *
      * @param dc The DC to change to.
      */
-    setDc(dc) {
-        if (this.session.dc != dc) {
-            this.session.dc = dc;
-            this.session.authKey = null;
-            if (this.shouldLoadSession) {
-                this.shouldLoadSession = false;
-            }
+    async setDc(dc) {
+        if (!this.storageInited) {
+            await this.storage.init();
+            this.storageInited = true;
+        }
+        if (await this.storage.getDc() != dc) {
+            await this.storage.setDc(dc);
+            await this.storage.setAuthKey(null);
         }
         super.setDc(dc);
     }
+    async setAuth(key) {
+        const hash = await sha1(key);
+        const id = bigIntFromBuffer(hash.slice(-8), true, false);
+        this.auth = { key, id };
+    }
     /**
      * Loads the session if `setDc` was not called, initializes and connnects
      * a `ClientPlain` to generate auth key if there was none, and connects the client.
      * Before establishing the connection, the session is saved.
      */
     async connect() {
-        if (this.shouldLoadSession) {
-            await this.session.load();
-            this.shouldLoadSession = false;
+        if (!this.storageInited) {
+            await this.storage.init();
+            this.storageInited = true;
         }
-        if (this.session.authKey == null) {
+        const authKey = await this.storage.getAuthKey();
+        if (authKey == null) {
             const plain = new ClientPlain(this.transportProvider);
-            if (this.session.dc != null) {
-                plain.setDc(this.session.dc);
+            const dc = await this.storage.getDc();
+            if (dc != null) {
+                plain.setDc(dc);
             }
             await plain.connect();
             const { authKey, salt } = await plain.createAuthKey();
             await plain.disconnect();
+            await this.storage.setAuthKey(authKey);
+            await this.setAuth(authKey);
             this.state.salt = salt;
-            this.session.authKey = authKey;
         }
-        if (this.session.dc != null) {
-            this.setDc(this.session.dc);
+        else {
+            await this.setAuth(authKey);
+        }
+        const dc = await this.storage.getDc();
+        if (dc != null) {
+            await this.setDc(dc);
         }
-        await this.session.save();
         await super.connect();
+        if (dc == null) {
+            await this.storage.setDc(DEFAULT_INITIAL_DC);
+        }
         // logger().debug("Client connected");
         this.receiveLoop();
         this.pingLoop();
@@ -204,6 +227,36 @@ export class Client extends ClientAbstract {
             systemLangCode: this.systemLangCode,
             systemVersion: this.systemVersion,
         }));
+        const handlePassword = async (err) => {
+            params = params;
+            if (err instanceof types.RPCError && err.errorMessage == "SESSION_PASSWORD_NEEDED") {
+                while (true) {
+                    const ap = await this.invoke(new functions.AccountGetPassword());
+                    if (ap.currentAlgo instanceof types.PasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) {
+                        try {
+                            const password = typeof params.password === "string" ? params.password : await params.password();
+                            const input = await checkPassword(password, ap);
+                            await this.invoke(new functions.AuthCheckPassword({ password: input }));
+                            break;
+                        }
+                        catch (err) {
+                            if (err instanceof types.RPCError && err.errorMessage == "PASSWORD_HASH_INVALID") {
+                                continue;
+                            }
+                            else {
+                                throw err;
+                            }
+                        }
+                    }
+                    else {
+                        throw new Error(`Handling ${ap.currentAlgo?.constructor.name} not implemented`);
+                    }
+                }
+            }
+            else {
+                throw err;
+            }
+        };
         try {
             await this.invoke(new functions.UpdatesGetState());
             return;
@@ -261,33 +314,7 @@ export class Client extends ClientAbstract {
                             }
                         }
                         catch (err) {
-                            if (err instanceof types.RPCError && err.errorMessage == "SESSION_PASSWORD_NEEDED") {
-                                while (true) {
-                                    const ap = await this.invoke(new functions.AccountGetPassword());
-                                    if (ap.currentAlgo instanceof types.PasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow) {
-                                        try {
-                                            const password = typeof params.password === "string" ? params.password : await params.password();
-                                            const input = await checkPassword(password, ap);
-                                            await this.invoke(new functions.AuthCheckPassword({ password: input }));
-                                            break;
-                                        }
-                                        catch (err) {
-                                            if (err instanceof types.RPCError && err.errorMessage == "PASSWORD_HASH_INVALID") {
-                                                continue;
-                                            }
-                                            else {
-                                                throw err;
-                                            }
-                                        }
-                                    }
-                                    else {
-                                        throw new Error(`Handling ${ap.currentAlgo?.constructor.name} not implemented`);
-                                    }
-                                }
-                            }
-                            else {
-                                throw err;
-                            }
+                            await handlePassword(err);
                         }
                     }
                     catch (err) {
@@ -320,7 +347,7 @@ export class Client extends ClientAbstract {
                     await this.authorize(params);
                 }
                 else {
-                    throw err;
+                    await handlePassword(err);
                 }
             }
             else {
@@ -329,7 +356,7 @@ export class Client extends ClientAbstract {
         }
     }
     async receiveLoop() {
-        if (!this.session.authKey) {
+        if (!this.auth) {
             throw new Error("Not connected");
         }
         while (this.connected) {
@@ -351,7 +378,7 @@ export class Client extends ClientAbstract {
             }
             let decrypted;
             try {
-                decrypted = await decryptMessage(buffer, this.session.authKey, (await this.session.authKeyId), this.sessionId);
+                decrypted = await decryptMessage(buffer, this.auth.key, this.auth.id, this.sessionId);
             }
             catch (_err) {
                 // logger().error(`Failed to decrypt message: ${err}`);
@@ -365,7 +392,7 @@ export class Client extends ClientAbstract {
                 }
                 // logger().debug(`Received ${body.constructor.name}`);
                 if (body instanceof types.Updates) {
-                    this.updatesHandler?.(this, body);
+                    this.processUpdates(body);
                 }
                 else if (message.body instanceof RPCResult) {
                     let result = message.body.result;
@@ -416,7 +443,7 @@ export class Client extends ClientAbstract {
         }
     }
     async invoke(function_, noWait) {
-        if (!this.session.authKey) {
+        if (!this.auth) {
             throw new Error("Not connected");
         }
         let seqNo = this.state.seqNo * 2;
@@ -425,7 +452,7 @@ export class Client extends ClientAbstract {
             this.state.seqNo++;
         }
         const message = new Message(getMessageId(), seqNo, function_);
-        await this.transport.send(await encryptMessage(message, this.session.authKey, (await this.session.authKeyId), this.state.salt, this.sessionId));
+        await this.transport.send(await encryptMessage(message, this.auth.key, this.auth.id, this.state.salt, this.sessionId));
         // logger().debug(`Invoked ${function_.constructor.name}`);
         if (noWait) {
             return;
@@ -446,4 +473,111 @@ export class Client extends ClientAbstract {
     send(function_) {
         return this.invoke(function_, true);
     }
+    async processChats(chats) {
+        for (const chat of chats) {
+            if (chat instanceof types.Channel && chat.accessHash) {
+                await this.storage.setChannelAccessHash(chat.id, chat.accessHash);
+                if (chat.username) {
+                    await this.storage.updateUsernames("channel", chat.id, [chat.username]);
+                }
+                if (chat.usernames) {
+                    await this.storage.updateUsernames("channel", chat.id, chat.usernames.map((v) => v[as](types.Username)).map((v) => v.username));
+                }
+            }
+        }
+    }
+    async processUsers(users) {
+        for (const user of users) {
+            if (user instanceof types.User && user.accessHash) {
+                await this.storage.setUserAccessHash(user.id, user.accessHash);
+                if (user.username) {
+                    await this.storage.updateUsernames("user", user.id, [user.username]);
+                }
+                if (user.usernames) {
+                    await this.storage.updateUsernames("user", user.id, user.usernames.map((v) => v[as](types.Username)).map((v) => v.username));
+                }
+            }
+        }
+    }
+    async processUpdates(updates) {
+        try {
+            await this.processChats(updates.chats);
+            await this.processUsers(updates.users);
+            for (const update of updates.updates) {
+                if (update instanceof types.UpdateUserName) {
+                    await this.storage.updateUsernames("user", update.userId, update.usernames.map((v) => v[as](types.Username)).map((v) => v.username));
+                }
+            }
+            await this.updatesHandler?.(this, updates);
+        }
+        catch (err) {
+            console.error("Error processing updates:", err);
+        }
+    }
+    async getInputPeer(id) {
+        if (typeof id === "string") {
+            if (!id.startsWith("@")) {
+                throw new Error("Expected username to start with @");
+            }
+            else {
+                id = id.slice(1);
+                if (!id) {
+                    throw new Error("Empty username");
+                }
+                let userId = 0n;
+                let channelId = 0n;
+                const maybeUsername = await this.storage.getUsername(id);
+                if (maybeUsername != null && Date.now() - maybeUsername[2].getTime() < USERNAME_TTL) {
+                    const [type, id] = maybeUsername;
+                    if (type == "user") {
+                        userId = id;
+                    }
+                    else {
+                        channelId = id;
+                    }
+                }
+                else {
+                    const resolved = await this.invoke(new functions.ContactsResolveUsername({ username: id }));
+                    await this.processChats(resolved.chats);
+                    await this.processUsers(resolved.users);
+                    if (resolved.peer instanceof types.PeerUser) {
+                        userId = resolved.peer.userId;
+                    }
+                    else if (resolved.peer instanceof types.PeerChannel) {
+                        channelId = resolved.peer.channelId;
+                    }
+                    else {
+                        throw new Error("Unreachable");
+                    }
+                }
+                if (userId) {
+                    const accessHash = await this.storage.getUserAccessHash(userId);
+                    return new types.InputPeerUser({ userId, accessHash: accessHash ?? 0n });
+                }
+                else if (channelId) {
+                    const accessHash = await this.storage.getChannelAccessHash(channelId);
+                    return new types.InputPeerChannel({ channelId, accessHash: accessHash ?? 0n });
+                }
+                else {
+                    throw new Error("Unreachable");
+                }
+            }
+        }
+        else if (id > 0) {
+            const id_ = BigInt(id);
+            const accessHash = await this.storage.getUserAccessHash(id_);
+            return new types.InputPeerUser({ userId: id_, accessHash: accessHash ?? 0n });
+        }
+        else if (-MAX_CHAT_ID <= id) {
+            return new types.InputPeerChat({ chatId: BigInt(Math.abs(id)) });
+        }
+        else if (ZERO_CHANNEL_ID - MAX_CHANNEL_ID <= id && id != ZERO_CHANNEL_ID) {
+            const id_ = BigInt(Math.abs(id - ZERO_CHANNEL_ID));
+            const accessHash = await this.storage.getChannelAccessHash(id_);
+            return new types.InputPeerChannel({ channelId: id_, accessHash: accessHash ?? 0n });
+        }
+        else {
+            throw new Error("ID format unknown or not implemented");
+        }
+    }
 }

package/esm/client/client_abstract.d.ts

@@ -1,6 +1,7 @@
 import { Connection } from "../connection/connection.js";
 import { Transport } from "../transport/transport.js";
 import { DC } from "../transport/transport_provider.js";
+import { MaybePromise } from "../types.js";
 export declare abstract class ClientAbstract {
     protected transportProvider: import("../transport/transport_provider.js").TransportProvider;
     protected connection: Connection;
@@ -9,7 +10,7 @@ export declare abstract class ClientAbstract {
     protected connected: boolean;
     constructor(transportProvider?: import("../transport/transport_provider.js").TransportProvider);
     get dcId(): number;
-    setDc(dc: DC): void;
+    setDc(dc: DC): MaybePromise<void>;
     connect(): Promise<void>;
     reconnect(dc?: DC): Promise<void>;
     disconnect(): Promise<void>;

package/esm/client/client_abstract.js

@@ -41,6 +41,7 @@ export class ClientAbstract {
     get dcId() {
         return this._dcId;
     }
+    // MaybePromise since `Client` has to deal with `Storage.set()`
     setDc(dc) {
         const { connection, transport, dcId } = this.transportProvider({ dc, cdn: false });
         this.connection = connection;

package/esm/constants.d.ts

@@ -10,3 +10,7 @@ export declare const DEFAULT_LANG_CODE = "en";
 export declare const DEFAULT_LANG_PACK = "";
 export declare const DEFAULT_SYSTEM_LANG_CODE = "en";
 export declare const DEFAULT_SYSTEM_VERSION = "1.0";
+export declare const USERNAME_TTL = 86400;
+export declare const MAX_CHAT_ID = 999999999999;
+export declare const MAX_CHANNEL_ID = 997852516352;
+export declare const ZERO_CHANNEL_ID = -1000000000000;

package/esm/constants.js

@@ -68,3 +68,7 @@ export const DEFAULT_LANG_CODE = "en";
 export const DEFAULT_LANG_PACK = "";
 export const DEFAULT_SYSTEM_LANG_CODE = "en";
 export const DEFAULT_SYSTEM_VERSION = "1.0";
+export const USERNAME_TTL = 86400;
+export const MAX_CHAT_ID = 999999999999;
+export const MAX_CHANNEL_ID = 997852516352;
+export const ZERO_CHANNEL_ID = -1000000000000;

package/esm/mod.d.ts

@@ -12,9 +12,10 @@ export * from "./tl/5_message.js";
 export * from "./tl/6_message_container.js";
 export * from "./client/client_plain.js";
 export * from "./client/client.js";
-export * from "./session/session.js";
-export * from "./session/session_memory.js";
-export * from "./session/session_local_storage.js";
+export * from "./storage/storage.js";
+export * from "./storage/storage_memory.js";
+export * from "./storage/storage_local_storage.js";
+export * from "./storage/storage_session_storage.js";
 export * from "./transport/transport_abridged.js";
 export * from "./transport/transport_intermediate.js";
 export * from "./transport/transport.js";

package/esm/mod.js

@@ -9,9 +9,10 @@ export * from "./tl/5_message.js";
 export * from "./tl/6_message_container.js";
 export * from "./client/client_plain.js";
 export * from "./client/client.js";
-export * from "./session/session.js";
-export * from "./session/session_memory.js";
-export * from "./session/session_local_storage.js";
+export * from "./storage/storage.js";
+export * from "./storage/storage_memory.js";
+export * from "./storage/storage_local_storage.js";
+export * from "./storage/storage_session_storage.js";
 export * from "./transport/transport_abridged.js";
 export * from "./transport/transport_intermediate.js";
 export * from "./transport/transport.js";

package/esm/storage/storage.d.ts

@@ -0,0 +1,23 @@
+import { MaybePromise } from "../types.js";
+import { DC } from "../transport/transport_provider.js";
+export declare abstract class Storage {
+    private _authKeyId;
+    abstract init(): MaybePromise<void>;
+    abstract set(key: string, value: string | null): MaybePromise<void>;
+    abstract get(key: string): MaybePromise<string | null>;
+    setDc(dc: DC | null): MaybePromise<void>;
+    getDc(): Promise<DC | null>;
+    private resetAuthKeyId;
+    getAuthKey(): Promise<Uint8Array | null>;
+    setAuthKey(authKey: Uint8Array | null): Promise<void>;
+    get authKeyId(): bigint | null;
+    private readonly channelAccessHash__;
+    setChannelAccessHash(id: bigint, accessHash: bigint): MaybePromise<void>;
+    getChannelAccessHash(id: bigint): Promise<bigint | null>;
+    private readonly userAccessHash__;
+    setUserAccessHash(id: bigint, accessHash: bigint): MaybePromise<void>;
+    getUserAccessHash(id: bigint): Promise<bigint | null>;
+    private readonly username__;
+    updateUsernames(type: "user" | "channel", id: bigint, usernames: string[]): Promise<void>;
+    getUsername(username: string): Promise<readonly ["user" | "channel", bigint, Date] | null>;
+}

package/esm/storage/storage.js

@@ -0,0 +1,98 @@
+import { sha1 } from "../utilities/0_hash.js";
+import { bigIntFromBuffer } from "../utilities/0_bigint.js";
+export class Storage {
+    constructor() {
+        Object.defineProperty(this, "_authKeyId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "channelAccessHash__", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "channelAccessHash__"
+        });
+        Object.defineProperty(this, "userAccessHash__", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "userAccessHash__"
+        });
+        Object.defineProperty(this, "username__", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "username__"
+        });
+    }
+    setDc(dc) {
+        return this.set("dc", dc);
+    }
+    async getDc() {
+        return await this.get("dc");
+    }
+    async resetAuthKeyId(authKey) {
+        if (authKey != null) {
+            this._authKeyId = await sha1(authKey).then((hash) => bigIntFromBuffer(hash.slice(-8), true, false));
+        }
+        else {
+            this._authKeyId = null;
+        }
+    }
+    async getAuthKey() {
+        const authKey_ = await this.get("authKey");
+        const authKey = authKey_ == null ? null : new Uint8Array(authKey_.split(/([0-9a-f]{2})/).filter((v) => v).map((v) => parseInt(v, 16)));
+        await this.resetAuthKeyId(authKey);
+        return authKey;
+    }
+    async setAuthKey(authKey) {
+        await this.set("authKey", authKey == null ? null : Array.from(authKey).map((v) => v.toString(16)).map((v) => v.padStart(2, "0")).join(""));
+        await this.resetAuthKeyId(authKey);
+    }
+    get authKeyId() {
+        return this._authKeyId;
+    }
+    setChannelAccessHash(id, accessHash) {
+        return this.set(`${this.channelAccessHash__}${id}`, String(accessHash));
+    }
+    async getChannelAccessHash(id) {
+        const accessHash = await this.get(`${this.channelAccessHash__}${id}`);
+        if (accessHash != null) {
+            return BigInt(accessHash);
+        }
+        else {
+            return null;
+        }
+    }
+    setUserAccessHash(id, accessHash) {
+        return this.set(`${this.userAccessHash__}${id}`, String(accessHash));
+    }
+    async getUserAccessHash(id) {
+        const accessHash = await this.get(`${this.userAccessHash__}${id}`);
+        if (accessHash != null) {
+            return BigInt(accessHash);
+        }
+        else {
+            return null;
+        }
+    }
+    async updateUsernames(type, id, usernames) {
+        for (let username of usernames) {
+            username = username.toLowerCase();
+            await this.set(`${this.username__}${username}`, JSON.stringify([type, String(id), new Date()]));
+        }
+    }
+    async getUsername(username) {
+        username = username.toLowerCase();
+        const username_ = await this.get(`${this.username__}${username}`);
+        if (username_ != null) {
+            const [type, id, updatedAt] = JSON.parse(username_);
+            return [type, BigInt(id), new Date(updatedAt)];
+        }
+        else {
+            return null;
+        }
+    }
+}

package/esm/storage/storage_local_storage.d.ts

@@ -0,0 +1,9 @@
+import { MaybePromise } from "../types.js";
+import { Storage } from "./storage.js";
+export declare class StorageLocalStorage extends Storage implements Storage {
+    private readonly prefix;
+    constructor(prefix: string);
+    init(): void;
+    get(key: string): string | null;
+    set(key: string, value: string | null): MaybePromise<void>;
+}