@mtkruto/browser 0.1.108 → 0.1.110

package/esm/connection/1_connection_web_socket.d.ts

@@ -1,17 +1,9 @@
 import { ConnectionUnframed } from "./0_connection.js";
 export declare class ConnectionWebSocket extends ConnectionUnframed implements ConnectionUnframed {
+    #private;
     private readonly url;
-    private webSocket;
-    private rMutex;
-    private wMutex;
-    private buffer;
-    private nextResolve;
     constructor(url: string | URL);
-    private initWs;
     get connected(): boolean;
-    private wasConnected;
-    private isConnecting;
-    private connectionError;
     open(): Promise<void>;
     read(p: Uint8Array): Promise<void>;
     write(p: Uint8Array): Promise<void>;

package/esm/connection/1_connection_web_socket.js

@@ -1,117 +1,56 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _ConnectionWebSocket_instances, _ConnectionWebSocket_webSocket, _ConnectionWebSocket_rMutex, _ConnectionWebSocket_wMutex, _ConnectionWebSocket_buffer, _ConnectionWebSocket_nextResolve, _ConnectionWebSocket_initWs, _ConnectionWebSocket_wasConnected, _ConnectionWebSocket_isConnecting, _ConnectionWebSocket_connectionError, _ConnectionWebSocket_assertConnected, _ConnectionWebSocket_rejectRead;
 import { debug, Mutex } from "../0_deps.js";
 import { UNREACHABLE } from "../1_utilities.js";
 import { ConnectionUnframed } from "./0_connection.js";
 const d = debug("ConnectionWebSocket");
+const errConnectionNotOpen = new Error("Connection not open");
 export class ConnectionWebSocket extends ConnectionUnframed {
     constructor(url) {
         super();
+        _ConnectionWebSocket_instances.add(this);
         Object.defineProperty(this, "url", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: url
         });
-        Object.defineProperty(this, "webSocket", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "rMutex", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Mutex()
-        });
-        Object.defineProperty(this, "wMutex", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Mutex()
-        });
-        Object.defineProperty(this, "buffer", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Array()
-        });
-        Object.defineProperty(this, "nextResolve", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "wasConnected", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "isConnecting", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "connectionError", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        this.webSocket = this.initWs();
-    }
-    initWs() {
-        const webSocket = new WebSocket(this.url, "binary");
-        const mutex = new Mutex();
-        webSocket.addEventListener("close", () => {
-            this.stateChangeHandler?.(false);
-        });
-        webSocket.addEventListener("open", () => {
-            this.stateChangeHandler?.(true);
-        });
-        webSocket.addEventListener("message", async (e) => {
-            if (typeof e.data === "string") {
-                return;
-            }
-            const release = await mutex.acquire();
-            const data = new Uint8Array(await new Blob([e.data].map((v) => v instanceof Blob || v instanceof Uint8Array ? v : v instanceof ArrayBuffer ? v : UNREACHABLE())).arrayBuffer());
-            for (const byte of data) {
-                this.buffer.push(byte);
-            }
-            if (this.nextResolve != null && this.buffer.length >= this.nextResolve[0]) {
-                this.nextResolve[1].resolve();
-                this.nextResolve = null;
-            }
-            release();
-        });
-        webSocket.addEventListener("error", (err) => {
-            if (this.isConnecting) {
-                // @ts-ignore: Node.js
-                this.connectionError = err;
-            }
-            if (this.connected) {
-                d("WebSocket error: %o", err);
-            }
-        });
-        return webSocket;
+        _ConnectionWebSocket_webSocket.set(this, void 0);
+        _ConnectionWebSocket_rMutex.set(this, new Mutex());
+        _ConnectionWebSocket_wMutex.set(this, new Mutex());
+        _ConnectionWebSocket_buffer.set(this, new Array());
+        _ConnectionWebSocket_nextResolve.set(this, null);
+        _ConnectionWebSocket_wasConnected.set(this, false);
+        _ConnectionWebSocket_isConnecting.set(this, false);
+        _ConnectionWebSocket_connectionError.set(this, null);
+        __classPrivateFieldSet(this, _ConnectionWebSocket_webSocket, __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_initWs).call(this), "f");
     }
     get connected() {
-        return this.webSocket.readyState == WebSocket.OPEN;
+        return __classPrivateFieldGet(this, _ConnectionWebSocket_webSocket, "f").readyState == WebSocket.OPEN;
     }
     async open() {
-        if (this.isConnecting) {
+        if (__classPrivateFieldGet(this, _ConnectionWebSocket_isConnecting, "f")) {
             throw new Error("Already connecting");
         }
-        this.isConnecting = true;
-        if (!this.connected && this.wasConnected) {
-            this.webSocket = this.initWs();
+        __classPrivateFieldSet(this, _ConnectionWebSocket_isConnecting, true, "f");
+        if (!this.connected && __classPrivateFieldGet(this, _ConnectionWebSocket_wasConnected, "f")) {
+            __classPrivateFieldSet(this, _ConnectionWebSocket_webSocket, __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_initWs).call(this), "f");
         }
         try {
-            while (this.webSocket.readyState != WebSocket.OPEN) {
-                if (this.webSocket.readyState == WebSocket.CLOSED) {
-                    if (this.connectionError instanceof ErrorEvent) {
-                        throw new Error(this.connectionError.message);
+            while (__classPrivateFieldGet(this, _ConnectionWebSocket_webSocket, "f").readyState != WebSocket.OPEN) {
+                if (__classPrivateFieldGet(this, _ConnectionWebSocket_webSocket, "f").readyState == WebSocket.CLOSED) {
+                    if (__classPrivateFieldGet(this, _ConnectionWebSocket_connectionError, "f") instanceof ErrorEvent) {
+                        throw new Error(__classPrivateFieldGet(this, _ConnectionWebSocket_connectionError, "f").message);
                     }
                     else {
                         throw new Error("Connection was closed");
@@ -121,47 +60,86 @@ export class ConnectionWebSocket extends ConnectionUnframed {
                     await new Promise((r) => setTimeout(r, 5));
                 }
             }
-            this.wasConnected = true;
+            __classPrivateFieldSet(this, _ConnectionWebSocket_wasConnected, true, "f");
         }
         finally {
-            this.isConnecting = false;
-            this.connectionError = null;
+            __classPrivateFieldSet(this, _ConnectionWebSocket_isConnecting, false, "f");
+            __classPrivateFieldSet(this, _ConnectionWebSocket_connectionError, null, "f");
         }
     }
     async read(p) {
-        if (this.webSocket.readyState != WebSocket.OPEN) {
-            throw new Error("Connection not open");
-        }
-        const release = await this.rMutex.acquire();
+        __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_assertConnected).call(this);
+        const release = await __classPrivateFieldGet(this, _ConnectionWebSocket_rMutex, "f").acquire();
         try {
-            if (this.buffer.length < p.length) {
-                await new Promise((resolve, reject) => this.nextResolve = [p.length, { resolve, reject }]);
+            __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_assertConnected).call(this);
+            if (__classPrivateFieldGet(this, _ConnectionWebSocket_buffer, "f").length < p.length) {
+                await new Promise((resolve, reject) => __classPrivateFieldSet(this, _ConnectionWebSocket_nextResolve, [p.length, { resolve, reject }], "f"));
             }
-            p.set(this.buffer.splice(0, p.length));
+            p.set(__classPrivateFieldGet(this, _ConnectionWebSocket_buffer, "f").splice(0, p.length));
         }
         finally {
             release();
         }
     }
     async write(p) {
-        if (this.webSocket.readyState == WebSocket.CLOSED) {
-            throw new Error("Connection not open");
-        }
-        const release = await this.wMutex.acquire();
+        __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_assertConnected).call(this);
+        const release = await __classPrivateFieldGet(this, _ConnectionWebSocket_wMutex, "f").acquire();
         try {
-            this.webSocket.send(p);
+            __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_assertConnected).call(this);
+            __classPrivateFieldGet(this, _ConnectionWebSocket_webSocket, "f").send(p);
         }
         finally {
             release();
         }
     }
     close() {
-        if (this.webSocket.readyState == WebSocket.CLOSED) {
-            throw new Error("Connection not open");
+        __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_assertConnected).call(this);
+        __classPrivateFieldGet(this, _ConnectionWebSocket_webSocket, "f").close(1000, "method");
+        __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_rejectRead).call(this);
+    }
+}
+_ConnectionWebSocket_webSocket = new WeakMap(), _ConnectionWebSocket_rMutex = new WeakMap(), _ConnectionWebSocket_wMutex = new WeakMap(), _ConnectionWebSocket_buffer = new WeakMap(), _ConnectionWebSocket_nextResolve = new WeakMap(), _ConnectionWebSocket_wasConnected = new WeakMap(), _ConnectionWebSocket_isConnecting = new WeakMap(), _ConnectionWebSocket_connectionError = new WeakMap(), _ConnectionWebSocket_instances = new WeakSet(), _ConnectionWebSocket_initWs = function _ConnectionWebSocket_initWs() {
+    const webSocket = new WebSocket(this.url, "binary");
+    const mutex = new Mutex();
+    webSocket.addEventListener("close", () => {
+        __classPrivateFieldGet(this, _ConnectionWebSocket_instances, "m", _ConnectionWebSocket_rejectRead).call(this);
+        this.stateChangeHandler?.(false);
+    });
+    webSocket.addEventListener("open", () => {
+        this.stateChangeHandler?.(true);
+    });
+    webSocket.addEventListener("message", async (e) => {
+        if (typeof e.data === "string") {
+            return;
+        }
+        const release = await mutex.acquire();
+        const data = new Uint8Array(await new Blob([e.data].map((v) => v instanceof Blob || v instanceof Uint8Array ? v : v instanceof ArrayBuffer ? v : UNREACHABLE())).arrayBuffer());
+        for (const byte of data) {
+            __classPrivateFieldGet(this, _ConnectionWebSocket_buffer, "f").push(byte);
+        }
+        if (__classPrivateFieldGet(this, _ConnectionWebSocket_nextResolve, "f") != null && __classPrivateFieldGet(this, _ConnectionWebSocket_buffer, "f").length >= __classPrivateFieldGet(this, _ConnectionWebSocket_nextResolve, "f")[0]) {
+            __classPrivateFieldGet(this, _ConnectionWebSocket_nextResolve, "f")[1].resolve();
+            __classPrivateFieldSet(this, _ConnectionWebSocket_nextResolve, null, "f");
         }
-        this.webSocket.close(1000, "method");
-        if (this.nextResolve != null) {
-            this.nextResolve[1].reject(new Error("Connection not open"));
+        release();
+    });
+    webSocket.addEventListener("error", (err) => {
+        if (__classPrivateFieldGet(this, _ConnectionWebSocket_isConnecting, "f")) {
+            // @ts-ignore: Node.js
+            __classPrivateFieldSet(this, _ConnectionWebSocket_connectionError, err, "f");
         }
+        if (this.connected) {
+            d("WebSocket error: %o", err);
+        }
+    });
+    return webSocket;
+}, _ConnectionWebSocket_assertConnected = function _ConnectionWebSocket_assertConnected() {
+    if (!this.connected) {
+        throw errConnectionNotOpen;
     }
-}
+}, _ConnectionWebSocket_rejectRead = function _ConnectionWebSocket_rejectRead() {
+    if (__classPrivateFieldGet(this, _ConnectionWebSocket_nextResolve, "f") != null) {
+        __classPrivateFieldGet(this, _ConnectionWebSocket_nextResolve, "f")[1].reject(errConnectionNotOpen);
+        __classPrivateFieldSet(this, _ConnectionWebSocket_nextResolve, null, "f");
+    }
+};

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

@@ -3,14 +3,13 @@ import { TLObject, types } from "../2_tl.js";
 import { DC } from "../3_transport.js";
 export type StorageKeyPart = string | number | bigint;
 export declare abstract class Storage {
-    private _authKeyId;
+    #private;
     abstract init(): MaybePromise<void>;
     abstract set(key: readonly StorageKeyPart[], value: unknown): 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]>>;
     setDc(dc: DC | null): MaybePromise<void>;
     getDc(): MaybePromise<DC | null>;
-    private resetAuthKeyId;
     getAuthKey(): Promise<Uint8Array | null>;
     setAuthKey(authKey: Uint8Array | null): Promise<void>;
     get authKeyId(): bigint | null;
@@ -41,4 +40,6 @@ export declare abstract class Storage {
     getAccountType(): MaybePromise<"bot" | "user" | null>;
     updateStickerSetName(id: bigint, accessHash: bigint, name: string): Promise<void>;
     getStickerSetName(id: bigint, accessHash: bigint): MaybePromise<[string, Date] | null>;
+    setServerSalt(serverSalt: bigint): Promise<void>;
+    getServerSalt(): MaybePromise<bigint | null>;
 }

package/esm/storage/0_storage.js

@@ -1,3 +1,15 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Storage_instances, _Storage__authKeyId, _Storage_resetAuthKeyId;
 import { bigIntFromBuffer, rleDecode, rleEncode, sha1, UNREACHABLE } from "../1_utilities.js";
 import { serialize, TLReader, types } from "../2_tl.js";
 import { ZERO_CHANNEL_ID } from "../4_constants.js";
@@ -15,12 +27,8 @@ const KPARTS_MESSAGE = (chatId, messageId) => ["messages", chatId, messageId];
 const KPARTS_MESSAGE_REF = (messageId) => ["messageRefs", messageId];
 export class Storage {
     constructor() {
-        Object.defineProperty(this, "_authKeyId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
+        _Storage_instances.add(this);
+        _Storage__authKeyId.set(this, null);
     }
     setDc(dc) {
         return this.set(KPARTS__DC, dc);
@@ -28,25 +36,17 @@ export class Storage {
     getDc() {
         return this.get(KPARTS__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(KPARTS__AUTH_KEY);
-        await this.resetAuthKeyId(authKey);
+        await __classPrivateFieldGet(this, _Storage_instances, "m", _Storage_resetAuthKeyId).call(this, authKey);
         return authKey;
     }
     async setAuthKey(authKey) {
         await this.set(KPARTS__AUTH_KEY, authKey);
-        await this.resetAuthKeyId(authKey);
+        await __classPrivateFieldGet(this, _Storage_instances, "m", _Storage_resetAuthKeyId).call(this, authKey);
     }
     get authKeyId() {
-        return this._authKeyId;
+        return __classPrivateFieldGet(this, _Storage__authKeyId, "f");
     }
     setChannelAccessHash(id, accessHash) {
         return this.set(KPARTS__CHANNEL_ACCESS_HASH(id), accessHash);
@@ -63,17 +63,12 @@ export class Storage {
     async updateUsernames(type, id, usernames) {
         for (let username of usernames) {
             username = username.toLowerCase();
-            await this.set(KPARTS__USERNAME(username), [type, String(id), new Date()]);
+            await this.set(KPARTS__USERNAME(username), [type, id, new Date()]);
         }
     }
     async getUsername(username) {
         username = username.toLowerCase();
-        const v = await this.get(KPARTS__USERNAME(username));
-        if (v != null) {
-            v[1] = BigInt(v[1]);
-            v[2] = new Date(v[2]);
-        }
-        return v;
+        return await this.get(KPARTS__USERNAME(username));
     }
     async setTlObject(key, value) {
         if (value == null) {
@@ -125,12 +120,12 @@ export class Storage {
     }
     async setEntity(peer) {
         const type = peer instanceof types.Channel ? "channel" : peer instanceof types.Chat ? "chat" : peer instanceof types.User ? "user" : UNREACHABLE();
-        await this.set(KPARTS__PEER(type, peer.id), peer[serialize]());
+        await this.set(KPARTS__PEER(type, peer.id), rleEncode(peer[serialize]()));
     }
     async getEntity(type, id) {
         const peer_ = await this.get(KPARTS__PEER(type, id));
         if (peer_ != null) {
-            return new TLReader(peer_).readObject();
+            return new TLReader(rleDecode(peer_)).readObject();
         }
         else {
             return null;
@@ -159,4 +154,18 @@ export class Storage {
     getStickerSetName(id, accessHash) {
         return this.get(KPARTS__STICKER_SET_NAME(id, accessHash));
     }
+    async setServerSalt(serverSalt) {
+        await this.set(["serverSalt"], serverSalt);
+    }
+    getServerSalt() {
+        return this.get(["serverSalt"]);
+    }
 }
+_Storage__authKeyId = new WeakMap(), _Storage_instances = new WeakSet(), _Storage_resetAuthKeyId = async function _Storage_resetAuthKeyId(authKey) {
+    if (authKey != null) {
+        __classPrivateFieldSet(this, _Storage__authKeyId, await sha1(authKey).then((hash) => bigIntFromBuffer(hash.slice(-8), true, false)), "f");
+    }
+    else {
+        __classPrivateFieldSet(this, _Storage__authKeyId, null, "f");
+    }
+};

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

@@ -9,6 +9,6 @@ export declare enum ValueType {
     Array = 6
 }
 export declare function toString(value: unknown): string;
-export declare function fromString<T>(string: string): any;
+export declare function fromString<T>(string: string): T;
 export declare function fixKey(key: readonly StorageKeyPart[]): (string | number)[];
 export declare function getPrefixKeyRange(prefix: any): IDBKeyRange;

package/esm/storage/0_utilities.js

@@ -1,4 +1,4 @@
-import { base64Decode, base64Encode } from "../0_deps.js";
+import { decodeBase64, encodeBase64 } from "../0_deps.js";
 import { UNREACHABLE } from "../1_utilities.js";
 export var ValueType;
 (function (ValueType) {
@@ -12,53 +12,83 @@ export var ValueType;
 })(ValueType || (ValueType = {}));
 export function toString(value) {
     if (typeof value === "boolean") {
-        return JSON.stringify([ValueType.Boolean, value]);
+        return `${ValueType.Boolean}${Number(value)}`;
     }
     else if (typeof value === "number") {
-        return JSON.stringify([ValueType.Number, value]);
+        return `${ValueType.Number}${value}`;
     }
     else if (typeof value === "string") {
-        return JSON.stringify([ValueType.String, value]);
+        return `${ValueType.String}${value}`;
     }
     else if (typeof value == "bigint") {
-        return JSON.stringify([ValueType.BigInt, String(value)]);
+        return `${ValueType.BigInt}${value}`;
     }
     else if (value instanceof Date) {
-        return JSON.stringify([ValueType.Date, value.getTime()]);
+        return `${ValueType.Date}${value.getTime()}`;
     }
     else if (value instanceof Uint8Array) {
-        return JSON.stringify([ValueType.Uint8Array, base64Encode(value)]);
+        return `${ValueType.Uint8Array}${encodeBase64(value)}`;
     }
     else if (Array.isArray(value)) {
-        return JSON.stringify([ValueType.Array, value.map(toString)]);
+        const items = value.map((v) => {
+            if (typeof v === "string" || v instanceof Uint8Array || Array.isArray(v)) {
+                const s = toString(v).slice(1);
+                return String(typeof v === "string" ? ValueType.String : v instanceof Uint8Array ? ValueType.Uint8Array : ValueType.Array) + toString(s.length).slice(1) + "\n" + s;
+            }
+            else {
+                return toString(v);
+            }
+        });
+        return `${ValueType.Array}${items.join("\n")}`;
     }
     else {
         UNREACHABLE();
     }
 }
 export function fromString(string) {
-    const [type, value] = JSON.parse(string);
-    if (type == ValueType.Boolean || type == ValueType.Number || type == ValueType.String) {
-        return value;
-    }
-    else if (type == ValueType.BigInt) {
-        return BigInt(value);
-    }
-    else if (type == ValueType.Date) {
-        return new Date(value);
-    }
-    else if (type == ValueType.Uint8Array) {
-        return base64Decode(value);
-    }
-    else if (type == ValueType.Array) {
-        return value.map(fromString);
-    }
-    else {
-        UNREACHABLE();
+    const [type, value] = [Number(string[0]), string.slice(1)];
+    switch (type) {
+        case ValueType.Boolean:
+            return Boolean(Number(value));
+        case ValueType.Number:
+            return Number(value);
+        case ValueType.String:
+            return value;
+        case ValueType.BigInt:
+            return BigInt(value);
+        case ValueType.Date:
+            return new Date(Number(value));
+        case ValueType.Uint8Array:
+            return decodeBase64(value);
+        case ValueType.Array: {
+            const arr = [];
+            for (let i = 0; i < value.length; ++i) {
+                const type = Number(value[i]);
+                let value_ = "";
+                while (value[++i] != "\n") {
+                    value_ += value[i];
+                    if (i == value.length - 1) {
+                        break;
+                    }
+                }
+                switch (type) {
+                    case ValueType.String:
+                    case ValueType.Uint8Array:
+                    case ValueType.Array: {
+                        const len = Number(value_);
+                        ++i;
+                        value_ = value.slice(i, i + Number(value_));
+                        i += len;
+                    }
+                }
+                arr.push(fromString(`${type}${value_}`));
+            }
+            return arr;
+        }
     }
 }
 export function fixKey(key) {
-    return key.map((v) => typeof v === "bigint" ? String(v) : v);
+    return key.map((v) => typeof v === "bigint" ? String(ValueType.BigInt) + String(v) : typeof v === "string" ? String(ValueType.String) + v : v);
 }
 // Source: https://gist.github.com/inexorabletash/5462871
 // deno-lint-ignore no-explicit-any

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

@@ -4,7 +4,7 @@ export declare class StorageLocalStorage extends Storage implements Storage {
     private readonly prefix;
     constructor(prefix: string);
     init(): void;
-    get(key_: readonly StorageKeyPart[]): any;
+    get<T>(key_: readonly StorageKeyPart[]): T | null;
     getMany<T>(prefix: readonly StorageKeyPart[]): Generator<[readonly StorageKeyPart[], T], void, unknown>;
     set(key_: readonly StorageKeyPart[], value: unknown): MaybePromise<void>;
 }

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

@@ -4,7 +4,7 @@ export declare class StorageSessionStorage extends Storage implements Storage {
     private readonly prefix;
     constructor(prefix: string);
     init(): void;
-    get(key_: readonly StorageKeyPart[]): any;
+    get<T>(key_: readonly StorageKeyPart[]): T | null;
     getMany<T>(prefix: readonly StorageKeyPart[]): Generator<[readonly StorageKeyPart[], T], void, unknown>;
     set(key_: readonly StorageKeyPart[], value: unknown): MaybePromise<void>;
 }

package/esm/transport/1_transport_abridged.d.ts

@@ -1,8 +1,7 @@
 import { Connection } from "../2_connection.js";
 import { Transport } from "./0_transport.js";
 export declare class TransportAbridged extends Transport implements Transport {
-    private readonly connection;
-    private readonly obfuscated;
+    #private;
     constructor(connection: Connection, obfuscated?: boolean);
     initialize(): Promise<void>;
     receive(): Promise<Uint8Array>;