@mtkruto/node 0.1.134 → 0.1.136

package/esm/0_deps.d.ts

@@ -5,7 +5,7 @@ export { contentType } from "./deps/deno.land/std@0.210.0/media_types/content_ty
 export declare function extension(mimeType: string): string;
 export { ctr256, factorize, ige256Decrypt, ige256Encrypt, init as initTgCrypto } from "./deps/deno.land/x/tgcrypto@0.3.3/mod.js";
 export { gunzip, gzip } from "./deps/raw.githubusercontent.com/MTKruto/compress/main/gzip/gzip.js";
-export { Mutex, type MutexInterface } from "async-mutex";
+export { Mutex } from "./deps/raw.githubusercontent.com/MTKruto/mutex/main/mod.js";
 export { Parser } from "./deps/deno.land/x/html_parser@v0.1.3/src/mod.js";
 import { debug as debug_ } from "./deps/raw.githubusercontent.com/MTKruto/debug/main/mod.js";
 export declare const debug: typeof debug_;

package/esm/0_deps.js

@@ -13,7 +13,7 @@ export function extension(mimeType) {
 }
 export { ctr256, factorize, ige256Decrypt, ige256Encrypt, init as initTgCrypto } from "./deps/deno.land/x/tgcrypto@0.3.3/mod.js";
 export { gunzip, gzip } from "./deps/raw.githubusercontent.com/MTKruto/compress/main/gzip/gzip.js";
-export { Mutex } from "async-mutex";
+export { Mutex } from "./deps/raw.githubusercontent.com/MTKruto/mutex/main/mod.js";
 export { Parser } from "./deps/deno.land/x/html_parser@v0.1.3/src/mod.js";
 import { debug as debug_ } from "./deps/raw.githubusercontent.com/MTKruto/debug/main/mod.js";
 export const debug = (v) => debug_(v);

package/esm/4_constants.d.ts

@@ -4,7 +4,7 @@ export type PublicKeys = readonly [bigint, [bigint, bigint]][];
 export declare const PUBLIC_KEYS: PublicKeys;
 export declare const INITIAL_DC: DC;
 export declare const LAYER = 169;
-export declare const APP_VERSION = "MTKruto 0.1.134";
+export declare const APP_VERSION = "MTKruto 0.1.136";
 export declare const DEVICE_MODEL: string;
 export declare const LANG_CODE: string;
 export declare const LANG_PACK = "";

package/esm/4_constants.js

@@ -53,7 +53,7 @@ export const PUBLIC_KEYS = Object.freeze([
 ]);
 export const INITIAL_DC = "2";
 export const LAYER = 169;
-export const APP_VERSION = "MTKruto 0.1.134";
+export const APP_VERSION = "MTKruto 0.1.136";
 // @ts-ignore: lib
 export const DEVICE_MODEL = typeof dntShim.Deno === "undefined" ? typeof navigator === "undefined" ? typeof process === "undefined" ? "Unknown" : process.platform + "-" + process.arch : navigator.userAgent.split(" ")[0] : dntShim.Deno.build.os + "-" + dntShim.Deno.build.arch;
 export const LANG_CODE = typeof navigator === "undefined" ? "en" : navigator.language.split("-")[0];

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

@@ -1,5 +1,5 @@
 import { enums, types } from "../2_tl.js";
-import { ChatP, Message, MessageTypes, UpdateMap, User } from "../3_types.js";
+import { ChatP, MessageTypes, UpdateMap, User } from "../3_types.js";
 export declare const resolve: () => Promise<void>;
 export type With<T, K extends keyof T> = T & Required<Pick<T, K>>;
 export declare function isPtsUpdate(v: enums.Update): v is types.UpdateNewMessage | types.UpdateDeleteMessages | types.UpdateReadHistoryInbox | types.UpdateReadHistoryOutbox | types.UpdatePinnedChannelMessages | types.UpdatePinnedMessages | types.UpdateFolderPeers | types.UpdateChannelWebPage | types.UpdateEditMessage | types.UpdateReadMessagesContents | types.UpdateWebPage;
@@ -12,29 +12,38 @@ export declare function getFileContents(source: FileSource, fileName?: string):
 export declare function isHttpUrl(string: string): boolean;
 export declare function getUsername(string: string): string;
 export declare function getChatListId(chatList: string): 0 | 1;
-type MessageWith<T extends keyof MessageTypes, F extends number | string | symbol> = F extends keyof MessageTypes[T] ? MessageTypes[T] & {
-    [P in F]-?: NonNullable<MessageTypes[T][P]>;
-} : MessageTypes[T];
-type Me<U extends keyof UpdateMap> = U extends "connectionState" | "authorizationState" ? {
-    me?: User;
-} : {
-    me: User;
-};
-type Msg<U extends keyof UpdateMap, T extends keyof MessageTypes, F extends number | string | symbol = ""> = U extends "message" | "editedMessage" ? {
-    msg: MessageFilter<U, T, F>;
+type AnyLevel1 = keyof UpdateMap;
+type GetLevel1Type<L1 extends AnyLevel1> = UpdateMap[L1];
+type GetAnyLevel2<L1 extends AnyLevel1> = L1 extends "message" | "editedMessage" ? keyof MessageTypes : never;
+type AnyLevel2<L1 extends AnyLevel1 = AnyLevel1> = L1 extends unknown ? `${L1 extends "message" | "editedMessage" ? L1 | "" : L1}:${GetAnyLevel2<L1>}` : never;
+type GetLevel2Type<L1 extends string, L2 extends string> = L2 extends keyof MessageTypes ? L1 extends "" ? {
+    [P in "message" | "editedMessage"]?: MessageTypes[L2];
+} : L1 extends "message" | "editedMessage" ? {
+    [P in L1]: MessageTypes[L2];
+} : never : never;
+type AnyLevelX = AnyLevel1 | AnyLevel2;
+type FilterCore<Q extends AnyLevelX = AnyLevelX> = Q extends AnyLevel1 ? GetLevel1Type<Q> : Q extends `${infer L1}:${infer L2}` ? GetLevel2Type<L1, L2> : 1;
+type Chat<T> = "msg" extends keyof T ? T & {
     chat: ChatP;
-} : {
-    msg?: Message;
-};
-type From<U extends keyof UpdateMap> = U extends "callbackQuery" | "inlineQuery" ? {
+} : T;
+type Msg<T> = "message" extends keyof T ? T & {
+    msg: NonNullable<T["message"]>;
+} : "editedMessage" extends keyof T ? T & {
+    msg: NonNullable<T["editedMessage"]>;
+} : "callbackQuery" extends keyof T ? "message" extends keyof T["callbackQuery"] ? T & {
+    msg: T["callbackQuery"]["message"];
+} : T : T;
+type From<T> = "callbackQuery" | "inlineQuery" extends keyof T ? T & {
     from: User;
-} : {
+} : "message" | "editedMessage" extends keyof T ? {
     from?: User;
-};
-type MessageFilter<U extends keyof UpdateMap, T extends keyof MessageTypes, F extends number | string | symbol> = U extends "message" ? {
-    message: MessageWith<T, F>;
-} : U extends "editedMessage" ? {
-    editedMessage: MessageWith<T, F>;
-} : UpdateMap[U];
-export type WithUpdate<C, U extends keyof UpdateMap, T extends keyof MessageTypes, F extends number | string | symbol = ""> = C & Me<U> & Msg<U, T, F> & From<U> & MessageFilter<U, T, F>;
+} : T;
+type SenderChat<T> = "message" | "editedMessage" extends keyof T ? {
+    senderChat?: ChatP;
+} : T;
+type Shortcuts<T> = SenderChat<From<Chat<Msg<T>>>>;
+type Filter<Q extends AnyLevelX> = Shortcuts<FilterCore<Q>>;
+export type FilterQuery = AnyLevelX;
+export type WithFilter<T, Q extends FilterQuery> = T & Filter<Q>;
+export declare function match<Q extends FilterQuery, T extends object>(filter: Q, value: T): boolean;
 export {};

package/esm/client/0_utilities.js

@@ -145,3 +145,30 @@ export function getChatListId(chatList) {
             UNREACHABLE();
     }
 }
+export function match(filter, value) {
+    let [type, ...other] = filter.split(":");
+    if (type != "" && !(type in value)) {
+        return false;
+    }
+    if (type == "") {
+        if (other.length != 1) {
+            return false;
+        }
+        if ("message" in value) {
+            type = "message";
+        }
+        else if ("editedMessage" in value) {
+            type = "editedMessage";
+        }
+        else {
+            return false;
+        }
+    }
+    const field = other[0];
+    if (field) {
+        if (!(field in value[type])) {
+            return false;
+        }
+    }
+    return true;
+}

package/esm/client/1_composer.d.ts

@@ -1,5 +1,5 @@
-import { MessageTypes, Update, UpdateIntersection, UpdateMap, User } from "../3_types.js";
-import { WithUpdate } from "./0_utilities.js";
+import { Update, UpdateIntersection, User } from "../3_types.js";
+import { FilterQuery, WithFilter } from "./0_utilities.js";
 type MaybePromise<T> = T | Promise<T>;
 export type NextFunction = () => Promise<void>;
 export type MiddlewareFn<C> = (ctx: C, next: NextFunction) => MaybePromise<unknown>;
@@ -21,10 +21,10 @@ export declare class Composer<C extends {
     branch(predicate: (ctx: UpdateIntersection<C>) => MaybePromise<boolean>, trueHandler_: Middleware<UpdateIntersection<C>>, falseHandler_: Middleware<UpdateIntersection<C>>): Composer<UpdateIntersection<C>>;
     filter<D extends C>(predicate: (ctx: UpdateIntersection<C>) => ctx is D, ...middleware: Middleware<D>[]): Composer<D>;
     filter(predicate: (ctx: UpdateIntersection<C>) => MaybePromise<boolean>, ...middleware: Middleware<UpdateIntersection<C>>[]): Composer<C>;
-    on<T extends keyof UpdateMap, F extends string, K extends keyof MessageTypes>(filter: T extends "message" | "editedMessage" ? T | [T, K, ...F[]] : T, ...middleawre: Middleware<WithUpdate<C, T, K, F>>[]): Composer<WithUpdate<C, T, K, F>>;
+    on<Q extends FilterQuery>(filter: Q, ...middleawre: Middleware<WithFilter<C, Q>>[]): Composer<UpdateIntersection<WithFilter<C, Q>>>;
     command(commands: string | RegExp | (string | RegExp)[] | {
         names: string | RegExp | (string | RegExp)[];
         prefixes: string | string[];
-    }, ...middleawre: Middleware<WithUpdate<C, "message", "text">>[]): Composer<WithUpdate<C, "message", "text", string>>;
+    }, ...middleawre: Middleware<WithFilter<C, "message:text">>[]): Composer<UpdateIntersection<WithFilter<C, "message:text">>>;
 }
 export {};

package/esm/client/1_composer.js

@@ -10,7 +10,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
 var _Composer_handle, _Composer_prefixes;
-import { assertMessageType } from "../3_types.js";
+import { match } from "./0_utilities.js";
 export function flatten(mw) {
     return typeof mw === "function" ? mw : (ctx, next) => mw.middleware()(ctx, next);
 }
@@ -69,34 +69,8 @@ export class Composer {
         return composer;
     }
     on(filter, ...middleawre) {
-        const type = typeof filter === "string" ? filter : filter[0];
-        let keys = Array.isArray(filter) ? filter.slice(1) : [];
-        let messageType = null;
-        if (type == "message") {
-            messageType = keys[0];
-            keys = keys.slice(1);
-        }
         return this.filter((ctx) => {
-            if (type in ctx) {
-                if (messageType != null) {
-                    // deno-lint-ignore ban-ts-comment
-                    // @ts-ignore
-                    assertMessageType(ctx[type], messageType);
-                }
-                if (keys.length > 0) {
-                    for (const key of keys) {
-                        // deno-lint-ignore ban-ts-comment
-                        // @ts-ignore
-                        if (!(key in ctx[type])) {
-                            return false;
-                        }
-                    }
-                }
-                return true;
-            }
-            else {
-                return false;
-            }
+            return match(filter, ctx);
         }, ...middleawre);
     }
     command(commands, ...middleawre) {
@@ -114,7 +88,7 @@ export class Composer {
                 }
             }
         }
-        return this.on(["message", "text"]).filter((ctx) => {
+        return this.on("message:text").filter((ctx) => {
             const prefixes_ = prefixes.length == 0 ? [!ctx.me?.isBot ? "\\" : "/"] : prefixes;
             if (prefixes_.length == 0) {
                 return false;

package/esm/client/4_client.d.ts

@@ -2,10 +2,10 @@ import { MaybePromise } from "../1_utilities.js";
 import { functions, ReadObject, types } from "../2_tl.js";
 import { Storage } from "../3_storage.js";
 import { DC } from "../3_transport.js";
-import { BotCommand, Chat, ChatAction, ChatID, ChatP, Document, InlineQueryResult, Message, MessageAnimation, MessageAudio, MessageContact, MessageDice, MessageDocument, MessageLocation, MessagePhoto, MessagePoll, MessageText, MessageTypes, MessageVenue, MessageVideo, MessageVideoNote, MessageVoice, NetworkStatistics, ParseMode, Reaction, Update, UpdateIntersection, UpdateMap, User } from "../3_types.js";
+import { BotCommand, Chat, ChatAction, ChatID, ChatP, Document, InlineQueryResult, Message, MessageAnimation, MessageAudio, MessageContact, MessageDice, MessageDocument, MessageLocation, MessagePhoto, MessagePoll, MessageText, MessageVenue, MessageVideo, MessageVideoNote, MessageVoice, NetworkStatistics, ParseMode, Reaction, Update, UpdateIntersection, User } from "../3_types.js";
 import { Migrate } from "../4_errors.js";
 import { ClientAbstract } from "./0_client_abstract.js";
-import { FileSource, WithUpdate } from "./0_utilities.js";
+import { FileSource, FilterQuery, WithFilter } from "./0_utilities.js";
 import { Composer, Middleware } from "./1_composer.js";
 import { AddReactionParams, AnswerCallbackQueryParams, AnswerInlineQueryParams, AuthorizeUserParams, ClientParams, DeleteMessageParams, DeleteMessagesParams, DownloadParams, EditMessageParams, ForwardMessagesParams, GetChatsParams, GetHistoryParams, GetMyCommandsParams, ReplyParams, SendAnimationParams, SendAudioParams, SendContactParams, SendDiceParams, SendDocumentParams, SendLocationParams, SendMessageParams, SendPhotoParams, SendPollParams, SendVenueParams, SendVideoNoteParams, SendVideoParams, SendVoiceParams, SetMyCommandsParams, SetReactionsParams, UploadParams } from "./3_params.js";
 export type NextFn<T = void> = () => Promise<T>;
@@ -339,11 +339,11 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
     branch(predicate: (ctx: UpdateIntersection<C>) => MaybePromise<boolean>, trueHandler_: Middleware<UpdateIntersection<C>>, falseHandler_: Middleware<UpdateIntersection<C>>): Composer<UpdateIntersection<C>>;
     filter<D extends C>(predicate: (ctx: UpdateIntersection<C>) => ctx is D, ...middleware: Middleware<D>[]): Composer<D>;
     filter(predicate: (ctx: UpdateIntersection<C>) => MaybePromise<boolean>, ...middleware: Middleware<UpdateIntersection<C>>[]): Composer<C>;
-    on<T extends keyof UpdateMap, F extends string, K extends keyof MessageTypes>(filter: T extends "message" | "editedMessage" ? T | [T, K, ...F[]] : T, ...middleawre: Middleware<WithUpdate<C, T, K, F>>[]): Composer<WithUpdate<C, T, K, F>>;
+    on<Q extends FilterQuery>(filter: Q, ...middleawre: Middleware<WithFilter<C, Q>>[]): Composer<UpdateIntersection<WithFilter<C, Q>>>;
     command(commands: string | RegExp | (string | RegExp)[] | {
         names: string | RegExp | (string | RegExp)[];
         prefixes: string | string[];
-    }, ...middleawre: Middleware<WithUpdate<C, "message", "text">>[]): Composer<WithUpdate<C, "message", "text", string>>;
+    }, ...middleawre: Middleware<WithFilter<C, "message:text">>[]): Composer<UpdateIntersection<WithFilter<C, "message:text">>>;
     /**
      * Set the bot's description in the given language. Bot-only.
      *

package/esm/client/4_client.js

@@ -21,7 +21,7 @@ import { ClientAbstract } from "./0_client_abstract.js";
 import { parseHtml } from "./0_html.js";
 import { decryptMessage, encryptMessage, getMessageId } from "./0_message.js";
 import { checkPassword } from "./0_password.js";
-import { getChatListId, getFileContents, getUsername, isChannelPtsUpdate, isHttpUrl, isPtsUpdate, resolve } from "./0_utilities.js";
+import { getChatListId, getFileContents, getUsername, isChannelPtsUpdate, isHttpUrl, isPtsUpdate, match, resolve } from "./0_utilities.js";
 import { Composer, concat, flatten, skip } from "./1_composer.js";
 import { ClientPlain } from "./2_client_plain.js";
 const d = debug("Client");
@@ -2231,34 +2231,8 @@ export class Client extends ClientAbstract {
         return composer;
     }
     on(filter, ...middleawre) {
-        const type = typeof filter === "string" ? filter : filter[0];
-        let keys = Array.isArray(filter) ? filter.slice(1) : [];
-        let messageType = null;
-        if (type == "message") {
-            messageType = keys[0];
-            keys = keys.slice(1);
-        }
         return this.filter((ctx) => {
-            if (type in ctx) {
-                if (messageType != null) {
-                    // deno-lint-ignore ban-ts-comment
-                    // @ts-ignore
-                    assertMessageType(ctx[type], messageType);
-                }
-                if (keys.length > 0) {
-                    for (const key of keys) {
-                        // deno-lint-ignore ban-ts-comment
-                        // @ts-ignore
-                        if (!(key in ctx[type])) {
-                            return false;
-                        }
-                    }
-                }
-                return true;
-            }
-            else {
-                return false;
-            }
+            return match(filter, ctx);
         }, ...middleawre);
     }
     command(commands, ...middleawre) {
@@ -2276,7 +2250,7 @@ export class Client extends ClientAbstract {
                 }
             }
         }
-        return this.on(["message", "text"]).filter((ctx) => {
+        return this.on("message:text").filter((ctx) => {
             const prefixes_ = prefixes.length == 0 ? [!ctx.me?.isBot ? "\\" : "/"] : prefixes;
             if (prefixes_.length == 0) {
                 return false;

package/esm/deps/raw.githubusercontent.com/MTKruto/mutex/main/mod.d.ts

@@ -0,0 +1,2 @@
+export * from "./mutex.js";
+export * from "./semaphore.js";

package/esm/deps/raw.githubusercontent.com/MTKruto/mutex/main/mod.js

@@ -0,0 +1,2 @@
+export * from "./mutex.js";
+export * from "./semaphore.js";

package/esm/deps/raw.githubusercontent.com/MTKruto/mutex/main/mutex.d.ts

@@ -0,0 +1,26 @@
+export interface MutexInterface {
+    acquire(): Promise<MutexInterface.Releaser>;
+    runExclusive<T>(callback: MutexInterface.Worker<T>): Promise<T>;
+    waitForUnlock(): Promise<void>;
+    isLocked(): boolean;
+    release(): void;
+    cancel(): void;
+}
+export declare namespace MutexInterface {
+    interface Releaser {
+        (): void;
+    }
+    interface Worker<T> {
+        (): Promise<T> | T;
+    }
+}
+export declare class Mutex implements MutexInterface {
+    constructor(cancelError?: Error);
+    acquire(): Promise<MutexInterface.Releaser>;
+    runExclusive<T>(callback: MutexInterface.Worker<T>): Promise<T>;
+    isLocked(): boolean;
+    waitForUnlock(): Promise<void>;
+    release(): void;
+    cancel(): void;
+    private _semaphore;
+}

package/esm/deps/raw.githubusercontent.com/MTKruto/mutex/main/mutex.js

@@ -0,0 +1,32 @@
+import { Semaphore } from "./semaphore.js";
+export class Mutex {
+    constructor(cancelError) {
+        Object.defineProperty(this, "_semaphore", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._semaphore = new Semaphore(1, cancelError);
+    }
+    async acquire() {
+        const [, releaser] = await this._semaphore.acquire();
+        return releaser;
+    }
+    runExclusive(callback) {
+        return this._semaphore.runExclusive(() => callback());
+    }
+    isLocked() {
+        return this._semaphore.isLocked();
+    }
+    waitForUnlock() {
+        return this._semaphore.waitForUnlock();
+    }
+    release() {
+        if (this._semaphore.isLocked())
+            this._semaphore.release();
+    }
+    cancel() {
+        return this._semaphore.cancel();
+    }
+}

package/esm/deps/raw.githubusercontent.com/MTKruto/mutex/main/semaphore.d.ts

@@ -0,0 +1,41 @@
+export declare const E_CANCELED: Error;
+export interface SemaphoreInterface {
+    acquire(weight?: number): Promise<[number, SemaphoreInterface.Releaser]>;
+    runExclusive<T>(callback: SemaphoreInterface.Worker<T>, weight?: number): Promise<T>;
+    waitForUnlock(weight?: number): Promise<void>;
+    isLocked(): boolean;
+    getValue(): number;
+    setValue(value: number): void;
+    release(weight?: number): void;
+    cancel(): void;
+}
+export declare namespace SemaphoreInterface {
+    interface Releaser {
+        (): void;
+    }
+    interface Worker<T> {
+        (value: number): Promise<T> | T;
+    }
+}
+export interface QueueEntry {
+    resolve(result: [number, SemaphoreInterface.Releaser]): void;
+    reject(error: unknown): void;
+}
+export declare class Semaphore implements SemaphoreInterface {
+    private _value;
+    private _cancelError;
+    constructor(_value: number, _cancelError?: Error);
+    acquire(weight?: number): Promise<[number, SemaphoreInterface.Releaser]>;
+    runExclusive<T>(callback: SemaphoreInterface.Worker<T>, weight?: number): Promise<T>;
+    waitForUnlock(weight?: number): Promise<void>;
+    isLocked(): boolean;
+    getValue(): number;
+    setValue(value: number): void;
+    release(weight?: number): void;
+    cancel(): void;
+    private _dispatch;
+    private _newReleaser;
+    private _drainUnlockWaiters;
+    private _weightedQueues;
+    private _weightedWaiters;
+}

package/esm/deps/raw.githubusercontent.com/MTKruto/mutex/main/semaphore.js

@@ -0,0 +1,113 @@
+export const E_CANCELED = new Error("request for lock canceled");
+export class Semaphore {
+    constructor(_value, _cancelError = E_CANCELED) {
+        Object.defineProperty(this, "_value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: _value
+        });
+        Object.defineProperty(this, "_cancelError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: _cancelError
+        });
+        Object.defineProperty(this, "_weightedQueues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "_weightedWaiters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    acquire(weight = 1) {
+        if (weight <= 0) {
+            throw new Error(`invalid weight ${weight}: must be positive`);
+        }
+        return new Promise((resolve, reject) => {
+            if (!this._weightedQueues[weight - 1]) {
+                this._weightedQueues[weight - 1] = [];
+            }
+            this._weightedQueues[weight - 1].push({ resolve, reject });
+            this._dispatch();
+        });
+    }
+    async runExclusive(callback, weight = 1) {
+        const [value, release] = await this.acquire(weight);
+        try {
+            return await callback(value);
+        }
+        finally {
+            release();
+        }
+    }
+    waitForUnlock(weight = 1) {
+        if (weight <= 0) {
+            throw new Error(`invalid weight ${weight}: must be positive`);
+        }
+        return new Promise((resolve) => {
+            if (!this._weightedWaiters[weight - 1]) {
+                this._weightedWaiters[weight - 1] = [];
+            }
+            this._weightedWaiters[weight - 1].push(resolve);
+            this._dispatch();
+        });
+    }
+    isLocked() {
+        return this._value <= 0;
+    }
+    getValue() {
+        return this._value;
+    }
+    setValue(value) {
+        this._value = value;
+        this._dispatch();
+    }
+    release(weight = 1) {
+        if (weight <= 0) {
+            throw new Error(`invalid weight ${weight}: must be positive`);
+        }
+        this._value += weight;
+        this._dispatch();
+    }
+    cancel() {
+        this._weightedQueues.forEach((queue) => queue.forEach((entry) => entry.reject(this._cancelError)));
+        this._weightedQueues = [];
+    }
+    _dispatch() {
+        for (let weight = this._value; weight > 0; weight--) {
+            const queueEntry = this._weightedQueues[weight - 1]?.shift();
+            if (!queueEntry)
+                continue;
+            const previousValue = this._value;
+            const previousWeight = weight;
+            this._value -= weight;
+            weight = this._value + 1;
+            queueEntry.resolve([previousValue, this._newReleaser(previousWeight)]);
+        }
+        this._drainUnlockWaiters();
+    }
+    _newReleaser(weight) {
+        let called = false;
+        return () => {
+            if (called)
+                return;
+            called = true;
+            this.release(weight);
+        };
+    }
+    _drainUnlockWaiters() {
+        for (let weight = this._value; weight > 0; weight--) {
+            if (!this._weightedWaiters[weight - 1])
+                continue;
+            this._weightedWaiters[weight - 1].forEach((waiter) => waiter());
+            this._weightedWaiters[weight - 1] = [];
+        }
+    }
+}

package/esm/storage/1_storage_local_storage.js

@@ -56,7 +56,7 @@ export class StorageLocalStorage extends Storage {
         if (params?.limit !== undefined) {
             entries = entries.slice(0, params.limit <= 0 ? 1 : params.limit);
         }
-        for (let [key, value] of entries) {
+        entries: for (let [key, value] of entries) {
             if (key.startsWith(this.prefix)) {
                 key = key.slice(this.prefix.length);
             }
@@ -65,7 +65,7 @@ export class StorageLocalStorage extends Storage {
                 if ("prefix" in filter) {
                     for (const [i, p] of filter.prefix.entries()) {
                         if (toString(p) != toString(parts[i])) {
-                            continue;
+                            continue entries;
                         }
                     }
                 }

package/esm/storage/1_storage_session_storage.js

@@ -56,7 +56,7 @@ export class StorageSessionStorage extends Storage {
         if (params?.limit !== undefined) {
             entries = entries.slice(0, params.limit <= 0 ? 1 : params.limit);
         }
-        for (let [key, value] of entries) {
+        entries: for (let [key, value] of entries) {
             if (key.startsWith(this.prefix)) {
                 key = key.slice(this.prefix.length);
             }
@@ -65,7 +65,7 @@ export class StorageSessionStorage extends Storage {
                 if ("prefix" in filter) {
                     for (const [i, p] of filter.prefix.entries()) {
                         if (toString(p) != toString(parts[i])) {
-                            continue;
+                            continue entries;
                         }
                     }
                 }