@mtcute/web 0.17.0 → 0.18.0-rc.5

package/client.cjs

@@ -0,0 +1,39 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const client_js = require("@mtcute/core/client.js");
+const crypto = require("./crypto.cjs");
+const index = require("./idb/index.cjs");
+const platform = require("./platform.cjs");
+const websocket = require("./websocket.cjs");
+class BaseTelegramClient extends client_js.BaseTelegramClient {
+  constructor(opts) {
+    super({
+      crypto: new crypto.WebCryptoProvider(),
+      transport: new websocket.WebSocketTransport(),
+      platform: new platform.WebPlatform(),
+      ...opts,
+      storage: typeof opts.storage === "string" ? new index.IdbStorage(opts.storage) : opts.storage ?? new index.IdbStorage("client.session")
+    });
+  }
+}
+class TelegramClient extends client_js.TelegramClient {
+  constructor(opts) {
+    if ("client" in opts) {
+      super(opts);
+      return;
+    }
+    super({
+      client: new BaseTelegramClient(opts),
+      disableUpdates: opts.disableUpdates,
+      skipConversationUpdates: opts.skipConversationUpdates,
+      updates: opts.updates
+    });
+  }
+}
+exports.BaseTelegramClient = BaseTelegramClient;
+exports.TelegramClient = TelegramClient;

package/client.d.ts

@@ -1,7 +1,7 @@
 import { ITelegramStorageProvider, PartialOnly } from '@mtcute/core';
 import { BaseTelegramClientOptions as BaseTelegramClientOptionsBase, TelegramClientOptions, BaseTelegramClient as BaseTelegramClientBase, TelegramClient as TelegramClientBase } from '@mtcute/core/client.js';
 export type { TelegramClientOptions };
-export interface BaseTelegramClientOptions extends PartialOnly<Omit<BaseTelegramClientOptionsBase, 'storage'>, 'transport' | 'crypto'> {
+export interface BaseTelegramClientOptions extends PartialOnly<Omit<BaseTelegramClientOptionsBase, 'storage'>, 'transport' | 'crypto' | 'platform'> {
     /**
      * Storage to use for this client.
      *
@@ -11,13 +11,6 @@ export interface BaseTelegramClientOptions extends PartialOnly<Omit<BaseTelegram
      * @default `"client.session"`
      */
     storage?: string | ITelegramStorageProvider;
-    /**
-     * **ADVANCED USE ONLY**
-     *
-     * Whether to not set up the platform.
-     * This is useful if you call `setPlatform` yourself.
-     */
-    platformless?: boolean;
 }
 export declare class BaseTelegramClient extends BaseTelegramClientBase {
     constructor(opts: BaseTelegramClientOptions);

package/client.js

@@ -0,0 +1,34 @@
+import { BaseTelegramClient as BaseTelegramClient$1, TelegramClient as TelegramClient$1 } from "@mtcute/core/client.js";
+import { WebCryptoProvider } from "./crypto.js";
+import { IdbStorage } from "./idb/index.js";
+import { WebPlatform } from "./platform.js";
+import { WebSocketTransport } from "./websocket.js";
+class BaseTelegramClient extends BaseTelegramClient$1 {
+  constructor(opts) {
+    super({
+      crypto: new WebCryptoProvider(),
+      transport: new WebSocketTransport(),
+      platform: new WebPlatform(),
+      ...opts,
+      storage: typeof opts.storage === "string" ? new IdbStorage(opts.storage) : opts.storage ?? new IdbStorage("client.session")
+    });
+  }
+}
+class TelegramClient extends TelegramClient$1 {
+  constructor(opts) {
+    if ("client" in opts) {
+      super(opts);
+      return;
+    }
+    super({
+      client: new BaseTelegramClient(opts),
+      disableUpdates: opts.disableUpdates,
+      skipConversationUpdates: opts.skipConversationUpdates,
+      updates: opts.updates
+    });
+  }
+}
+export {
+  BaseTelegramClient,
+  TelegramClient
+};

package/common-internals-web/logging.cjs

@@ -0,0 +1,48 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const BASE_FORMAT = "%s [%c%s%c] [%c%s%c] ";
+const LEVEL_NAMES = [
+  "",
+  // OFF
+  "ERR",
+  "WRN",
+  "INF",
+  "DBG",
+  "VRB"
+];
+const COLORS = [
+  "",
+  // OFF
+  "color: #7a5f9d",
+  "color: #8d7041",
+  "color: #396c9e",
+  "color: #437761",
+  "color: #7a5f9d"
+];
+const TAG_COLORS = [
+  "color: #437761",
+  "color: #537a36",
+  "color: #8d7041",
+  "color: #396c9e",
+  "color: #7a5f9d",
+  "color: #7a5f9d"
+];
+const defaultLoggingHandler = (color, level, tag, fmt, args) => {
+  console.log(
+    BASE_FORMAT + fmt,
+    (/* @__PURE__ */ new Date()).toISOString(),
+    COLORS[level],
+    LEVEL_NAMES[level],
+    "",
+    TAG_COLORS[color],
+    tag,
+    "",
+    ...args
+  );
+};
+exports.defaultLoggingHandler = defaultLoggingHandler;

package/common-internals-web/logging.js

@@ -0,0 +1,43 @@
+const BASE_FORMAT = "%s [%c%s%c] [%c%s%c] ";
+const LEVEL_NAMES = [
+  "",
+  // OFF
+  "ERR",
+  "WRN",
+  "INF",
+  "DBG",
+  "VRB"
+];
+const COLORS = [
+  "",
+  // OFF
+  "color: #7a5f9d",
+  "color: #8d7041",
+  "color: #396c9e",
+  "color: #437761",
+  "color: #7a5f9d"
+];
+const TAG_COLORS = [
+  "color: #437761",
+  "color: #537a36",
+  "color: #8d7041",
+  "color: #396c9e",
+  "color: #7a5f9d",
+  "color: #7a5f9d"
+];
+const defaultLoggingHandler = (color, level, tag, fmt, args) => {
+  console.log(
+    BASE_FORMAT + fmt,
+    (/* @__PURE__ */ new Date()).toISOString(),
+    COLORS[level],
+    LEVEL_NAMES[level],
+    "",
+    TAG_COLORS[color],
+    tag,
+    "",
+    ...args
+  );
+};
+export {
+  defaultLoggingHandler
+};

package/crypto.cjs

@@ -0,0 +1,84 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils_js = require("@mtcute/core/utils.js");
+const wasm = require("@mtcute/wasm");
+const wasm$1 = require("./wasm.cjs");
+const ALGO_TO_SUBTLE = {
+  sha256: "SHA-256",
+  sha1: "SHA-1",
+  sha512: "SHA-512"
+};
+class WebCryptoProvider extends utils_js.BaseCryptoProvider {
+  crypto;
+  _wasmInput;
+  sha1(data) {
+    return wasm.sha1(data);
+  }
+  sha256(data) {
+    return wasm.sha256(data);
+  }
+  createAesCtr(key, iv) {
+    const ctx = wasm.createCtr256(key, iv);
+    return {
+      process: (data) => wasm.ctr256(ctx, data),
+      close: () => wasm.freeCtr256(ctx)
+    };
+  }
+  createAesIge(key, iv) {
+    return {
+      encrypt: (data) => wasm.ige256Encrypt(data, key, iv),
+      decrypt: (data) => wasm.ige256Decrypt(data, key, iv)
+    };
+  }
+  gzip(data, maxSize) {
+    return wasm.deflateMaxSize(data, maxSize);
+  }
+  gunzip(data) {
+    return wasm.gunzip(data);
+  }
+  constructor(params) {
+    super();
+    const crypto = params?.crypto ?? globalThis.crypto;
+    if (!crypto || !crypto.subtle) {
+      throw new Error("WebCrypto is not available");
+    }
+    this.crypto = crypto;
+    this._wasmInput = params?.wasmInput;
+  }
+  async initialize() {
+    wasm.initSync(await wasm$1.loadWasmBinary(this._wasmInput));
+  }
+  async pbkdf2(password, salt, iterations, keylen, algo) {
+    const keyMaterial = await this.crypto.subtle.importKey("raw", password, "PBKDF2", false, ["deriveBits"]);
+    return this.crypto.subtle.deriveBits(
+      {
+        name: "PBKDF2",
+        salt,
+        iterations,
+        hash: algo ? ALGO_TO_SUBTLE[algo] : "SHA-512"
+      },
+      keyMaterial,
+      (keylen || 64) * 8
+    ).then((result) => new Uint8Array(result));
+  }
+  async hmacSha256(data, key) {
+    const keyMaterial = await this.crypto.subtle.importKey(
+      "raw",
+      key,
+      { name: "HMAC", hash: { name: "SHA-256" } },
+      false,
+      ["sign"]
+    );
+    const res = await this.crypto.subtle.sign({ name: "HMAC" }, keyMaterial, data);
+    return new Uint8Array(res);
+  }
+  randomFill(buf) {
+    this.crypto.getRandomValues(buf);
+  }
+}
+exports.WebCryptoProvider = WebCryptoProvider;

package/crypto.js

@@ -0,0 +1,79 @@
+import { BaseCryptoProvider } from "@mtcute/core/utils.js";
+import { sha1, sha256, createCtr256, freeCtr256, ctr256, ige256Decrypt, ige256Encrypt, deflateMaxSize, gunzip, initSync } from "@mtcute/wasm";
+import { loadWasmBinary } from "./wasm.js";
+const ALGO_TO_SUBTLE = {
+  sha256: "SHA-256",
+  sha1: "SHA-1",
+  sha512: "SHA-512"
+};
+class WebCryptoProvider extends BaseCryptoProvider {
+  crypto;
+  _wasmInput;
+  sha1(data) {
+    return sha1(data);
+  }
+  sha256(data) {
+    return sha256(data);
+  }
+  createAesCtr(key, iv) {
+    const ctx = createCtr256(key, iv);
+    return {
+      process: (data) => ctr256(ctx, data),
+      close: () => freeCtr256(ctx)
+    };
+  }
+  createAesIge(key, iv) {
+    return {
+      encrypt: (data) => ige256Encrypt(data, key, iv),
+      decrypt: (data) => ige256Decrypt(data, key, iv)
+    };
+  }
+  gzip(data, maxSize) {
+    return deflateMaxSize(data, maxSize);
+  }
+  gunzip(data) {
+    return gunzip(data);
+  }
+  constructor(params) {
+    super();
+    const crypto = params?.crypto ?? globalThis.crypto;
+    if (!crypto || !crypto.subtle) {
+      throw new Error("WebCrypto is not available");
+    }
+    this.crypto = crypto;
+    this._wasmInput = params?.wasmInput;
+  }
+  async initialize() {
+    initSync(await loadWasmBinary(this._wasmInput));
+  }
+  async pbkdf2(password, salt, iterations, keylen, algo) {
+    const keyMaterial = await this.crypto.subtle.importKey("raw", password, "PBKDF2", false, ["deriveBits"]);
+    return this.crypto.subtle.deriveBits(
+      {
+        name: "PBKDF2",
+        salt,
+        iterations,
+        hash: algo ? ALGO_TO_SUBTLE[algo] : "SHA-512"
+      },
+      keyMaterial,
+      (keylen || 64) * 8
+    ).then((result) => new Uint8Array(result));
+  }
+  async hmacSha256(data, key) {
+    const keyMaterial = await this.crypto.subtle.importKey(
+      "raw",
+      key,
+      { name: "HMAC", hash: { name: "SHA-256" } },
+      false,
+      ["sign"]
+    );
+    const res = await this.crypto.subtle.sign({ name: "HMAC" }, keyMaterial, data);
+    return new Uint8Array(res);
+  }
+  randomFill(buf) {
+    this.crypto.getRandomValues(buf);
+  }
+}
+export {
+  WebCryptoProvider
+};

package/exit-hook.cjs

@@ -0,0 +1,28 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const callbacks = /* @__PURE__ */ new Set();
+let registered = false;
+function beforeExit(fn) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  if (!registered) {
+    registered = true;
+    window.addEventListener("beforeunload", () => {
+      for (const callback of callbacks) {
+        callback();
+      }
+    });
+  }
+  callbacks.add(fn);
+  return () => {
+    callbacks.delete(fn);
+  };
+}
+exports.beforeExit = beforeExit;

package/exit-hook.js

@@ -0,0 +1,23 @@
+const callbacks = /* @__PURE__ */ new Set();
+let registered = false;
+function beforeExit(fn) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  if (!registered) {
+    registered = true;
+    window.addEventListener("beforeunload", () => {
+      for (const callback of callbacks) {
+        callback();
+      }
+    });
+  }
+  callbacks.add(fn);
+  return () => {
+    callbacks.delete(fn);
+  };
+}
+export {
+  beforeExit
+};

package/idb/driver.cjs

@@ -0,0 +1,123 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@mtcute/core");
+const utils = require("./utils.cjs");
+const REPO_VERSION_PREFIX = "__version:";
+class IdbStorageDriver extends core.BaseStorageDriver {
+  constructor(_dbName) {
+    super();
+    this._dbName = _dbName;
+    if (typeof indexedDB === "undefined") {
+      throw new core.MtUnsupportedError("IndexedDB is not available");
+    }
+  }
+  db;
+  _pendingWrites = [];
+  _pendingWritesOses = /* @__PURE__ */ new Set();
+  _migrations = /* @__PURE__ */ new Map();
+  _maxVersion = /* @__PURE__ */ new Map();
+  registerMigration(repo, version, migration) {
+    if (this.loaded) {
+      throw new Error("Cannot register migrations after loading");
+    }
+    let map = this._migrations.get(repo);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this._migrations.set(repo, map);
+    }
+    if (map.has(version)) {
+      throw new Error(`Migration for ${repo} version ${version} is already registered`);
+    }
+    map.set(version, migration);
+    const prevMax = this._maxVersion.get(repo) ?? 0;
+    if (version > prevMax) {
+      this._maxVersion.set(repo, version);
+    }
+  }
+  writeLater(os, obj) {
+    this._pendingWrites.push([os, obj]);
+    this._pendingWritesOses.add(os);
+  }
+  async _load() {
+    this.db = await new Promise((resolve, reject) => {
+      const req = indexedDB.open(this._dbName, Date.now());
+      req.onerror = () => reject(req.error);
+      const postUpgrade = [];
+      req.onsuccess = async () => {
+        try {
+          for (const cb of postUpgrade) {
+            await cb(req.result);
+          }
+          resolve(req.result);
+        } catch (e) {
+          reject(e);
+        }
+      };
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        const didUpgrade = /* @__PURE__ */ new Set();
+        const doUpgrade = (repo, fromVersion) => {
+          const migrations = this._migrations.get(repo);
+          if (!migrations) return;
+          const targetVer = this._maxVersion.get(repo);
+          while (fromVersion < targetVer) {
+            const nextVersion = fromVersion + 1;
+            const migration = migrations.get(nextVersion);
+            if (!migration) {
+              throw new Error(`No migration for ${repo} to version ${nextVersion}`);
+            }
+            const result = migration(db);
+            if (result) {
+              postUpgrade.push(result);
+            }
+            fromVersion = nextVersion;
+          }
+          didUpgrade.add(repo);
+          db.createObjectStore(`${REPO_VERSION_PREFIX}${repo}:${targetVer}`);
+        };
+        for (const key of db.objectStoreNames) {
+          if (!key.startsWith(REPO_VERSION_PREFIX)) continue;
+          const [, repo, version] = key.split(":");
+          const currentVer = Number(version);
+          db.deleteObjectStore(key);
+          doUpgrade(repo, currentVer);
+          didUpgrade.add(repo);
+        }
+        for (const repo of this._migrations.keys()) {
+          if (didUpgrade.has(repo)) continue;
+          doUpgrade(repo, 0);
+        }
+      };
+    });
+  }
+  async _save() {
+    if (this._pendingWritesOses.size === 0) return;
+    const writes = this._pendingWrites;
+    const oses = this._pendingWritesOses;
+    this._pendingWrites = [];
+    this._pendingWritesOses = /* @__PURE__ */ new Set();
+    const tx = this.db.transaction(oses, "readwrite");
+    const osMap = /* @__PURE__ */ new Map();
+    for (const table of oses) {
+      osMap.set(table, tx.objectStore(table));
+    }
+    for (const [table, obj] of writes) {
+      const os = osMap.get(table);
+      if (obj === null) {
+        os.delete(table);
+      } else {
+        os.put(obj);
+      }
+    }
+    await utils.txToPromise(tx);
+  }
+  _destroy() {
+    this.db.close();
+  }
+}
+exports.IdbStorageDriver = IdbStorageDriver;

package/idb/driver.js

@@ -0,0 +1,118 @@
+import { BaseStorageDriver, MtUnsupportedError } from "@mtcute/core";
+import { txToPromise } from "./utils.js";
+const REPO_VERSION_PREFIX = "__version:";
+class IdbStorageDriver extends BaseStorageDriver {
+  constructor(_dbName) {
+    super();
+    this._dbName = _dbName;
+    if (typeof indexedDB === "undefined") {
+      throw new MtUnsupportedError("IndexedDB is not available");
+    }
+  }
+  db;
+  _pendingWrites = [];
+  _pendingWritesOses = /* @__PURE__ */ new Set();
+  _migrations = /* @__PURE__ */ new Map();
+  _maxVersion = /* @__PURE__ */ new Map();
+  registerMigration(repo, version, migration) {
+    if (this.loaded) {
+      throw new Error("Cannot register migrations after loading");
+    }
+    let map = this._migrations.get(repo);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this._migrations.set(repo, map);
+    }
+    if (map.has(version)) {
+      throw new Error(`Migration for ${repo} version ${version} is already registered`);
+    }
+    map.set(version, migration);
+    const prevMax = this._maxVersion.get(repo) ?? 0;
+    if (version > prevMax) {
+      this._maxVersion.set(repo, version);
+    }
+  }
+  writeLater(os, obj) {
+    this._pendingWrites.push([os, obj]);
+    this._pendingWritesOses.add(os);
+  }
+  async _load() {
+    this.db = await new Promise((resolve, reject) => {
+      const req = indexedDB.open(this._dbName, Date.now());
+      req.onerror = () => reject(req.error);
+      const postUpgrade = [];
+      req.onsuccess = async () => {
+        try {
+          for (const cb of postUpgrade) {
+            await cb(req.result);
+          }
+          resolve(req.result);
+        } catch (e) {
+          reject(e);
+        }
+      };
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        const didUpgrade = /* @__PURE__ */ new Set();
+        const doUpgrade = (repo, fromVersion) => {
+          const migrations = this._migrations.get(repo);
+          if (!migrations) return;
+          const targetVer = this._maxVersion.get(repo);
+          while (fromVersion < targetVer) {
+            const nextVersion = fromVersion + 1;
+            const migration = migrations.get(nextVersion);
+            if (!migration) {
+              throw new Error(`No migration for ${repo} to version ${nextVersion}`);
+            }
+            const result = migration(db);
+            if (result) {
+              postUpgrade.push(result);
+            }
+            fromVersion = nextVersion;
+          }
+          didUpgrade.add(repo);
+          db.createObjectStore(`${REPO_VERSION_PREFIX}${repo}:${targetVer}`);
+        };
+        for (const key of db.objectStoreNames) {
+          if (!key.startsWith(REPO_VERSION_PREFIX)) continue;
+          const [, repo, version] = key.split(":");
+          const currentVer = Number(version);
+          db.deleteObjectStore(key);
+          doUpgrade(repo, currentVer);
+          didUpgrade.add(repo);
+        }
+        for (const repo of this._migrations.keys()) {
+          if (didUpgrade.has(repo)) continue;
+          doUpgrade(repo, 0);
+        }
+      };
+    });
+  }
+  async _save() {
+    if (this._pendingWritesOses.size === 0) return;
+    const writes = this._pendingWrites;
+    const oses = this._pendingWritesOses;
+    this._pendingWrites = [];
+    this._pendingWritesOses = /* @__PURE__ */ new Set();
+    const tx = this.db.transaction(oses, "readwrite");
+    const osMap = /* @__PURE__ */ new Map();
+    for (const table of oses) {
+      osMap.set(table, tx.objectStore(table));
+    }
+    for (const [table, obj] of writes) {
+      const os = osMap.get(table);
+      if (obj === null) {
+        os.delete(table);
+      } else {
+        os.put(obj);
+      }
+    }
+    await txToPromise(tx);
+  }
+  _destroy() {
+    this.db.close();
+  }
+}
+export {
+  IdbStorageDriver
+};

package/idb/index.cjs

@@ -0,0 +1,29 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const driver = require("./driver.cjs");
+const authKeys = require("./repository/auth-keys.cjs");
+const kv = require("./repository/kv.cjs");
+const peers = require("./repository/peers.cjs");
+const refMessages = require("./repository/ref-messages.cjs");
+class IdbStorage {
+  constructor(dbName) {
+    this.dbName = dbName;
+    this.driver = new driver.IdbStorageDriver(this.dbName);
+    this.kv = new kv.IdbKvRepository(this.driver);
+    this.authKeys = new authKeys.IdbAuthKeysRepository(this.driver);
+    this.peers = new peers.IdbPeersRepository(this.driver);
+    this.refMessages = new refMessages.IdbRefMsgRepository(this.driver);
+  }
+  driver;
+  kv;
+  authKeys;
+  peers;
+  refMessages;
+}
+exports.IdbStorageDriver = driver.IdbStorageDriver;
+exports.IdbStorage = IdbStorage;