penpal 7.0.3 → 7.0.4

package/dist/penpal.js

@@ -1,1101 +1,958 @@
-var Penpal = (function () {
+var Penpal = (function (exports) {
   'use strict';
 
-  class PenpalError extends Error {
-      code;
-      constructor(code, message) {
-          super(message);
-          this.name = 'PenpalError';
-          this.code = code;
-      }
-  }
+  // src/PenpalError.ts
+  var PenpalError = class extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.name = "PenpalError";
+      this.code = code;
+    }
+  };
+  var PenpalError_default = PenpalError;
 
-  /**
-   * Converts an error object into a plain object.
-   */
-  const serializeError = (error) => ({
-      name: error.name,
-      message: error.message,
-      stack: error.stack,
-      penpalCode: error instanceof PenpalError ? error.code : undefined,
+  // src/errorSerialization.ts
+  var serializeError = (error) => ({
+    name: error.name,
+    message: error.message,
+    stack: error.stack,
+    penpalCode: error instanceof PenpalError_default ? error.code : void 0
   });
-  /**
-   * Converts a plain object into an error object.
-   */
-  const deserializeError = ({ name, message, stack, penpalCode, }) => {
-      const deserializedError = penpalCode
-          ? new PenpalError(penpalCode, message)
-          : new Error(message);
-      deserializedError.name = name;
-      deserializedError.stack = stack;
-      return deserializedError;
+  var deserializeError = ({
+    name,
+    message,
+    stack,
+    penpalCode
+  }) => {
+    const deserializedError = penpalCode ? new PenpalError_default(penpalCode, message) : new Error(message);
+    deserializedError.name = name;
+    deserializedError.stack = stack;
+    return deserializedError;
   };
 
-  const brand$1 = Symbol('Reply');
-  class Reply {
-      value;
-      transferables;
-      // Allows TypeScript to distinguish between an actual instance of this
-      // class versus an object that looks structurally similar.
-      // eslint-disable-next-line no-unused-private-class-members
-      #brand = brand$1;
-      constructor(value, options) {
-          this.value = value;
-          this.transferables = options?.transferables;
-      }
-  }
+  // src/Reply.ts
+  var brand = Symbol("Reply");
+  var Reply = class {
+    value;
+    transferables;
+    // Allows TypeScript to distinguish between an actual instance of this
+    // class versus an object that looks structurally similar.
+    // eslint-disable-next-line no-unused-private-class-members
+    #brand = brand;
+    constructor(value, options) {
+      this.value = value;
+      this.transferables = options?.transferables;
+    }
+  };
+  var Reply_default = Reply;
 
-  var namespace = 'penpal';
+  // src/namespace.ts
+  var namespace_default = "penpal";
 
-  const isObject = (value) => {
-      return typeof value === 'object' && value !== null;
+  // src/guards.ts
+  var isObject = (value) => {
+    return typeof value === "object" && value !== null;
   };
-  const isFunction = (value) => {
-      return typeof value === 'function';
+  var isFunction = (value) => {
+    return typeof value === "function";
   };
-  const isMessage = (data) => {
-      return isObject(data) && data.namespace === namespace;
+  var isMessage = (data) => {
+    return isObject(data) && data.namespace === namespace_default;
   };
-  const isSynMessage = (message) => {
-      return message.type === 'SYN';
+  var isSynMessage = (message) => {
+    return message.type === "SYN";
   };
-  const isAck1Message = (message) => {
-      return message.type === 'ACK1';
+  var isAck1Message = (message) => {
+    return message.type === "ACK1";
   };
-  const isAck2Message = (message) => {
-      return message.type === 'ACK2';
+  var isAck2Message = (message) => {
+    return message.type === "ACK2";
   };
-  const isCallMessage = (message) => {
-      return message.type === 'CALL';
+  var isCallMessage = (message) => {
+    return message.type === "CALL";
   };
-  const isReplyMessage = (message) => {
-      return message.type === 'REPLY';
+  var isReplyMessage = (message) => {
+    return message.type === "REPLY";
   };
-  const isDestroyMessage = (message) => {
-      return message.type === 'DESTROY';
+  var isDestroyMessage = (message) => {
+    return message.type === "DESTROY";
   };
 
-  // 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']
-   * ]
-   */
-  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]));
-          }
+  // src/methodSerialization.ts
+  var 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;
+    }
+    return methodPaths;
   };
-  const getMethodAtMethodPath = (methodPath, methods) => {
-      const result = methodPath.reduce((acc, pathSegment) => {
-          return isObject(acc) ? acc[pathSegment] : undefined;
-      }, methods);
-      return isFunction(result) ? result : undefined;
+  var getMethodAtMethodPath = (methodPath, methods) => {
+    const result = methodPath.reduce(
+      (acc, pathSegment) => {
+        return isObject(acc) ? acc[pathSegment] : void 0;
+      },
+      methods
+    );
+    return isFunction(result) ? result : void 0;
   };
-  const formatMethodPath = (methodPath) => {
-      return methodPath.join('.');
+  var formatMethodPath = (methodPath) => {
+    return methodPath.join(".");
   };
 
-  const createErrorReplyMessage = (channel, callId, error) => ({
-      namespace,
-      channel,
-      type: 'REPLY',
-      callId,
-      isError: true,
-      ...(error instanceof Error
-          ? { value: serializeError(error), isSerializedErrorInstance: true }
-          : { value: error }),
+  // src/connectCallHandler.ts
+  var createErrorReplyMessage = (channel, callId, error) => ({
+    namespace: namespace_default,
+    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);
-      };
+  var connectCallHandler = (messenger, methods, channel, log) => {
+    let isDestroyed = false;
+    const handleMessage = async (message) => {
+      if (isDestroyed) {
+        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_default(
+            "METHOD_NOT_FOUND",
+            `Method \`${formatMethodPath(methodPath)}\` is not found.`
+          );
+        }
+        let value = await method(...args);
+        if (value instanceof Reply_default) {
+          transferables = value.transferables;
+          value = await value.value;
+        }
+        replyMessage = {
+          namespace: namespace_default,
+          channel,
+          type: "REPLY",
+          callId,
+          value
+        };
+      } catch (error) {
+        replyMessage = createErrorReplyMessage(channel, callId, error);
+      }
+      if (isDestroyed) {
+        return;
+      }
+      try {
+        log?.(`Sending ${formatMethodPath(methodPath)}() reply`, replyMessage);
+        messenger.sendMessage(replyMessage, transferables);
+      } catch (error) {
+        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);
+    };
   };
+  var connectCallHandler_default = connectCallHandler;
 
-  /**
-   * @return A unique ID
-   */
-  // crypto.randomUUID is not available in insecure contexts.
-  var generateId = crypto.randomUUID?.bind(crypto) ??
-      (() => new Array(4)
-          .fill(0)
-          .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))
-          .join('-'));
+  // src/generateId.ts
+  var generateId_default = crypto.randomUUID?.bind(crypto) ?? (() => new Array(4).fill(0).map(
+    () => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)
+  ).join("-"));
 
-  const brand = Symbol('CallOptions');
-  class CallOptions {
-      transferables;
-      timeout;
-      // Allows TypeScript to distinguish between an actual instance of this
-      // class versus an object that looks structurally similar.
-      // eslint-disable-next-line no-unused-private-class-members
-      #brand = brand;
-      constructor(options) {
-          this.transferables = options?.transferables;
-          this.timeout = options?.timeout;
-      }
-  }
+  // src/CallOptions.ts
+  var brand2 = Symbol("CallOptions");
+  var CallOptions = class {
+    transferables;
+    timeout;
+    // Allows TypeScript to distinguish between an actual instance of this
+    // class versus an object that looks structurally similar.
+    // eslint-disable-next-line no-unused-private-class-members
+    #brand = brand2;
+    constructor(options) {
+      this.transferables = options?.transferables;
+      this.timeout = options?.timeout;
+    }
+  };
+  var CallOptions_default = CallOptions;
 
-  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);
-          },
-      });
+  // src/connectRemoteProxy.ts
+  var methodsToTreatAsNative = /* @__PURE__ */ new Set(["apply", "call", "bind"]);
+  var createRemoteProxy = (callback, log, path = []) => {
+    return new Proxy(
+      path.length ? () => {
+      } : /* @__PURE__ */ Object.create(null),
+      {
+        get(target, prop) {
+          if (prop === "then") {
+            return;
+          }
+          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`);
+  var getDestroyedConnectionMethodCallError = (methodPath) => {
+    return new PenpalError_default(
+      "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;
-          }
+  var connectRemoteProxy = (messenger, channel, log) => {
+    let isDestroyed = false;
+    const replyHandlers = /* @__PURE__ */ 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_default();
+      const lastArg = args[args.length - 1];
+      const lastArgIsOptions = lastArg instanceof CallOptions_default;
+      const { timeout, transferables } = lastArgIsOptions ? lastArg : {};
+      const argsWithoutOptions = lastArgIsOptions ? args.slice(0, -1) : args;
+      return new Promise((resolve, reject) => {
+        const timeoutId = timeout !== void 0 ? window.setTimeout(() => {
           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();
+          reject(
+            new PenpalError_default(
+              "METHOD_CALL_TIMEOUT",
+              `Method call ${formatMethodPath(
+              methodPath
+            )}() timed out after ${timeout}ms`
+            )
+          );
+        }, timeout) : void 0;
+        replyHandlers.set(callId, { methodPath, resolve, reject, timeoutId });
+        try {
+          const callMessage = {
+            namespace: namespace_default,
+            channel,
+            type: "CALL",
+            id: callId,
+            methodPath,
+            args: argsWithoutOptions
+          };
+          log?.(`Sending ${formatMethodPath(methodPath)}() call`, callMessage);
+          messenger.sendMessage(callMessage, transferables);
+        } catch (error) {
+          reject(
+            new PenpalError_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
+    };
+  };
+  var connectRemoteProxy_default = connectRemoteProxy;
+
+  // src/getPromiseWithResolvers.ts
+  var getPromiseWithResolvers = () => {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return {
+      promise,
+      resolve,
+      reject
+    };
+  };
+  var getPromiseWithResolvers_default = getPromiseWithResolvers;
+
+  // src/PenpalBugError.ts
+  var PenpalBugError = class extends Error {
+    constructor(message) {
+      super(
+        `You've hit a bug in Penpal. Please file an issue with the following information: ${message}`
+      );
+    }
+  };
+  var PenpalBugError_default = PenpalBugError;
+
+  // src/backwardCompatibility.ts
+  var DEPRECATED_PENPAL_PARTICIPANT_ID = "deprecated-penpal";
+  var isDeprecatedMessage = (data) => {
+    return isObject(data) && "penpal" in data;
+  };
+  var upgradeMethodPath = (methodPath) => methodPath.split(".");
+  var downgradeMethodPath = (methodPath) => methodPath.join(".");
+  var getUnexpectedMessageError = (message) => {
+    return new PenpalBugError_default(
+      `Unexpected message to translate: ${JSON.stringify(message)}`
+    );
+  };
+  var upgradeMessage = (message) => {
+    if (message.penpal === "syn" /* Syn */) {
+      return {
+        namespace: namespace_default,
+        channel: void 0,
+        type: "SYN",
+        participantId: DEPRECATED_PENPAL_PARTICIPANT_ID
       };
+    }
+    if (message.penpal === "ack" /* Ack */) {
       return {
-          remoteProxy,
-          destroy,
+        namespace: namespace_default,
+        channel: void 0,
+        type: "ACK2"
       };
+    }
+    if (message.penpal === "call" /* Call */) {
+      return {
+        namespace: namespace_default,
+        channel: void 0,
+        type: "CALL",
+        // Actually converting the ID to a string would break communication.
+        id: message.id,
+        methodPath: upgradeMethodPath(message.methodName),
+        args: message.args
+      };
+    }
+    if (message.penpal === "reply" /* Reply */) {
+      if (message.resolution === "fulfilled" /* Fulfilled */) {
+        return {
+          namespace: namespace_default,
+          channel: void 0,
+          type: "REPLY",
+          // Actually converting the ID to a string would break communication.
+          callId: message.id,
+          value: message.returnValue
+        };
+      } else {
+        return {
+          namespace: namespace_default,
+          channel: void 0,
+          type: "REPLY",
+          // Actually converting the ID to a string would break communication.
+          callId: message.id,
+          isError: true,
+          ...message.returnValueIsError ? {
+            value: message.returnValue,
+            isSerializedErrorInstance: true
+          } : {
+            value: message.returnValue
+          }
+        };
+      }
+    }
+    throw getUnexpectedMessageError(message);
   };
-
-  // 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;
-      });
+  var downgradeMessage = (message) => {
+    if (isAck1Message(message)) {
       return {
-          promise,
-          resolve: resolve,
-          reject: reject,
+        penpal: "synAck" /* SynAck */,
+        methodNames: message.methodPaths.map(downgradeMethodPath)
       };
+    }
+    if (isCallMessage(message)) {
+      return {
+        penpal: "call" /* Call */,
+        // Actually converting the ID to a number would break communication.
+        id: message.id,
+        methodName: downgradeMethodPath(message.methodPath),
+        args: message.args
+      };
+    }
+    if (isReplyMessage(message)) {
+      if (message.isError) {
+        return {
+          penpal: "reply" /* Reply */,
+          // Actually converting the ID to a number would break communication.
+          id: message.callId,
+          resolution: "rejected" /* Rejected */,
+          ...message.isSerializedErrorInstance ? {
+            returnValue: message.value,
+            returnValueIsError: true
+          } : { returnValue: message.value }
+        };
+      } else {
+        return {
+          penpal: "reply" /* Reply */,
+          // Actually converting the ID to a number would break communication.
+          id: message.callId,
+          resolution: "fulfilled" /* Fulfilled */,
+          returnValue: message.value
+        };
+      }
+    }
+    throw getUnexpectedMessageError(message);
   };
 
-  /**
-   * Error class that is thrown when we've reached a situation that we believe to
-   * be a bug in Penpal and not anything the consumer has done.
-   */
-  class PenpalBugError extends Error {
-      constructor(message) {
-          super(`You've hit a bug in Penpal. Please file an issue with the following information: ${message}`);
+  // src/shakeHands.ts
+  var shakeHands = ({
+    messenger,
+    methods,
+    timeout,
+    channel,
+    log
+  }) => {
+    const participantId = generateId_default();
+    let remoteParticipantId;
+    const destroyHandlers = [];
+    let isComplete = false;
+    const methodPaths = extractMethodPathsFromMethods(methods);
+    const { promise, resolve, reject } = getPromiseWithResolvers_default();
+    const timeoutId = timeout !== void 0 ? setTimeout(() => {
+      reject(
+        new PenpalError_default(
+          "CONNECTION_TIMEOUT",
+          `Connection timed out after ${timeout}ms`
+        )
+      );
+    }, timeout) : void 0;
+    const destroy = () => {
+      for (const destroyHandler of destroyHandlers) {
+        destroyHandler();
       }
-  }
-
-  const DEPRECATED_PENPAL_PARTICIPANT_ID = 'deprecated-penpal';
-  // TODO: This file is used for backward-compatibility. Remove in next major version.
-  var DeprecatedMessageType;
-  (function (DeprecatedMessageType) {
-      DeprecatedMessageType["Call"] = "call";
-      DeprecatedMessageType["Reply"] = "reply";
-      DeprecatedMessageType["Syn"] = "syn";
-      DeprecatedMessageType["SynAck"] = "synAck";
-      DeprecatedMessageType["Ack"] = "ack";
-  })(DeprecatedMessageType || (DeprecatedMessageType = {}));
-  var DeprecatedResolution;
-  (function (DeprecatedResolution) {
-      DeprecatedResolution["Fulfilled"] = "fulfilled";
-      DeprecatedResolution["Rejected"] = "rejected";
-  })(DeprecatedResolution || (DeprecatedResolution = {}));
-  const isDeprecatedMessage = (data) => {
-      return isObject(data) && 'penpal' in data;
-  };
-  const upgradeMethodPath = (methodPath) => methodPath.split('.');
-  const downgradeMethodPath = (methodPath) => methodPath.join('.');
-  const getUnexpectedMessageError = (message) => {
-      return new PenpalBugError(`Unexpected message to translate: ${JSON.stringify(message)}`);
-  };
-  const upgradeMessage = (message) => {
-      if (message.penpal === DeprecatedMessageType.Syn) {
-          return {
-              namespace,
-              channel: undefined,
-              type: 'SYN',
-              participantId: DEPRECATED_PENPAL_PARTICIPANT_ID,
-          };
+    };
+    const connectCallHandlerAndMethodProxies = () => {
+      if (isComplete) {
+        return;
       }
-      if (message.penpal === DeprecatedMessageType.Ack) {
-          return {
-              namespace,
-              channel: undefined,
-              type: 'ACK2',
-          };
+      destroyHandlers.push(connectCallHandler_default(messenger, methods, channel, log));
+      const { remoteProxy, destroy: destroyMethodProxies } = connectRemoteProxy_default(messenger, channel, log);
+      destroyHandlers.push(destroyMethodProxies);
+      clearTimeout(timeoutId);
+      isComplete = true;
+      resolve({
+        remoteProxy,
+        destroy
+      });
+    };
+    const sendSynMessage = () => {
+      const synMessage = {
+        namespace: namespace_default,
+        type: "SYN",
+        channel,
+        participantId
+      };
+      log?.(`Sending handshake SYN`, synMessage);
+      try {
+        messenger.sendMessage(synMessage);
+      } catch (error) {
+        reject(new PenpalError_default("TRANSMISSION_FAILED", error.message));
       }
-      if (message.penpal === DeprecatedMessageType.Call) {
-          return {
-              namespace,
-              channel: undefined,
-              type: 'CALL',
-              // Actually converting the ID to a string would break communication.
-              id: message.id,
-              methodPath: upgradeMethodPath(message.methodName),
-              args: message.args,
-          };
+    };
+    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;
       }
-      if (message.penpal === DeprecatedMessageType.Reply) {
-          if (message.resolution === DeprecatedResolution.Fulfilled) {
-              return {
-                  namespace,
-                  channel: undefined,
-                  type: 'REPLY',
-                  // Actually converting the ID to a string would break communication.
-                  callId: message.id,
-                  value: message.returnValue,
-              };
-          }
-          else {
-              return {
-                  namespace,
-                  channel: undefined,
-                  type: 'REPLY',
-                  // Actually converting the ID to a string would break communication.
-                  callId: message.id,
-                  isError: true,
-                  ...(message.returnValueIsError
-                      ? {
-                          value: message.returnValue,
-                          isSerializedErrorInstance: true,
-                      }
-                      : {
-                          value: message.returnValue,
-                      }),
-              };
-          }
+      remoteParticipantId = message.participantId;
+      sendSynMessage();
+      const isHandshakeLeader = participantId > remoteParticipantId || // TODO: Used for backward-compatibility. Remove in next major version.
+      remoteParticipantId === DEPRECATED_PENPAL_PARTICIPANT_ID;
+      if (!isHandshakeLeader) {
+        return;
       }
-      throw getUnexpectedMessageError(message);
-  };
-  const downgradeMessage = (message) => {
-      if (isAck1Message(message)) {
-          return {
-              penpal: DeprecatedMessageType.SynAck,
-              methodNames: message.methodPaths.map(downgradeMethodPath),
-          };
+      const ack1Message = {
+        namespace: namespace_default,
+        channel,
+        type: "ACK1",
+        methodPaths
+      };
+      log?.(`Sending handshake ACK1`, ack1Message);
+      try {
+        messenger.sendMessage(ack1Message);
+      } catch (error) {
+        reject(new PenpalError_default("TRANSMISSION_FAILED", error.message));
+        return;
       }
-      if (isCallMessage(message)) {
-          return {
-              penpal: DeprecatedMessageType.Call,
-              // Actually converting the ID to a number would break communication.
-              id: message.id,
-              methodName: downgradeMethodPath(message.methodPath),
-              args: message.args,
-          };
+    };
+    const handleAck1Message = (message) => {
+      log?.(`Received handshake ACK1`, message);
+      const ack2Message = {
+        namespace: namespace_default,
+        channel,
+        type: "ACK2"
+      };
+      log?.(`Sending handshake ACK2`, ack2Message);
+      try {
+        messenger.sendMessage(ack2Message);
+      } catch (error) {
+        reject(new PenpalError_default("TRANSMISSION_FAILED", error.message));
+        return;
       }
-      if (isReplyMessage(message)) {
-          if (message.isError) {
-              return {
-                  penpal: DeprecatedMessageType.Reply,
-                  // Actually converting the ID to a number would break communication.
-                  id: message.callId,
-                  resolution: DeprecatedResolution.Rejected,
-                  ...(message.isSerializedErrorInstance
-                      ? {
-                          returnValue: message.value,
-                          returnValueIsError: true,
-                      }
-                      : { returnValue: message.value }),
-              };
-          }
-          else {
-              return {
-                  penpal: DeprecatedMessageType.Reply,
-                  // Actually converting the ID to a number would break communication.
-                  id: message.callId,
-                  resolution: DeprecatedResolution.Fulfilled,
-                  returnValue: message.value,
-              };
-          }
+      connectCallHandlerAndMethodProxies();
+    };
+    const handleAck2Message = (message) => {
+      log?.(`Received handshake ACK2`, message);
+      connectCallHandlerAndMethodProxies();
+    };
+    const handleMessage = (message) => {
+      if (isSynMessage(message)) {
+        handleSynMessage(message);
+      }
+      if (isAck1Message(message)) {
+        handleAck1Message(message);
       }
-      throw getUnexpectedMessageError(message);
+      if (isAck2Message(message)) {
+        handleAck2Message(message);
+      }
+    };
+    messenger.addMessageHandler(handleMessage);
+    destroyHandlers.push(() => messenger.removeMessageHandler(handleMessage));
+    sendSynMessage();
+    return promise;
   };
+  var shakeHands_default = shakeHands;
 
-  /**
-   * 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;
+  // src/once.ts
+  var once = (fn) => {
+    let isCalled = false;
+    let result;
+    return (...args) => {
+      if (!isCalled) {
+        isCalled = true;
+        result = fn(...args);
+      }
+      return result;
+    };
   };
+  var once_default = once;
 
-  // 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;
-      };
+  // src/connect.ts
+  var usedMessengers = /* @__PURE__ */ new WeakSet();
+  var connect = ({
+    messenger,
+    methods = {},
+    timeout,
+    channel,
+    log
+  }) => {
+    if (!messenger) {
+      throw new PenpalError_default("INVALID_ARGUMENT", "messenger must be defined");
+    }
+    if (usedMessengers.has(messenger)) {
+      throw new PenpalError_default(
+        "INVALID_ARGUMENT",
+        "A messenger can only be used for a single connection"
+      );
+    }
+    usedMessengers.add(messenger);
+    const connectionDestroyedHandlers = [messenger.destroy];
+    const destroyConnection = once_default((notifyOtherParticipant) => {
+      if (notifyOtherParticipant) {
+        const destroyMessage = {
+          namespace: namespace_default,
+          channel,
+          type: "DESTROY"
+        };
+        try {
+          messenger.sendMessage(destroyMessage);
+        } catch (_) {
+        }
+      }
+      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_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);
+      }
+    };
   };
+  var connect_default = connect;
 
-  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');
+  // src/messengers/WindowMessenger.ts
+  var WindowMessenger = class {
+    #remoteWindow;
+    #allowedOrigins;
+    #log;
+    #validateReceivedMessage;
+    #concreteRemoteOrigin;
+    #messageCallbacks = /* @__PURE__ */ new Set();
+    #port;
+    // TODO: Used for backward-compatibility. Remove in next major version.
+    #isChildUsingDeprecatedProtocol = false;
+    constructor({ remoteWindow, allowedOrigins }) {
+      if (!remoteWindow) {
+        throw new PenpalError_default("INVALID_ARGUMENT", "remoteWindow must be defined");
       }
-      if (usedMessengers.has(messenger)) {
-          throw new PenpalError('INVALID_ARGUMENT', 'A messenger can only be used for a single connection');
+      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;
       }
-      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);
-          },
-      };
+      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_default("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) => {
+      if (isSynMessage(message)) {
+        return "*";
+      }
+      if (!this.#concreteRemoteOrigin) {
+        throw new PenpalBugError_default("Concrete remote origin not set");
+      }
+      return this.#concreteRemoteOrigin === "null" && this.#allowedOrigins.includes("*") ? "*" : this.#concreteRemoteOrigin;
+    };
+    #destroyPort = () => {
+      this.#port?.removeEventListener("message", this.#handleMessageFromPort);
+      this.#port?.close();
+      this.#port = void 0;
+    };
+    #handleMessageFromRemoteWindow = ({
+      source,
+      origin,
+      ports,
+      data
+    }) => {
+      if (source !== this.#remoteWindow) {
+        return;
+      }
+      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)) {
+        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_default("No port received on ACK2");
+        }
+        this.#port.addEventListener("message", this.#handleMessageFromPort);
+        this.#port.start();
+      }
+      for (const callback of this.#messageCallbacks) {
+        callback(data);
+      }
+    };
+    #handleMessageFromPort = ({ data }) => {
+      if (!this.#validateReceivedMessage?.(data)) {
+        return;
+      }
+      for (const callback of this.#messageCallbacks) {
+        callback(data);
+      }
+    };
   };
+  var WindowMessenger_default = WindowMessenger;
 
-  /**
-   * 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];
+  // src/messengers/WorkerMessenger.ts
+  var WorkerMessenger = class {
+    #worker;
+    #validateReceivedMessage;
+    #messageCallbacks = /* @__PURE__ */ new Set();
+    #port;
+    constructor({ worker }) {
+      if (!worker) {
+        throw new PenpalError_default("INVALID_ARGUMENT", "worker must be defined");
       }
-      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);
-          }
-      };
-  }
-
-  /**
-   * 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;
+      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;
       }
-      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);
-          }
-      };
-  }
-
-  /**
-   * 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;
+      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;
       }
-      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);
-          }
-      };
-  }
+      if (this.#port) {
+        this.#port.postMessage(message, {
+          transfer: transferables
+        });
+        return;
+      }
+      throw new PenpalBugError_default("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 = void 0;
+    };
+    #handleMessage = ({ ports, data }) => {
+      if (!this.#validateReceivedMessage?.(data)) {
+        return;
+      }
+      if (isSynMessage(data)) {
+        this.#destroyPort();
+      }
+      if (isAck2Message(data)) {
+        this.#port = ports[0];
+        if (!this.#port) {
+          throw new PenpalBugError_default("No port received on ACK2");
+        }
+        this.#port.addEventListener("message", this.#handleMessage);
+        this.#port.start();
+      }
+      for (const callback of this.#messageCallbacks) {
+        callback(data);
+      }
+    };
+  };
+  var WorkerMessenger_default = WorkerMessenger;
 
-  // Not intended to be used internally. Can be useful externally
-  // in projects not using TypeScript. It has the `Obj` suffix to disambiguate
-  // it from the ErrorCode string union.
-  const ErrorCodeObj = {
-      ConnectionDestroyed: 'CONNECTION_DESTROYED',
-      ConnectionTimeout: 'CONNECTION_TIMEOUT',
-      InvalidArgument: 'INVALID_ARGUMENT',
-      MethodCallTimeout: 'METHOD_CALL_TIMEOUT',
-      MethodNotFound: 'METHOD_NOT_FOUND',
-      TransmissionFailed: 'TRANSMISSION_FAILED',
+  // src/messengers/PortMessenger.ts
+  var PortMessenger = class {
+    #port;
+    #validateReceivedMessage;
+    #messageCallbacks = /* @__PURE__ */ new Set();
+    constructor({ port }) {
+      if (!port) {
+        throw new PenpalError_default("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);
+      }
+    };
   };
+  var PortMessenger_default = PortMessenger;
 
-  const debug = (prefix) => {
-      return (...args) => {
-          console.log(`✍️ %c${prefix}%c`, 'font-weight: bold;', '', ...args);
-      };
+  // src/ErrorCodeObj.ts
+  var ErrorCodeObj = {
+    ConnectionDestroyed: "CONNECTION_DESTROYED",
+    ConnectionTimeout: "CONNECTION_TIMEOUT",
+    InvalidArgument: "INVALID_ARGUMENT",
+    MethodCallTimeout: "METHOD_CALL_TIMEOUT",
+    MethodNotFound: "METHOD_NOT_FOUND",
+    TransmissionFailed: "TRANSMISSION_FAILED"
   };
+  var ErrorCodeObj_default = ErrorCodeObj;
 
-  var indexForBundle = {
-      connect,
-      WindowMessenger,
-      WorkerMessenger,
-      PortMessenger,
-      CallOptions,
-      Reply,
-      PenpalError,
-      debug,
-      ErrorCode: ErrorCodeObj,
+  // src/debug.ts
+  var debug = (prefix) => {
+    return (...args) => {
+      console.log(`\u270D\uFE0F %c${prefix}%c`, "font-weight: bold;", "", ...args);
+    };
   };
+  var debug_default = debug;
+
+  exports.CallOptions = CallOptions_default;
+  exports.ErrorCode = ErrorCodeObj_default;
+  exports.PenpalError = PenpalError_default;
+  exports.PortMessenger = PortMessenger_default;
+  exports.Reply = Reply_default;
+  exports.WindowMessenger = WindowMessenger_default;
+  exports.WorkerMessenger = WorkerMessenger_default;
+  exports.connect = connect_default;
+  exports.debug = debug_default;
 
-  return indexForBundle;
+  return exports;
 
-})();
+})({});
+//# sourceMappingURL=penpal.js.map
+//# sourceMappingURL=penpal.js.map