@mtkruto/node 0.1.125 → 0.1.126

package/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_string_includes.js

@@ -3,6 +3,14 @@ import { AssertionError } from "./assertion_error.js";
 /**
  * Make an assertion that actual includes expected. If not
  * then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertStringIncludes } from "https://deno.land/std@$STD_VERSION/assert/assert_string_includes.ts";
+ *
+ * assertStringIncludes("Hello", "ello"); // Doesn't throw
+ * assertStringIncludes("Hello", "world"); // Throws
+ * ```
  */
 export function assertStringIncludes(actual, expected, msg) {
     if (!actual.includes(expected)) {

package/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_throws.d.ts

@@ -6,18 +6,8 @@
  * ```ts
  * import { assertThrows } from "https://deno.land/std@$STD_VERSION/assert/assert_throws.ts";
  *
- * Deno.test("doesThrow", function (): void {
- *   assertThrows((): void => {
- *     throw new TypeError("hello world!");
- *   });
- * });
- *
- * // This test will not pass.
- * Deno.test("fails", function (): void {
- *   assertThrows((): void => {
- *     console.log("Hello world");
- *   });
- * });
+ * assertThrows(() => { throw new TypeError("hello world!"); }); // Doesn't throw
+ * assertThrows(() => console.log("hello world!")); // Throws
  * ```
  */
 export declare function assertThrows(fn: () => unknown, msg?: string): unknown;
@@ -30,25 +20,8 @@ export declare function assertThrows(fn: () => unknown, msg?: string): unknown;
  * ```ts
  * import { assertThrows } from "https://deno.land/std@$STD_VERSION/assert/assert_throws.ts";
  *
- * Deno.test("doesThrow", function (): void {
- *   assertThrows((): void => {
- *     throw new TypeError("hello world!");
- *   }, TypeError);
- *   assertThrows(
- *     (): void => {
- *       throw new TypeError("hello world!");
- *     },
- *     TypeError,
- *     "hello",
- *   );
- * });
- *
- * // This test will not pass.
- * Deno.test("fails", function (): void {
- *   assertThrows((): void => {
- *     console.log("Hello world");
- *   });
- * });
+ * assertThrows(() => { throw new TypeError("hello world!"); }, TypeError); // Doesn't throw
+ * assertThrows(() => { throw new TypeError("hello world!"); }, RangeError); // Throws
  * ```
  */
 export declare function assertThrows<E extends Error = Error>(fn: () => unknown, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): E;

package/esm/deps/deno.land/std@0.209.0/assert/assertion_error.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example
+ * ```ts
+ * import { AssertionError } from "https://deno.land/std@$STD_VERSION/assert/assertion_error.ts";
+ *
+ * throw new AssertionError("Assertion failed");
+ * ```
+ */
+export declare class AssertionError extends Error {
+    /** Constructs a new instance. */
+    constructor(message: string);
+}

package/esm/deps/deno.land/std@0.209.0/assert/assertion_error.js

@@ -0,0 +1,18 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example
+ * ```ts
+ * import { AssertionError } from "https://deno.land/std@$STD_VERSION/assert/assertion_error.ts";
+ *
+ * throw new AssertionError("Assertion failed");
+ * ```
+ */
+export class AssertionError extends Error {
+    /** Constructs a new instance. */
+    constructor(message) {
+        super(message);
+        this.name = "AssertionError";
+    }
+}

package/esm/deps/deno.land/std@0.209.0/assert/equal.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Deep equality comparison used in assertions
+ * @param c actual value
+ * @param d expected value
+ *
+ * @example
+ * ```ts
+ * import { equal } from "https://deno.land/std@$STD_VERSION/assert/equal.ts";
+ *
+ * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
+ * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false
+ * ```
+ */
+export declare function equal(c: unknown, d: unknown): boolean;

package/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/equal.js

@@ -11,6 +11,14 @@ function constructorsEqual(a, b) {
  * Deep equality comparison used in assertions
  * @param c actual value
  * @param d expected value
+ *
+ * @example
+ * ```ts
+ * import { equal } from "https://deno.land/std@$STD_VERSION/assert/equal.ts";
+ *
+ * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
+ * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false
+ * ```
  */
 export function equal(c, d) {
     const seen = new Map();

package/esm/deps/deno.land/std@0.209.0/assert/fail.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Forcefully throws a failed assertion.
+ *
+ * @example
+ * ```ts
+ * import { fail } from "https://deno.land/std@$STD_VERSION/assert/fail.ts";
+ *
+ * fail("Deliberately failed!"); // Throws
+ * ```
+ */
+export declare function fail(msg?: string): never;

package/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/fail.js

@@ -1,7 +1,14 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 import { assert } from "./assert.js";
 /**
- * Forcefully throws a failed assertion
+ * Forcefully throws a failed assertion.
+ *
+ * @example
+ * ```ts
+ * import { fail } from "https://deno.land/std@$STD_VERSION/assert/fail.ts";
+ *
+ * fail("Deliberately failed!"); // Throws
+ * ```
  */
 export function fail(msg) {
     const msgSuffix = msg ? `: ${msg}` : ".";

package/esm/deps/deno.land/std@0.209.0/assert/unimplemented.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Use this to stub out methods that will throw when invoked.
+ *
+ * @example
+ * ```ts
+ * import { unimplemented } from "https://deno.land/std@$STD_VERSION/assert/unimplemented.ts";
+ *
+ * unimplemented(); // Throws
+ * ```
+ */
+export declare function unimplemented(msg?: string): never;

package/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/unimplemented.js

@@ -1,6 +1,15 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 import { AssertionError } from "./assertion_error.js";
-/** Use this to stub out methods that will throw when invoked. */
+/**
+ * Use this to stub out methods that will throw when invoked.
+ *
+ * @example
+ * ```ts
+ * import { unimplemented } from "https://deno.land/std@$STD_VERSION/assert/unimplemented.ts";
+ *
+ * unimplemented(); // Throws
+ * ```
+ */
 export function unimplemented(msg) {
     const msgSuffix = msg ? `: ${msg}` : ".";
     throw new AssertionError(`Unimplemented${msgSuffix}`);

package/esm/deps/deno.land/std@0.209.0/assert/unreachable.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Use this to assert unreachable code.
+ *
+ * @example
+ * ```ts
+ * import { unreachable } from "https://deno.land/std@$STD_VERSION/assert/unreachable.ts";
+ *
+ * unreachable(); // Throws
+ * ```
+ */
+export declare function unreachable(): never;

package/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/unreachable.js

@@ -1,6 +1,15 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 import { AssertionError } from "./assertion_error.js";
-/** Use this to assert unreachable code. */
+/**
+ * Use this to assert unreachable code.
+ *
+ * @example
+ * ```ts
+ * import { unreachable } from "https://deno.land/std@$STD_VERSION/assert/unreachable.ts";
+ *
+ * unreachable(); // Throws
+ * ```
+ */
 export function unreachable() {
     throw new AssertionError("unreachable");
 }

package/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/encoding/base64.d.ts

@@ -1,23 +1,39 @@
 /**
- * @deprecated (will be removed in 0.210.0) Use {@linkcode encodeBase64} instead.
- *
  * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
  * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
- * @param data
+ *
+ * @deprecated (will be removed in 0.210.0) Use {@linkcode encodeBase64} instead.
  */
 export declare const encode: typeof encodeBase64;
 /**
- * @deprecated (will be removed in 0.210.0) Use {@linkcode decodeBase64} instead.
- *
  * Decodes a given RFC4648 base64 encoded string
- * @param b64
+ *
+ * @deprecated (will be removed in 0.210.0) Use {@linkcode decodeBase64} instead.
  */
 export declare const decode: typeof decodeBase64;
 /**
- * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ * Converts data into a base64-encoded string.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc4648#section-4}
+ *
+ * @example
+ * ```ts
+ * import { encodeBase64 } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
+ *
+ * encodeBase64("foobar"); // "Zm9vYmFy"
+ * ```
  */
 export declare function encodeBase64(data: ArrayBuffer | Uint8Array | string): string;
 /**
- * Decodes a given RFC4648 base64 encoded string
+ * Decodes a base64-encoded string.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc4648#section-4}
+ *
+ * @example
+ * ```ts
+ * import { encodeBase64 } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
+ *
+ * encodeBase64("foobar"); // "Zm9vYmFy"
+ * ```
  */
 export declare function decodeBase64(b64: string): Uint8Array;

package/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/encoding/base64.js

@@ -2,28 +2,12 @@
 // This module is browser compatible.
 import { validateBinaryLike } from "./_util.js";
 /**
- * {@linkcode encodeBase64} and {@linkcode decodeBase64} for
- * [base64](https://en.wikipedia.org/wiki/Base64) encoding.
+ * Utilities for
+ * [base64]{@link https://datatracker.ietf.org/doc/html/rfc4648#section-4}
+ * encoding and decoding.
  *
  * This module is browser compatible.
  *
- * @example
- * ```ts
- * import {
- *   decodeBase64,
- *   encodeBase64,
- * } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
- *
- * const b64Repr = "Zm9vYg==";
- *
- * const binaryData = decodeBase64(b64Repr);
- * console.log(binaryData);
- * // => Uint8Array [ 102, 111, 111, 98 ]
- *
- * console.log(encodeBase64(binaryData));
- * // => Zm9vYg==
- * ```
- *
  * @module
  */
 const base64abc = [
@@ -93,22 +77,29 @@ const base64abc = [
     "/",
 ];
 /**
- * @deprecated (will be removed in 0.210.0) Use {@linkcode encodeBase64} instead.
- *
  * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
  * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
- * @param data
+ *
+ * @deprecated (will be removed in 0.210.0) Use {@linkcode encodeBase64} instead.
  */
 export const encode = encodeBase64;
 /**
- * @deprecated (will be removed in 0.210.0) Use {@linkcode decodeBase64} instead.
- *
  * Decodes a given RFC4648 base64 encoded string
- * @param b64
+ *
+ * @deprecated (will be removed in 0.210.0) Use {@linkcode decodeBase64} instead.
  */
 export const decode = decodeBase64;
 /**
- * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ * Converts data into a base64-encoded string.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc4648#section-4}
+ *
+ * @example
+ * ```ts
+ * import { encodeBase64 } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
+ *
+ * encodeBase64("foobar"); // "Zm9vYmFy"
+ * ```
  */
 export function encodeBase64(data) {
     // CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
@@ -137,7 +128,16 @@ export function encodeBase64(data) {
     return result;
 }
 /**
- * Decodes a given RFC4648 base64 encoded string
+ * Decodes a base64-encoded string.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc4648#section-4}
+ *
+ * @example
+ * ```ts
+ * import { encodeBase64 } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
+ *
+ * encodeBase64("foobar"); // "Zm9vYmFy"
+ * ```
  */
 export function decodeBase64(b64) {
     const binString = atob(b64);

package/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/media_types/content_type.js

@@ -3,7 +3,7 @@
 import { parseMediaType } from "./parse_media_type.js";
 import { getCharset } from "./get_charset.js";
 import { formatMediaType } from "./format_media_type.js";
-import { types } from "./_db.js";
+import { typeByExtension } from "./type_by_extension.js";
 /**
  * Given an extension or media type, return a full `Content-Type` or
  * `Content-Disposition` header value.
@@ -53,8 +53,3 @@ export function contentType(extensionOrType) {
     }
     return undefined;
 }
-function typeByExtension(extension) {
-    extension = extension.startsWith(".") ? extension.slice(1) : extension;
-    // @ts-ignore workaround around denoland/dnt#148
-    return types.get(extension.toLowerCase());
-}

package/esm/deps/deno.land/std@0.209.0/media_types/type_by_extension.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Returns the media type associated with the file extension. Values are
+ * normalized to lower case and matched irrespective of a leading `.`.
+ *
+ * When `extension` has no associated type, the function returns `undefined`.
+ *
+ * @example
+ * ```ts
+ * import { typeByExtension } from "https://deno.land/std@$STD_VERSION/media_types/type_by_extension.ts";
+ *
+ * typeByExtension("js"); // `application/json`
+ * typeByExtension(".HTML"); // `text/html`
+ * typeByExtension("foo"); // undefined
+ * typeByExtension("file.json"); // undefined
+ * ```
+ */
+export declare function typeByExtension(extension: string): string | undefined;

package/esm/deps/deno.land/std@0.209.0/media_types/type_by_extension.js

@@ -0,0 +1,24 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { types } from "./_db.js";
+/**
+ * Returns the media type associated with the file extension. Values are
+ * normalized to lower case and matched irrespective of a leading `.`.
+ *
+ * When `extension` has no associated type, the function returns `undefined`.
+ *
+ * @example
+ * ```ts
+ * import { typeByExtension } from "https://deno.land/std@$STD_VERSION/media_types/type_by_extension.ts";
+ *
+ * typeByExtension("js"); // `application/json`
+ * typeByExtension(".HTML"); // `text/html`
+ * typeByExtension("foo"); // undefined
+ * typeByExtension("file.json"); // undefined
+ * ```
+ */
+export function typeByExtension(extension) {
+    extension = extension.startsWith(".") ? extension.slice(1) : extension;
+    // @ts-ignore workaround around denoland/dnt#148
+    return types.get(extension.toLowerCase());
+}

package/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/path/_common/glob_to_reg_exp.d.ts

@@ -1,3 +1,4 @@
+/** Options for {@linkcode globToRegExp}. */
 export interface GlobOptions {
     /** Extended glob syntax.
      * See https://www.linuxjournal.com/content/bash-extended-globbing.

package/esm/storage/0_storage.d.ts

@@ -2,13 +2,22 @@ import { MaybePromise } from "../1_utilities.js";
 import { enums, TLObject, types } from "../2_tl.js";
 import { DC } from "../3_transport.js";
 export type StorageKeyPart = string | number | bigint;
+export type GetManyFilter = {
+    prefix: readonly StorageKeyPart[];
+} | {
+    start: readonly StorageKeyPart[];
+    end: readonly StorageKeyPart[];
+};
 export declare abstract class Storage {
     #private;
     abstract init(): MaybePromise<void>;
     abstract set(key: readonly StorageKeyPart[], value: unknown): MaybePromise<void>;
     abstract incr(key: readonly StorageKeyPart[], by: number): MaybePromise<void>;
     abstract get<T>(key: readonly StorageKeyPart[]): MaybePromise<T | null>;
-    abstract getMany<T>(prefix: readonly StorageKeyPart[]): MaybePromise<Generator<[readonly StorageKeyPart[], T]> | AsyncGenerator<[readonly StorageKeyPart[], T]>>;
+    abstract getMany<T>(prefix: GetManyFilter, params?: {
+        limit?: number;
+        reverse?: boolean;
+    }): MaybePromise<Generator<[readonly StorageKeyPart[], T]> | AsyncGenerator<[readonly StorageKeyPart[], T]>>;
     setDc(dc: DC | null): MaybePromise<void>;
     getDc(): MaybePromise<DC | null>;
     getAuthKey(): Promise<Uint8Array | null>;
@@ -21,13 +30,14 @@ export declare abstract class Storage {
     updateUsernames(type: "user" | "channel", id: bigint, usernames: string[]): Promise<void>;
     getUsername(username: string): Promise<["channel" | "user", bigint, Date] | null>;
     setTlObject(key: readonly StorageKeyPart[], value: TLObject | null): Promise<void>;
-    getTLObject(key: readonly StorageKeyPart[]): Promise<import("../2_tl.js").ReadObject | null>;
+    getTLObject(keyOrBuffer: Uint8Array | readonly StorageKeyPart[]): Promise<import("../2_tl.js").ReadObject | null>;
     setState(state: enums.updates.State): Promise<void>;
     getState(): Promise<import("../tl/2_types.js").updates_State_ | null>;
     setMessage(chatId: number, messageId: number, message: enums.Message | null): Promise<void>;
     deleteMessages(): Promise<void>;
     getMessageChat(messageId: number): MaybePromise<number | null>;
     getMessage(chatId: number, messageId: number): Promise<enums.Message | null>;
+    getLastMessage(chatId: number): Promise<enums.Message | null>;
     setChannelPts(channelId: bigint, pts: number): Promise<void>;
     getChannelPts(channelId: bigint): MaybePromise<number | null>;
     setEntity(peer: types.Channel): Promise<void>;
@@ -43,4 +53,17 @@ export declare abstract class Storage {
     getStickerSetName(id: bigint, accessHash: bigint): MaybePromise<[string, Date] | null>;
     setServerSalt(serverSalt: bigint): Promise<void>;
     getServerSalt(): MaybePromise<bigint | null>;
+    setChat(listId: number, chatId: number, pinned: number, topMessageId: number, topMessageDate: Date): Promise<void>;
+    getChats(listId: number): Promise<{
+        chatId: number;
+        pinned: number;
+        topMessageId: number;
+        topMessageDate: Date;
+    }[]>;
+    removeChats(listId: number): Promise<void>;
+    setHasAllChats(listId: number, hasAllChats: boolean): Promise<void>;
+    hasAllChats(listId: number): Promise<boolean>;
+    setPinnedChats(listId: number, chatIds: number[] | null): Promise<void>;
+    getPinnedChats(listId: number): Promise<number[] | null>;
+    getHistory(chatId: number, offsetId: number, limit: number): Promise<enums.Message[]>;
 }

package/esm/storage/0_storage.js

@@ -23,7 +23,13 @@ const KPARTS__PEER = (type, id) => ["peer", type, id];
 const KPARTS__ACCOUNT_TYPE = ["accountType"];
 const KPARTS__STICKER_SET_NAME = (id, accessHash) => ["stickerSetName", id, accessHash];
 const KPARTS_MESSAGE = (chatId, messageId) => ["messages", chatId, messageId];
+const KPARTS_MESSAGES = (chatId) => ["messages", chatId];
 const KPARTS_MESSAGE_REF = (messageId) => ["messageRefs", messageId];
+const KPARTS_HAS_ALL_CHATS = (listId) => ["hasAllChats", listId];
+const KPARTS_CHATS = (listId) => ["chats", listId];
+const KPARTS_CHAT = (listId, chatId) => ["chats", listId, chatId];
+const KPARTS_PINNED_CHATS = (listId) => ["pinnedChats", listId];
+const KPARTS_SERVER_SALT = ["serverSalt"];
 export class Storage {
     constructor() {
         _Storage_instances.add(this);
@@ -77,8 +83,8 @@ export class Storage {
             await this.set(key, rleEncode(value[serialize]()));
         }
     }
-    async getTLObject(key) {
-        const buffer = await this.get(key);
+    async getTLObject(keyOrBuffer) {
+        const buffer = keyOrBuffer instanceof Uint8Array ? keyOrBuffer : await this.get(keyOrBuffer);
         if (buffer != null) {
             return new TLReader(rleDecode(buffer)).readObject();
         }
@@ -100,7 +106,7 @@ export class Storage {
     }
     async deleteMessages() {
         const maybePromises = new Array();
-        for await (const [k, o] of await this.getMany(["messageRefs"])) {
+        for await (const [k, o] of await this.getMany({ prefix: ["messageRefs"] })) {
             maybePromises.push(Promise.all([this.set(k, null), o == null ? Promise.resolve() : this.set(KPARTS_MESSAGE(o, k[1]), null)]).then(() => { }));
         }
         await Promise.all(maybePromises.filter((v) => v instanceof Promise));
@@ -111,6 +117,12 @@ export class Storage {
     async getMessage(chatId, messageId) {
         return await this.getTLObject(KPARTS_MESSAGE(chatId, messageId));
     }
+    async getLastMessage(chatId) {
+        for await (const [_, buffer] of await this.getMany({ prefix: KPARTS_MESSAGES(chatId) }, { limit: 1, reverse: true })) {
+            return await this.getTLObject(buffer);
+        }
+        return null;
+    }
     async setChannelPts(channelId, pts) {
         await this.set(KPARTS__CHANNEL_PTS(channelId), pts);
     }
@@ -154,10 +166,53 @@ export class Storage {
         return this.get(KPARTS__STICKER_SET_NAME(id, accessHash));
     }
     async setServerSalt(serverSalt) {
-        await this.set(["serverSalt"], serverSalt);
+        await this.set(KPARTS_SERVER_SALT, serverSalt);
     }
     getServerSalt() {
-        return this.get(["serverSalt"]);
+        return this.get(KPARTS_SERVER_SALT);
+    }
+    async setChat(listId, chatId, pinned, topMessageId, topMessageDate) {
+        await this.set(KPARTS_CHAT(listId, chatId), [pinned, topMessageId, topMessageDate]);
+    }
+    async getChats(listId) {
+        const chats = new Array();
+        for await (const [key, value] of await this.getMany({ prefix: KPARTS_CHATS(listId) })) {
+            if (key.length != 3 || typeof key[2] !== "number") {
+                continue;
+            }
+            chats.push({ chatId: key[2], pinned: value[0], topMessageId: value[1], topMessageDate: value[2] });
+        }
+        return chats;
+    }
+    async removeChats(listId) {
+        for await (const [key] of await this.getMany({ prefix: KPARTS_CHATS(listId) })) {
+            await this.set(key, null);
+        }
+        await this.setHasAllChats(listId, false);
+        await this.setPinnedChats(listId, null);
+    }
+    async setHasAllChats(listId, hasAllChats) {
+        await this.set(KPARTS_HAS_ALL_CHATS(listId), hasAllChats);
+    }
+    async hasAllChats(listId) {
+        const v = await this.get(KPARTS_HAS_ALL_CHATS(listId));
+        return v == true;
+    }
+    async setPinnedChats(listId, chatIds) {
+        await this.set(KPARTS_PINNED_CHATS(listId), chatIds);
+    }
+    async getPinnedChats(listId) {
+        return await this.get(KPARTS_PINNED_CHATS(listId));
+    }
+    async getHistory(chatId, offsetId, limit) {
+        if (offsetId == 0) {
+            offsetId = Infinity;
+        }
+        const messages = new Array();
+        for await (const [_, buffer] of await this.getMany({ start: KPARTS_MESSAGE(chatId, 0), end: KPARTS_MESSAGE(chatId, offsetId) }, { limit, reverse: true })) {
+            messages.push(await this.getTLObject(buffer));
+        }
+        return messages;
     }
 }
 _Storage__authKeyId = new WeakMap(), _Storage_instances = new WeakSet(), _Storage_resetAuthKeyId = async function _Storage_resetAuthKeyId(authKey) {

package/esm/storage/0_utilities.d.ts

@@ -11,4 +11,6 @@ export declare enum ValueType {
 export declare function toString(value: unknown): string;
 export declare function fromString<T>(string: string): T;
 export declare function fixKey(key: readonly StorageKeyPart[]): (string | number)[];
+export declare function restoreKey(key: readonly StorageKeyPart[]): (string | number | bigint)[];
 export declare function getPrefixKeyRange(prefix: any): IDBKeyRange;
+export declare function isInRange(key: StorageKeyPart[], start: readonly StorageKeyPart[], end: readonly StorageKeyPart[]): boolean;

package/esm/storage/0_utilities.js

@@ -90,6 +90,25 @@ export function fromString(string) {
 export function fixKey(key) {
     return key.map((v) => typeof v === "bigint" ? String(ValueType.BigInt) + String(v) : typeof v === "string" ? String(ValueType.String) + v : v);
 }
+export function restoreKey(key) {
+    return key.map((v) => {
+        if (typeof v === "string") {
+            const t = Number(v[0]);
+            if (t == ValueType.BigInt) {
+                return BigInt(v.slice(1));
+            }
+            else if (t == ValueType.String) {
+                return v.slice(1);
+            }
+            else {
+                return v;
+            }
+        }
+        else {
+            return v;
+        }
+    });
+}
 // Source: https://gist.github.com/inexorabletash/5462871
 // deno-lint-ignore no-explicit-any
 export function getPrefixKeyRange(prefix) {
@@ -153,3 +172,17 @@ function successor(key) {
     }
     throw new TypeError();
 }
+export function isInRange(key, start, end) {
+    for (const [i, part] of key.entries()) {
+        const left = start[i];
+        const right = end[i];
+        if (left === undefined || right === undefined) {
+            return false;
+        }
+        if (part >= left && part <= right) {
+            continue;
+        }
+        return false;
+    }
+    return true;
+}

package/esm/storage/1_storage_indexed_db.d.ts

@@ -1,4 +1,4 @@
-import { Storage, StorageKeyPart } from "./0_storage.js";
+import { GetManyFilter, Storage, StorageKeyPart } from "./0_storage.js";
 export declare class StorageIndexedDB extends Storage {
     readonly name: string;
     database: IDBDatabase | null;
@@ -6,6 +6,9 @@ export declare class StorageIndexedDB extends Storage {
     init(): Promise<void>;
     set(k: readonly StorageKeyPart[], v: unknown, tx_?: IDBTransaction): Promise<void>;
     get<T>(k: readonly StorageKeyPart[], tx_?: IDBTransaction): Promise<T | null>;
-    getMany<T>(prefix: readonly StorageKeyPart[], tx_?: IDBTransaction): AsyncGenerator<[readonly StorageKeyPart[], T], void, unknown>;
+    getMany<T>(filter: GetManyFilter, params?: {
+        limit?: number;
+        reverse?: boolean;
+    }, tx_?: IDBTransaction): AsyncGenerator<[readonly StorageKeyPart[], T], void, unknown>;
     incr(key: readonly StorageKeyPart[], by: number): Promise<void>;
 }