@payment-kit-js/vanilla 0.3.0-alpha.1 → 0.3.0

package/dist/cdn/paymentkit.js

@@ -0,0 +1,1979 @@
+/**
+ * PaymentKit.js v0.3.0
+ * https://paymentkit.com
+ *
+ * @license MIT
+ */
+
+"use strict";
+var PaymentKit = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __typeError = (msg) => {
+    throw TypeError(msg);
+  };
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+  var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+  var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+  var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+  // src/cdn.ts
+  var cdn_exports = {};
+  __export(cdn_exports, {
+    PaymentMethods: () => PaymentMethods,
+    default: () => cdn_default
+  });
+
+  // package.json
+  var version = "0.3.0";
+
+  // ../../node_modules/penpal/dist/penpal.mjs
+  var PenpalError = class extends Error {
+    constructor(code, message) {
+      super(message);
+      __publicField(this, "code");
+      this.name = "PenpalError";
+      this.code = code;
+    }
+  };
+  var PenpalError_default = PenpalError;
+  var serializeError = (error) => ({
+    name: error.name,
+    message: error.message,
+    stack: error.stack,
+    penpalCode: error instanceof PenpalError_default ? error.code : void 0
+  });
+  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;
+  };
+  var brand = Symbol("Reply");
+  var _brand, _a;
+  var Reply = (_a = class {
+    constructor(value, options) {
+      __publicField(this, "value");
+      __publicField(this, "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
+      __privateAdd(this, _brand, brand);
+      this.value = value;
+      this.transferables = options?.transferables;
+    }
+  }, _brand = new WeakMap(), _a);
+  var Reply_default = Reply;
+  var namespace_default = "penpal";
+  var isObject = (value) => {
+    return typeof value === "object" && value !== null;
+  };
+  var isFunction = (value) => {
+    return typeof value === "function";
+  };
+  var isMessage = (data) => {
+    return isObject(data) && data.namespace === namespace_default;
+  };
+  var isSynMessage = (message) => {
+    return message.type === "SYN";
+  };
+  var isAck1Message = (message) => {
+    return message.type === "ACK1";
+  };
+  var isAck2Message = (message) => {
+    return message.type === "ACK2";
+  };
+  var isCallMessage = (message) => {
+    return message.type === "CALL";
+  };
+  var isReplyMessage = (message) => {
+    return message.type === "REPLY";
+  };
+  var isDestroyMessage = (message) => {
+    return message.type === "DESTROY";
+  };
+  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;
+  };
+  var getMethodAtMethodPath = (methodPath, methods) => {
+    const result = methodPath.reduce(
+      (acc, pathSegment) => {
+        return isObject(acc) ? acc[pathSegment] : void 0;
+      },
+      methods
+    );
+    return isFunction(result) ? result : void 0;
+  };
+  var formatMethodPath = (methodPath) => {
+    return methodPath.join(".");
+  };
+  var createErrorReplyMessage = (channel, callId, error) => ({
+    namespace: namespace_default,
+    channel,
+    type: "REPLY",
+    callId,
+    isError: true,
+    ...error instanceof Error ? { value: serializeError(error), isSerializedErrorInstance: true } : { value: error }
+  });
+  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;
+  var generateId_default = crypto.randomUUID?.bind(crypto) ?? (() => new Array(4).fill(0).map(
+    () => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)
+  ).join("-"));
+  var brand2 = Symbol("CallOptions");
+  var _brand2, _a2;
+  var CallOptions = (_a2 = class {
+    constructor(options) {
+      __publicField(this, "transferables");
+      __publicField(this, "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
+      __privateAdd(this, _brand2, brand2);
+      this.transferables = options?.transferables;
+      this.timeout = options?.timeout;
+    }
+  }, _brand2 = new WeakMap(), _a2);
+  var CallOptions_default = CallOptions;
+  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);
+        }
+      }
+    );
+  };
+  var getDestroyedConnectionMethodCallError = (methodPath) => {
+    return new PenpalError_default(
+      "CONNECTION_DESTROYED",
+      `Method call ${formatMethodPath(
+        methodPath
+      )}() failed due to destroyed connection`
+    );
+  };
+  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);
+          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;
+  var getPromiseWithResolvers = () => {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return {
+      promise,
+      resolve,
+      reject
+    };
+  };
+  var getPromiseWithResolvers_default = getPromiseWithResolvers;
+  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;
+  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") {
+      return {
+        namespace: namespace_default,
+        channel: void 0,
+        type: "SYN",
+        participantId: DEPRECATED_PENPAL_PARTICIPANT_ID
+      };
+    }
+    if (message.penpal === "ack") {
+      return {
+        namespace: namespace_default,
+        channel: void 0,
+        type: "ACK2"
+      };
+    }
+    if (message.penpal === "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") {
+      if (message.resolution === "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);
+  };
+  var downgradeMessage = (message) => {
+    if (isAck1Message(message)) {
+      return {
+        penpal: "synAck",
+        methodNames: message.methodPaths.map(downgradeMethodPath)
+      };
+    }
+    if (isCallMessage(message)) {
+      return {
+        penpal: "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",
+          // Actually converting the ID to a number would break communication.
+          id: message.callId,
+          resolution: "rejected",
+          ...message.isSerializedErrorInstance ? {
+            returnValue: message.value,
+            returnValueIsError: true
+          } : { returnValue: message.value }
+        };
+      } else {
+        return {
+          penpal: "reply",
+          // Actually converting the ID to a number would break communication.
+          id: message.callId,
+          resolution: "fulfilled",
+          returnValue: message.value
+        };
+      }
+    }
+    throw getUnexpectedMessageError(message);
+  };
+  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 connectCallHandlerAndMethodProxies = () => {
+      if (isComplete) {
+        return;
+      }
+      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));
+      }
+    };
+    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;
+      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: 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;
+      }
+    };
+    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;
+      }
+      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;
+  };
+  var shakeHands_default = shakeHands;
+  var once = (fn) => {
+    let isCalled = false;
+    let result;
+    return (...args) => {
+      if (!isCalled) {
+        isCalled = true;
+        result = fn(...args);
+      }
+      return result;
+    };
+  };
+  var once_default = once;
+  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;
+  var _remoteWindow, _allowedOrigins, _log, _validateReceivedMessage, _concreteRemoteOrigin, _messageCallbacks, _port, _isChildUsingDeprecatedProtocol, _isAllowedOrigin, _getOriginForSendingMessage, _destroyPort, _handleMessageFromRemoteWindow, _handleMessageFromPort, _a3;
+  var WindowMessenger = (_a3 = class {
+    constructor({ remoteWindow, allowedOrigins }) {
+      __privateAdd(this, _remoteWindow);
+      __privateAdd(this, _allowedOrigins);
+      __privateAdd(this, _log);
+      __privateAdd(this, _validateReceivedMessage);
+      __privateAdd(this, _concreteRemoteOrigin);
+      __privateAdd(this, _messageCallbacks, /* @__PURE__ */ new Set());
+      __privateAdd(this, _port);
+      // TODO: Used for backward-compatibility. Remove in next major version.
+      __privateAdd(this, _isChildUsingDeprecatedProtocol, false);
+      __publicField(this, "initialize", ({
+        log,
+        validateReceivedMessage
+      }) => {
+        __privateSet(this, _log, log);
+        __privateSet(this, _validateReceivedMessage, validateReceivedMessage);
+        window.addEventListener("message", __privateGet(this, _handleMessageFromRemoteWindow));
+      });
+      __publicField(this, "sendMessage", (message, transferables) => {
+        if (isSynMessage(message)) {
+          const originForSending = __privateGet(this, _getOriginForSendingMessage).call(this, message);
+          __privateGet(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.
+        __privateGet(this, _isChildUsingDeprecatedProtocol)) {
+          const payload = __privateGet(this, _isChildUsingDeprecatedProtocol) ? downgradeMessage(message) : message;
+          const originForSending = __privateGet(this, _getOriginForSendingMessage).call(this, message);
+          __privateGet(this, _remoteWindow).postMessage(payload, {
+            targetOrigin: originForSending,
+            transfer: transferables
+          });
+          return;
+        }
+        if (isAck2Message(message)) {
+          const { port1, port2 } = new MessageChannel();
+          __privateSet(this, _port, port1);
+          port1.addEventListener("message", __privateGet(this, _handleMessageFromPort));
+          port1.start();
+          const transferablesToSend = [port2, ...transferables || []];
+          const originForSending = __privateGet(this, _getOriginForSendingMessage).call(this, message);
+          __privateGet(this, _remoteWindow).postMessage(message, {
+            targetOrigin: originForSending,
+            transfer: transferablesToSend
+          });
+          return;
+        }
+        if (__privateGet(this, _port)) {
+          __privateGet(this, _port).postMessage(message, {
+            transfer: transferables
+          });
+          return;
+        }
+        throw new PenpalBugError_default("Port is undefined");
+      });
+      __publicField(this, "addMessageHandler", (callback) => {
+        __privateGet(this, _messageCallbacks).add(callback);
+      });
+      __publicField(this, "removeMessageHandler", (callback) => {
+        __privateGet(this, _messageCallbacks).delete(callback);
+      });
+      __publicField(this, "destroy", () => {
+        window.removeEventListener("message", __privateGet(this, _handleMessageFromRemoteWindow));
+        __privateGet(this, _destroyPort).call(this);
+        __privateGet(this, _messageCallbacks).clear();
+      });
+      __privateAdd(this, _isAllowedOrigin, (origin) => {
+        return __privateGet(this, _allowedOrigins).some(
+          (allowedOrigin) => allowedOrigin instanceof RegExp ? allowedOrigin.test(origin) : allowedOrigin === origin || allowedOrigin === "*"
+        );
+      });
+      __privateAdd(this, _getOriginForSendingMessage, (message) => {
+        if (isSynMessage(message)) {
+          return "*";
+        }
+        if (!__privateGet(this, _concreteRemoteOrigin)) {
+          throw new PenpalBugError_default("Concrete remote origin not set");
+        }
+        return __privateGet(this, _concreteRemoteOrigin) === "null" && __privateGet(this, _allowedOrigins).includes("*") ? "*" : __privateGet(this, _concreteRemoteOrigin);
+      });
+      __privateAdd(this, _destroyPort, () => {
+        __privateGet(this, _port)?.removeEventListener("message", __privateGet(this, _handleMessageFromPort));
+        __privateGet(this, _port)?.close();
+        __privateSet(this, _port, void 0);
+      });
+      __privateAdd(this, _handleMessageFromRemoteWindow, ({
+        source,
+        origin,
+        ports,
+        data
+      }) => {
+        var _a4, _b, _c;
+        if (source !== __privateGet(this, _remoteWindow)) {
+          return;
+        }
+        if (isDeprecatedMessage(data)) {
+          (_a4 = __privateGet(this, _log)) == null ? void 0 : _a4.call(
+            this,
+            "Please upgrade the child window to the latest version of Penpal."
+          );
+          __privateSet(this, _isChildUsingDeprecatedProtocol, true);
+          data = upgradeMessage(data);
+        }
+        if (!((_b = __privateGet(this, _validateReceivedMessage)) == null ? void 0 : _b.call(this, data))) {
+          return;
+        }
+        if (!__privateGet(this, _isAllowedOrigin).call(this, origin)) {
+          (_c = __privateGet(this, _log)) == null ? void 0 : _c.call(
+            this,
+            `Received a message from origin \`${origin}\` which did not match allowed origins \`[${__privateGet(this, _allowedOrigins).join(", ")}]\``
+          );
+          return;
+        }
+        if (isSynMessage(data)) {
+          __privateGet(this, _destroyPort).call(this);
+          __privateSet(this, _concreteRemoteOrigin, origin);
+        }
+        if (isAck2Message(data) && // Previous versions of Penpal don't use MessagePorts and do all
+        // communication through the window.
+        !__privateGet(this, _isChildUsingDeprecatedProtocol)) {
+          __privateSet(this, _port, ports[0]);
+          if (!__privateGet(this, _port)) {
+            throw new PenpalBugError_default("No port received on ACK2");
+          }
+          __privateGet(this, _port).addEventListener("message", __privateGet(this, _handleMessageFromPort));
+          __privateGet(this, _port).start();
+        }
+        for (const callback of __privateGet(this, _messageCallbacks)) {
+          callback(data);
+        }
+      });
+      __privateAdd(this, _handleMessageFromPort, ({ data }) => {
+        var _a4;
+        if (!((_a4 = __privateGet(this, _validateReceivedMessage)) == null ? void 0 : _a4.call(this, data))) {
+          return;
+        }
+        for (const callback of __privateGet(this, _messageCallbacks)) {
+          callback(data);
+        }
+      });
+      if (!remoteWindow) {
+        throw new PenpalError_default("INVALID_ARGUMENT", "remoteWindow must be defined");
+      }
+      __privateSet(this, _remoteWindow, remoteWindow);
+      __privateSet(this, _allowedOrigins, allowedOrigins?.length ? allowedOrigins : [window.origin]);
+    }
+  }, _remoteWindow = new WeakMap(), _allowedOrigins = new WeakMap(), _log = new WeakMap(), _validateReceivedMessage = new WeakMap(), _concreteRemoteOrigin = new WeakMap(), _messageCallbacks = new WeakMap(), _port = new WeakMap(), _isChildUsingDeprecatedProtocol = new WeakMap(), _isAllowedOrigin = new WeakMap(), _getOriginForSendingMessage = new WeakMap(), _destroyPort = new WeakMap(), _handleMessageFromRemoteWindow = new WeakMap(), _handleMessageFromPort = new WeakMap(), _a3);
+  var WindowMessenger_default = WindowMessenger;
+
+  // src/penpal/index.ts
+  var connectToWindow = ({
+    window: window2,
+    methods
+  }) => {
+    const messenger = new WindowMessenger_default({
+      remoteWindow: window2,
+      // Allow all origins since the iframe is loaded from a trusted source (baseUrl)
+      // The security boundary is the checkout_token, not the origin
+      allowedOrigins: ["*"]
+    });
+    return connect_default({ methods, messenger });
+  };
+
+  // src/penpal/connect-tunnel-x.ts
+  var connectToTunnelXIframe = (iframe, methods) => {
+    return connectToWindow({ window: iframe.contentWindow, methods });
+  };
+  var _TunnelXManager = class _TunnelXManager {
+    constructor(penpalConn, penpalMethods) {
+      __publicField(this, "penpalConn");
+      __publicField(this, "_methods");
+      this.penpalConn = penpalConn;
+      this._methods = penpalMethods;
+    }
+    /**
+     * Makes publicEndpoints act like a real PK client, but actually forwards all calls
+     * through queryPublicEndpoint and sends it through penpal.
+     */
+    get publicEndpoints() {
+      const handler = {
+        get: (_target, prop) => {
+          return async (...args) => {
+            return await this._methods.queryPublicEndpoint(prop, args[0], args[1]);
+          };
+        }
+      };
+      return new Proxy({}, handler);
+    }
+    destroy() {
+      this.penpalConn.destroy();
+    }
+  };
+  __publicField(_TunnelXManager, "createFromPenpalConnection", async (penpalConn) => {
+    const methods = await penpalConn.promise;
+    const manager = new _TunnelXManager(penpalConn, methods);
+    return manager;
+  });
+  var TunnelXManager = _TunnelXManager;
+
+  // src/types.ts
+  var ENVIRONMENT_URLS = {
+    local: {
+      baseUrl: "http://localhost:9101",
+      apiBaseUrl: "http://localhost:9000"
+    },
+    sandbox: {
+      baseUrl: "https://staging.paymentkit.com/customer",
+      apiBaseUrl: "https://staging.paymentkit.com"
+    },
+    production: {
+      baseUrl: "https://paymentkit.com/customer",
+      apiBaseUrl: "https://paymentkit.com"
+    }
+  };
+  function getUrlsForEnvironment(environment) {
+    const env = environment;
+    const urls = ENVIRONMENT_URLS[env];
+    if (!urls) {
+      throw new Error(`Invalid environment: ${environment}. Must be one of: local, sandbox, production`);
+    }
+    return urls;
+  }
+
+  // ../../node_modules/valibot/dist/index.mjs
+  var store$4;
+  // @__NO_SIDE_EFFECTS__
+  function getGlobalConfig(config$1) {
+    return {
+      lang: config$1?.lang ?? store$4?.lang,
+      message: config$1?.message,
+      abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+      abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
+    };
+  }
+  var store$3;
+  // @__NO_SIDE_EFFECTS__
+  function getGlobalMessage(lang) {
+    return store$3?.get(lang);
+  }
+  var store$2;
+  // @__NO_SIDE_EFFECTS__
+  function getSchemaMessage(lang) {
+    return store$2?.get(lang);
+  }
+  var store$1;
+  // @__NO_SIDE_EFFECTS__
+  function getSpecificMessage(reference, lang) {
+    return store$1?.get(reference)?.get(lang);
+  }
+  // @__NO_SIDE_EFFECTS__
+  function _stringify(input) {
+    const type = typeof input;
+    if (type === "string") return `"${input}"`;
+    if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+    if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+    return type;
+  }
+  function _addIssue(context, label, dataset, config$1, other) {
+    const input = other && "input" in other ? other.input : dataset.value;
+    const expected = other?.expected ?? context.expects ?? null;
+    const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+    const issue = {
+      kind: context.kind,
+      type: context.type,
+      input,
+      expected,
+      received,
+      message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+      requirement: context.requirement,
+      path: other?.path,
+      issues: other?.issues,
+      lang: config$1.lang,
+      abortEarly: config$1.abortEarly,
+      abortPipeEarly: config$1.abortPipeEarly
+    };
+    const isSchema = context.kind === "schema";
+    const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+    if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+    if (isSchema) dataset.typed = false;
+    if (dataset.issues) dataset.issues.push(issue);
+    else dataset.issues = [issue];
+  }
+  // @__NO_SIDE_EFFECTS__
+  function _getStandardProps(context) {
+    return {
+      version: 1,
+      vendor: "valibot",
+      validate(value$1) {
+        return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function getDotPath(issue) {
+    if (issue.path) {
+      let key = "";
+      for (const item of issue.path) if (typeof item.key === "string" || typeof item.key === "number") if (key) key += `.${item.key}`;
+      else key += item.key;
+      else return null;
+      return key;
+    }
+    return null;
+  }
+  var EMAIL_REGEX = /^[\w+-]+(?:\.[\w+-]+)*@[\da-z]+(?:[.-][\da-z]+)*\.[a-z]{2,}$/iu;
+  // @__NO_SIDE_EFFECTS__
+  function email(message$1) {
+    return {
+      kind: "validation",
+      type: "email",
+      reference: email,
+      expects: null,
+      async: false,
+      requirement: EMAIL_REGEX,
+      message: message$1,
+      "~run"(dataset, config$1) {
+        if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "email", dataset, config$1);
+        return dataset;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function maxLength(requirement, message$1) {
+    return {
+      kind: "validation",
+      type: "max_length",
+      reference: maxLength,
+      async: false,
+      expects: `<=${requirement}`,
+      requirement,
+      message: message$1,
+      "~run"(dataset, config$1) {
+        if (dataset.typed && dataset.value.length > this.requirement) _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
+        return dataset;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function minLength(requirement, message$1) {
+    return {
+      kind: "validation",
+      type: "min_length",
+      reference: minLength,
+      async: false,
+      expects: `>=${requirement}`,
+      requirement,
+      message: message$1,
+      "~run"(dataset, config$1) {
+        if (dataset.typed && dataset.value.length < this.requirement) _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
+        return dataset;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function nonEmpty(message$1) {
+    return {
+      kind: "validation",
+      type: "non_empty",
+      reference: nonEmpty,
+      async: false,
+      expects: "!0",
+      message: message$1,
+      "~run"(dataset, config$1) {
+        if (dataset.typed && dataset.value.length === 0) _addIssue(this, "length", dataset, config$1, { received: "0" });
+        return dataset;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function getFallback(schema, dataset, config$1) {
+    return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function getDefault(schema, dataset, config$1) {
+    return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
+  }
+  // @__NO_SIDE_EFFECTS__
+  function object(entries$1, message$1) {
+    return {
+      kind: "schema",
+      type: "object",
+      reference: object,
+      expects: "Object",
+      async: false,
+      entries: entries$1,
+      message: message$1,
+      get "~standard"() {
+        return /* @__PURE__ */ _getStandardProps(this);
+      },
+      "~run"(dataset, config$1) {
+        const input = dataset.value;
+        if (input && typeof input === "object") {
+          dataset.typed = true;
+          dataset.value = {};
+          for (const key in this.entries) {
+            const valueSchema = this.entries[key];
+            if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+              const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+              const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+              if (valueDataset.issues) {
+                const pathItem = {
+                  type: "object",
+                  origin: "value",
+                  input,
+                  key,
+                  value: value$1
+                };
+                for (const issue of valueDataset.issues) {
+                  if (issue.path) issue.path.unshift(pathItem);
+                  else issue.path = [pathItem];
+                  dataset.issues?.push(issue);
+                }
+                if (!dataset.issues) dataset.issues = valueDataset.issues;
+                if (config$1.abortEarly) {
+                  dataset.typed = false;
+                  break;
+                }
+              }
+              if (!valueDataset.typed) dataset.typed = false;
+              dataset.value[key] = valueDataset.value;
+            } else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+            else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+              _addIssue(this, "key", dataset, config$1, {
+                input: void 0,
+                expected: `"${key}"`,
+                path: [{
+                  type: "object",
+                  origin: "key",
+                  input,
+                  key,
+                  value: input[key]
+                }]
+              });
+              if (config$1.abortEarly) break;
+            }
+          }
+        } else _addIssue(this, "type", dataset, config$1);
+        return dataset;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function string(message$1) {
+    return {
+      kind: "schema",
+      type: "string",
+      reference: string,
+      expects: "string",
+      async: false,
+      message: message$1,
+      get "~standard"() {
+        return /* @__PURE__ */ _getStandardProps(this);
+      },
+      "~run"(dataset, config$1) {
+        if (typeof dataset.value === "string") dataset.typed = true;
+        else _addIssue(this, "type", dataset, config$1);
+        return dataset;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function pipe(...pipe$1) {
+    return {
+      ...pipe$1[0],
+      pipe: pipe$1,
+      get "~standard"() {
+        return /* @__PURE__ */ _getStandardProps(this);
+      },
+      "~run"(dataset, config$1) {
+        for (const item of pipe$1) if (item.kind !== "metadata") {
+          if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+            dataset.typed = false;
+            break;
+          }
+          if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly) dataset = item["~run"](dataset, config$1);
+        }
+        return dataset;
+      }
+    };
+  }
+  // @__NO_SIDE_EFFECTS__
+  function safeParse(schema, input, config$1) {
+    const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+    return {
+      typed: dataset.typed,
+      success: !dataset.issues,
+      output: dataset.value,
+      issues: dataset.issues
+    };
+  }
+
+  // src/utils/validate-form-fields.ts
+  var validateFormFields = async (fields, options = {}) => {
+    const schema = object({
+      customer_name: pipe(
+        string("required"),
+        nonEmpty("required"),
+        minLength(4, "invalid"),
+        maxLength(40, "invalid")
+      ),
+      customer_email: pipe(string("required"), nonEmpty("required"), email("invalid")),
+      customer_country: pipe(string("required"), nonEmpty("required")),
+      customer_zip_code: options.optionalZipCode ? pipe(string("required")) : pipe(string("required"), nonEmpty("required"))
+    });
+    const result = safeParse(schema, fields);
+    if (result.issues) {
+      const errors = result.issues.reduce((errors2, issue) => {
+        const field = getDotPath(issue);
+        errors2[field] = issue.kind === "schema" ? "required" : issue.message;
+        return errors2;
+      }, {});
+      return { isSuccess: false, errors };
+    }
+    return { isSuccess: true };
+  };
+
+  // src/utils/index.ts
+  var $ = (selector) => {
+    const ele = document.querySelector(selector);
+    if (!ele) {
+      throw new Error(`Cannot find element with selector: ${selector}`);
+    }
+    return ele;
+  };
+  var definePaymentMethod = (paymentMethod) => paymentMethod;
+  var createCheckoutIFrame = (type, baseUrl, params) => {
+    const iframe = document.createElement("iframe");
+    const searchParams = new URLSearchParams(params);
+    const searchParamsStr = searchParams.toString();
+    iframe.src = `${baseUrl}/embeds/v1/${type}${searchParamsStr ? `?${searchParamsStr}` : ""}`;
+    Object.assign(iframe.style, { width: "100%", height: "100%", border: "none" });
+    return iframe;
+  };
+  function collectFraudMetadata() {
+    return {
+      ipAddress: void 0,
+      // IP address should be collected server-side
+      browserInfo: {
+        userAgent: navigator.userAgent,
+        language: navigator.language,
+        screenHeight: window.screen.height,
+        screenWidth: window.screen.width,
+        colorDepth: window.screen.colorDepth,
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+      },
+      processorFraudInfo: void 0
+    };
+  }
+
+  // src/index.ts
+  var createTunnelXConnection = (baseUrl, apiBaseUrl, token) => {
+    const iframe = createCheckoutIFrame("tunnel-x", baseUrl, {
+      checkout_token: token,
+      api_base_url: apiBaseUrl
+    });
+    document.body.appendChild(iframe);
+    const connection = connectToTunnelXIframe(iframe, {});
+    const unmount = () => {
+      connection.destroy();
+      document.body.removeChild(iframe);
+    };
+    return { unmount, connection };
+  };
+  var PaymentKit = ({ environment, secureToken, paymentMethods }) => {
+    const { baseUrl, apiBaseUrl } = getUrlsForEnvironment(environment);
+    console.log(`[PaymentKit] v${version} initialized (env: ${environment})`);
+    const { connection: tunnelXConnection, unmount: unmountTunnelX } = createTunnelXConnection(
+      baseUrl,
+      apiBaseUrl,
+      secureToken
+    );
+    const paymentKitStates = {
+      baseUrl,
+      apiBaseUrl,
+      secureToken,
+      tunnelXConnection
+    };
+    const pmInstances = paymentMethods.map((paymentMethod) => paymentMethod(paymentKitStates));
+    const externalFuncsMapByPm = pmInstances.reduce(
+      (acc, { name, externalFuncs }) => {
+        acc[name] = externalFuncs;
+        return acc;
+      },
+      {}
+    );
+    const submit = ({
+      paymentMethod: paymentMethodName,
+      fields,
+      options,
+      onSuccess,
+      onError
+    }) => {
+      const paymentMethod = pmInstances.find(({ name }) => name === paymentMethodName);
+      if (!paymentMethod) {
+        onError({ root: "payment_method_not_found" });
+        return;
+      }
+      paymentMethod.internalFuncs.submitPayment(fields, options).then(({ data, errors }) => {
+        errors ? onError(errors) : onSuccess(data);
+      }).catch((e) => {
+        console.error("PaymentKit:submit:catch", e);
+        if (e?.response?.data) {
+          onError(e.response.data);
+        } else if (e?.message) {
+          onError({ root: e.message });
+        } else {
+          onError({ root: "unknown_error" });
+        }
+      });
+    };
+    const cleanup = () => {
+      for (const pm of pmInstances) {
+        if (pm.internalFuncs.cleanup) {
+          pm.internalFuncs.cleanup();
+        }
+      }
+      unmountTunnelX();
+    };
+    return {
+      submit,
+      cleanup,
+      ...externalFuncsMapByPm
+    };
+  };
+  var index_default = PaymentKit;
+
+  // src/penpal/connect-card.ts
+  var connectToCardIframe = (iframe, methods) => {
+    return connectToWindow({ window: iframe.contentWindow, methods });
+  };
+
+  // src/payment-methods/next-action-handlers.ts
+  var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  var isStripeJsPresent = () => "Stripe" in window;
+  var getLoadedStripe = async (publishableKey) => {
+    for (let i = 0; i < 10; i++) {
+      if (isStripeJsPresent()) {
+        break;
+      }
+      await sleep(500);
+    }
+    if (!isStripeJsPresent()) {
+      throw new Error(
+        'Stripe.js not loaded. Add this script tag to your HTML <head>:\n<script src="https://js.stripe.com/v3/"><\/script>'
+      );
+    }
+    const stripe = new window.Stripe(publishableKey);
+    return stripe;
+  };
+  var handleStripe3ds = async (nextAction) => {
+    console.log("3DS authentication required, loading Stripe...");
+    const { clientSecret, stripePk } = nextAction;
+    const stripe = await getLoadedStripe(stripePk);
+    const { error: stripeError } = await stripe.confirmCardPayment(clientSecret);
+    if (stripeError) {
+      console.error("3DS authentication failed:", stripeError);
+      return { success: false, error: stripeError.message || "3DS authentication failed" };
+    }
+    console.log("3DS authentication completed");
+    return { success: true };
+  };
+  var handleNextAction = async (nextAction) => {
+    switch (nextAction.type) {
+      case "stripe_3ds":
+        return handleStripe3ds(nextAction);
+      default:
+        return { success: false, error: `Unknown next action type: ${nextAction.type}` };
+    }
+  };
+
+  // src/payment-methods/card.ts
+  var splitName = (fullName) => {
+    const trimmed = fullName.trim();
+    const spaceIndex = trimmed.indexOf(" ");
+    if (spaceIndex === -1) {
+      return { firstName: trimmed };
+    }
+    return {
+      firstName: trimmed.substring(0, spaceIndex),
+      lastName: trimmed.substring(spaceIndex + 1).trim() || void 0
+    };
+  };
+  var mapFieldsToCustomerInfo = (fields) => {
+    const { firstName, lastName } = splitName(fields.customer_name);
+    return {
+      email: fields.customer_email || void 0,
+      firstName,
+      lastName,
+      billingAddress: fields.customer_country || fields.customer_zip_code ? {
+        country: fields.customer_country || void 0,
+        zipCode: fields.customer_zip_code || void 0
+      } : void 0
+    };
+  };
+  var defCreateElement = (states) => {
+    const { baseUrl, apiBaseUrl, cardInputConnections, secureToken } = states;
+    return (type, options) => {
+      const { style, onLoaded, onFocusChange } = options;
+      const mountIFrame = (parentSelector) => {
+        const parent = $(parentSelector);
+        const params = {
+          checkout_token: secureToken,
+          api_base_url: apiBaseUrl
+        };
+        if (style) {
+          params.style = JSON.stringify(style);
+        }
+        const iframe = createCheckoutIFrame(type.replace("_", "-"), baseUrl, params);
+        parent.appendChild(iframe);
+        iframe.onload = () => {
+          const connection = connectToCardIframe(iframe, {
+            onLoaded: onLoaded || (() => {
+            }),
+            onFocusChange: onFocusChange || (() => {
+            })
+          });
+          states.cardInputConnections[type] = connection;
+        };
+        const unmount = () => {
+          const connection = cardInputConnections[type];
+          connection?.destroy();
+          parent.removeChild(iframe);
+          states.cardInputConnections[type] = void 0;
+        };
+        return { unmount };
+      };
+      return { mount: mountIFrame };
+    };
+  };
+  var defSubmitPayment = (states) => {
+    const submitPayment = async (fields) => {
+      const tunnelX = await TunnelXManager.createFromPenpalConnection(states.tunnelXConnection);
+      const validateCardResult = await validateCardFields(states);
+      const validateFormResult = await validateFormFields(fields);
+      if (!(validateCardResult.isSuccess && validateFormResult.isSuccess)) {
+        return { errors: { ...validateCardResult.errors, ...validateFormResult.errors } };
+      }
+      if (!states.cardSetupIntentId) {
+        const res = await tunnelX.publicEndpoints.createCardSetupIntent({
+          checkoutToken: states.secureToken
+        });
+        states.cardSetupIntentId = res.cardSetupIntentId;
+      }
+      const submitCardResult = await submitCardFields(states);
+      if (!submitCardResult.isSuccess) {
+        return { errors: submitCardResult.errors };
+      }
+      const cardSetupIntent = await tunnelX.publicEndpoints.getCardSetupIntent({
+        cardSetupIntentId: states.cardSetupIntentId,
+        checkoutToken: states.secureToken
+      });
+      if (!cardSetupIntent.isCardAllSet) {
+        const errors = {};
+        if (!cardSetupIntent.isCardPanSet) errors.card_pan = "required";
+        if (!cardSetupIntent.isCardExpSet) errors.card_exp = "required";
+        if (!cardSetupIntent.isCardCvcSet) errors.card_cvc = "required";
+        return { errors };
+      }
+      console.log("Card setup intent is set \u2705", cardSetupIntent);
+      console.log("Fields", fields);
+      let currentResult = await tunnelX.publicEndpoints.cardCheckout({
+        checkoutToken: states.secureToken,
+        publicCardCheckoutRequest: {
+          cardSetupIntentId: states.cardSetupIntentId,
+          customerInfo: mapFieldsToCustomerInfo(fields),
+          fraudMetadata: collectFraudMetadata()
+        }
+      });
+      console.log("Card checkout result:", currentResult);
+      const MAX_USER_ACTIONS = 5;
+      let userActionCount = 0;
+      while (currentResult.nextAction && userActionCount < MAX_USER_ACTIONS) {
+        userActionCount++;
+        console.log(`Handling user action ${userActionCount}/${MAX_USER_ACTIONS}...`);
+        const actionResult = await handleNextAction(currentResult.nextAction);
+        console.log("User action completed, verifying checkout...");
+        const verifyResult = await tunnelX.publicEndpoints.cardCheckoutVerify({
+          checkoutToken: states.secureToken
+        });
+        if (verifyResult.nextAction) {
+          if (!actionResult.success) {
+            console.log("3DS failed but cascade triggered new action, continuing loop...");
+          } else {
+            console.log("Another user action required, continuing loop...");
+          }
+          currentResult = verifyResult;
+          continue;
+        }
+        if (!actionResult.success) {
+          console.log("3DS authentication failed, checkout concluded:", verifyResult);
+          return { errors: { root: actionResult.error } };
+        }
+        console.log("Card checkout verified \u2705", verifyResult);
+        return { data: verifyResult };
+      }
+      if (userActionCount >= MAX_USER_ACTIONS) {
+        console.error("Max user actions exceeded");
+        return { errors: { root: "Too many authentication attempts. Please try again." } };
+      }
+      console.log("Card checkout completed \u2705", currentResult);
+      return { data: currentResult };
+    };
+    return submitPayment;
+  };
+  var submitCardFields = async (states) => {
+    const errors = {};
+    const { cardSetupIntentId, cardInputConnections } = states;
+    const submitPromises = Object.entries(cardInputConnections).map(async ([_type, connection]) => {
+      const type = _type;
+      const remote = await connection.promise;
+      const result = await remote.onSubmit(cardSetupIntentId || "");
+      if ("error" in result) {
+        errors[type] = result.error;
+      }
+    });
+    await Promise.allSettled(submitPromises);
+    return {
+      errors,
+      isSuccess: Object.keys(errors).length === 0
+    };
+  };
+  var validateCardFields = async (states) => {
+    const errors = {};
+    const { cardInputConnections } = states;
+    const validatePromises = Object.entries(cardInputConnections).map(async ([_type, connection]) => {
+      const type = _type;
+      if (!connection) {
+        errors[type] = "penpal_not_connected";
+        return;
+      }
+      const remote = await connection.promise;
+      const errorMsg = await remote.onValidate();
+      if (errorMsg) {
+        errors[type] = errorMsg;
+      }
+    });
+    await Promise.allSettled(validatePromises);
+    return {
+      errors,
+      isSuccess: Object.keys(errors).length === 0
+    };
+  };
+  var CardPaymentMethod = definePaymentMethod((paymentKitStates) => {
+    const localStates = { ...paymentKitStates, cardInputConnections: {} };
+    return {
+      name: "card",
+      externalFuncs: {
+        createElement: defCreateElement(localStates)
+      },
+      internalFuncs: {
+        submitPayment: defSubmitPayment(localStates),
+        cleanup: () => {
+          for (const connection of Object.values(localStates.cardInputConnections)) {
+            connection?.destroy();
+          }
+          localStates.cardInputConnections = {};
+        }
+      }
+    };
+  });
+  var card_default = CardPaymentMethod;
+
+  // src/payment-methods/stripe-google-pay-adapter.ts
+  var StripeGooglePayAdapter = class {
+    constructor(mockScenario) {
+      __publicField(this, "stripe", null);
+      __publicField(this, "paymentRequest", null);
+      __publicField(this, "mockScenario");
+      this.mockScenario = mockScenario ?? "none" /* None */;
+    }
+    initialize(publishableKey) {
+      switch (this.mockScenario) {
+        case "none" /* None */: {
+          console.log("[GooglePay] initialize called");
+          if (!window.Stripe) {
+            console.log("[GooglePay] Stripe.js not loaded");
+            return false;
+          }
+          this.stripe = window.Stripe(publishableKey);
+          const success = this.stripe !== null;
+          console.log("[GooglePay] initialize result:", success);
+          return success;
+        }
+        case "success" /* Success */:
+        case "cancelled" /* Cancelled */: {
+          console.log("[MockGooglePay] initialize called");
+          console.log("[MockGooglePay] initialize result:", true);
+          return true;
+        }
+      }
+    }
+    createPaymentRequest(config) {
+      switch (this.mockScenario) {
+        case "none" /* None */: {
+          console.log("[GooglePay] createPaymentRequest called", config);
+          if (!this.stripe) {
+            throw new Error("Stripe not initialized");
+          }
+          this.paymentRequest = this.stripe.paymentRequest(config);
+          console.log("[GooglePay] paymentRequest created");
+          return;
+        }
+        case "success" /* Success */:
+        case "cancelled" /* Cancelled */: {
+          console.log("[MockGooglePay] createPaymentRequest called", config);
+          return;
+        }
+      }
+    }
+    async canMakePayment() {
+      switch (this.mockScenario) {
+        case "none" /* None */: {
+          console.log("[GooglePay] canMakePayment called");
+          if (!this.paymentRequest) {
+            console.log("[GooglePay] canMakePayment: no paymentRequest");
+            return false;
+          }
+          const result = await this.paymentRequest.canMakePayment();
+          const isAvailable = result?.googlePay ?? false;
+          console.log("[GooglePay] canMakePayment result:", { result, isAvailable });
+          return isAvailable;
+        }
+        case "success" /* Success */:
+        case "cancelled" /* Cancelled */: {
+          console.log("[MockGooglePay] canMakePayment called");
+          console.log("[MockGooglePay] canMakePayment result:", { result: { googlePay: true }, isAvailable: true });
+          return true;
+        }
+      }
+    }
+    async showPaymentSheet() {
+      switch (this.mockScenario) {
+        case "none" /* None */: {
+          console.log("[GooglePay] showPaymentSheet called");
+          if (!this.paymentRequest) {
+            console.log("[GooglePay] showPaymentSheet: no paymentRequest");
+            return { success: false, error: "Payment request not created" };
+          }
+          return new Promise((resolve) => {
+            this.paymentRequest.on("paymentmethod", (event) => {
+              console.log("[GooglePay] showPaymentSheet: paymentmethod event", {
+                paymentMethodId: event.paymentMethod.id
+              });
+              resolve({
+                success: true,
+                paymentMethodId: event.paymentMethod.id,
+                complete: (status) => {
+                  console.log("[GooglePay] complete called:", status);
+                  event.complete(status);
+                }
+              });
+            });
+            this.paymentRequest.on("cancel", () => {
+              console.log("[GooglePay] showPaymentSheet: cancelled by user");
+              resolve({ success: false, cancelled: true });
+            });
+            console.log("[GooglePay] showing payment sheet...");
+            this.paymentRequest.show();
+          });
+        }
+        case "success" /* Success */: {
+          console.log("[MockGooglePay] showPaymentSheet: success");
+          await new Promise((resolve) => setTimeout(resolve, 500));
+          return {
+            success: true,
+            paymentMethodId: "pm_mock_123456789",
+            complete: (status) => console.log(`[MockGooglePay] complete: ${status}`)
+          };
+        }
+        case "cancelled" /* Cancelled */: {
+          console.log("[MockGooglePay] showPaymentSheet: cancelled");
+          await new Promise((resolve) => setTimeout(resolve, 500));
+          return { success: false, cancelled: true };
+        }
+      }
+    }
+    async confirmCardSetup(clientSecret, paymentMethodId) {
+      switch (this.mockScenario) {
+        case "none" /* None */: {
+          console.log("[GooglePay] confirmCardSetup called", {
+            clientSecret: `${clientSecret.slice(0, 20)}...`,
+            paymentMethodId
+          });
+          if (!this.stripe) {
+            console.log("[GooglePay] confirmCardSetup: Stripe not initialized");
+            return { success: false, error: "Stripe not initialized" };
+          }
+          const { error } = await this.stripe.confirmCardSetup(clientSecret, {
+            payment_method: paymentMethodId
+          });
+          if (error) {
+            console.log("[GooglePay] confirmCardSetup error:", error);
+            return { success: false, error: error.message ?? "Card setup failed" };
+          }
+          console.log("[GooglePay] confirmCardSetup success");
+          return { success: true };
+        }
+        case "success" /* Success */: {
+          console.log("[MockGooglePay] confirmCardSetup called", { clientSecret, paymentMethodId });
+          return { success: true };
+        }
+        case "cancelled" /* Cancelled */: {
+          throw new Error("confirmCardSetup should not be called when scenario is Cancelled");
+        }
+      }
+    }
+  };
+
+  // src/payment-methods/google-pay.ts
+  async function apiCall(url, options) {
+    const response = await fetch(url, options);
+    if (!response.ok) {
+      let errorMessage = `Request failed (${response.status})`;
+      try {
+        const errorData = await response.json();
+        errorMessage = errorData.detail || errorMessage;
+      } catch {
+        errorMessage = response.statusText || errorMessage;
+      }
+      return { error: errorMessage };
+    }
+    return { data: await response.json() };
+  }
+  function validateOptions(options) {
+    if (!options?.processorId) {
+      return { processor_id: "Processor ID is required" };
+    }
+    if (!options?.customerInfo?.first_name || !options?.customerInfo?.last_name) {
+      return { customer_name: "Customer first and last name are required" };
+    }
+    return null;
+  }
+  function getMockScenarioStr(mockScenario) {
+    return mockScenario && mockScenario !== "none" /* None */ ? mockScenario : void 0;
+  }
+  async function callStartEndpoint(apiBaseUrl, secureToken, options, mockScenarioStr) {
+    return apiCall(`${apiBaseUrl}/api/checkout/${secureToken}/google-pay/start`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        processor_id: options.processorId,
+        customer_info: options.customerInfo,
+        fraud_metadata: collectFraudMetadata(),
+        mock_scenario: mockScenarioStr
+      })
+    });
+  }
+  function initializeAdapter(stripePk, startData, mockScenario) {
+    const adapter = new StripeGooglePayAdapter(mockScenario);
+    if (!adapter.initialize(stripePk)) {
+      return { error: 'Stripe.js not loaded. Add <script src="https://js.stripe.com/v3/"><\/script> to your page.' };
+    }
+    const prConfig = {
+      country: startData.country,
+      currency: startData.currency.toLowerCase(),
+      total: { label: "Total", amount: startData.amount },
+      requestPayerName: true,
+      requestPayerEmail: true
+    };
+    console.log("[GooglePay] PaymentRequest config:", prConfig);
+    adapter.createPaymentRequest(prConfig);
+    return { adapter };
+  }
+  async function showPaymentSheetAndConfirm(adapter, clientSecret) {
+    const isAvailable = await adapter.canMakePayment();
+    console.log("[GooglePay] canMakePayment result:", isAvailable);
+    if (!isAvailable) {
+      return { success: false, error: "Google Pay not available on this device" };
+    }
+    const paymentResult = await adapter.showPaymentSheet();
+    if (!paymentResult.success) {
+      if ("cancelled" in paymentResult && paymentResult.cancelled) {
+        return { success: false, error: "Google Pay cancelled by user" };
+      }
+      const errorMessage = "error" in paymentResult ? paymentResult.error : "Unknown error";
+      return { success: false, error: errorMessage };
+    }
+    const confirmResult = await adapter.confirmCardSetup(clientSecret, paymentResult.paymentMethodId);
+    if (!confirmResult.success) {
+      paymentResult.complete("fail");
+      return { success: false, error: confirmResult.error };
+    }
+    paymentResult.complete("success");
+    return { success: true };
+  }
+  async function callConfirmEndpoint(apiBaseUrl, secureToken, mockScenarioStr) {
+    const result = await apiCall(
+      `${apiBaseUrl}/api/checkout/${secureToken}/google-pay/confirm`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ mock_scenario: mockScenarioStr })
+      }
+    );
+    if (result.error || !result.data) {
+      return { errors: { google_pay: result.error || "Failed to confirm payment" } };
+    }
+    const confirmData = result.data;
+    if (confirmData.charge_status === "success") {
+      return {
+        data: {
+          id: confirmData.transaction_id,
+          checkoutAttemptId: confirmData.checkout_attempt_id,
+          checkoutSessionId: secureToken,
+          state: "checkout_succeeded"
+        }
+      };
+    }
+    return { errors: { google_pay: confirmData.error_message || "Payment failed" } };
+  }
+  var defSubmitPayment2 = (states) => {
+    const submitPayment = async (_fields, options) => {
+      const { apiBaseUrl, secureToken } = states;
+      const gpayOptions = options;
+      const validationError = validateOptions(gpayOptions);
+      if (validationError) {
+        return { errors: validationError };
+      }
+      try {
+        const mockScenarioStr = getMockScenarioStr(gpayOptions.mockScenario);
+        const startResult = await callStartEndpoint(apiBaseUrl, secureToken, gpayOptions, mockScenarioStr);
+        if (startResult.error || !startResult.data) {
+          return { errors: { google_pay: startResult.error || "Failed to start Google Pay" } };
+        }
+        const { adapter, error: adapterError } = initializeAdapter(
+          startResult.data.stripe_pk,
+          startResult.data,
+          gpayOptions.mockScenario
+        );
+        if (!adapter) {
+          return { errors: { google_pay: adapterError } };
+        }
+        const paymentResult = await showPaymentSheetAndConfirm(adapter, startResult.data.client_secret);
+        if (!paymentResult.success) {
+          return { errors: { google_pay: paymentResult.error } };
+        }
+        return await callConfirmEndpoint(apiBaseUrl, secureToken, mockScenarioStr);
+      } catch (error) {
+        return { errors: { google_pay: `Google Pay error: ${error}` } };
+      }
+    };
+    return submitPayment;
+  };
+  var GooglePayPaymentMethod = definePaymentMethod((paymentKitStates) => {
+    return {
+      name: "google_pay",
+      externalFuncs: {},
+      internalFuncs: {
+        submitPayment: defSubmitPayment2(paymentKitStates),
+        cleanup: () => {
+        }
+      }
+    };
+  });
+  var google_pay_default = GooglePayPaymentMethod;
+
+  // src/payment-methods/paypal.ts
+  var defSubmitPayment3 = (states) => {
+    const submitPayment = async (_fields, options) => {
+      const { apiBaseUrl, secureToken } = states;
+      const paypalOptions = options;
+      if (!paypalOptions?.processorId) {
+        return { errors: { processor_id: "Processor ID is required" } };
+      }
+      if (!paypalOptions?.customerInfo?.first_name || !paypalOptions?.customerInfo?.last_name) {
+        return {
+          errors: {
+            customer_name: "Customer first and last name are required"
+          }
+        };
+      }
+      try {
+        const startResponse = await fetch(`${apiBaseUrl}/api/checkout/${secureToken}/paypal/start`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            processor_id: paypalOptions.processorId,
+            customer_info: paypalOptions.customerInfo,
+            fraud_metadata: collectFraudMetadata()
+          })
+        });
+        if (!startResponse.ok) {
+          let errorMessage = `Failed to start PayPal checkout (${startResponse.status})`;
+          try {
+            const errorData = await startResponse.json();
+            errorMessage = errorData.detail || errorMessage;
+          } catch {
+            errorMessage = startResponse.statusText || errorMessage;
+          }
+          return {
+            errors: {
+              paypal: errorMessage
+            }
+          };
+        }
+        const { approval_url, popup_token, checkout_attempt_id } = await startResponse.json();
+        const popup = window.open(approval_url, "PayPal", "width=600,height=700");
+        if (!popup) {
+          return {
+            errors: {
+              paypal: "Failed to open PayPal popup. Please allow popups for this site."
+            }
+          };
+        }
+        states.popup = popup;
+        return new Promise((resolve) => {
+          const pollInterval = setInterval(async () => {
+            try {
+              const statusResponse = await fetch(
+                `${apiBaseUrl}/api/checkout/${secureToken}/popup/status?popup_token=${popup_token}`
+              );
+              if (!statusResponse.ok) {
+                clearInterval(pollInterval);
+                popup.close();
+                resolve({
+                  errors: {
+                    paypal: "Failed to check PayPal status"
+                  }
+                });
+                return;
+              }
+              const statusResult = await statusResponse.json();
+              if (statusResult.completed) {
+                clearInterval(pollInterval);
+                popup.close();
+                if (statusResult.status === "success") {
+                  const result = statusResult.result || {
+                    id: checkout_attempt_id,
+                    checkoutAttemptId: checkout_attempt_id,
+                    checkoutSessionId: secureToken,
+                    state: "checkout_succeeded"
+                  };
+                  resolve({ data: result });
+                } else {
+                  resolve({
+                    errors: {
+                      paypal: statusResult.error || `PayPal checkout ${statusResult.status}`
+                    }
+                  });
+                }
+                return;
+              }
+              if (popup.closed) {
+                clearInterval(pollInterval);
+                resolve({
+                  errors: {
+                    paypal: "PayPal popup closed by user"
+                  }
+                });
+                return;
+              }
+            } catch (error) {
+              clearInterval(pollInterval);
+              popup.close();
+              resolve({
+                errors: {
+                  paypal: `Polling error: ${error}`
+                }
+              });
+            }
+          }, 2e3);
+          states.pollInterval = pollInterval;
+        });
+      } catch (error) {
+        return {
+          errors: {
+            paypal: `PayPal checkout error: ${error}`
+          }
+        };
+      }
+    };
+    return submitPayment;
+  };
+  var PayPalPaymentMethod = definePaymentMethod((paymentKitStates) => {
+    const localStates = { ...paymentKitStates };
+    return {
+      name: "paypal",
+      externalFuncs: {
+        // PayPal doesn't need createElement like card iframes
+      },
+      internalFuncs: {
+        submitPayment: defSubmitPayment3(localStates),
+        cleanup: () => {
+          if (localStates.pollInterval) {
+            clearInterval(localStates.pollInterval);
+          }
+          if (localStates.popup && !localStates.popup.closed) {
+            localStates.popup.close();
+          }
+        }
+      }
+    };
+  });
+  var paypal_default = PayPalPaymentMethod;
+
+  // src/cdn.ts
+  var cdn_default = index_default;
+  var PaymentMethods = {
+    card: card_default,
+    googlePay: google_pay_default,
+    paypal: paypal_default
+  };
+  return __toCommonJS(cdn_exports);
+})();
+//# sourceMappingURL=paymentkit.js.map