penpal 7.0.3 → 7.0.4

package/lib/messengers/WindowMessenger.js

@@ -1,176 +0,0 @@
-import { downgradeMessage, isDeprecatedMessage, upgradeMessage, } from '../backwardCompatibility.js';
-import { isAck2Message, isAck1Message, isSynMessage } from '../guards.js';
-import PenpalError from '../PenpalError.js';
-import PenpalBugError from '../PenpalBugError.js';
-/**
- * Handles the details of communicating with a child window.
- */
-class WindowMessenger {
-    #remoteWindow;
-    #allowedOrigins;
-    #log;
-    #validateReceivedMessage;
-    #concreteRemoteOrigin;
-    #messageCallbacks = new Set();
-    #port;
-    // TODO: Used for backward-compatibility. Remove in next major version.
-    #isChildUsingDeprecatedProtocol = false;
-    constructor({ remoteWindow, allowedOrigins }) {
-        if (!remoteWindow) {
-            throw new PenpalError('INVALID_ARGUMENT', 'remoteWindow must be defined');
-        }
-        this.#remoteWindow = remoteWindow;
-        this.#allowedOrigins = allowedOrigins?.length
-            ? allowedOrigins
-            : [window.origin];
-    }
-    initialize = ({ log, validateReceivedMessage, }) => {
-        this.#log = log;
-        this.#validateReceivedMessage = validateReceivedMessage;
-        window.addEventListener('message', this.#handleMessageFromRemoteWindow);
-    };
-    sendMessage = (message, transferables) => {
-        if (isSynMessage(message)) {
-            const originForSending = this.#getOriginForSendingMessage(message);
-            this.#remoteWindow.postMessage(message, {
-                targetOrigin: originForSending,
-                transfer: transferables,
-            });
-            return;
-        }
-        if (isAck1Message(message) ||
-            // If the child is using a previous version of Penpal, we need to
-            // downgrade the message and send it through the window rather than
-            // the port because older versions of Penpal don't use MessagePorts.
-            this.#isChildUsingDeprecatedProtocol) {
-            const payload = this.#isChildUsingDeprecatedProtocol
-                ? downgradeMessage(message)
-                : message;
-            const originForSending = this.#getOriginForSendingMessage(message);
-            this.#remoteWindow.postMessage(payload, {
-                targetOrigin: originForSending,
-                transfer: transferables,
-            });
-            return;
-        }
-        if (isAck2Message(message)) {
-            const { port1, port2 } = new MessageChannel();
-            this.#port = port1;
-            port1.addEventListener('message', this.#handleMessageFromPort);
-            port1.start();
-            const transferablesToSend = [port2, ...(transferables || [])];
-            const originForSending = this.#getOriginForSendingMessage(message);
-            this.#remoteWindow.postMessage(message, {
-                targetOrigin: originForSending,
-                transfer: transferablesToSend,
-            });
-            return;
-        }
-        if (this.#port) {
-            this.#port.postMessage(message, {
-                transfer: transferables,
-            });
-            return;
-        }
-        throw new PenpalBugError('Port is undefined');
-    };
-    addMessageHandler = (callback) => {
-        this.#messageCallbacks.add(callback);
-    };
-    removeMessageHandler = (callback) => {
-        this.#messageCallbacks.delete(callback);
-    };
-    destroy = () => {
-        window.removeEventListener('message', this.#handleMessageFromRemoteWindow);
-        this.#destroyPort();
-        this.#messageCallbacks.clear();
-    };
-    #isAllowedOrigin = (origin) => {
-        return this.#allowedOrigins.some((allowedOrigin) => allowedOrigin instanceof RegExp
-            ? allowedOrigin.test(origin)
-            : allowedOrigin === origin || allowedOrigin === '*');
-    };
-    #getOriginForSendingMessage = (message) => {
-        // It's safe to send the SYN message to any origin because it doesn't contain
-        // anything sensitive. When Penpal receives a SYN message, the origin on
-        // the message (which we call the concrete origin) is validated against the
-        // configured allowed origins. All subsequent messages will be sent to the
-        // concrete origin.
-        // If you decide to change this, consider https://github.com/Aaronius/penpal/issues/103
-        if (isSynMessage(message)) {
-            return '*';
-        }
-        if (!this.#concreteRemoteOrigin) {
-            throw new PenpalBugError('Concrete remote origin not set');
-        }
-        // If the concrete remote origin (the origin we received from the remote
-        // on a prior message) is 'null', it means the remote is within
-        // an "opaque origin". The only way to post a message to an
-        // opaque origin is by using '*'. This does carry some security risk,
-        // so we only do this if the consumer has specifically defined '*' as
-        // an allowed origin. Opaque origins occur, for example, when
-        // loading an HTML document directly from the filesystem (not a
-        // web server) or through a data URI.
-        return this.#concreteRemoteOrigin === 'null' &&
-            this.#allowedOrigins.includes('*')
-            ? '*'
-            : this.#concreteRemoteOrigin;
-    };
-    #destroyPort = () => {
-        this.#port?.removeEventListener('message', this.#handleMessageFromPort);
-        this.#port?.close();
-        this.#port = undefined;
-    };
-    #handleMessageFromRemoteWindow = ({ source, origin, ports, data, }) => {
-        if (source !== this.#remoteWindow) {
-            return;
-        }
-        // TODO: Used for backward-compatibility. Remove in next major version.
-        if (isDeprecatedMessage(data)) {
-            this.#log?.('Please upgrade the child window to the latest version of Penpal.');
-            this.#isChildUsingDeprecatedProtocol = true;
-            data = upgradeMessage(data);
-        }
-        if (!this.#validateReceivedMessage?.(data)) {
-            return;
-        }
-        if (!this.#isAllowedOrigin(origin)) {
-            this.#log?.(`Received a message from origin \`${origin}\` which did not match ` +
-                `allowed origins \`[${this.#allowedOrigins.join(', ')}]\``);
-            return;
-        }
-        if (isSynMessage(data)) {
-            // If we receive a SYN message and already have a port, it means
-            // the child is re-connecting, in which case we'll receive a new port.
-            // For this reason, we always make sure we destroy the existing port.
-            this.#destroyPort();
-            this.#concreteRemoteOrigin = origin;
-        }
-        if (isAck2Message(data) &&
-            // Previous versions of Penpal don't use MessagePorts and do all
-            // communication through the window.
-            !this.#isChildUsingDeprecatedProtocol) {
-            this.#port = ports[0];
-            if (!this.#port) {
-                throw new PenpalBugError('No port received on ACK2');
-            }
-            this.#port.addEventListener('message', this.#handleMessageFromPort);
-            this.#port.start();
-        }
-        for (const callback of this.#messageCallbacks) {
-            callback(data);
-        }
-    };
-    #handleMessageFromPort = ({ data }) => {
-        // Unlike in _handleMessageFromWindow, we don't need to check if
-        // the message is from a deprecated version of Penpal because older versions
-        // of Penpal don't use MessagePorts.
-        if (!this.#validateReceivedMessage?.(data)) {
-            return;
-        }
-        for (const callback of this.#messageCallbacks) {
-            callback(data);
-        }
-    };
-}
-export default WindowMessenger;

package/lib/messengers/WorkerMessenger.d.ts

@@ -1,23 +0,0 @@
-import { Message } from '../types.js';
-import Messenger, { InitializeMessengerOptions, MessageHandler } from './Messenger.js';
-type Options = {
-    /**
-     * The web worker receiving/sending communication from/to the parent window.
-     * If this messenger is being used within the worker, `worker` should
-     * typically be set to `self`.
-     */
-    worker: Worker | DedicatedWorkerGlobalScope;
-};
-/**
- * Handles the details of communicating with a child web worker.
- */
-declare class WorkerMessenger implements Messenger {
-    #private;
-    constructor({ worker }: Options);
-    initialize: ({ validateReceivedMessage }: InitializeMessengerOptions) => void;
-    sendMessage: (message: Message, transferables?: Transferable[]) => void;
-    addMessageHandler: (callback: MessageHandler) => void;
-    removeMessageHandler: (callback: MessageHandler) => void;
-    destroy: () => void;
-}
-export default WorkerMessenger;

package/lib/messengers/WorkerMessenger.js

@@ -1,84 +0,0 @@
-import { isAck2Message, isAck1Message, isSynMessage } from '../guards.js';
-import PenpalError from '../PenpalError.js';
-import PenpalBugError from '../PenpalBugError.js';
-/**
- * Handles the details of communicating with a child web worker.
- */
-class WorkerMessenger {
-    #worker;
-    #validateReceivedMessage;
-    #messageCallbacks = new Set();
-    #port;
-    constructor({ worker }) {
-        if (!worker) {
-            throw new PenpalError('INVALID_ARGUMENT', 'worker must be defined');
-        }
-        this.#worker = worker;
-    }
-    initialize = ({ validateReceivedMessage }) => {
-        this.#validateReceivedMessage = validateReceivedMessage;
-        this.#worker.addEventListener('message', this.#handleMessage);
-    };
-    sendMessage = (message, transferables) => {
-        if (isSynMessage(message) || isAck1Message(message)) {
-            this.#worker.postMessage(message, { transfer: transferables });
-            return;
-        }
-        if (isAck2Message(message)) {
-            const { port1, port2 } = new MessageChannel();
-            this.#port = port1;
-            port1.addEventListener('message', this.#handleMessage);
-            port1.start();
-            this.#worker.postMessage(message, {
-                transfer: [port2, ...(transferables || [])],
-            });
-            return;
-        }
-        if (this.#port) {
-            this.#port.postMessage(message, {
-                transfer: transferables,
-            });
-            return;
-        }
-        throw new PenpalBugError('Port is undefined');
-    };
-    addMessageHandler = (callback) => {
-        this.#messageCallbacks.add(callback);
-    };
-    removeMessageHandler = (callback) => {
-        this.#messageCallbacks.delete(callback);
-    };
-    destroy = () => {
-        this.#worker.removeEventListener('message', this.#handleMessage);
-        this.#destroyPort();
-        this.#messageCallbacks.clear();
-    };
-    #destroyPort = () => {
-        this.#port?.removeEventListener('message', this.#handleMessage);
-        this.#port?.close();
-        this.#port = undefined;
-    };
-    #handleMessage = ({ ports, data }) => {
-        if (!this.#validateReceivedMessage?.(data)) {
-            return;
-        }
-        if (isSynMessage(data)) {
-            // If we receive a SYN message and already have a port, it means
-            // the child is re-connecting, in which case we'll receive a new port.
-            // For this reason, we always make sure we destroy the existing port.
-            this.#destroyPort();
-        }
-        if (isAck2Message(data)) {
-            this.#port = ports[0];
-            if (!this.#port) {
-                throw new PenpalBugError('No port received on ACK2');
-            }
-            this.#port.addEventListener('message', this.#handleMessage);
-            this.#port.start();
-        }
-        for (const callback of this.#messageCallbacks) {
-            callback(data);
-        }
-    };
-}
-export default WorkerMessenger;

package/lib/methodSerialization.d.ts

@@ -1,22 +0,0 @@
-import { MethodPath, Methods } from './types.js';
-/**
- * Given an object of (nested) keys to functions, extract paths to each function.
- *
- * @example
- * Given this Method object:
- * {
- *   one: {
- *     two: () => {}
- *   }
- *   three: () => {}
- * }
- *
- * the extracted MethodPath[] would be:
- * [
- *   ['one', 'two'],
- *   ['three']
- * ]
- */
-export declare const extractMethodPathsFromMethods: (methods: Methods, currentPath?: MethodPath) => MethodPath[];
-export declare const getMethodAtMethodPath: (methodPath: MethodPath, methods: Methods) => Function | undefined;
-export declare const formatMethodPath: (methodPath: MethodPath) => string;

package/lib/methodSerialization.js

@@ -1,42 +0,0 @@
-import { isFunction, isObject } from './guards.js';
-// TODO: Used for backward-compatibility. Remove in next major version.
-/**
- * Given an object of (nested) keys to functions, extract paths to each function.
- *
- * @example
- * Given this Method object:
- * {
- *   one: {
- *     two: () => {}
- *   }
- *   three: () => {}
- * }
- *
- * the extracted MethodPath[] would be:
- * [
- *   ['one', 'two'],
- *   ['three']
- * ]
- */
-export const extractMethodPathsFromMethods = (methods, currentPath = []) => {
-    const methodPaths = [];
-    for (const key of Object.keys(methods)) {
-        const value = methods[key];
-        if (isFunction(value)) {
-            methodPaths.push([...currentPath, key]);
-        }
-        else if (isObject(value)) {
-            methodPaths.push(...extractMethodPathsFromMethods(value, [...currentPath, key]));
-        }
-    }
-    return methodPaths;
-};
-export const getMethodAtMethodPath = (methodPath, methods) => {
-    const result = methodPath.reduce((acc, pathSegment) => {
-        return isObject(acc) ? acc[pathSegment] : undefined;
-    }, methods);
-    return isFunction(result) ? result : undefined;
-};
-export const formatMethodPath = (methodPath) => {
-    return methodPath.join('.');
-};

package/lib/namespace.d.ts

@@ -1,2 +0,0 @@
-declare const _default: "penpal";
-export default _default;

package/lib/namespace.js

@@ -1 +0,0 @@
-export default 'penpal';

package/lib/once.d.ts

@@ -1,2 +0,0 @@
-declare const once: <T extends (...args: any[]) => any>(fn: T) => ((...args: Parameters<T>) => ReturnType<T>);
-export default once;

package/lib/once.js

@@ -1,13 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const once = (fn) => {
-    let isCalled = false;
-    let result;
-    return (...args) => {
-        if (!isCalled) {
-            isCalled = true;
-            result = fn(...args);
-        }
-        return result;
-    };
-};
-export default once;

package/lib/shakeHands.d.ts

@@ -1,76 +0,0 @@
-import Messenger from './messengers/Messenger.js';
-import { Methods, RemoteProxy, Log } from './types.js';
-type Options = {
-    messenger: Messenger;
-    methods: Methods;
-    timeout: number | undefined;
-    channel: string | undefined;
-    log: Log | undefined;
-};
-type HandshakeResult<TMethods extends Methods> = {
-    remoteProxy: RemoteProxy<TMethods>;
-    destroy: () => void;
-};
-/**
- * Attempts to establish communication with the remote via a handshake protocol.
- * The handshake protocol fulfills a few requirements:
- *
- * 1. One participant in the handshake may not be available when the other
- *    participant starts the handshake. For example, a document inside an iframe
- *    may not be loaded when the parent window starts a handshake.
- * 2. While #1 could be solved by having the consumer of Penpal specify which
- *    participant should initiate the handshake, we'd rather avoid this
- *    unnecessary cognitive load.
- * 3. While #1 could be solved by having the consumer of Penpal specify which
- *    participant is the "parent" or "child" and then having Penpal assume
- *    the child should initiate the handshake, we'd rather avoid parent-child
- *    terminology since Penpal can support communication between two
- *    participants where neither would be considered a parent nor child. It may
- *    also be too presumptive that the child should always initiate the
- *    handshake.
- * 4. For robustness, each participant must know that the other participant is
- *    receiving its messages for the handshake to be considered complete.
- * 5. The handshake should support a participant attempting to
- *    re-establish the connection. This can occur, for example, if an end user
- *    were to right-click within an iframe and click reload.
- * 6. The handshake should allow a Messenger to easily attach something to
- *    a handshake message from one participant to the other unidirectionally
- *    (rather than from both participants to each other).
- *    This is important when a participant needs to be in charge of, for
- *    example, creating a MessageChannel and sending one MessagePort from the
- *    MessagePort pair to the other participant. If both participants attempted
- *    to do this it could lead to confusion.
- * 7. The handshake ideally shouldn't require sending handshake messages on an
- *    interval (retrying until the other participant is ready to receive them).
- *    Intervals can increase compute resources if the interval is too short
- *    or increase latency if the interval is too long. While we could make this
- *    configurable, it's additional mental load for the consumer. Additionally,
- *    setInterval and setTimeout are not available within some contexts
- *    (like AudioWorklet), where a consumer may like to use Penpal.
- *
- * To accomplish these requirements, the handshake protocol is as follows:
- * 1. Each participant generates a random participant ID.
- * 2. As soon as possible, each participant sends a SYN message containing its
- *    participant ID to the other participant.
- * 3. When the SYN messages were sent, one of the participants may not have
- *    been ready to receive the SYN message from the other. At least one
- *    of the participants was ready, however, and should have received a SYN
- *    message from the other participant. Each participant that did receive
- *    a SYN message knows for sure that the other participant is now ready
- *    to receive a SYN message, so it will send another SYN message in case
- *    the other participant did not receive the first SYN message. This
- *    ultimately results in each participant sending two SYN messages.
- * 4. Each participant now should have received at least one SYN message from
- *    the other participant. Each participant compares their own ID with the
- *    other participant's ID. Whichever participant has the higher ID
- *    (using a simple string comparison) is considered the handshake leader
- *    and will send an ACK1 message to the other participant.
- * 5. At this point, the handshake leader does not know whether the other
- *    participant is actually receiving messages. The participant receiving
- *    the ACK1 message will respond with an ACK2, informing the handshake
- *    leader that it is indeed receiving messages.
- * 6. At this point, both participants know the other is receiving messages
- *    and the handshake is complete.
- */
-declare const shakeHands: <TMethods extends Methods>({ messenger, methods, timeout, channel, log, }: Options) => Promise<HandshakeResult<TMethods>>;
-export default shakeHands;

package/lib/shakeHands.js

@@ -1,188 +0,0 @@
-import PenpalError from './PenpalError.js';
-import connectCallHandler from './connectCallHandler.js';
-import connectRemoteProxy from './connectRemoteProxy.js';
-import { isAck2Message, isAck1Message, isSynMessage } from './guards.js';
-import getPromiseWithResolvers from './getPromiseWithResolvers.js';
-import { extractMethodPathsFromMethods } from './methodSerialization.js';
-import generateId from './generateId.js';
-import { DEPRECATED_PENPAL_PARTICIPANT_ID } from './backwardCompatibility.js';
-import namespace from './namespace.js';
-/**
- * Attempts to establish communication with the remote via a handshake protocol.
- * The handshake protocol fulfills a few requirements:
- *
- * 1. One participant in the handshake may not be available when the other
- *    participant starts the handshake. For example, a document inside an iframe
- *    may not be loaded when the parent window starts a handshake.
- * 2. While #1 could be solved by having the consumer of Penpal specify which
- *    participant should initiate the handshake, we'd rather avoid this
- *    unnecessary cognitive load.
- * 3. While #1 could be solved by having the consumer of Penpal specify which
- *    participant is the "parent" or "child" and then having Penpal assume
- *    the child should initiate the handshake, we'd rather avoid parent-child
- *    terminology since Penpal can support communication between two
- *    participants where neither would be considered a parent nor child. It may
- *    also be too presumptive that the child should always initiate the
- *    handshake.
- * 4. For robustness, each participant must know that the other participant is
- *    receiving its messages for the handshake to be considered complete.
- * 5. The handshake should support a participant attempting to
- *    re-establish the connection. This can occur, for example, if an end user
- *    were to right-click within an iframe and click reload.
- * 6. The handshake should allow a Messenger to easily attach something to
- *    a handshake message from one participant to the other unidirectionally
- *    (rather than from both participants to each other).
- *    This is important when a participant needs to be in charge of, for
- *    example, creating a MessageChannel and sending one MessagePort from the
- *    MessagePort pair to the other participant. If both participants attempted
- *    to do this it could lead to confusion.
- * 7. The handshake ideally shouldn't require sending handshake messages on an
- *    interval (retrying until the other participant is ready to receive them).
- *    Intervals can increase compute resources if the interval is too short
- *    or increase latency if the interval is too long. While we could make this
- *    configurable, it's additional mental load for the consumer. Additionally,
- *    setInterval and setTimeout are not available within some contexts
- *    (like AudioWorklet), where a consumer may like to use Penpal.
- *
- * To accomplish these requirements, the handshake protocol is as follows:
- * 1. Each participant generates a random participant ID.
- * 2. As soon as possible, each participant sends a SYN message containing its
- *    participant ID to the other participant.
- * 3. When the SYN messages were sent, one of the participants may not have
- *    been ready to receive the SYN message from the other. At least one
- *    of the participants was ready, however, and should have received a SYN
- *    message from the other participant. Each participant that did receive
- *    a SYN message knows for sure that the other participant is now ready
- *    to receive a SYN message, so it will send another SYN message in case
- *    the other participant did not receive the first SYN message. This
- *    ultimately results in each participant sending two SYN messages.
- * 4. Each participant now should have received at least one SYN message from
- *    the other participant. Each participant compares their own ID with the
- *    other participant's ID. Whichever participant has the higher ID
- *    (using a simple string comparison) is considered the handshake leader
- *    and will send an ACK1 message to the other participant.
- * 5. At this point, the handshake leader does not know whether the other
- *    participant is actually receiving messages. The participant receiving
- *    the ACK1 message will respond with an ACK2, informing the handshake
- *    leader that it is indeed receiving messages.
- * 6. At this point, both participants know the other is receiving messages
- *    and the handshake is complete.
- */
-const shakeHands = ({ messenger, methods, timeout, channel, log, }) => {
-    const participantId = generateId();
-    let remoteParticipantId;
-    const destroyHandlers = [];
-    let isComplete = false;
-    const methodPaths = extractMethodPathsFromMethods(methods);
-    const { promise, resolve, reject } = getPromiseWithResolvers();
-    const timeoutId = timeout !== undefined
-        ? setTimeout(() => {
-            reject(new PenpalError('CONNECTION_TIMEOUT', `Connection timed out after ${timeout}ms`));
-        }, timeout)
-        : undefined;
-    const destroy = () => {
-        for (const destroyHandler of destroyHandlers) {
-            destroyHandler();
-        }
-    };
-    const connectCallHandlerAndMethodProxies = () => {
-        if (isComplete) {
-            // If we get here, it means the remote is attempting to re-connect. While
-            // that's supported, we don't need to run the rest of this function again.
-            return;
-        }
-        destroyHandlers.push(connectCallHandler(messenger, methods, channel, log));
-        const { remoteProxy, destroy: destroyMethodProxies } = connectRemoteProxy(messenger, channel, log);
-        destroyHandlers.push(destroyMethodProxies);
-        clearTimeout(timeoutId);
-        isComplete = true;
-        resolve({
-            remoteProxy,
-            destroy: destroy,
-        });
-    };
-    const sendSynMessage = () => {
-        const synMessage = {
-            namespace,
-            type: 'SYN',
-            channel,
-            participantId: participantId,
-        };
-        log?.(`Sending handshake SYN`, synMessage);
-        try {
-            messenger.sendMessage(synMessage);
-        }
-        catch (error) {
-            reject(new PenpalError('TRANSMISSION_FAILED', error.message));
-        }
-    };
-    const handleSynMessage = (message) => {
-        log?.(`Received handshake SYN`, message);
-        if (message.participantId === remoteParticipantId &&
-            // TODO: Used for backward-compatibility. Remove in next major version.
-            remoteParticipantId !== DEPRECATED_PENPAL_PARTICIPANT_ID) {
-            return;
-        }
-        remoteParticipantId = message.participantId;
-        // We send another SYN message in case the other participant was not ready
-        // when we sent the first SYN message.
-        sendSynMessage();
-        const isHandshakeLeader = participantId > remoteParticipantId ||
-            // TODO: Used for backward-compatibility. Remove in next major version.
-            remoteParticipantId === DEPRECATED_PENPAL_PARTICIPANT_ID;
-        if (!isHandshakeLeader) {
-            return;
-        }
-        const ack1Message = {
-            namespace,
-            channel,
-            type: 'ACK1',
-            methodPaths,
-        };
-        log?.(`Sending handshake ACK1`, ack1Message);
-        try {
-            messenger.sendMessage(ack1Message);
-        }
-        catch (error) {
-            reject(new PenpalError('TRANSMISSION_FAILED', error.message));
-            return;
-        }
-    };
-    const handleAck1Message = (message) => {
-        log?.(`Received handshake ACK1`, message);
-        const ack2Message = {
-            namespace,
-            channel,
-            type: 'ACK2',
-        };
-        log?.(`Sending handshake ACK2`, ack2Message);
-        try {
-            messenger.sendMessage(ack2Message);
-        }
-        catch (error) {
-            reject(new PenpalError('TRANSMISSION_FAILED', error.message));
-            return;
-        }
-        connectCallHandlerAndMethodProxies();
-    };
-    const handleAck2Message = (message) => {
-        log?.(`Received handshake ACK2`, message);
-        connectCallHandlerAndMethodProxies();
-    };
-    const handleMessage = (message) => {
-        if (isSynMessage(message)) {
-            handleSynMessage(message);
-        }
-        if (isAck1Message(message)) {
-            handleAck1Message(message);
-        }
-        if (isAck2Message(message)) {
-            handleAck2Message(message);
-        }
-    };
-    messenger.addMessageHandler(handleMessage);
-    destroyHandlers.push(() => messenger.removeMessageHandler(handleMessage));
-    sendSynMessage();
-    return promise;
-};
-export default shakeHands;