@mtcute/web 0.17.0 → 0.18.0

package/methods.cjs

@@ -1,7 +1,7 @@
 if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
   globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
-  console.warn("[@mtcute/web] CommonJS support is deprecated and will be removed soon. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
-  console.warn("[@mtcute/web] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+  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" });

package/package.json

@@ -1,11 +1,15 @@
 {
     "name": "@mtcute/web",
     "type": "module",
-    "version": "0.17.0",
+    "version": "0.18.0",
     "description": "Meta-package for the web platform",
-    "author": "alina sireneva <alina@tei.su>",
     "license": "MIT",
-    "sideEffects": false,
+    "dependencies": {
+        "@mtcute/core": "^0.18.0",
+        "@mtcute/wasm": "^0.18.0",
+        "@fuman/net": "0.0.4",
+        "events": "3.2.0"
+    },
     "exports": {
         ".": {
             "import": {
@@ -38,12 +42,8 @@
             }
         }
     },
-    "scripts": {},
-    "dependencies": {
-        "@mtcute/core": "^0.17.0",
-        "@mtcute/wasm": "^0.17.0",
-        "events": "3.2.0"
-    },
+    "author": "alina sireneva <alina@tei.su>",
+    "sideEffects": false,
     "denoJson": {
         "compilerOptions": {
             "lib": [
@@ -56,6 +56,7 @@
     "homepage": "https://mtcute.dev",
     "repository": {
         "type": "git",
-        "url": "https://github.com/mtcute/mtcute"
-    }
+        "url": "git+https://github.com/mtcute/mtcute.git"
+    },
+    "scripts": {}
 }

package/platform.cjs

@@ -0,0 +1,41 @@
+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 logging = require("./common-internals-web/logging.cjs");
+const exitHook = require("./exit-hook.cjs");
+class WebPlatform {
+  getDeviceModel() {
+    if (typeof navigator === "undefined") return "Browser";
+    return navigator.userAgent;
+  }
+  getDefaultLogLevel() {
+    if (typeof localStorage !== "undefined") {
+      const localLogLevel = Number.parseInt(localStorage.MTCUTE_LOG_LEVEL);
+      if (!Number.isNaN(localLogLevel)) {
+        return localLogLevel;
+      }
+    }
+    return null;
+  }
+  onNetworkChanged(fn) {
+    if (!("onLine" in navigator)) return () => {
+    };
+    const onlineHandler = () => fn(navigator.onLine);
+    window.addEventListener("online", onlineHandler);
+    window.addEventListener("offline", onlineHandler);
+    return () => {
+      window.removeEventListener("online", onlineHandler);
+      window.removeEventListener("offline", onlineHandler);
+    };
+  }
+  isOnline() {
+    return navigator.onLine;
+  }
+}
+WebPlatform.prototype.log = logging.defaultLoggingHandler;
+WebPlatform.prototype.beforeExit = exitHook.beforeExit;
+exports.WebPlatform = WebPlatform;

package/platform.d.cts

@@ -0,0 +1,11 @@
+import { ICorePlatform } from '@mtcute/core';
+import { defaultLoggingHandler } from './common-internals-web/logging.js';
+import { beforeExit } from './exit-hook.js';
+export declare class WebPlatform implements ICorePlatform {
+    log: typeof defaultLoggingHandler;
+    beforeExit: typeof beforeExit;
+    getDeviceModel(): string;
+    getDefaultLogLevel(): number | null;
+    onNetworkChanged(fn: (connected: boolean) => void): () => void;
+    isOnline(): boolean;
+}

package/platform.d.ts

@@ -1,8 +1,5 @@
-import { ICorePlatform } from '@mtcute/core/platform.js';
-import { base64Decode, base64Encode } from './common-internals-web/base64.js';
-import { hexDecode, hexEncode } from './common-internals-web/hex.js';
+import { ICorePlatform } from '@mtcute/core';
 import { defaultLoggingHandler } from './common-internals-web/logging.js';
-import { utf8ByteLength, utf8Decode, utf8Encode } from './common-internals-web/utf8.js';
 import { beforeExit } from './exit-hook.js';
 export declare class WebPlatform implements ICorePlatform {
     log: typeof defaultLoggingHandler;
@@ -11,11 +8,4 @@ export declare class WebPlatform implements ICorePlatform {
     getDefaultLogLevel(): number | null;
     onNetworkChanged(fn: (connected: boolean) => void): () => void;
     isOnline(): boolean;
-    utf8ByteLength: typeof utf8ByteLength;
-    utf8Encode: typeof utf8Encode;
-    utf8Decode: typeof utf8Decode;
-    hexEncode: typeof hexEncode;
-    hexDecode: typeof hexDecode;
-    base64Encode: typeof base64Encode;
-    base64Decode: typeof base64Decode;
 }

package/platform.js

@@ -0,0 +1,36 @@
+import { defaultLoggingHandler } from "./common-internals-web/logging.js";
+import { beforeExit } from "./exit-hook.js";
+class WebPlatform {
+  getDeviceModel() {
+    if (typeof navigator === "undefined") return "Browser";
+    return navigator.userAgent;
+  }
+  getDefaultLogLevel() {
+    if (typeof localStorage !== "undefined") {
+      const localLogLevel = Number.parseInt(localStorage.MTCUTE_LOG_LEVEL);
+      if (!Number.isNaN(localLogLevel)) {
+        return localLogLevel;
+      }
+    }
+    return null;
+  }
+  onNetworkChanged(fn) {
+    if (!("onLine" in navigator)) return () => {
+    };
+    const onlineHandler = () => fn(navigator.onLine);
+    window.addEventListener("online", onlineHandler);
+    window.addEventListener("offline", onlineHandler);
+    return () => {
+      window.removeEventListener("online", onlineHandler);
+      window.removeEventListener("offline", onlineHandler);
+    };
+  }
+  isOnline() {
+    return navigator.onLine;
+  }
+}
+WebPlatform.prototype.log = defaultLoggingHandler;
+WebPlatform.prototype.beforeExit = beforeExit;
+export {
+  WebPlatform
+};

package/utils.cjs

@@ -1,7 +1,7 @@
 if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
   globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
-  console.warn("[@mtcute/web] CommonJS support is deprecated and will be removed soon. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
-  console.warn("[@mtcute/web] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+  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" });

package/wasm.cjs

@@ -0,0 +1,38 @@
+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 wasm = require("@mtcute/wasm");
+async function loadWasmBinary(input) {
+  if (typeof input === "undefined") {
+    input = wasm.getWasmUrl();
+  }
+  if (typeof input === "string" || typeof Request === "function" && input instanceof Request || typeof URL === "function" && input instanceof URL) {
+    input = await fetch(input);
+  }
+  if (typeof Response === "function" && input instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        const { instance: instance2 } = await WebAssembly.instantiateStreaming(input);
+        return instance2;
+      } catch (e) {
+        if (input.headers.get("Content-Type") !== "application/wasm") {
+          console.warn(
+            "`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n",
+            e
+          );
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await input.arrayBuffer();
+    const { instance } = await WebAssembly.instantiate(bytes);
+    return instance;
+  }
+  return WebAssembly.instantiate(input);
+}
+exports.loadWasmBinary = loadWasmBinary;

package/wasm.d.cts

@@ -0,0 +1,2 @@
+export type WasmInitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+export declare function loadWasmBinary(input?: WasmInitInput): Promise<WebAssembly.Instance>;

package/wasm.js

@@ -0,0 +1,33 @@
+import { getWasmUrl } from "@mtcute/wasm";
+async function loadWasmBinary(input) {
+  if (typeof input === "undefined") {
+    input = getWasmUrl();
+  }
+  if (typeof input === "string" || typeof Request === "function" && input instanceof Request || typeof URL === "function" && input instanceof URL) {
+    input = await fetch(input);
+  }
+  if (typeof Response === "function" && input instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        const { instance: instance2 } = await WebAssembly.instantiateStreaming(input);
+        return instance2;
+      } catch (e) {
+        if (input.headers.get("Content-Type") !== "application/wasm") {
+          console.warn(
+            "`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n",
+            e
+          );
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await input.arrayBuffer();
+    const { instance } = await WebAssembly.instantiate(bytes);
+    return instance;
+  }
+  return WebAssembly.instantiate(input);
+}
+export {
+  loadWasmBinary
+};

package/websocket.cjs

@@ -0,0 +1,50 @@
+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 net = require("@fuman/net");
+const core = require("@mtcute/core");
+const subdomainsMap = {
+  1: "pluto",
+  2: "venus",
+  3: "aurora",
+  4: "vesta",
+  5: "flora"
+};
+class WebSocketTransport {
+  _baseDomain;
+  _subdomains;
+  _WebSocket;
+  constructor({
+    ws = WebSocket,
+    baseDomain = "web.telegram.org",
+    subdomains = subdomainsMap
+  } = {}) {
+    if (!ws) {
+      throw new core.MtUnsupportedError(
+        "To use WebSocket transport with NodeJS, install `ws` package and pass it to constructor"
+      );
+    }
+    if ("default" in ws) {
+      ws = ws.default;
+    }
+    this._baseDomain = baseDomain;
+    this._subdomains = subdomains;
+    this._WebSocket = ws;
+  }
+  async connect(dc) {
+    const url = `wss://${this._subdomains[dc.id]}.${this._baseDomain}/apiws${dc.testMode ? "_test" : ""}`;
+    return net.connectWs({
+      url,
+      implementation: this._WebSocket,
+      protocols: "binary"
+    });
+  }
+  packetCodec() {
+    return new core.ObfuscatedPacketCodec(new core.IntermediatePacketCodec());
+  }
+}
+exports.WebSocketTransport = WebSocketTransport;

package/websocket.d.cts

@@ -0,0 +1,18 @@
+import { WebSocketConstructor } from '@fuman/net';
+import { IPacketCodec, ITelegramConnection, TelegramTransport } from '@mtcute/core';
+import { BasicDcOption } from './utils.js';
+export declare class WebSocketTransport implements TelegramTransport {
+    private _baseDomain;
+    private _subdomains;
+    private _WebSocket;
+    constructor({ ws, baseDomain, subdomains, }?: {
+        /** Custom implementation of WebSocket (e.g. https://npm.im/ws) */
+        ws?: WebSocketConstructor;
+        /** Base WebSocket domain */
+        baseDomain?: string;
+        /** Map of sub-domains (key is DC ID, value is string) */
+        subdomains?: Record<string, string>;
+    });
+    connect(dc: BasicDcOption): Promise<ITelegramConnection>;
+    packetCodec(): IPacketCodec;
+}

package/websocket.d.ts

@@ -1,21 +1,7 @@
-import { default as EventEmitter } from 'events';
-import { IPacketCodec, ITelegramTransport, ObfuscatedPacketCodec, TransportState } from '@mtcute/core';
-import { BasicDcOption, ICryptoProvider, Logger } from '@mtcute/core/utils.js';
-export interface WebSocketConstructor {
-    new (address: string, protocol?: string): WebSocket;
-}
-/**
- * Base for WebSocket transports.
- * Subclasses must provide packet codec in `_packetCodec` property
- */
-export declare abstract class BaseWebSocketTransport extends EventEmitter implements ITelegramTransport {
-    private _currentDc;
-    private _state;
-    private _socket;
-    private _crypto;
-    protected log: Logger;
-    abstract _packetCodec: IPacketCodec;
-    packetCodecInitialized: boolean;
+import { WebSocketConstructor } from '@fuman/net';
+import { IPacketCodec, ITelegramConnection, TelegramTransport } from '@mtcute/core';
+import { BasicDcOption } from './utils.js';
+export declare class WebSocketTransport implements TelegramTransport {
     private _baseDomain;
     private _subdomains;
     private _WebSocket;
@@ -27,20 +13,6 @@ export declare abstract class BaseWebSocketTransport extends EventEmitter implem
         /** Map of sub-domains (key is DC ID, value is string) */
         subdomains?: Record<string, string>;
     });
-    private _updateLogPrefix;
-    setup(crypto: ICryptoProvider, log: Logger): void;
-    state(): TransportState;
-    currentDc(): BasicDcOption | null;
-    connect(dc: BasicDcOption, testMode: boolean): void;
-    private _closeWaiters;
-    close(): Promise<void>;
-    handleClosed(): void;
-    handleError(event: Event | {
-        error: Error;
-    }): void;
-    handleConnect(): void;
-    send(bytes: Uint8Array): Promise<void>;
-}
-export declare class WebSocketTransport extends BaseWebSocketTransport {
-    _packetCodec: ObfuscatedPacketCodec;
+    connect(dc: BasicDcOption): Promise<ITelegramConnection>;
+    packetCodec(): IPacketCodec;
 }

package/websocket.js

@@ -0,0 +1,45 @@
+import { connectWs } from "@fuman/net";
+import { MtUnsupportedError, ObfuscatedPacketCodec, IntermediatePacketCodec } from "@mtcute/core";
+const subdomainsMap = {
+  1: "pluto",
+  2: "venus",
+  3: "aurora",
+  4: "vesta",
+  5: "flora"
+};
+class WebSocketTransport {
+  _baseDomain;
+  _subdomains;
+  _WebSocket;
+  constructor({
+    ws = WebSocket,
+    baseDomain = "web.telegram.org",
+    subdomains = subdomainsMap
+  } = {}) {
+    if (!ws) {
+      throw new MtUnsupportedError(
+        "To use WebSocket transport with NodeJS, install `ws` package and pass it to constructor"
+      );
+    }
+    if ("default" in ws) {
+      ws = ws.default;
+    }
+    this._baseDomain = baseDomain;
+    this._subdomains = subdomains;
+    this._WebSocket = ws;
+  }
+  async connect(dc) {
+    const url = `wss://${this._subdomains[dc.id]}.${this._baseDomain}/apiws${dc.testMode ? "_test" : ""}`;
+    return connectWs({
+      url,
+      implementation: this._WebSocket,
+      protocols: "binary"
+    });
+  }
+  packetCodec() {
+    return new ObfuscatedPacketCodec(new IntermediatePacketCodec());
+  }
+}
+export {
+  WebSocketTransport
+};

package/worker.cjs

@@ -0,0 +1,116 @@
+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 worker_js = require("@mtcute/core/worker.js");
+const platform$1 = require("./platform.cjs");
+let _registered = false;
+class TelegramWorker extends worker_js.TelegramWorker {
+  registerWorker(handler) {
+    if (_registered) {
+      throw new Error("TelegramWorker must be created only once");
+    }
+    _registered = true;
+    if (typeof SharedWorkerGlobalScope !== "undefined" && self instanceof SharedWorkerGlobalScope) {
+      const connections = [];
+      const broadcast = (message) => {
+        for (const port of connections) {
+          port.postMessage(message);
+        }
+      };
+      self.onconnect = (event) => {
+        const port = event.ports[0];
+        connections.push(port);
+        const respond = port.postMessage.bind(port);
+        const onClose = () => {
+          port.close();
+          const idx = connections.indexOf(port);
+          if (idx >= 0) {
+            connections.splice(connections.indexOf(port), 1);
+          }
+        };
+        const onTimeout = () => {
+          console.warn("some connection timed out!");
+          respond({ __type__: "timeout" });
+          onClose();
+        };
+        let timeout = setTimeout(onTimeout, 6e4);
+        port.addEventListener("message", (message) => {
+          if (message.data.__type__ === "close") {
+            onClose();
+            return;
+          }
+          if (message.data.__type__ === "ping") {
+            clearTimeout(timeout);
+            timeout = setTimeout(onTimeout, 6e4);
+            return;
+          }
+          handler(message.data, respond);
+        });
+        port.start();
+      };
+      return broadcast;
+    }
+    if (typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope) {
+      const respond = self.postMessage.bind(self);
+      self.addEventListener("message", (message) => handler(message.data, respond));
+      return respond;
+    }
+    throw new Error("TelegramWorker must be created from a worker");
+  }
+}
+const platform = /* @__PURE__ */ new platform$1.WebPlatform();
+class TelegramWorkerPort extends worker_js.TelegramWorkerPort {
+  constructor(options) {
+    super({
+      worker: options.worker,
+      platform
+    });
+  }
+  connectToWorker(worker, handler) {
+    if (worker instanceof Worker) {
+      const send = worker.postMessage.bind(worker);
+      const messageHandler = (ev) => {
+        handler(ev.data);
+      };
+      worker.addEventListener("message", messageHandler);
+      return [
+        send,
+        () => {
+          worker.removeEventListener("message", messageHandler);
+        }
+      ];
+    }
+    if (worker instanceof SharedWorker) {
+      const send = worker.port.postMessage.bind(worker.port);
+      const pingInterval = setInterval(() => {
+        worker.port.postMessage({ __type__: "ping" });
+      }, 1e4);
+      const messageHandler = (ev) => {
+        if (ev.data.__type__ === "timeout") {
+          location.reload();
+          return;
+        }
+        handler(ev.data);
+      };
+      worker.port.addEventListener("message", messageHandler);
+      worker.port.start();
+      let cancelBeforeExit;
+      const close = () => {
+        clearInterval(pingInterval);
+        worker.port.postMessage({ __type__: "close" });
+        worker.port.removeEventListener("message", messageHandler);
+        worker.port.close();
+        cancelBeforeExit();
+      };
+      cancelBeforeExit = platform.beforeExit(close);
+      return [send, close];
+    }
+    throw new Error("Only workers and shared workers are supported");
+  }
+}
+exports.TelegramWorker = TelegramWorker;
+exports.TelegramWorkerPort = TelegramWorkerPort;

package/worker.d.cts

@@ -0,0 +1,12 @@
+import { ClientMessageHandler, RespondFn, SendFn, SomeWorker, TelegramWorkerOptions, WorkerCustomMethods, WorkerMessageHandler, TelegramWorker as TelegramWorkerBase, TelegramWorkerPort as TelegramWorkerPortBase } from '@mtcute/core/worker.js';
+export type { TelegramWorkerOptions, WorkerCustomMethods };
+export interface TelegramWorkerPortOptions {
+    worker: SomeWorker;
+}
+export declare class TelegramWorker<T extends WorkerCustomMethods> extends TelegramWorkerBase<T> {
+    registerWorker(handler: WorkerMessageHandler): RespondFn;
+}
+export declare class TelegramWorkerPort<T extends WorkerCustomMethods> extends TelegramWorkerPortBase<T> {
+    constructor(options: TelegramWorkerPortOptions);
+    connectToWorker(worker: SomeWorker, handler: ClientMessageHandler): [SendFn, () => void];
+}

package/worker.d.ts

@@ -1,10 +1,12 @@
-import { ClientMessageHandler, RespondFn, SendFn, SomeWorker, TelegramWorkerOptions, TelegramWorkerPortOptions, WorkerCustomMethods, WorkerMessageHandler, TelegramWorker as TelegramWorkerBase, TelegramWorkerPort as TelegramWorkerPortBase } from '@mtcute/core/worker.js';
-export type { TelegramWorkerOptions, TelegramWorkerPortOptions, WorkerCustomMethods };
+import { ClientMessageHandler, RespondFn, SendFn, SomeWorker, TelegramWorkerOptions, WorkerCustomMethods, WorkerMessageHandler, TelegramWorker as TelegramWorkerBase, TelegramWorkerPort as TelegramWorkerPortBase } from '@mtcute/core/worker.js';
+export type { TelegramWorkerOptions, WorkerCustomMethods };
+export interface TelegramWorkerPortOptions {
+    worker: SomeWorker;
+}
 export declare class TelegramWorker<T extends WorkerCustomMethods> extends TelegramWorkerBase<T> {
     registerWorker(handler: WorkerMessageHandler): RespondFn;
 }
 export declare class TelegramWorkerPort<T extends WorkerCustomMethods> extends TelegramWorkerPortBase<T> {
-    readonly options: TelegramWorkerPortOptions;
     constructor(options: TelegramWorkerPortOptions);
     connectToWorker(worker: SomeWorker, handler: ClientMessageHandler): [SendFn, () => void];
 }