penpal 7.0.3 → 7.0.4

package/cjs/connect.js

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const PenpalError_js_1 = require("./PenpalError.js");
-const shakeHands_js_1 = require("./shakeHands.js");
-const guards_js_1 = require("./guards.js");
-const once_js_1 = require("./once.js");
-const namespace_js_1 = require("./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_js_1.default('INVALID_ARGUMENT', 'messenger must be defined');
-    }
-    if (usedMessengers.has(messenger)) {
-        throw new PenpalError_js_1.default('INVALID_ARGUMENT', 'A messenger can only be used for a single connection');
-    }
-    usedMessengers.add(messenger);
-    const connectionDestroyedHandlers = [messenger.destroy];
-    const destroyConnection = (0, once_js_1.default)((notifyOtherParticipant) => {
-        if (notifyOtherParticipant) {
-            const destroyMessage = {
-                namespace: namespace_js_1.default,
-                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 (0, guards_js_1.isMessage)(data) && data.channel === channel;
-    };
-    const promise = (async () => {
-        try {
-            messenger.initialize({ log, validateReceivedMessage });
-            messenger.addMessageHandler((message) => {
-                if ((0, guards_js_1.isDestroyMessage)(message)) {
-                    destroyConnection(false);
-                }
-            });
-            const { remoteProxy, destroy } = await (0, shakeHands_js_1.default)({
-                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);
-        },
-    };
-};
-exports.default = connect;

package/cjs/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/cjs/connectCallHandler.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errorSerialization_js_1 = require("./errorSerialization.js");
-const Reply_js_1 = require("./Reply.js");
-const PenpalError_js_1 = require("./PenpalError.js");
-const methodSerialization_js_1 = require("./methodSerialization.js");
-const guards_js_1 = require("./guards.js");
-const namespace_js_1 = require("./namespace.js");
-const createErrorReplyMessage = (channel, callId, error) => ({
-    namespace: namespace_js_1.default,
-    channel,
-    type: 'REPLY',
-    callId,
-    isError: true,
-    ...(error instanceof Error
-        ? { value: (0, errorSerialization_js_1.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 (!(0, guards_js_1.isCallMessage)(message)) {
-            return;
-        }
-        log?.(`Received ${(0, methodSerialization_js_1.formatMethodPath)(message.methodPath)}() call`, message);
-        const { methodPath, args, id: callId } = message;
-        let replyMessage;
-        let transferables;
-        try {
-            const method = (0, methodSerialization_js_1.getMethodAtMethodPath)(methodPath, methods);
-            if (!method) {
-                throw new PenpalError_js_1.default('METHOD_NOT_FOUND', `Method \`${(0, methodSerialization_js_1.formatMethodPath)(methodPath)}\` is not found.`);
-            }
-            let value = await method(...args);
-            if (value instanceof Reply_js_1.default) {
-                transferables = value.transferables;
-                value = await value.value;
-            }
-            replyMessage = {
-                namespace: namespace_js_1.default,
-                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 ${(0, methodSerialization_js_1.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 ${(0, methodSerialization_js_1.formatMethodPath)(methodPath)}() reply`, replyMessage);
-                messenger.sendMessage(replyMessage);
-            }
-            throw error;
-        }
-    };
-    messenger.addMessageHandler(handleMessage);
-    return () => {
-        isDestroyed = true;
-        messenger.removeMessageHandler(handleMessage);
-    };
-};
-exports.default = connectCallHandler;

package/cjs/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/cjs/connectRemoteProxy.js

@@ -1,139 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const generateId_js_1 = require("./generateId.js");
-const errorSerialization_js_1 = require("./errorSerialization.js");
-const methodSerialization_js_1 = require("./methodSerialization.js");
-const CallOptions_js_1 = require("./CallOptions.js");
-const PenpalError_js_1 = require("./PenpalError.js");
-const guards_js_1 = require("./guards.js");
-const namespace_js_1 = require("./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_js_1.default('CONNECTION_DESTROYED', `Method call ${(0, methodSerialization_js_1.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 (!(0, guards_js_1.isReplyMessage)(message)) {
-            return;
-        }
-        const { callId, value, isError, isSerializedErrorInstance } = message;
-        const replyHandler = replyHandlers.get(callId);
-        if (!replyHandler) {
-            return;
-        }
-        replyHandlers.delete(callId);
-        log?.(`Received ${(0, methodSerialization_js_1.formatMethodPath)(replyHandler.methodPath)}() call`, message);
-        if (isError) {
-            replyHandler.reject(isSerializedErrorInstance ? (0, errorSerialization_js_1.deserializeError)(value) : value);
-        }
-        else {
-            replyHandler.resolve(value);
-        }
-    };
-    messenger.addMessageHandler(handleMessage);
-    const remoteProxy = createRemoteProxy((methodPath, args) => {
-        if (isDestroyed) {
-            throw getDestroyedConnectionMethodCallError(methodPath);
-        }
-        const callId = (0, generateId_js_1.default)();
-        const lastArg = args[args.length - 1];
-        const lastArgIsOptions = lastArg instanceof CallOptions_js_1.default;
-        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_js_1.default('METHOD_CALL_TIMEOUT', `Method call ${(0, methodSerialization_js_1.formatMethodPath)(methodPath)}() timed out after ${timeout}ms`));
-                }, timeout)
-                : undefined;
-            replyHandlers.set(callId, { methodPath, resolve, reject, timeoutId });
-            try {
-                const callMessage = {
-                    namespace: namespace_js_1.default,
-                    channel,
-                    type: 'CALL',
-                    id: callId,
-                    methodPath,
-                    args: argsWithoutOptions,
-                };
-                log?.(`Sending ${(0, methodSerialization_js_1.formatMethodPath)(methodPath)}() call`, callMessage);
-                messenger.sendMessage(callMessage, transferables);
-            }
-            catch (error) {
-                reject(new PenpalError_js_1.default('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,
-    };
-};
-exports.default = connectRemoteProxy;

package/cjs/debug.d.ts

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

package/cjs/debug.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const debug = (prefix) => {
-    return (...args) => {
-        console.log(`✍️ %c${prefix}%c`, 'font-weight: bold;', '', ...args);
-    };
-};
-exports.default = debug;

package/cjs/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/cjs/errorSerialization.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deserializeError = exports.serializeError = void 0;
-const PenpalError_js_1 = require("./PenpalError.js");
-/**
- * Converts an error object into a plain object.
- */
-const serializeError = (error) => ({
-    name: error.name,
-    message: error.message,
-    stack: error.stack,
-    penpalCode: error instanceof PenpalError_js_1.default ? error.code : undefined,
-});
-exports.serializeError = serializeError;
-/**
- * Converts a plain object into an error object.
- */
-const deserializeError = ({ name, message, stack, penpalCode, }) => {
-    const deserializedError = penpalCode
-        ? new PenpalError_js_1.default(penpalCode, message)
-        : new Error(message);
-    deserializedError.name = name;
-    deserializedError.stack = stack;
-    return deserializedError;
-};
-exports.deserializeError = deserializeError;

package/cjs/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/cjs/generateId.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * @return A unique ID
- */
-// crypto.randomUUID is not available in insecure contexts.
-exports.default = crypto.randomUUID?.bind(crypto) ??
-    (() => new Array(4)
-        .fill(0)
-        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))
-        .join('-'));

package/cjs/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/cjs/getPromiseWithResolvers.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// 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,
-    };
-};
-exports.default = getPromiseWithResolvers;

package/cjs/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/cjs/guards.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDestroyMessage = exports.isReplyMessage = exports.isCallMessage = exports.isAck2Message = exports.isAck1Message = exports.isSynMessage = exports.isMessage = exports.isFunction = exports.isObject = void 0;
-const namespace_js_1 = require("./namespace.js");
-const isObject = (value) => {
-    return typeof value === 'object' && value !== null;
-};
-exports.isObject = isObject;
-const isFunction = (value) => {
-    return typeof value === 'function';
-};
-exports.isFunction = isFunction;
-const isMessage = (data) => {
-    return (0, exports.isObject)(data) && data.namespace === namespace_js_1.default;
-};
-exports.isMessage = isMessage;
-const isSynMessage = (message) => {
-    return message.type === 'SYN';
-};
-exports.isSynMessage = isSynMessage;
-const isAck1Message = (message) => {
-    return message.type === 'ACK1';
-};
-exports.isAck1Message = isAck1Message;
-const isAck2Message = (message) => {
-    return message.type === 'ACK2';
-};
-exports.isAck2Message = isAck2Message;
-const isCallMessage = (message) => {
-    return message.type === 'CALL';
-};
-exports.isCallMessage = isCallMessage;
-const isReplyMessage = (message) => {
-    return message.type === 'REPLY';
-};
-exports.isReplyMessage = isReplyMessage;
-const isDestroyMessage = (message) => {
-    return message.type === 'DESTROY';
-};
-exports.isDestroyMessage = isDestroyMessage;

package/cjs/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/cjs/index.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.debug = exports.ErrorCode = exports.PenpalError = exports.Reply = exports.CallOptions = exports.PortMessenger = exports.WorkerMessenger = exports.WindowMessenger = exports.connect = void 0;
-var connect_js_1 = require("./connect.js");
-Object.defineProperty(exports, "connect", { enumerable: true, get: function () { return connect_js_1.default; } });
-var WindowMessenger_js_1 = require("./messengers/WindowMessenger.js");
-Object.defineProperty(exports, "WindowMessenger", { enumerable: true, get: function () { return WindowMessenger_js_1.default; } });
-var WorkerMessenger_js_1 = require("./messengers/WorkerMessenger.js");
-Object.defineProperty(exports, "WorkerMessenger", { enumerable: true, get: function () { return WorkerMessenger_js_1.default; } });
-var PortMessenger_js_1 = require("./messengers/PortMessenger.js");
-Object.defineProperty(exports, "PortMessenger", { enumerable: true, get: function () { return PortMessenger_js_1.default; } });
-var CallOptions_js_1 = require("./CallOptions.js");
-Object.defineProperty(exports, "CallOptions", { enumerable: true, get: function () { return CallOptions_js_1.default; } });
-var Reply_js_1 = require("./Reply.js");
-Object.defineProperty(exports, "Reply", { enumerable: true, get: function () { return Reply_js_1.default; } });
-var PenpalError_js_1 = require("./PenpalError.js");
-Object.defineProperty(exports, "PenpalError", { enumerable: true, get: function () { return PenpalError_js_1.default; } });
-var ErrorCodeObj_js_1 = require("./ErrorCodeObj.js");
-Object.defineProperty(exports, "ErrorCode", { enumerable: true, get: function () { return ErrorCodeObj_js_1.default; } });
-var debug_js_1 = require("./debug.js");
-Object.defineProperty(exports, "debug", { enumerable: true, get: function () { return debug_js_1.default; } });

package/cjs/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/cjs/indexForBundle.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const connect_js_1 = require("./connect.js");
-const WindowMessenger_js_1 = require("./messengers/WindowMessenger.js");
-const WorkerMessenger_js_1 = require("./messengers/WorkerMessenger.js");
-const PortMessenger_js_1 = require("./messengers/PortMessenger.js");
-const CallOptions_js_1 = require("./CallOptions.js");
-const Reply_js_1 = require("./Reply.js");
-const PenpalError_js_1 = require("./PenpalError.js");
-const ErrorCodeObj_js_1 = require("./ErrorCodeObj.js");
-const debug_js_1 = require("./debug.js");
-exports.default = {
-    connect: connect_js_1.default,
-    WindowMessenger: WindowMessenger_js_1.default,
-    WorkerMessenger: WorkerMessenger_js_1.default,
-    PortMessenger: PortMessenger_js_1.default,
-    CallOptions: CallOptions_js_1.default,
-    Reply: Reply_js_1.default,
-    PenpalError: PenpalError_js_1.default,
-    debug: debug_js_1.default,
-    ErrorCode: ErrorCodeObj_js_1.default,
-};

package/cjs/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/cjs/messengers/Messenger.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/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;