penpal 7.0.3 → 7.0.4

package/lib/connect.js

@@ -1,76 +0,0 @@
-import PenpalError from './PenpalError.js';
-import shakeHands from './shakeHands.js';
-import { isDestroyMessage, isMessage } from './guards.js';
-import once from './once.js';
-import namespace from './namespace.js';
-const usedMessengers = new WeakSet();
-/**
- * Attempts to establish communication with the remote.
- */
-const connect = ({ messenger, methods = {}, timeout, channel, log, }) => {
-    if (!messenger) {
-        throw new PenpalError('INVALID_ARGUMENT', 'messenger must be defined');
-    }
-    if (usedMessengers.has(messenger)) {
-        throw new PenpalError('INVALID_ARGUMENT', 'A messenger can only be used for a single connection');
-    }
-    usedMessengers.add(messenger);
-    const connectionDestroyedHandlers = [messenger.destroy];
-    const destroyConnection = once((notifyOtherParticipant) => {
-        if (notifyOtherParticipant) {
-            const destroyMessage = {
-                namespace,
-                channel,
-                type: 'DESTROY',
-            };
-            try {
-                messenger.sendMessage(destroyMessage);
-            }
-            catch (_) {
-                // We do our best to notify the other participant of the connection, but
-                // if there's an error in doing so (e.g., maybe the handshake hasn't
-                // completed and a messenger can't send the message), it's probably not
-                // worth bothering the consumer with an error.
-            }
-        }
-        for (const connectionDestroyedHandler of connectionDestroyedHandlers) {
-            connectionDestroyedHandler();
-        }
-        log?.('Connection destroyed');
-    });
-    const validateReceivedMessage = (data) => {
-        return isMessage(data) && data.channel === channel;
-    };
-    const promise = (async () => {
-        try {
-            messenger.initialize({ log, validateReceivedMessage });
-            messenger.addMessageHandler((message) => {
-                if (isDestroyMessage(message)) {
-                    destroyConnection(false);
-                }
-            });
-            const { remoteProxy, destroy } = await shakeHands({
-                messenger,
-                methods,
-                timeout,
-                channel,
-                log,
-            });
-            connectionDestroyedHandlers.push(destroy);
-            return remoteProxy;
-        }
-        catch (error) {
-            destroyConnection(true);
-            throw error;
-        }
-    })();
-    return {
-        promise,
-        // Why we don't reject the connection promise when consumer calls destroy():
-        // https://github.com/Aaronius/penpal/issues/51
-        destroy: () => {
-            destroyConnection(true);
-        },
-    };
-};
-export default connect;

package/lib/connectCallHandler.d.ts

@@ -1,8 +0,0 @@
-import { Methods, Log } from './types.js';
-import Messenger from './messengers/Messenger.js';
-/**
- * Listens for "call" messages from the remote, executes the corresponding method,
- * and responds with the return value or error.
- */
-declare const connectCallHandler: (messenger: Messenger, methods: Methods, channel: string | undefined, log: Log | undefined) => () => void;
-export default connectCallHandler;

package/lib/connectCallHandler.js

@@ -1,88 +0,0 @@
-import { serializeError } from './errorSerialization.js';
-import Reply from './Reply.js';
-import PenpalError from './PenpalError.js';
-import { formatMethodPath, getMethodAtMethodPath, } from './methodSerialization.js';
-import { isCallMessage } from './guards.js';
-import namespace from './namespace.js';
-const createErrorReplyMessage = (channel, callId, error) => ({
-    namespace,
-    channel,
-    type: 'REPLY',
-    callId,
-    isError: true,
-    ...(error instanceof Error
-        ? { value: serializeError(error), isSerializedErrorInstance: true }
-        : { value: error }),
-});
-/**
- * Listens for "call" messages from the remote, executes the corresponding method,
- * and responds with the return value or error.
- */
-const connectCallHandler = (messenger, methods, channel, log) => {
-    let isDestroyed = false;
-    const handleMessage = async (message) => {
-        if (isDestroyed) {
-            // It's possible to throw an error here, but it would only be catchable
-            // using window.onerror since we're in an asynchronously-called function.
-            // There is no method call the consumer is making that they could wrap in
-            // a try-catch. Even if the consumer were to catch the error somehow,
-            // the value of doing so is questionable.
-            return;
-        }
-        if (!isCallMessage(message)) {
-            return;
-        }
-        log?.(`Received ${formatMethodPath(message.methodPath)}() call`, message);
-        const { methodPath, args, id: callId } = message;
-        let replyMessage;
-        let transferables;
-        try {
-            const method = getMethodAtMethodPath(methodPath, methods);
-            if (!method) {
-                throw new PenpalError('METHOD_NOT_FOUND', `Method \`${formatMethodPath(methodPath)}\` is not found.`);
-            }
-            let value = await method(...args);
-            if (value instanceof Reply) {
-                transferables = value.transferables;
-                value = await value.value;
-            }
-            replyMessage = {
-                namespace,
-                channel,
-                type: 'REPLY',
-                callId,
-                value,
-            };
-        }
-        catch (error) {
-            replyMessage = createErrorReplyMessage(channel, callId, error);
-        }
-        // Although we checked this at the beginning of the function, we need to
-        // check it again because we've made async calls, and the connection may
-        // have been destroyed in the meantime.
-        if (isDestroyed) {
-            return;
-        }
-        try {
-            log?.(`Sending ${formatMethodPath(methodPath)}() reply`, replyMessage);
-            messenger.sendMessage(replyMessage, transferables);
-        }
-        catch (error) {
-            // If a consumer attempts to send an object that's not
-            // cloneable (e.g., window), we want to ensure the receiver's promise
-            // gets rejected.
-            if (error.name === 'DataCloneError') {
-                replyMessage = createErrorReplyMessage(channel, callId, error);
-                log?.(`Sending ${formatMethodPath(methodPath)}() reply`, replyMessage);
-                messenger.sendMessage(replyMessage);
-            }
-            throw error;
-        }
-    };
-    messenger.addMessageHandler(handleMessage);
-    return () => {
-        isDestroyed = true;
-        messenger.removeMessageHandler(handleMessage);
-    };
-};
-export default connectCallHandler;

package/lib/connectRemoteProxy.d.ts

@@ -1,12 +0,0 @@
-import { RemoteProxy, Methods, Log } from './types.js';
-import Messenger from './messengers/Messenger.js';
-/**
- * Creates a proxy. When methods are called on the proxy, a "call" message will
- * be sent to the remote, the remote's corresponding method will be
- * executed, and the method's return value will be returned via a message.
- */
-declare const connectRemoteProxy: <TMethods extends Methods>(messenger: Messenger, channel: string | undefined, log: Log | undefined) => {
-    remoteProxy: RemoteProxy<TMethods>;
-    destroy: () => void;
-};
-export default connectRemoteProxy;

package/lib/connectRemoteProxy.js

@@ -1,137 +0,0 @@
-import generateId from './generateId.js';
-import { deserializeError } from './errorSerialization.js';
-import { formatMethodPath } from './methodSerialization.js';
-import CallOptions from './CallOptions.js';
-import PenpalError from './PenpalError.js';
-import { isReplyMessage } from './guards.js';
-import namespace from './namespace.js';
-const methodsToTreatAsNative = new Set(['apply', 'call', 'bind']);
-const createRemoteProxy = (callback, log, path = []) => {
-    return new Proxy(path.length
-        ? () => {
-            // Intentionally empty
-        }
-        : Object.create(null), {
-        get(target, prop) {
-            // If a promise is resolved with this proxy object, the JavaScript
-            // runtime will look for a `then` property on this object to determine
-            // if it should be treated as a promise (to support promise chaining).
-            // If we don't return undefined here, the JavaScript runtime will treat
-            // this object as a promise and attempt to call `then`, which will
-            // then send a call message to the remote. This is not what we want.
-            if (prop === 'then') {
-                return;
-            }
-            // Because we're using a proxy and because Penpal supports developers
-            // exposing nested methods, we have a predicament. If a developer
-            // calls, for example, remote.auth.apply(), are they
-            // attempting to call a nested apply() method that a developer has
-            // explicitly exposed from the remote? Could they instead be attempting
-            // to call Function.prototype.apply() on the remote.auth() method?
-            // Without the remote telling the local Penpal which methods the
-            // developer has exposed, it has no way of knowing (and the main reason
-            // we use a proxy is so that Penpal doesn't have to communicate which
-            // methods are exposed). So, we treat certain methods as native methods
-            // and return the native method rather than a proxy. The downside of
-            // this is that if a developer has explicitly exposed a nested method
-            // with the same name as one of these native method names, the developer
-            // will be unable to call the exposed remote method because they will
-            // be calling the method on the Function prototype instead.
-            if (path.length && methodsToTreatAsNative.has(prop)) {
-                return Reflect.get(target, prop);
-            }
-            return createRemoteProxy(callback, log, [...path, prop]);
-        },
-        apply(target, _thisArg, args) {
-            return callback(path, args);
-        },
-    });
-};
-const getDestroyedConnectionMethodCallError = (methodPath) => {
-    return new PenpalError('CONNECTION_DESTROYED', `Method call ${formatMethodPath(methodPath)}() failed due to destroyed connection`);
-};
-/**
- * Creates a proxy. When methods are called on the proxy, a "call" message will
- * be sent to the remote, the remote's corresponding method will be
- * executed, and the method's return value will be returned via a message.
- */
-const connectRemoteProxy = (messenger, channel, log) => {
-    let isDestroyed = false;
-    const replyHandlers = new Map();
-    const handleMessage = (message) => {
-        if (!isReplyMessage(message)) {
-            return;
-        }
-        const { callId, value, isError, isSerializedErrorInstance } = message;
-        const replyHandler = replyHandlers.get(callId);
-        if (!replyHandler) {
-            return;
-        }
-        replyHandlers.delete(callId);
-        log?.(`Received ${formatMethodPath(replyHandler.methodPath)}() call`, message);
-        if (isError) {
-            replyHandler.reject(isSerializedErrorInstance ? deserializeError(value) : value);
-        }
-        else {
-            replyHandler.resolve(value);
-        }
-    };
-    messenger.addMessageHandler(handleMessage);
-    const remoteProxy = createRemoteProxy((methodPath, args) => {
-        if (isDestroyed) {
-            throw getDestroyedConnectionMethodCallError(methodPath);
-        }
-        const callId = generateId();
-        const lastArg = args[args.length - 1];
-        const lastArgIsOptions = lastArg instanceof CallOptions;
-        const { timeout, transferables } = lastArgIsOptions ? lastArg : {};
-        const argsWithoutOptions = lastArgIsOptions ? args.slice(0, -1) : args;
-        return new Promise((resolve, reject) => {
-            // We reference `window.setTimeout` instead of just `setTimeout`
-            // so that the TypeScript engine doesn't
-            // get confused when running tests. Something within
-            // Karma + @rollup/plugin-typescript leaks node types into source
-            // files when running tests. Node's setTimeout has a return type of
-            // Timeout rather than number, resulting in a build error when
-            // running tests if we don't disambiguate the browser setTimeout
-            // from node's setTimeout. There may be a better way to configure
-            // Karma + Rollup + Typescript to avoid node type leakage.
-            const timeoutId = timeout !== undefined
-                ? window.setTimeout(() => {
-                    replyHandlers.delete(callId);
-                    reject(new PenpalError('METHOD_CALL_TIMEOUT', `Method call ${formatMethodPath(methodPath)}() timed out after ${timeout}ms`));
-                }, timeout)
-                : undefined;
-            replyHandlers.set(callId, { methodPath, resolve, reject, timeoutId });
-            try {
-                const callMessage = {
-                    namespace,
-                    channel,
-                    type: 'CALL',
-                    id: callId,
-                    methodPath,
-                    args: argsWithoutOptions,
-                };
-                log?.(`Sending ${formatMethodPath(methodPath)}() call`, callMessage);
-                messenger.sendMessage(callMessage, transferables);
-            }
-            catch (error) {
-                reject(new PenpalError('TRANSMISSION_FAILED', error.message));
-            }
-        });
-    }, log);
-    const destroy = () => {
-        isDestroyed = true;
-        messenger.removeMessageHandler(handleMessage);
-        for (const { methodPath, reject, timeoutId } of replyHandlers.values()) {
-            clearTimeout(timeoutId);
-            reject(getDestroyedConnectionMethodCallError(methodPath));
-        }
-        replyHandlers.clear();
-    };
-    return {
-        remoteProxy,
-        destroy,
-    };
-};
-export default connectRemoteProxy;

package/lib/debug.d.ts

@@ -1,3 +0,0 @@
-import { Log } from './types.js';
-declare const debug: (prefix?: string) => Log;
-export default debug;

package/lib/debug.js

@@ -1,6 +0,0 @@
-const debug = (prefix) => {
-    return (...args) => {
-        console.log(`✍️ %c${prefix}%c`, 'font-weight: bold;', '', ...args);
-    };
-};
-export default debug;

package/lib/errorSerialization.d.ts

@@ -1,9 +0,0 @@
-import { SerializedError } from './types.js';
-/**
- * Converts an error object into a plain object.
- */
-export declare const serializeError: (error: Error) => SerializedError;
-/**
- * Converts a plain object into an error object.
- */
-export declare const deserializeError: ({ name, message, stack, penpalCode, }: SerializedError) => Error;

package/lib/errorSerialization.js

@@ -1,21 +0,0 @@
-import PenpalError from './PenpalError.js';
-/**
- * Converts an error object into a plain object.
- */
-export const serializeError = (error) => ({
-    name: error.name,
-    message: error.message,
-    stack: error.stack,
-    penpalCode: error instanceof PenpalError ? error.code : undefined,
-});
-/**
- * Converts a plain object into an error object.
- */
-export const deserializeError = ({ name, message, stack, penpalCode, }) => {
-    const deserializedError = penpalCode
-        ? new PenpalError(penpalCode, message)
-        : new Error(message);
-    deserializedError.name = name;
-    deserializedError.stack = stack;
-    return deserializedError;
-};

package/lib/generateId.d.ts

@@ -1,8 +0,0 @@
-/**
- * @return A unique ID
- */
-declare const _default: {
-    (): `${string}-${string}-${string}-${string}-${string}`;
-    (): `${string}-${string}-${string}-${string}-${string}`;
-};
-export default _default;

package/lib/generateId.js

@@ -1,9 +0,0 @@
-/**
- * @return A unique ID
- */
-// crypto.randomUUID is not available in insecure contexts.
-export default crypto.randomUUID?.bind(crypto) ??
-    (() => new Array(4)
-        .fill(0)
-        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))
-        .join('-'));

package/lib/getPromiseWithResolvers.d.ts

@@ -1,6 +0,0 @@
-declare const getPromiseWithResolvers: <ResolvedValueType, RejectedValueType>() => {
-    promise: Promise<ResolvedValueType>;
-    resolve: (value: ResolvedValueType) => void;
-    reject: (error: RejectedValueType) => void;
-};
-export default getPromiseWithResolvers;

package/lib/getPromiseWithResolvers.js

@@ -1,17 +0,0 @@
-// Just use the native Promise.withResolvers() once it gains a bit more
-// adoption. Safari was the last major browser to support it, which happened
-// on March 5, 2024 in Safari 17.4.
-const getPromiseWithResolvers = () => {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-    });
-    return {
-        promise,
-        resolve: resolve,
-        reject: reject,
-    };
-};
-export default getPromiseWithResolvers;

package/lib/guards.d.ts

@@ -1,10 +0,0 @@
-import { Ack2Message, CallMessage, Message, ReplyMessage, Ack1Message, SynMessage, DestroyMessage } from './types.js';
-export declare const isObject: (value: unknown) => value is Record<string | number | symbol, unknown>;
-export declare const isFunction: (value: unknown) => value is Function;
-export declare const isMessage: (data: unknown) => data is Message;
-export declare const isSynMessage: (message: Message) => message is SynMessage;
-export declare const isAck1Message: (message: Message) => message is Ack1Message;
-export declare const isAck2Message: (message: Message) => message is Ack2Message;
-export declare const isCallMessage: (message: Message) => message is CallMessage;
-export declare const isReplyMessage: (message: Message) => message is ReplyMessage;
-export declare const isDestroyMessage: (message: Message) => message is DestroyMessage;

package/lib/guards.js

@@ -1,28 +0,0 @@
-import namespace from './namespace.js';
-export const isObject = (value) => {
-    return typeof value === 'object' && value !== null;
-};
-export const isFunction = (value) => {
-    return typeof value === 'function';
-};
-export const isMessage = (data) => {
-    return isObject(data) && data.namespace === namespace;
-};
-export const isSynMessage = (message) => {
-    return message.type === 'SYN';
-};
-export const isAck1Message = (message) => {
-    return message.type === 'ACK1';
-};
-export const isAck2Message = (message) => {
-    return message.type === 'ACK2';
-};
-export const isCallMessage = (message) => {
-    return message.type === 'CALL';
-};
-export const isReplyMessage = (message) => {
-    return message.type === 'REPLY';
-};
-export const isDestroyMessage = (message) => {
-    return message.type === 'DESTROY';
-};

package/lib/index.d.ts

@@ -1,12 +0,0 @@
-export { default as connect } from './connect.js';
-export { default as WindowMessenger } from './messengers/WindowMessenger.js';
-export { default as WorkerMessenger } from './messengers/WorkerMessenger.js';
-export { default as PortMessenger } from './messengers/PortMessenger.js';
-export { default as CallOptions } from './CallOptions.js';
-export { default as Reply } from './Reply.js';
-export { default as PenpalError } from './PenpalError.js';
-export { default as ErrorCode } from './ErrorCodeObj.js';
-export { default as debug } from './debug.js';
-export { Connection, RemoteProxy, Methods } from './types.js';
-export { default as Messenger, InitializeMessengerOptions, MessageHandler, } from './messengers/Messenger.js';
-export { Log, Message, SynMessage, Ack1Message, Ack2Message, CallMessage, ReplyMessage, DestroyMessage, } from './types.js';

package/lib/index.js

@@ -1,9 +0,0 @@
-export { default as connect } from './connect.js';
-export { default as WindowMessenger } from './messengers/WindowMessenger.js';
-export { default as WorkerMessenger } from './messengers/WorkerMessenger.js';
-export { default as PortMessenger } from './messengers/PortMessenger.js';
-export { default as CallOptions } from './CallOptions.js';
-export { default as Reply } from './Reply.js';
-export { default as PenpalError } from './PenpalError.js';
-export { default as ErrorCode } from './ErrorCodeObj.js';
-export { default as debug } from './debug.js';

package/lib/indexForBundle.d.ts

@@ -1,31 +0,0 @@
-import WindowMessenger from './messengers/WindowMessenger.js';
-import WorkerMessenger from './messengers/WorkerMessenger.js';
-import PortMessenger from './messengers/PortMessenger.js';
-import CallOptions from './CallOptions.js';
-import Reply from './Reply.js';
-import PenpalError from './PenpalError.js';
-declare const _default: {
-    connect: <TMethods extends import("./types.js").Methods>({ messenger, methods, timeout, channel, log, }: {
-        messenger: import("./index.js").Messenger;
-        methods?: import("./types.js").Methods;
-        timeout?: number;
-        channel?: string;
-        log?: import("./types.js").Log;
-    }) => import("./types.js").Connection<TMethods>;
-    WindowMessenger: typeof WindowMessenger;
-    WorkerMessenger: typeof WorkerMessenger;
-    PortMessenger: typeof PortMessenger;
-    CallOptions: typeof CallOptions;
-    Reply: typeof Reply;
-    PenpalError: typeof PenpalError;
-    debug: (prefix?: string) => import("./types.js").Log;
-    ErrorCode: {
-        readonly ConnectionDestroyed: "CONNECTION_DESTROYED";
-        readonly ConnectionTimeout: "CONNECTION_TIMEOUT";
-        readonly InvalidArgument: "INVALID_ARGUMENT";
-        readonly MethodCallTimeout: "METHOD_CALL_TIMEOUT";
-        readonly MethodNotFound: "METHOD_NOT_FOUND";
-        readonly TransmissionFailed: "TRANSMISSION_FAILED";
-    };
-};
-export default _default;

package/lib/indexForBundle.js

@@ -1,20 +0,0 @@
-import connect from './connect.js';
-import WindowMessenger from './messengers/WindowMessenger.js';
-import WorkerMessenger from './messengers/WorkerMessenger.js';
-import PortMessenger from './messengers/PortMessenger.js';
-import CallOptions from './CallOptions.js';
-import Reply from './Reply.js';
-import PenpalError from './PenpalError.js';
-import ErrorCode from './ErrorCodeObj.js';
-import debug from './debug.js';
-export default {
-    connect,
-    WindowMessenger,
-    WorkerMessenger,
-    PortMessenger,
-    CallOptions,
-    Reply,
-    PenpalError,
-    debug,
-    ErrorCode,
-};

package/lib/messengers/Messenger.d.ts

@@ -1,14 +0,0 @@
-import { Message, Log } from '../types.js';
-export type MessageHandler = (message: Message) => void;
-export type InitializeMessengerOptions = {
-    log?: Log;
-    validateReceivedMessage: (data: unknown) => data is Message;
-};
-interface Messenger {
-    sendMessage: (message: Message, transferables?: Transferable[]) => void;
-    addMessageHandler: (callback: MessageHandler) => void;
-    removeMessageHandler: (callback: MessageHandler) => void;
-    initialize: (options: InitializeMessengerOptions) => void;
-    destroy: () => void;
-}
-export default Messenger;

package/lib/messengers/Messenger.js

@@ -1 +0,0 @@
-export {};

package/lib/messengers/PortMessenger.d.ts

@@ -1,21 +0,0 @@
-import { Message } from '../types.js';
-import Messenger, { InitializeMessengerOptions, MessageHandler } from './Messenger.js';
-type Options = {
-    /**
-     * The port used to communicate to the other port of the port pair.
-     */
-    port: MessagePort;
-};
-/**
- * Handles the details of communicating on a MessagePort.
- */
-declare class PortMessenger implements Messenger {
-    #private;
-    constructor({ port }: Options);
-    initialize: ({ validateReceivedMessage }: InitializeMessengerOptions) => void;
-    sendMessage: (message: Message, transferables?: Transferable[]) => void;
-    addMessageHandler: (callback: MessageHandler) => void;
-    removeMessageHandler: (callback: MessageHandler) => void;
-    destroy: () => void;
-}
-export default PortMessenger;

package/lib/messengers/PortMessenger.js

@@ -1,45 +0,0 @@
-import PenpalError from '../PenpalError.js';
-/**
- * Handles the details of communicating on a MessagePort.
- */
-class PortMessenger {
-    #port;
-    #validateReceivedMessage;
-    #messageCallbacks = new Set();
-    constructor({ port }) {
-        if (!port) {
-            throw new PenpalError('INVALID_ARGUMENT', 'port must be defined');
-        }
-        this.#port = port;
-    }
-    initialize = ({ validateReceivedMessage }) => {
-        this.#validateReceivedMessage = validateReceivedMessage;
-        this.#port.addEventListener('message', this.#handleMessage);
-        this.#port.start();
-    };
-    sendMessage = (message, transferables) => {
-        this.#port?.postMessage(message, {
-            transfer: transferables,
-        });
-    };
-    addMessageHandler = (callback) => {
-        this.#messageCallbacks.add(callback);
-    };
-    removeMessageHandler = (callback) => {
-        this.#messageCallbacks.delete(callback);
-    };
-    destroy = () => {
-        this.#port.removeEventListener('message', this.#handleMessage);
-        this.#port.close();
-        this.#messageCallbacks.clear();
-    };
-    #handleMessage = ({ data }) => {
-        if (!this.#validateReceivedMessage?.(data)) {
-            return;
-        }
-        for (const callback of this.#messageCallbacks) {
-            callback(data);
-        }
-    };
-}
-export default PortMessenger;

package/lib/messengers/WindowMessenger.d.ts

@@ -1,29 +0,0 @@
-import { Message } from '../types.js';
-import Messenger, { InitializeMessengerOptions, MessageHandler } from './Messenger.js';
-type Options = {
-    /**
-     * The window with which the current window will communicate.
-     */
-    remoteWindow: Window;
-    /**
-     * An array of strings or regular expressions defining to which origins
-     * communication will be allowed. If not provided, communication will be
-     * restricted to the origin of the current page. You may specify an allowed
-     * origin of `*` to not restrict communication, but beware the risks of
-     * doing so.
-     */
-    allowedOrigins?: (string | RegExp)[];
-};
-/**
- * Handles the details of communicating with a child window.
- */
-declare class WindowMessenger implements Messenger {
-    #private;
-    constructor({ remoteWindow, allowedOrigins }: Options);
-    initialize: ({ log, validateReceivedMessage, }: InitializeMessengerOptions) => void;
-    sendMessage: (message: Message, transferables?: Transferable[]) => void;
-    addMessageHandler: (callback: MessageHandler) => void;
-    removeMessageHandler: (callback: MessageHandler) => void;
-    destroy: () => void;
-}
-export default WindowMessenger;