@appfunnel-dev/sdk 2.0.0-canary.1 → 2.0.0-canary.11

package/dist/driver-paddle.js

@@ -0,0 +1,814 @@
+import { completeWithPoll, postComplete, settlementToResult, postSession, leaveForRedirect, toCheckoutError } from './chunk-JAO6AA4R.js';
+import { checkoutError } from './chunk-OXQBEKZ5.js';
+import './chunk-G3PMV62Z.js';
+import { createElement, useState, useId, useRef, useEffect } from 'react';
+
+// ../../node_modules/@paddle/paddle-js/dist/index.esm.js
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c), u = i.value;
+  } catch (n2) {
+    return void e(n2);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function() {
+    var t = this, e = arguments;
+    return new Promise(function(r, o) {
+      var a = n.apply(t, e);
+      function _next(n2) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n2);
+      }
+      function _throw(n2) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n2);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
+      _defineProperty(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+    });
+  }
+  return e;
+}
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o, r, i = _objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var s = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (e.includes(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+function _regeneratorRuntime() {
+  _regeneratorRuntime = function() {
+    return e;
+  };
+  var t, e = {}, r = Object.prototype, n = r.hasOwnProperty, o = Object.defineProperty || function(t2, e2, r2) {
+    t2[e2] = r2.value;
+  }, i = "function" == typeof Symbol ? Symbol : {}, a = i.iterator || "@@iterator", c = i.asyncIterator || "@@asyncIterator", u = i.toStringTag || "@@toStringTag";
+  function define(t2, e2, r2) {
+    return Object.defineProperty(t2, e2, {
+      value: r2,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }), t2[e2];
+  }
+  try {
+    define({}, "");
+  } catch (t2) {
+    define = function(t3, e2, r2) {
+      return t3[e2] = r2;
+    };
+  }
+  function wrap(t2, e2, r2, n2) {
+    var i2 = e2 && e2.prototype instanceof Generator ? e2 : Generator, a2 = Object.create(i2.prototype), c2 = new Context(n2 || []);
+    return o(a2, "_invoke", {
+      value: makeInvokeMethod(t2, r2, c2)
+    }), a2;
+  }
+  function tryCatch(t2, e2, r2) {
+    try {
+      return {
+        type: "normal",
+        arg: t2.call(e2, r2)
+      };
+    } catch (t3) {
+      return {
+        type: "throw",
+        arg: t3
+      };
+    }
+  }
+  e.wrap = wrap;
+  var h = "suspendedStart", l = "suspendedYield", f = "executing", s = "completed", y = {};
+  function Generator() {
+  }
+  function GeneratorFunction() {
+  }
+  function GeneratorFunctionPrototype() {
+  }
+  var p = {};
+  define(p, a, function() {
+    return this;
+  });
+  var d = Object.getPrototypeOf, v = d && d(d(values([])));
+  v && v !== r && n.call(v, a) && (p = v);
+  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+  function defineIteratorMethods(t2) {
+    ["next", "throw", "return"].forEach(function(e2) {
+      define(t2, e2, function(t3) {
+        return this._invoke(e2, t3);
+      });
+    });
+  }
+  function AsyncIterator(t2, e2) {
+    function invoke(r3, o2, i2, a2) {
+      var c2 = tryCatch(t2[r3], t2, o2);
+      if ("throw" !== c2.type) {
+        var u2 = c2.arg, h2 = u2.value;
+        return h2 && "object" == typeof h2 && n.call(h2, "__await") ? e2.resolve(h2.__await).then(function(t3) {
+          invoke("next", t3, i2, a2);
+        }, function(t3) {
+          invoke("throw", t3, i2, a2);
+        }) : e2.resolve(h2).then(function(t3) {
+          u2.value = t3, i2(u2);
+        }, function(t3) {
+          return invoke("throw", t3, i2, a2);
+        });
+      }
+      a2(c2.arg);
+    }
+    var r2;
+    o(this, "_invoke", {
+      value: function(t3, n2) {
+        function callInvokeWithMethodAndArg() {
+          return new e2(function(e3, r3) {
+            invoke(t3, n2, e3, r3);
+          });
+        }
+        return r2 = r2 ? r2.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+      }
+    });
+  }
+  function makeInvokeMethod(e2, r2, n2) {
+    var o2 = h;
+    return function(i2, a2) {
+      if (o2 === f) throw Error("Generator is already running");
+      if (o2 === s) {
+        if ("throw" === i2) throw a2;
+        return {
+          value: t,
+          done: true
+        };
+      }
+      for (n2.method = i2, n2.arg = a2; ; ) {
+        var c2 = n2.delegate;
+        if (c2) {
+          var u2 = maybeInvokeDelegate(c2, n2);
+          if (u2) {
+            if (u2 === y) continue;
+            return u2;
+          }
+        }
+        if ("next" === n2.method) n2.sent = n2._sent = n2.arg;
+        else if ("throw" === n2.method) {
+          if (o2 === h) throw o2 = s, n2.arg;
+          n2.dispatchException(n2.arg);
+        } else "return" === n2.method && n2.abrupt("return", n2.arg);
+        o2 = f;
+        var p2 = tryCatch(e2, r2, n2);
+        if ("normal" === p2.type) {
+          if (o2 = n2.done ? s : l, p2.arg === y) continue;
+          return {
+            value: p2.arg,
+            done: n2.done
+          };
+        }
+        "throw" === p2.type && (o2 = s, n2.method = "throw", n2.arg = p2.arg);
+      }
+    };
+  }
+  function maybeInvokeDelegate(e2, r2) {
+    var n2 = r2.method, o2 = e2.iterator[n2];
+    if (o2 === t) return r2.delegate = null, "throw" === n2 && e2.iterator.return && (r2.method = "return", r2.arg = t, maybeInvokeDelegate(e2, r2), "throw" === r2.method) || "return" !== n2 && (r2.method = "throw", r2.arg = new TypeError("The iterator does not provide a '" + n2 + "' method")), y;
+    var i2 = tryCatch(o2, e2.iterator, r2.arg);
+    if ("throw" === i2.type) return r2.method = "throw", r2.arg = i2.arg, r2.delegate = null, y;
+    var a2 = i2.arg;
+    return a2 ? a2.done ? (r2[e2.resultName] = a2.value, r2.next = e2.nextLoc, "return" !== r2.method && (r2.method = "next", r2.arg = t), r2.delegate = null, y) : a2 : (r2.method = "throw", r2.arg = new TypeError("iterator result is not an object"), r2.delegate = null, y);
+  }
+  function pushTryEntry(t2) {
+    var e2 = {
+      tryLoc: t2[0]
+    };
+    1 in t2 && (e2.catchLoc = t2[1]), 2 in t2 && (e2.finallyLoc = t2[2], e2.afterLoc = t2[3]), this.tryEntries.push(e2);
+  }
+  function resetTryEntry(t2) {
+    var e2 = t2.completion || {};
+    e2.type = "normal", delete e2.arg, t2.completion = e2;
+  }
+  function Context(t2) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], t2.forEach(pushTryEntry, this), this.reset(true);
+  }
+  function values(e2) {
+    if (e2 || "" === e2) {
+      var r2 = e2[a];
+      if (r2) return r2.call(e2);
+      if ("function" == typeof e2.next) return e2;
+      if (!isNaN(e2.length)) {
+        var o2 = -1, i2 = function next() {
+          for (; ++o2 < e2.length; ) if (n.call(e2, o2)) return next.value = e2[o2], next.done = false, next;
+          return next.value = t, next.done = true, next;
+        };
+        return i2.next = i2;
+      }
+    }
+    throw new TypeError(typeof e2 + " is not iterable");
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
+    value: GeneratorFunctionPrototype,
+    configurable: true
+  }), o(GeneratorFunctionPrototype, "constructor", {
+    value: GeneratorFunction,
+    configurable: true
+  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function(t2) {
+    var e2 = "function" == typeof t2 && t2.constructor;
+    return !!e2 && (e2 === GeneratorFunction || "GeneratorFunction" === (e2.displayName || e2.name));
+  }, e.mark = function(t2) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(t2, GeneratorFunctionPrototype) : (t2.__proto__ = GeneratorFunctionPrototype, define(t2, u, "GeneratorFunction")), t2.prototype = Object.create(g), t2;
+  }, e.awrap = function(t2) {
+    return {
+      __await: t2
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function() {
+    return this;
+  }), e.AsyncIterator = AsyncIterator, e.async = function(t2, r2, n2, o2, i2) {
+    void 0 === i2 && (i2 = Promise);
+    var a2 = new AsyncIterator(wrap(t2, r2, n2, o2), i2);
+    return e.isGeneratorFunction(r2) ? a2 : a2.next().then(function(t3) {
+      return t3.done ? t3.value : a2.next();
+    });
+  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function() {
+    return this;
+  }), define(g, "toString", function() {
+    return "[object Generator]";
+  }), e.keys = function(t2) {
+    var e2 = Object(t2), r2 = [];
+    for (var n2 in e2) r2.push(n2);
+    return r2.reverse(), function next() {
+      for (; r2.length; ) {
+        var t3 = r2.pop();
+        if (t3 in e2) return next.value = t3, next.done = false, next;
+      }
+      return next.done = true, next;
+    };
+  }, e.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function(e2) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = false, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e2) for (var r2 in this) "t" === r2.charAt(0) && n.call(this, r2) && !isNaN(+r2.slice(1)) && (this[r2] = t);
+    },
+    stop: function() {
+      this.done = true;
+      var t2 = this.tryEntries[0].completion;
+      if ("throw" === t2.type) throw t2.arg;
+      return this.rval;
+    },
+    dispatchException: function(e2) {
+      if (this.done) throw e2;
+      var r2 = this;
+      function handle(n2, o3) {
+        return a2.type = "throw", a2.arg = e2, r2.next = n2, o3 && (r2.method = "next", r2.arg = t), !!o3;
+      }
+      for (var o2 = this.tryEntries.length - 1; o2 >= 0; --o2) {
+        var i2 = this.tryEntries[o2], a2 = i2.completion;
+        if ("root" === i2.tryLoc) return handle("end");
+        if (i2.tryLoc <= this.prev) {
+          var c2 = n.call(i2, "catchLoc"), u2 = n.call(i2, "finallyLoc");
+          if (c2 && u2) {
+            if (this.prev < i2.catchLoc) return handle(i2.catchLoc, true);
+            if (this.prev < i2.finallyLoc) return handle(i2.finallyLoc);
+          } else if (c2) {
+            if (this.prev < i2.catchLoc) return handle(i2.catchLoc, true);
+          } else {
+            if (!u2) throw Error("try statement without catch or finally");
+            if (this.prev < i2.finallyLoc) return handle(i2.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function(t2, e2) {
+      for (var r2 = this.tryEntries.length - 1; r2 >= 0; --r2) {
+        var o2 = this.tryEntries[r2];
+        if (o2.tryLoc <= this.prev && n.call(o2, "finallyLoc") && this.prev < o2.finallyLoc) {
+          var i2 = o2;
+          break;
+        }
+      }
+      i2 && ("break" === t2 || "continue" === t2) && i2.tryLoc <= e2 && e2 <= i2.finallyLoc && (i2 = null);
+      var a2 = i2 ? i2.completion : {};
+      return a2.type = t2, a2.arg = e2, i2 ? (this.method = "next", this.next = i2.finallyLoc, y) : this.complete(a2);
+    },
+    complete: function(t2, e2) {
+      if ("throw" === t2.type) throw t2.arg;
+      return "break" === t2.type || "continue" === t2.type ? this.next = t2.arg : "return" === t2.type ? (this.rval = this.arg = t2.arg, this.method = "return", this.next = "end") : "normal" === t2.type && e2 && (this.next = e2), y;
+    },
+    finish: function(t2) {
+      for (var e2 = this.tryEntries.length - 1; e2 >= 0; --e2) {
+        var r2 = this.tryEntries[e2];
+        if (r2.finallyLoc === t2) return this.complete(r2.completion, r2.afterLoc), resetTryEntry(r2), y;
+      }
+    },
+    catch: function(t2) {
+      for (var e2 = this.tryEntries.length - 1; e2 >= 0; --e2) {
+        var r2 = this.tryEntries[e2];
+        if (r2.tryLoc === t2) {
+          var n2 = r2.completion;
+          if ("throw" === n2.type) {
+            var o2 = n2.arg;
+            resetTryEntry(r2);
+          }
+          return o2;
+        }
+      }
+      throw Error("illegal catch attempt");
+    },
+    delegateYield: function(e2, r2, n2) {
+      return this.delegate = {
+        iterator: values(e2),
+        resultName: r2,
+        nextLoc: n2
+      }, "next" === this.method && (this.arg = t), y;
+    }
+  }, e;
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+var Versions = {
+  CLASSIC: "classic",
+  V1: "v1"
+};
+var DefaultVersion = Versions.V1;
+var PaddleClassicCDNUrl = "https://cdn.paddle.com/paddle/paddle.js";
+var PaddleBillingCDNUrl = "https://cdn.paddle.com/paddle/v2/paddle.js";
+var PaddleClassicInfo = {
+  url: PaddleClassicCDNUrl
+};
+var PaddleBillingV1Info = {
+  url: PaddleBillingCDNUrl
+};
+function findScript(cdnUrl) {
+  return document.querySelector('script[src="'.concat(cdnUrl, '"]')) || void 0;
+}
+function injectScript(src) {
+  var script = document.createElement("script");
+  script.src = src;
+  var headOrBody = document.head || document.body;
+  if (!headOrBody) {
+    throw new Error("Cannot inject Paddle.js. It needs a <head> or <body> element.");
+  }
+  headOrBody.appendChild(script);
+  return script;
+}
+var promiseMap = {
+  classic: void 0,
+  v1: void 0
+};
+var VersionToPaddleMap = {
+  classic: "PaddleClassic",
+  v1: "PaddleBillingV1"
+};
+function loadFromCDN(version) {
+  var _getCDNInfoBasedOnVer;
+  var cdnUrl = (_getCDNInfoBasedOnVer = getCDNInfoBasedOnVersion(version)) === null || _getCDNInfoBasedOnVer === void 0 ? void 0 : _getCDNInfoBasedOnVer.url;
+  if (!cdnUrl) {
+    return;
+  }
+  var existingPromise = promiseMap[version];
+  var paddleInstanceName = VersionToPaddleMap[version];
+  if (existingPromise !== void 0) {
+    return existingPromise;
+  }
+  promiseMap[version] = new Promise(function(resolve, reject) {
+    if (typeof window === "undefined") {
+      resolve(void 0);
+      return;
+    }
+    if (window[paddleInstanceName]) {
+      resolve(window[paddleInstanceName]);
+      return;
+    }
+    try {
+      var script = findScript(cdnUrl);
+      if (!script) {
+        script = injectScript(cdnUrl);
+      }
+      script.addEventListener("load", function() {
+        if (window[paddleInstanceName]) {
+          resolve(window[paddleInstanceName]);
+        } else {
+          reject(new Error("Paddle.js not available"));
+        }
+      });
+      script.addEventListener("error", function() {
+        reject(new Error("Failed to load Paddle.js - ".concat(version)));
+      });
+    } catch (error) {
+      reject(error);
+      return;
+    }
+  });
+  return promiseMap[version];
+}
+function getCDNInfoBasedOnVersion(version) {
+  if (version === Versions.CLASSIC) {
+    return PaddleClassicInfo;
+  }
+  if (version === Versions.V1) {
+    return PaddleBillingV1Info;
+  } else {
+    console.error("[Paddle] Unknown Paddle Version");
+    return;
+  }
+}
+var _excluded = ["environment", "version"];
+var _excluded2 = ["environment", "version"];
+function initializePaddleBillingV1(options, paddle) {
+  var environment = options.environment;
+  options.version;
+  var rest = _objectWithoutProperties(options, _excluded);
+  try {
+    if (environment) {
+      paddle.Environment.set(environment);
+    }
+    if (paddle.Initialized) {
+      paddle.Update(_objectSpread2({}, rest));
+    } else {
+      paddle.Initialize(_objectSpread2({}, rest));
+    }
+  } catch (e) {
+    console.warn("[Paddle] Paddle Initialization failed. Please check the inputs", e);
+  }
+}
+function initializePaddleClassic(options, paddle) {
+  var environment = options.environment;
+  options.version;
+  var rest = _objectWithoutProperties(options, _excluded2);
+  try {
+    if (environment) {
+      paddle.Environment.set(environment);
+    }
+    paddle.Setup(_objectSpread2({}, rest));
+  } catch (e) {
+    console.warn("[Paddle] Paddle Initialization failed. Please check the inputs", e);
+  }
+}
+var CheckoutEventNames;
+(function(CheckoutEventNames2) {
+  CheckoutEventNames2["CHECKOUT_LOADED"] = "checkout.loaded";
+  CheckoutEventNames2["CHECKOUT_CLOSED"] = "checkout.closed";
+  CheckoutEventNames2["CHECKOUT_UPDATED"] = "checkout.updated";
+  CheckoutEventNames2["CHECKOUT_COMPLETED"] = "checkout.completed";
+  CheckoutEventNames2["CHECKOUT_ERROR"] = "checkout.error";
+  CheckoutEventNames2["CHECKOUT_FAILED"] = "checkout.failed";
+  CheckoutEventNames2["CHECKOUT_ITEMS_UPDATED"] = "checkout.items.updated";
+  CheckoutEventNames2["CHECKOUT_ITEMS_REMOVED"] = "checkout.items.removed";
+  CheckoutEventNames2["CHECKOUT_CUSTOMER_CREATED"] = "checkout.customer.created";
+  CheckoutEventNames2["CHECKOUT_CUSTOMER_UPDATED"] = "checkout.customer.updated";
+  CheckoutEventNames2["CHECKOUT_CUSTOMER_REMOVED"] = "checkout.customer.removed";
+  CheckoutEventNames2["CHECKOUT_PAYMENT_SELECTED"] = "checkout.payment.selected";
+  CheckoutEventNames2["CHECKOUT_PAYMENT_INITIATED"] = "checkout.payment.initiated";
+  CheckoutEventNames2["CHECKOUT_PAYMENT_FAILED"] = "checkout.payment.failed";
+  CheckoutEventNames2["CHECKOUT_PAYMENT_ERROR"] = "checkout.payment.error";
+  CheckoutEventNames2["CHECKOUT_DISCOUNT_APPLIED"] = "checkout.discount.applied";
+  CheckoutEventNames2["CHECKOUT_DISCOUNT_REMOVED"] = "checkout.discount.removed";
+  CheckoutEventNames2["CHECKOUT_UPSELL_CANCELED"] = "checkout.upsell.canceled";
+})(CheckoutEventNames || (CheckoutEventNames = {}));
+var CheckoutEventsTimePeriodInterval;
+(function(CheckoutEventsTimePeriodInterval2) {
+  CheckoutEventsTimePeriodInterval2["DAY"] = "day";
+  CheckoutEventsTimePeriodInterval2["WEEK"] = "week";
+  CheckoutEventsTimePeriodInterval2["MONTH"] = "month";
+  CheckoutEventsTimePeriodInterval2["YEAR"] = "year";
+})(CheckoutEventsTimePeriodInterval || (CheckoutEventsTimePeriodInterval = {}));
+var CheckoutEventsPaymentMethodTypes;
+(function(CheckoutEventsPaymentMethodTypes2) {
+  CheckoutEventsPaymentMethodTypes2["ALIPAY"] = "alipay";
+  CheckoutEventsPaymentMethodTypes2["APPLE_PAY"] = "apple-pay";
+  CheckoutEventsPaymentMethodTypes2["CARD"] = "card";
+  CheckoutEventsPaymentMethodTypes2["GOOGLE_PAY"] = "google-pay";
+  CheckoutEventsPaymentMethodTypes2["IDEAL"] = "ideal";
+  CheckoutEventsPaymentMethodTypes2["PAYPAL"] = "paypal";
+  CheckoutEventsPaymentMethodTypes2["WECHAT_PAY"] = "wechat-pay";
+  CheckoutEventsPaymentMethodTypes2["WIRE_TRANSFER"] = "wire-transfer";
+  CheckoutEventsPaymentMethodTypes2["NONE"] = "none";
+})(CheckoutEventsPaymentMethodTypes || (CheckoutEventsPaymentMethodTypes = {}));
+var CheckoutEventsPaymentMethodCardTypes;
+(function(CheckoutEventsPaymentMethodCardTypes2) {
+  CheckoutEventsPaymentMethodCardTypes2["AMERICAN_EXPRESS"] = "american_express";
+  CheckoutEventsPaymentMethodCardTypes2["DINERS_CLUB"] = "diners_club";
+  CheckoutEventsPaymentMethodCardTypes2["DISCOVER"] = "discover";
+  CheckoutEventsPaymentMethodCardTypes2["JCB"] = "jcb";
+  CheckoutEventsPaymentMethodCardTypes2["MADA"] = "mada";
+  CheckoutEventsPaymentMethodCardTypes2["MAESTRO"] = "maestro";
+  CheckoutEventsPaymentMethodCardTypes2["MASTER_CARD"] = "mastercard";
+  CheckoutEventsPaymentMethodCardTypes2["UNION_PAY"] = "union_pay";
+  CheckoutEventsPaymentMethodCardTypes2["VISA"] = "visa";
+  CheckoutEventsPaymentMethodCardTypes2["UNKNOWN"] = "unknown";
+})(CheckoutEventsPaymentMethodCardTypes || (CheckoutEventsPaymentMethodCardTypes = {}));
+var CheckoutEventsStatus;
+(function(CheckoutEventsStatus2) {
+  CheckoutEventsStatus2["DRAFT"] = "draft";
+  CheckoutEventsStatus2["READY"] = "ready";
+  CheckoutEventsStatus2["COMPLETED"] = "completed";
+  CheckoutEventsStatus2["BILLED"] = "billed";
+  CheckoutEventsStatus2["canceled"] = "canceled";
+  CheckoutEventsStatus2["PAST_DUE"] = "past_due";
+})(CheckoutEventsStatus || (CheckoutEventsStatus = {}));
+function initializePaddle(_x) {
+  return _initializePaddle.apply(this, arguments);
+}
+function _initializePaddle() {
+  _initializePaddle = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee(options) {
+    var requestedVersion, paddle;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          requestedVersion = (options === null || options === void 0 ? void 0 : options.version) || DefaultVersion;
+          _context.next = 3;
+          return loadFromCDN(requestedVersion);
+        case 3:
+          paddle = _context.sent;
+          if (!paddle) {
+            _context.next = 9;
+            break;
+          }
+          if (options) {
+            if (requestedVersion === Versions.V1) {
+              initializePaddleBillingV1(options, paddle);
+            } else if (requestedVersion === Versions.CLASSIC) {
+              initializePaddleClassic(options, paddle);
+            }
+          }
+          return _context.abrupt("return", paddle);
+        case 9:
+          console.error("[Paddle] Error Loading Paddle");
+          return _context.abrupt("return");
+        case 11:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _initializePaddle.apply(this, arguments);
+}
+
+// src/drivers/paddle.tsx
+var PADDLE_TIMEOUT_MESSAGE = "The payment is still being confirmed \u2014 if you completed checkout, your receipt will arrive by email.";
+var PADDLE_PENDING_TIMEOUT_MESSAGE = "The charge is still being confirmed \u2014 it may still complete; please check back shortly.";
+var listeners = /* @__PURE__ */ new Set();
+function eventMatchesAttempt(event, correlationId, transactionId) {
+  if (transactionId) {
+    const eventTransactionId = event.data?.transaction_id;
+    if (eventTransactionId == null) return true;
+    return eventTransactionId === transactionId;
+  }
+  const customData = event.data?.custom_data;
+  if (customData == null) return true;
+  return customData.af_correlation_id === correlationId;
+}
+var pendingTimeouts = /* @__PURE__ */ new Map();
+var pendingKeyOf = (req) => `${req.product}::${req.intent}`;
+function rememberIfStillPending(req, correlationId, result) {
+  if (!result.ok && result.error?.declineCode === "completion_timeout") {
+    pendingTimeouts.set(pendingKeyOf(req), correlationId);
+  }
+  return result;
+}
+function __resetPaddleDriverState() {
+  pendingTimeouts.clear();
+}
+var paddleInstances = /* @__PURE__ */ new Map();
+function getPaddle(clientToken, environment) {
+  const key = `${environment}:${clientToken}`;
+  let instance = paddleInstances.get(key);
+  if (!instance) {
+    instance = initializePaddle({
+      token: clientToken,
+      environment,
+      eventCallback: (event) => {
+        for (const listener of Array.from(listeners)) listener({ name: event.name, data: event.data });
+      }
+    });
+    paddleInstances.set(key, instance);
+  }
+  return instance;
+}
+async function openCheckout(ctx, session, correlationId, display) {
+  if (!session.transactionId && !session.items) {
+    return {
+      ok: false,
+      error: checkoutError("processing_error", "provider_checkout carried neither items nor a transactionId")
+    };
+  }
+  const paddle = await getPaddle(session.clientToken, session.providerEnvironment);
+  if (!paddle) {
+    return { ok: false, error: checkoutError("processing_error", "Paddle.js failed to initialize") };
+  }
+  return await new Promise((resolve) => {
+    let done = false;
+    const listener = (event) => {
+      if (done) return;
+      if (!eventMatchesAttempt(event, correlationId, session.transactionId)) return;
+      if (event.name === "checkout.completed") {
+        done = true;
+        listeners.delete(listener);
+        void completeWithPoll(ctx, correlationId, {
+          attempts: 10,
+          intervalMs: 3e3,
+          timeoutMessage: PADDLE_TIMEOUT_MESSAGE
+        }).then(resolve);
+      } else if (event.name === "checkout.closed") {
+        done = true;
+        listeners.delete(listener);
+        resolve({ ok: false, error: checkoutError("canceled", "Checkout was closed before completing") });
+      }
+    };
+    listeners.add(listener);
+    if (session.transactionId) {
+      paddle.Checkout.open({ transactionId: session.transactionId, settings: display });
+    } else {
+      paddle.Checkout.open({
+        // Provider-native line items resolved by the server from the binding —
+        // the browser never sees or chooses raw price ids beyond passing these through.
+        items: session.items,
+        // Carries the correlationId into Paddle's transaction custom data — the
+        // webhook links back to this attempt through it.
+        customData: session.customData,
+        settings: display
+      });
+    }
+  });
+}
+function paddleCheckoutDriver(ctx) {
+  return {
+    provider: "paddle",
+    async start(req) {
+      const priorKey = pendingKeyOf(req);
+      const prior = pendingTimeouts.get(priorKey);
+      if (prior) {
+        pendingTimeouts.delete(priorKey);
+        try {
+          const check = await postComplete(ctx, prior);
+          if (check.step === "settled") return settlementToResult(check.result);
+        } catch {
+        }
+      }
+      const correlationId = crypto.randomUUID();
+      try {
+        const session = await postSession(ctx, req, correlationId);
+        switch (session.step) {
+          case "settled":
+            return settlementToResult(session.result);
+          case "pending":
+            return rememberIfStillPending(
+              req,
+              correlationId,
+              await completeWithPoll(ctx, correlationId, {
+                timeoutMessage: PADDLE_PENDING_TIMEOUT_MESSAGE
+              })
+            );
+          case "failed":
+            return { ok: false, error: session.error };
+          case "redirect":
+            return leaveForRedirect(session.url);
+          case "provider_checkout":
+            return rememberIfStillPending(
+              req,
+              correlationId,
+              await openCheckout(ctx, session, correlationId, { displayMode: "overlay" })
+            );
+          default:
+            return {
+              ok: false,
+              error: checkoutError(
+                "processing_error",
+                `Paddle returned '${session.step}' for a trigger start \u2014 Paddle has no in-page confirm step`
+              )
+            };
+        }
+      } catch (e) {
+        return { ok: false, error: toCheckoutError(e) };
+      }
+    },
+    renderInline(req, cb) {
+      return createElement(PaddleInline, { ctx, req, cb });
+    },
+    // Redirect-return resume: verify an existing attempt. Webhook-dependent, so it
+    // gets the same ~10×3s window the overlay completion poll uses.
+    resume(correlationId) {
+      return completeWithPoll(ctx, correlationId, {
+        attempts: 10,
+        intervalMs: 3e3,
+        timeoutMessage: PADDLE_TIMEOUT_MESSAGE
+      });
+    }
+  };
+}
+function PaddleInline({
+  ctx,
+  req,
+  cb
+}) {
+  const [correlationId] = useState(() => crypto.randomUUID());
+  const uid = useId().replace(/[^a-zA-Z0-9_-]/g, "");
+  const frameClass = `af-paddle-frame-${uid}`;
+  const cbRef = useRef(cb);
+  cbRef.current = cb;
+  useEffect(() => {
+    let disposed = false;
+    void (async () => {
+      try {
+        const session = await postSession(ctx, req, correlationId);
+        if (disposed) return;
+        switch (session.step) {
+          case "provider_checkout": {
+            cbRef.current.onStart?.();
+            const express = req.surface === "express";
+            const result = await openCheckout(ctx, session, correlationId, {
+              displayMode: "inline",
+              frameTarget: frameClass,
+              frameInitialHeight: express ? 182 : 450,
+              // Paddle's documented inline-frame baseline: fluid width, no chrome.
+              frameStyle: "width: 100%; min-width: 286px; background-color: transparent; border: none;",
+              ...express ? { variant: "express" } : {}
+            });
+            if (disposed) return;
+            if (result.ok) cbRef.current.onSuccess(result);
+            else cbRef.current.onError(result.error ?? checkoutError("unknown", "Checkout failed"));
+            return;
+          }
+          case "settled":
+            cbRef.current.onSuccess(settlementToResult(session.result));
+            return;
+          case "failed":
+            cbRef.current.onError(session.error);
+            return;
+          case "redirect": {
+            const result = await leaveForRedirect(session.url);
+            if (!disposed && !result.ok) {
+              cbRef.current.onError(result.error ?? checkoutError("canceled", "Checkout was canceled"));
+            }
+            return;
+          }
+          default:
+            cbRef.current.onError(
+              checkoutError("processing_error", "unexpected step for a Paddle inline surface")
+            );
+        }
+      } catch (e) {
+        if (!disposed) cbRef.current.onError(toCheckoutError(e));
+      }
+    })();
+    return () => {
+      disposed = true;
+    };
+  }, []);
+  return createElement("div", {
+    "data-appfunnel-checkout": "paddle",
+    "data-checkout-surface": req.surface,
+    className: frameClass
+  });
+}
+
+export { __resetPaddleDriverState, paddleCheckoutDriver };
+//# sourceMappingURL=driver-paddle.js.map
+//# sourceMappingURL=driver-paddle.js.map