crain-react-pelcro-js 1.0.0-beta.5 → 1.0.0-beta.7

package/dist/index.cjs.js

@@ -3,8 +3,6 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var React = require('react');
-var stripeJs = require('@stripe/stripe-js');
-var reactStripeJs = require('@stripe/react-stripe-js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -6955,7 +6953,7 @@ const persistImpl = (config, baseOptions) => (set, get, api) => {
 };
 const persist = persistImpl;
 
-function _defineProperty$3(obj, key, value) {
+function _defineProperty$4(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value: value,
@@ -8193,15 +8191,15 @@ function warn(s) {
   console.warn('[react-ga]', s);
 }
 
-function _typeof$1(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1 = function _typeof(obj) { return typeof obj; }; } else { _typeof$1 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1(obj); }
+function _typeof$3(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$3 = function _typeof(obj) { return typeof obj; }; } else { _typeof$3 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$3(obj); }
 
-function ownKeys$2(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+function ownKeys$3(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$2(source, true).forEach(function (key) { _defineProperty$2(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$2(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$3(source, true).forEach(function (key) { _defineProperty$3(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$3(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-function _objectWithoutProperties$1(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose$1(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutProperties$2(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose$2(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
 
-function _objectWithoutPropertiesLoose$1(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _objectWithoutPropertiesLoose$2(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
@@ -8209,7 +8207,7 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
-function _possibleConstructorReturn(self, call) { if (call && (_typeof$1(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof$3(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
 
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
@@ -8219,7 +8217,7 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
 
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
-function _defineProperty$2(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _defineProperty$3(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 var NEWTAB = '_blank';
 var MIDDLECLICK = 1;
 
@@ -8241,7 +8239,7 @@ function (_Component) {
 
     _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(OutboundLink)).call.apply(_getPrototypeOf2, [this].concat(args)));
 
-    _defineProperty$2(_assertThisInitialized(_this), "handleClick", function (event) {
+    _defineProperty$3(_assertThisInitialized(_this), "handleClick", function (event) {
       var _this$props = _this.props,
           target = _this$props.target,
           eventLabel = _this$props.eventLabel,
@@ -8276,7 +8274,7 @@ function (_Component) {
     value: function render() {
       var _this$props2 = this.props,
           href = _this$props2.to,
-          oldProps = _objectWithoutProperties$1(_this$props2, ["to"]);
+          oldProps = _objectWithoutProperties$2(_this$props2, ["to"]);
 
       var props = _objectSpread$2({}, oldProps, {
         href: href,
@@ -8296,11 +8294,11 @@ function (_Component) {
   return OutboundLink;
 }(React.Component);
 
-_defineProperty$2(OutboundLink$1, "trackLink", function () {
+_defineProperty$3(OutboundLink$1, "trackLink", function () {
   warn('ga tracking not enabled');
 });
 
-_defineProperty$2(OutboundLink$1, "propTypes", {
+_defineProperty$3(OutboundLink$1, "propTypes", {
   eventLabel: PropTypes.string.isRequired,
   target: PropTypes.string,
   to: PropTypes.string,
@@ -8308,7 +8306,7 @@ _defineProperty$2(OutboundLink$1, "propTypes", {
   trackerNames: PropTypes.arrayOf(PropTypes.string)
 });
 
-_defineProperty$2(OutboundLink$1, "defaultProps", {
+_defineProperty$3(OutboundLink$1, "defaultProps", {
   target: null,
   to: null,
   onClick: null,
@@ -8415,17 +8413,17 @@ var TestModeAPI = {
   }
 };
 
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutProperties$1(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose$1(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
 
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _objectWithoutPropertiesLoose$1(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
 
-function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+function ownKeys$2(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(source, true).forEach(function (key) { _defineProperty$1(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$2(source, true).forEach(function (key) { _defineProperty$2(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$2(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-function _defineProperty$1(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _defineProperty$2(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+function _typeof$2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$2 = function _typeof(obj) { return typeof obj; }; } else { _typeof$2 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$2(obj); }
 
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
 
@@ -8520,7 +8518,7 @@ function initialize(configsOrTrackingId, options) {
 
   if (Array.isArray(configsOrTrackingId)) {
     configsOrTrackingId.forEach(function (config) {
-      if (_typeof(config) !== 'object') {
+      if (_typeof$2(config) !== 'object') {
         warn('All configs must be an object');
         return;
       }
@@ -8567,7 +8565,7 @@ function set(fieldsObject, trackerNames) {
     return;
   }
 
-  if (_typeof(fieldsObject) !== 'object') {
+  if (_typeof$2(fieldsObject) !== 'object') {
     warn('Expected `fieldsObject` arg to be an Object');
     return;
   }
@@ -8738,7 +8736,7 @@ function event() {
       value = _ref2.value,
       nonInteraction = _ref2.nonInteraction,
       transport = _ref2.transport,
-      args = _objectWithoutProperties(_ref2, ["category", "action", "label", "value", "nonInteraction", "transport"]);
+      args = _objectWithoutProperties$1(_ref2, ["category", "action", "label", "value", "nonInteraction", "transport"]);
 
   var trackerNames = arguments.length > 1 ? arguments[1] : undefined;
 
@@ -8862,7 +8860,7 @@ var plugin = {
       var requireString = trackerName ? "".concat(trackerName, ".require") : 'require'; // Optional Fields
 
       if (options) {
-        if (_typeof(options) !== 'object') {
+        if (_typeof$2(options) !== 'object') {
           warn('Expected `options` arg to be an Object');
           return;
         }
@@ -9032,11 +9030,11 @@ var Defaults = /*#__PURE__*/Object.freeze({
   'default': core
 });
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(source, true).forEach(function (key) { _defineProperty$1(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _defineProperty$1(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 OutboundLink$1.origTrackLink = OutboundLink$1.trackLink;
 OutboundLink$1.trackLink = outboundLink;
 var OutboundLink = OutboundLink$1;
@@ -9350,7 +9348,7 @@ var src_default = ga4_default;
 class PelcroActions {
   constructor(storeSetter, storeGetter) {
     var _this = this;
-    _defineProperty$3(this, "resetState", () => {
+    _defineProperty$4(this, "resetState", () => {
       const {
         view,
         cartItems,
@@ -9358,7 +9356,7 @@ class PelcroActions {
       } = initialState$1;
       this.set(otherStateFields);
     });
-    _defineProperty$3(this, "switchView", view => {
+    _defineProperty$4(this, "switchView", view => {
       var _window$Pelcro$site$r;
       // view switching guards
       if (userMustVerifyEmail() && !["dashboard", "meter", "login", null].includes(view)) {
@@ -9385,7 +9383,7 @@ class PelcroActions {
         view
       });
     });
-    _defineProperty$3(this, "resetView", () => {
+    _defineProperty$4(this, "resetView", () => {
       const {
         switchView,
         resetState
@@ -9393,7 +9391,7 @@ class PelcroActions {
       switchView(null);
       resetState();
     });
-    _defineProperty$3(this, "switchToPaymentView", () => {
+    _defineProperty$4(this, "switchToPaymentView", () => {
       const {
         switchView,
         resetView,
@@ -9411,7 +9409,7 @@ class PelcroActions {
       }
       return resetView();
     });
-    _defineProperty$3(this, "switchToCheckoutForm", () => {
+    _defineProperty$4(this, "switchToCheckoutForm", () => {
       const {
         switchView,
         product,
@@ -9432,7 +9430,7 @@ class PelcroActions {
         return switchView("invoice-payment");
       }
     });
-    _defineProperty$3(this, "switchToAddressView", () => {
+    _defineProperty$4(this, "switchToAddressView", () => {
       const {
         switchView
       } = this.get();
@@ -9442,21 +9440,21 @@ class PelcroActions {
         switchView("address-create");
       }
     });
-    _defineProperty$3(this, "setProduct", id => {
+    _defineProperty$4(this, "setProduct", id => {
       const product = window.Pelcro.product.getById(id);
       if (!product) return console.error("invalid product id");
       this.set({
         product
       });
     });
-    _defineProperty$3(this, "setPlan", id => {
+    _defineProperty$4(this, "setPlan", id => {
       const plan = window.Pelcro.plan.getById(id);
       if (!plan) return console.error("invalid plan id");
       this.set({
         plan
       });
     });
-    _defineProperty$3(this, "setSubscriptionToCancel", id => {
+    _defineProperty$4(this, "setSubscriptionToCancel", id => {
       var _window$Pelcro$subscr;
       const subscriptions = (_window$Pelcro$subscr = window.Pelcro.subscription.list()) !== null && _window$Pelcro$subscr !== void 0 ? _window$Pelcro$subscr : [];
       const subscriptionToCancel = subscriptions.filter(sub => String(sub.id) === String(id))[0];
@@ -9467,7 +9465,7 @@ class PelcroActions {
         subscriptionToCancel
       });
     });
-    _defineProperty$3(this, "setSubscriptionToSuspend", id => {
+    _defineProperty$4(this, "setSubscriptionToSuspend", id => {
       var _window$Pelcro$subscr2;
       const subscriptions = (_window$Pelcro$subscr2 = window.Pelcro.subscription.list()) !== null && _window$Pelcro$subscr2 !== void 0 ? _window$Pelcro$subscr2 : [];
       const subscriptionToSuspend = subscriptions.filter(sub => String(sub.id) === String(id))[0];
@@ -9478,7 +9476,7 @@ class PelcroActions {
         subscriptionToSuspend
       });
     });
-    _defineProperty$3(this, "setSubscriptionToManageMembers", id => {
+    _defineProperty$4(this, "setSubscriptionToManageMembers", id => {
       var _window$Pelcro$subscr3, _subscriptionToManage;
       const subscriptions = (_window$Pelcro$subscr3 = window.Pelcro.subscription.list()) !== null && _window$Pelcro$subscr3 !== void 0 ? _window$Pelcro$subscr3 : [];
       const subscriptionToManageMembers = subscriptions.filter(sub => String(sub.id) === String(id))[0];
@@ -9493,7 +9491,7 @@ class PelcroActions {
       });
       return true;
     });
-    _defineProperty$3(this, "setInvoice", id => {
+    _defineProperty$4(this, "setInvoice", id => {
       var _window$Pelcro$invoic;
       const invoices = (_window$Pelcro$invoic = window.Pelcro.invoice.list()) !== null && _window$Pelcro$invoic !== void 0 ? _window$Pelcro$invoic : [];
       const invoice = invoices.find(inv => String(inv.id) === String(id));
@@ -9506,7 +9504,7 @@ class PelcroActions {
       });
       return true;
     });
-    _defineProperty$3(this, "setSelectedMembership", id => {
+    _defineProperty$4(this, "setSelectedMembership", id => {
       var _window$Pelcro$user$r, _window$Pelcro$user$r2;
       const memberships = (_window$Pelcro$user$r = (_window$Pelcro$user$r2 = window.Pelcro.user.read()) === null || _window$Pelcro$user$r2 === void 0 ? void 0 : _window$Pelcro$user$r2.memberships) !== null && _window$Pelcro$user$r !== void 0 ? _window$Pelcro$user$r : [];
       const membership = memberships.find(membership => String(membership.id) === String(id));
@@ -9519,13 +9517,13 @@ class PelcroActions {
       });
       return true;
     });
-    _defineProperty$3(this, "setCouponCode", couponCode => {
+    _defineProperty$4(this, "setCouponCode", couponCode => {
       if (!couponCode) return console.error("invalid coupon code");
       this.set({
         couponCode
       });
     });
-    _defineProperty$3(this, "logout", function () {
+    _defineProperty$4(this, "logout", function () {
       var _window, _window$Pelcro, _window$Pelcro$uiSett;
       let displayLogin = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
       const {
@@ -9556,7 +9554,7 @@ class PelcroActions {
         switchView("login");
       }
     });
-    _defineProperty$3(this, "addToCart", itemSkuId => {
+    _defineProperty$4(this, "addToCart", itemSkuId => {
       const itemToAdd = window.Pelcro.ecommerce.products.getBySkuId(Number(itemSkuId));
       if (!itemToAdd) {
         console.error("invalid item SKU id");
@@ -9596,7 +9594,7 @@ class PelcroActions {
       }));
       return true;
     });
-    _defineProperty$3(this, "removeFromCart", itemSkuId => {
+    _defineProperty$4(this, "removeFromCart", itemSkuId => {
       const {
         cartItems
       } = this.get();
@@ -9630,7 +9628,7 @@ class PelcroActions {
       });
       return true;
     });
-    _defineProperty$3(this, "purchaseItem", itemSkuId => {
+    _defineProperty$4(this, "purchaseItem", itemSkuId => {
       const quickPurchaseItem = window.Pelcro.ecommerce.products.getBySkuId(Number(itemSkuId));
       if (!quickPurchaseItem) {
         console.error("invalid item SKU id");
@@ -9667,7 +9665,7 @@ class PelcroActions {
       }
       switchToAddressView();
     });
-    _defineProperty$3(this, "setPaymentMethodToEdit", id => {
+    _defineProperty$4(this, "setPaymentMethodToEdit", id => {
       window.Pelcro.paymentMethods.getPaymentMethod({
         auth_token: window.Pelcro.user.read().auth_token,
         payment_method_id: id
@@ -9683,7 +9681,7 @@ class PelcroActions {
         }
       });
     });
-    _defineProperty$3(this, "setPaymentMethodToDelete", id => {
+    _defineProperty$4(this, "setPaymentMethodToDelete", id => {
       window.Pelcro.paymentMethods.getPaymentMethod({
         auth_token: window.Pelcro.user.read().auth_token,
         payment_method_id: id
@@ -9699,7 +9697,7 @@ class PelcroActions {
         }
       });
     });
-    _defineProperty$3(this, "setPaymentMethodToVerify", paymentMethod => {
+    _defineProperty$4(this, "setPaymentMethodToVerify", paymentMethod => {
       this.set({
         paymentMethodToVerify: paymentMethod
       });
@@ -9715,7 +9713,7 @@ class PelcroActions {
 
 class PelcroCallbacks {
   constructor() {
-    _defineProperty$3(this, "whenSiteReady", callback => {
+    _defineProperty$4(this, "whenSiteReady", callback => {
       var _window$Pelcro$site$r;
       if ((_window$Pelcro$site$r = window.Pelcro.site.read()) !== null && _window$Pelcro$site$r !== void 0 && _window$Pelcro$site$r.settings) {
         callback(window.Pelcro.site.read());
@@ -9725,7 +9723,7 @@ class PelcroCallbacks {
         });
       }
     });
-    _defineProperty$3(this, "whenUserReady", (callback, listenerOptions) => {
+    _defineProperty$4(this, "whenUserReady", (callback, listenerOptions) => {
       var _window$Pelcro$user$r;
       if ((_window$Pelcro$user$r = window.Pelcro.user.read()) !== null && _window$Pelcro$user$r !== void 0 && _window$Pelcro$user$r.id) {
         callback(window.Pelcro.user.read());
@@ -9735,7 +9733,7 @@ class PelcroCallbacks {
         }, listenerOptions);
       }
     });
-    _defineProperty$3(this, "whenEcommerceLoaded", callback => {
+    _defineProperty$4(this, "whenEcommerceLoaded", callback => {
       var _window$Pelcro$ecomme;
       if ((_window$Pelcro$ecomme = window.Pelcro.ecommerce.products.read()) !== null && _window$Pelcro$ecomme !== void 0 && _window$Pelcro$ecomme.length) {
         callback(window.Pelcro.ecommerce.products.read());
@@ -10105,6 +10103,1015 @@ pageLanguageObserver.observe(document.documentElement, {
   attributes: true
 });
 
+function _typeof$1(obj) {
+  "@babel/helpers - typeof";
+
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof$1 = function (obj) {
+      return typeof obj;
+    };
+  } else {
+    _typeof$1 = function (obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+  }
+
+  return _typeof$1(obj);
+}
+
+var RELEASE_TRAIN = 'dahlia';
+
+var runtimeVersionToUrlVersion = function runtimeVersionToUrlVersion(version) {
+  return version === 3 ? 'v3' : version;
+};
+
+var ORIGIN = 'https://js.stripe.com';
+var STRIPE_JS_URL = "".concat(ORIGIN, "/").concat(RELEASE_TRAIN, "/stripe.js");
+var V3_URL_REGEX = /^https:\/\/js\.stripe\.com\/v3\/?(\?.*)?$/;
+var STRIPE_JS_URL_REGEX = /^https:\/\/js\.stripe\.com\/(v3|[a-z]+)\/stripe\.js(\?.*)?$/;
+var EXISTING_SCRIPT_MESSAGE = 'loadStripe.setLoadParameters was called but an existing Stripe.js script already exists in the document; existing script parameters will be used';
+
+var isStripeJSURL = function isStripeJSURL(url) {
+  return V3_URL_REGEX.test(url) || STRIPE_JS_URL_REGEX.test(url);
+};
+
+var findScript = function findScript() {
+  var scripts = document.querySelectorAll("script[src^=\"".concat(ORIGIN, "\"]"));
+
+  for (var i = 0; i < scripts.length; i++) {
+    var script = scripts[i];
+
+    if (!isStripeJSURL(script.src)) {
+      continue;
+    }
+
+    return script;
+  }
+
+  return null;
+};
+
+var injectScript = function injectScript(params) {
+  var queryString = params && !params.advancedFraudSignals ? '?advancedFraudSignals=false' : '';
+  var script = document.createElement('script');
+  script.src = "".concat(STRIPE_JS_URL).concat(queryString);
+  var headOrBody = document.head || document.body;
+
+  if (!headOrBody) {
+    throw new Error('Expected document.body not to be null. Stripe.js requires a <body> element.');
+  }
+
+  headOrBody.appendChild(script);
+  return script;
+};
+
+var registerWrapper = function registerWrapper(stripe, startTime) {
+  if (!stripe || !stripe._registerWrapper) {
+    return;
+  }
+
+  stripe._registerWrapper({
+    name: 'stripe-js',
+    version: "9.1.0",
+    startTime: startTime
+  });
+};
+
+var stripePromise$1 = null;
+var onErrorListener = null;
+var onLoadListener = null;
+
+var onError = function onError(reject) {
+  return function (cause) {
+    reject(new Error('Failed to load Stripe.js', {
+      cause: cause
+    }));
+  };
+};
+
+var onLoad = function onLoad(resolve, reject) {
+  return function () {
+    if (window.Stripe) {
+      resolve(window.Stripe);
+    } else {
+      reject(new Error('Stripe.js not available'));
+    }
+  };
+};
+
+var loadScript = function loadScript(params) {
+  // Ensure that we only attempt to load Stripe.js at most once
+  if (stripePromise$1 !== null) {
+    return stripePromise$1;
+  }
+
+  stripePromise$1 = new Promise(function (resolve, reject) {
+    if (typeof window === 'undefined' || typeof document === 'undefined') {
+      // Resolve to null when imported server side. This makes the module
+      // safe to import in an isomorphic code base.
+      resolve(null);
+      return;
+    }
+
+    if (window.Stripe && params) {
+      console.warn(EXISTING_SCRIPT_MESSAGE);
+    }
+
+    if (window.Stripe) {
+      resolve(window.Stripe);
+      return;
+    }
+
+    try {
+      var script = findScript();
+
+      if (script && params) {
+        console.warn(EXISTING_SCRIPT_MESSAGE);
+      } else if (!script) {
+        script = injectScript(params);
+      } else if (script && onLoadListener !== null && onErrorListener !== null) {
+        var _script$parentNode;
+
+        // remove event listeners
+        script.removeEventListener('load', onLoadListener);
+        script.removeEventListener('error', onErrorListener); // if script exists, but we are reloading due to an error,
+        // reload script to trigger 'load' event
+
+        (_script$parentNode = script.parentNode) === null || _script$parentNode === void 0 ? void 0 : _script$parentNode.removeChild(script);
+        script = injectScript(params);
+      }
+
+      onLoadListener = onLoad(resolve, reject);
+      onErrorListener = onError(reject);
+      script.addEventListener('load', onLoadListener);
+      script.addEventListener('error', onErrorListener);
+    } catch (error) {
+      reject(error);
+      return;
+    }
+  }); // Resets stripePromise on error
+
+  return stripePromise$1["catch"](function (error) {
+    stripePromise$1 = null;
+    return Promise.reject(error);
+  });
+};
+var initStripe = function initStripe(maybeStripe, args, startTime) {
+  if (maybeStripe === null) {
+    return null;
+  }
+
+  var pk = args[0];
+
+  if (typeof pk !== 'string') {
+    throw new Error("Expected publishable key to be of type string, got type ".concat(_typeof$1(pk), " instead."));
+  }
+
+  var isTestKey = pk.match(/^pk_test/); // @ts-expect-error this is not publicly typed
+
+  var version = runtimeVersionToUrlVersion(maybeStripe.version);
+  var expectedVersion = RELEASE_TRAIN;
+
+  if (isTestKey && version !== expectedVersion) {
+    console.warn("Stripe.js@".concat(version, " was loaded on the page, but @stripe/stripe-js@").concat("9.1.0", " expected Stripe.js@").concat(expectedVersion, ". This may result in unexpected behavior. For more information, see https://docs.stripe.com/sdks/stripejs-versioning"));
+  }
+
+  var stripe = maybeStripe.apply(undefined, args);
+  registerWrapper(stripe, startTime);
+  return stripe;
+}; // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+
+var stripePromise;
+var loadCalled = false;
+
+var getStripePromise = function getStripePromise() {
+  if (stripePromise) {
+    return stripePromise;
+  }
+
+  stripePromise = loadScript(null)["catch"](function (error) {
+    // clear cache on error
+    stripePromise = null;
+    return Promise.reject(error);
+  });
+  return stripePromise;
+}; // Execute our own script injection after a tick to give users time to do their
+// own script injection.
+
+
+Promise.resolve().then(function () {
+  return getStripePromise();
+})["catch"](function (error) {
+  if (!loadCalled) {
+    console.warn(error);
+  }
+});
+var loadStripe = function loadStripe() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  loadCalled = true;
+  var startTime = Date.now(); // if previous attempts are unsuccessful, will re-load script
+
+  return getStripePromise().then(function (maybeStripe) {
+    return initStripe(maybeStripe, args, startTime);
+  });
+};
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+
+    if (enumerableOnly) {
+      symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+    }
+
+    keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function (key) {
+        _defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+
+  return target;
+}
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function (obj) {
+      return typeof obj;
+    };
+  } else {
+    _typeof = function (obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+  }
+
+  return _typeof(obj);
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+
+  var key, i;
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
+
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+function _iterableToArrayLimit(arr, i) {
+  var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]);
+
+  if (_i == null) return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+
+  var _s, _e;
+
+  try {
+    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+  return arr2;
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+var useAttachEvent = function useAttachEvent(element, event, cb) {
+  var cbDefined = !!cb;
+  var cbRef = React__default["default"].useRef(cb); // In many integrations the callback prop changes on each render.
+  // Using a ref saves us from calling element.on/.off every render.
+
+  React__default["default"].useEffect(function () {
+    cbRef.current = cb;
+  }, [cb]);
+  React__default["default"].useEffect(function () {
+    if (!cbDefined || !element) {
+      return function () {};
+    }
+
+    var decoratedCb = function decoratedCb() {
+      if (cbRef.current) {
+        cbRef.current.apply(cbRef, arguments);
+      }
+    };
+
+    element.on(event, decoratedCb);
+    return function () {
+      element.off(event, decoratedCb);
+    };
+  }, [cbDefined, event, element, cbRef]);
+};
+
+var usePrevious = function usePrevious(value) {
+  var ref = React__default["default"].useRef(value);
+  React__default["default"].useEffect(function () {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+};
+
+var isUnknownObject = function isUnknownObject(raw) {
+  return raw !== null && _typeof(raw) === 'object';
+};
+var isPromise = function isPromise(raw) {
+  return isUnknownObject(raw) && typeof raw.then === 'function';
+}; // We are using types to enforce the `stripe` prop in this lib,
+// but in an untyped integration `stripe` could be anything, so we need
+// to do some sanity validation to prevent type errors.
+
+var isStripe = function isStripe(raw) {
+  return isUnknownObject(raw) && typeof raw.elements === 'function' && typeof raw.createToken === 'function' && typeof raw.createPaymentMethod === 'function' && typeof raw.confirmCardPayment === 'function';
+};
+
+var PLAIN_OBJECT_STR = '[object Object]';
+var isEqual = function isEqual(left, right) {
+  if (!isUnknownObject(left) || !isUnknownObject(right)) {
+    return left === right;
+  }
+
+  var leftArray = Array.isArray(left);
+  var rightArray = Array.isArray(right);
+  if (leftArray !== rightArray) return false;
+  var leftPlainObject = Object.prototype.toString.call(left) === PLAIN_OBJECT_STR;
+  var rightPlainObject = Object.prototype.toString.call(right) === PLAIN_OBJECT_STR;
+  if (leftPlainObject !== rightPlainObject) return false; // not sure what sort of special object this is (regexp is one option), so
+  // fallback to reference check.
+
+  if (!leftPlainObject && !leftArray) return left === right;
+  var leftKeys = Object.keys(left);
+  var rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) return false;
+  var keySet = {};
+
+  for (var i = 0; i < leftKeys.length; i += 1) {
+    keySet[leftKeys[i]] = true;
+  }
+
+  for (var _i = 0; _i < rightKeys.length; _i += 1) {
+    keySet[rightKeys[_i]] = true;
+  }
+
+  var allKeys = Object.keys(keySet);
+
+  if (allKeys.length !== leftKeys.length) {
+    return false;
+  }
+
+  var l = left;
+  var r = right;
+
+  var pred = function pred(key) {
+    return isEqual(l[key], r[key]);
+  };
+
+  return allKeys.every(pred);
+};
+
+var extractAllowedOptionsUpdates = function extractAllowedOptionsUpdates(options, prevOptions, immutableKeys) {
+  if (!isUnknownObject(options)) {
+    return null;
+  }
+
+  return Object.keys(options).reduce(function (newOptions, key) {
+    var isUpdated = !isUnknownObject(prevOptions) || !isEqual(options[key], prevOptions[key]);
+
+    if (immutableKeys.includes(key)) {
+      if (isUpdated) {
+        console.warn("Unsupported prop change: options.".concat(key, " is not a mutable property."));
+      }
+
+      return newOptions;
+    }
+
+    if (!isUpdated) {
+      return newOptions;
+    }
+
+    return _objectSpread2(_objectSpread2({}, newOptions || {}), {}, _defineProperty({}, key, options[key]));
+  }, null);
+};
+
+var INVALID_STRIPE_ERROR$1 = 'Invalid prop `stripe` supplied to `Elements`. We recommend using the `loadStripe` utility from `@stripe/stripe-js`. See https://stripe.com/docs/stripe-js/react#elements-props-stripe for details.'; // We are using types to enforce the `stripe` prop in this lib, but in a real
+// integration `stripe` could be anything, so we need to do some sanity
+// validation to prevent type errors.
+
+var validateStripe = function validateStripe(maybeStripe) {
+  var errorMsg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : INVALID_STRIPE_ERROR$1;
+
+  if (maybeStripe === null || isStripe(maybeStripe)) {
+    return maybeStripe;
+  }
+
+  throw new Error(errorMsg);
+};
+
+var parseStripeProp = function parseStripeProp(raw) {
+  var errorMsg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : INVALID_STRIPE_ERROR$1;
+
+  if (isPromise(raw)) {
+    return {
+      tag: 'async',
+      stripePromise: Promise.resolve(raw).then(function (result) {
+        return validateStripe(result, errorMsg);
+      })
+    };
+  }
+
+  var stripe = validateStripe(raw, errorMsg);
+
+  if (stripe === null) {
+    return {
+      tag: 'empty'
+    };
+  }
+
+  return {
+    tag: 'sync',
+    stripe: stripe
+  };
+};
+
+var registerWithStripeJs = function registerWithStripeJs(stripe) {
+  if (!stripe || !stripe._registerWrapper || !stripe.registerAppInfo) {
+    return;
+  }
+
+  stripe._registerWrapper({
+    name: 'react-stripe-js',
+    version: "6.1.0"
+  });
+
+  stripe.registerAppInfo({
+    name: 'react-stripe-js',
+    version: "6.1.0",
+    url: 'https://stripe.com/docs/stripe-js/react'
+  });
+};
+
+var ElementsContext = /*#__PURE__*/React__default["default"].createContext(null);
+ElementsContext.displayName = 'ElementsContext';
+var parseElementsContext = function parseElementsContext(ctx, useCase) {
+  if (!ctx) {
+    throw new Error("Could not find Elements context; You need to wrap the part of your app that ".concat(useCase, " in an <Elements> provider."));
+  }
+
+  return ctx;
+};
+/**
+ * The `Elements` provider allows you to use [Element components](https://stripe.com/docs/stripe-js/react#element-components) and access the [Stripe object](https://stripe.com/docs/js/initializing) in any nested component.
+ * Render an `Elements` provider at the root of your React app so that it is available everywhere you need it.
+ *
+ * To use the `Elements` provider, call `loadStripe` from `@stripe/stripe-js` with your publishable key.
+ * The `loadStripe` function will asynchronously load the Stripe.js script and initialize a `Stripe` object.
+ * Pass the returned `Promise` to `Elements`.
+ *
+ * @docs https://docs.stripe.com/sdks/stripejs-react?ui=elements#elements-provider
+ */
+
+var Elements = function Elements(_ref) {
+  var rawStripeProp = _ref.stripe,
+      options = _ref.options,
+      children = _ref.children;
+  var parsed = React__default["default"].useMemo(function () {
+    return parseStripeProp(rawStripeProp);
+  }, [rawStripeProp]); // For a sync stripe instance, initialize into context
+
+  var _React$useState = React__default["default"].useState(function () {
+    return {
+      stripe: parsed.tag === 'sync' ? parsed.stripe : null,
+      elements: parsed.tag === 'sync' ? parsed.stripe.elements(options) : null
+    };
+  }),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      ctx = _React$useState2[0],
+      setContext = _React$useState2[1];
+
+  React__default["default"].useEffect(function () {
+    var isMounted = true;
+
+    var safeSetContext = function safeSetContext(stripe) {
+      setContext(function (ctx) {
+        // no-op if we already have a stripe instance (https://github.com/stripe/react-stripe-js/issues/296)
+        if (ctx.stripe) return ctx;
+        return {
+          stripe: stripe,
+          elements: stripe.elements(options)
+        };
+      });
+    }; // For an async stripePromise, store it in context once resolved
+
+
+    if (parsed.tag === 'async' && !ctx.stripe) {
+      parsed.stripePromise.then(function (stripe) {
+        if (stripe && isMounted) {
+          // Only update Elements context if the component is still mounted
+          // and stripe is not null. We allow stripe to be null to make
+          // handling SSR easier.
+          safeSetContext(stripe);
+        }
+      });
+    } else if (parsed.tag === 'sync' && !ctx.stripe) {
+      // Or, handle a sync stripe instance going from null -> populated
+      safeSetContext(parsed.stripe);
+    }
+
+    return function () {
+      isMounted = false;
+    };
+  }, [parsed, ctx, options]); // Warn on changes to stripe prop
+
+  var prevStripe = usePrevious(rawStripeProp);
+  React__default["default"].useEffect(function () {
+    if (prevStripe !== null && prevStripe !== rawStripeProp) {
+      console.warn('Unsupported prop change on Elements: You cannot change the `stripe` prop after setting it.');
+    }
+  }, [prevStripe, rawStripeProp]); // Apply updates to elements when options prop has relevant changes
+
+  var prevOptions = usePrevious(options);
+  React__default["default"].useEffect(function () {
+    if (!ctx.elements) {
+      return;
+    }
+
+    var updates = extractAllowedOptionsUpdates(options, prevOptions, ['clientSecret', 'fonts']);
+
+    if (updates) {
+      ctx.elements.update(updates);
+    }
+  }, [options, prevOptions, ctx.elements]); // Attach react-stripe-js version to stripe.js instance
+
+  React__default["default"].useEffect(function () {
+    registerWithStripeJs(ctx.stripe);
+  }, [ctx.stripe]);
+  return /*#__PURE__*/React__default["default"].createElement(ElementsContext.Provider, {
+    value: ctx
+  }, children);
+};
+Elements.propTypes = {
+  stripe: PropTypes.any,
+  options: PropTypes.object
+};
+var useElementsContextWithUseCase = function useElementsContextWithUseCase(useCaseMessage) {
+  var ctx = React__default["default"].useContext(ElementsContext);
+  return parseElementsContext(ctx, useCaseMessage);
+};
+/**
+ * @docs https://stripe.com/docs/stripe-js/react#useelements-hook
+ */
+
+var useElements = function useElements() {
+  var _useElementsContextWi = useElementsContextWithUseCase('calls useElements()'),
+      elements = _useElementsContextWi.elements;
+
+  return elements;
+};
+({
+  children: PropTypes.func.isRequired
+});
+
+var CheckoutContext = /*#__PURE__*/React__default["default"].createContext(null);
+CheckoutContext.displayName = 'CheckoutContext';
+var useElementsOrCheckoutContextWithUseCase = function useElementsOrCheckoutContextWithUseCase(useCaseString) {
+  var checkout = React__default["default"].useContext(CheckoutContext);
+  var elements = React__default["default"].useContext(ElementsContext);
+
+  if (checkout) {
+    if (elements) {
+      throw new Error("You cannot wrap the part of your app that ".concat(useCaseString, " in both a checkout provider and <Elements> provider."));
+    } else {
+      return checkout;
+    }
+  } else {
+    return parseElementsContext(elements, useCaseString);
+  }
+};
+
+var _excluded = ["mode"];
+
+var capitalized = function capitalized(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+
+var createElementComponent = function createElementComponent(type, isServer, customDisplayName) {
+  var displayName = "".concat(capitalized(type), "Element");
+
+  var ClientElement = function ClientElement(_ref) {
+    var id = _ref.id,
+        className = _ref.className,
+        _ref$options = _ref.options,
+        options = _ref$options === void 0 ? {} : _ref$options,
+        onBlur = _ref.onBlur,
+        onFocus = _ref.onFocus,
+        onReady = _ref.onReady,
+        onChange = _ref.onChange,
+        onEscape = _ref.onEscape,
+        onClick = _ref.onClick,
+        onLoadError = _ref.onLoadError,
+        onLoaderStart = _ref.onLoaderStart,
+        onNetworksChange = _ref.onNetworksChange,
+        onConfirm = _ref.onConfirm,
+        onCancel = _ref.onCancel,
+        onShippingAddressChange = _ref.onShippingAddressChange,
+        onShippingRateChange = _ref.onShippingRateChange,
+        onSavedPaymentMethodRemove = _ref.onSavedPaymentMethodRemove,
+        onSavedPaymentMethodUpdate = _ref.onSavedPaymentMethodUpdate;
+    var ctx = useElementsOrCheckoutContextWithUseCase("mounts <".concat(displayName, ">"));
+    var elements = 'elements' in ctx ? ctx.elements : null;
+    var checkoutState = 'checkoutState' in ctx ? ctx.checkoutState : null;
+    var checkoutSdk = (checkoutState === null || checkoutState === void 0 ? void 0 : checkoutState.type) === 'success' || (checkoutState === null || checkoutState === void 0 ? void 0 : checkoutState.type) === 'loading' ? checkoutState.sdk : null;
+
+    var _React$useState = React__default["default"].useState(null),
+        _React$useState2 = _slicedToArray(_React$useState, 2),
+        element = _React$useState2[0],
+        setElement = _React$useState2[1];
+
+    var elementRef = React__default["default"].useRef(null);
+    var domNode = React__default["default"].useRef(null); // For every event where the merchant provides a callback, call element.on
+    // with that callback. If the merchant ever changes the callback, removes
+    // the old callback with element.off and then call element.on with the new one.
+
+    useAttachEvent(element, 'blur', onBlur);
+    useAttachEvent(element, 'focus', onFocus);
+    useAttachEvent(element, 'escape', onEscape);
+    useAttachEvent(element, 'click', onClick);
+    useAttachEvent(element, 'loaderror', onLoadError);
+    useAttachEvent(element, 'loaderstart', onLoaderStart);
+    useAttachEvent(element, 'networkschange', onNetworksChange);
+    useAttachEvent(element, 'confirm', onConfirm);
+    useAttachEvent(element, 'cancel', onCancel);
+    useAttachEvent(element, 'shippingaddresschange', onShippingAddressChange);
+    useAttachEvent(element, 'shippingratechange', onShippingRateChange);
+    useAttachEvent(element, 'savedpaymentmethodremove', onSavedPaymentMethodRemove);
+    useAttachEvent(element, 'savedpaymentmethodupdate', onSavedPaymentMethodUpdate);
+    useAttachEvent(element, 'change', onChange);
+    var readyCallback;
+
+    if (onReady) {
+      if (type === 'expressCheckout') {
+        // Passes through the event, which includes visible PM types
+        readyCallback = onReady;
+      } else {
+        // For other Elements, pass through the Element itself.
+        readyCallback = function readyCallback() {
+          onReady(element);
+        };
+      }
+    }
+
+    useAttachEvent(element, 'ready', readyCallback);
+    React__default["default"].useLayoutEffect(function () {
+      if (elementRef.current === null && domNode.current !== null && (elements || checkoutSdk)) {
+        var newElement = null;
+
+        if (checkoutSdk) {
+          var elementsSdk = checkoutSdk;
+          var formSdk = checkoutSdk;
+
+          switch (type) {
+            case 'paymentForm':
+              newElement = formSdk.createForm(options);
+              break;
+
+            case 'payment':
+              newElement = elementsSdk.createPaymentElement(options);
+              break;
+
+            case 'address':
+              if ('mode' in options) {
+                var mode = options.mode,
+                    restOptions = _objectWithoutProperties(options, _excluded);
+
+                if (mode === 'shipping') {
+                  newElement = elementsSdk.createShippingAddressElement(restOptions);
+                } else if (mode === 'billing') {
+                  newElement = elementsSdk.createBillingAddressElement(restOptions);
+                } else {
+                  throw new Error("Invalid options.mode. mode must be 'billing' or 'shipping'.");
+                }
+              } else {
+                throw new Error("You must supply options.mode. mode must be 'billing' or 'shipping'.");
+              }
+
+              break;
+
+            case 'expressCheckout':
+              newElement = elementsSdk.createExpressCheckoutElement(options);
+              break;
+
+            case 'currencySelector':
+              newElement = checkoutSdk.createCurrencySelectorElement();
+              break;
+
+            case 'taxId':
+              newElement = elementsSdk.createTaxIdElement(options);
+              break;
+
+            default:
+              throw new Error("<".concat(displayName, "> is not supported inside a checkout provider. Use an <Elements> provider instead."));
+          }
+        } else if (elements) {
+          newElement = elements.create(type, options);
+        } // Store element in a ref to ensure it's _immediately_ available in cleanup hooks in StrictMode
+
+
+        elementRef.current = newElement; // Store element in state to facilitate event listener attachment
+
+        setElement(newElement);
+
+        if (newElement) {
+          newElement.mount(domNode.current);
+        }
+      }
+    }, [elements, checkoutSdk, options]);
+    var prevOptions = usePrevious(options);
+    React__default["default"].useEffect(function () {
+      if (!elementRef.current) {
+        return;
+      }
+
+      var updates = extractAllowedOptionsUpdates(options, prevOptions, ['paymentRequest']);
+
+      if (updates && 'update' in elementRef.current) {
+        elementRef.current.update(updates);
+      }
+    }, [options, prevOptions]);
+    React__default["default"].useLayoutEffect(function () {
+      return function () {
+        if (elementRef.current && typeof elementRef.current.destroy === 'function') {
+          try {
+            elementRef.current.destroy();
+            elementRef.current = null;
+          } catch (error) {// Do nothing
+          }
+        }
+      };
+    }, []);
+    return /*#__PURE__*/React__default["default"].createElement("div", {
+      id: id,
+      className: className,
+      ref: domNode
+    });
+  }; // Only render the Element wrapper in a server environment.
+
+
+  var ServerElement = function ServerElement(props) {
+    useElementsOrCheckoutContextWithUseCase("mounts <".concat(displayName, ">"));
+    var id = props.id,
+        className = props.className;
+    return /*#__PURE__*/React__default["default"].createElement("div", {
+      id: id,
+      className: className
+    });
+  };
+
+  var Element = isServer ? ServerElement : ClientElement;
+  Element.propTypes = {
+    id: PropTypes.string,
+    className: PropTypes.string,
+    onChange: PropTypes.func,
+    onBlur: PropTypes.func,
+    onFocus: PropTypes.func,
+    onReady: PropTypes.func,
+    onEscape: PropTypes.func,
+    onClick: PropTypes.func,
+    onLoadError: PropTypes.func,
+    onLoaderStart: PropTypes.func,
+    onNetworksChange: PropTypes.func,
+    onConfirm: PropTypes.func,
+    onCancel: PropTypes.func,
+    onShippingAddressChange: PropTypes.func,
+    onShippingRateChange: PropTypes.func,
+    onSavedPaymentMethodRemove: PropTypes.func,
+    onSavedPaymentMethodUpdate: PropTypes.func,
+    options: PropTypes.object
+  };
+  Element.displayName = displayName;
+  Element.__elementType = type;
+  return Element;
+};
+
+var isServer = typeof window === 'undefined';
+
+var EmbeddedCheckoutContext = /*#__PURE__*/React__default["default"].createContext(null);
+EmbeddedCheckoutContext.displayName = 'EmbeddedCheckoutProviderContext';
+
+/**
+ * @docs https://stripe.com/docs/stripe-js/react#usestripe-hook
+ */
+
+var useStripe = function useStripe() {
+  var _useElementsOrCheckou = useElementsOrCheckoutContextWithUseCase('calls useStripe()'),
+      stripe = _useElementsOrCheckou.stripe;
+
+  return stripe;
+};
+
+/**
+ * Requires beta access:
+ * Contact [Stripe support](https://support.stripe.com/) for more information.
+ *
+ * @docs https://stripe.com/docs/stripe-js/react#element-components
+ */
+
+createElementComponent('auBankAccount', isServer);
+/**
+ * @docs https://stripe.com/docs/stripe-js/react#element-components
+ */
+
+createElementComponent('card', isServer);
+/**
+ * @docs https://stripe.com/docs/stripe-js/react#element-components
+ */
+
+createElementComponent('cardNumber', isServer);
+/**
+ * @docs https://stripe.com/docs/stripe-js/react#element-components
+ */
+
+createElementComponent('cardExpiry', isServer);
+/**
+ * @docs https://stripe.com/docs/stripe-js/react#element-components
+ */
+
+createElementComponent('cardCvc', isServer);
+/**
+ * @docs https://stripe.com/docs/stripe-js/react#element-components
+ */
+
+createElementComponent('iban', isServer);
+var PaymentElement = createElementComponent('payment', isServer);
+/**
+ * @docs https://stripe.com/docs/stripe-js/react#element-components
+ */
+
+createElementComponent('expressCheckout', isServer);
+/**
+ * @docs https://stripe.com/docs/stripe-js/react#element-components
+ */
+
+var PaymentRequestButtonElement = createElementComponent('paymentRequestButton', isServer);
+/**
+ * @docs https://stripe.com/docs/stripe-js/react#element-components
+ */
+
+createElementComponent('linkAuthentication', isServer);
+/**
+ * @docs https://stripe.com/docs/stripe-js/react#element-components
+ */
+
+createElementComponent('address', isServer);
+/**
+ * @deprecated
+ * Use `AddressElement` instead.
+ *
+ * @docs https://stripe.com/docs/stripe-js/react#element-components
+ */
+
+createElementComponent('shippingAddress', isServer);
+/**
+ * @docs https://stripe.com/docs/stripe-js/react#element-components
+ */
+
+createElementComponent('paymentMethodMessaging', isServer);
+/**
+ * Requires beta access:
+ * Contact [Stripe support](https://support.stripe.com/) for more information.
+ */
+
+createElementComponent('taxId', isServer);
+/**
+ * @docs https://stripe.com/docs/issuing/elements
+ */
+
+createElementComponent('issuingCardNumberDisplay', isServer);
+/**
+ * @docs https://stripe.com/docs/issuing/elements
+ */
+
+createElementComponent('issuingCardCvcDisplay', isServer);
+/**
+ * @docs https://stripe.com/docs/issuing/elements
+ */
+
+createElementComponent('issuingCardExpiryDisplay', isServer);
+/**
+ * @docs https://stripe.com/docs/issuing/elements
+ */
+
+createElementComponent('issuingCardPinDisplay', isServer);
+/**
+ * @docs https://stripe.com/docs/issuing/elements
+ */
+
+createElementComponent('issuingCardCopyButton', isServer);
+
 var lib = {};
 
 Object.defineProperty(lib, "__esModule", {
@@ -10557,7 +11564,7 @@ class Payment {
    * @param {(StripeGateway|PaypalGateway|VantivGateway|TapGateway|CybersourceGateway|BraintreeGateway)} paymentGateway
    */
   constructor(paymentGateway) {
-    _defineProperty$3(this, "execute", (options, callback) => {
+    _defineProperty$4(this, "execute", (options, callback) => {
       if (!this.paymentGateway) {
         callback(_classPrivateFieldGet(this, _generateUserError).call(this), null);
         return console.error("No payment gateway provided");
@@ -10652,7 +11659,7 @@ class StripeGateway {
       writable: true,
       value: PAYMENT_GATEWAYS_ENUM["stripe"]
     });
-    _defineProperty$3(this, "execute", (options, callback) => {
+    _defineProperty$4(this, "execute", (options, callback) => {
       const types = PAYMENT_TYPES;
       switch (options.type) {
         case types.CREATE_SUBSCRIPTION:
@@ -10839,7 +11846,7 @@ class PaypalGateway {
       writable: true,
       value: PAYMENT_GATEWAYS_ENUM["paypal"]
     });
-    _defineProperty$3(this, "execute", (options, callback) => {
+    _defineProperty$4(this, "execute", (options, callback) => {
       const types = PAYMENT_TYPES;
       switch (options.type) {
         case types.CREATE_SUBSCRIPTION:
@@ -10939,7 +11946,7 @@ class VantivGateway {
       writable: true,
       value: PAYMENT_GATEWAYS_ENUM["vantiv"]
     });
-    _defineProperty$3(this, "execute", (options, callback) => {
+    _defineProperty$4(this, "execute", (options, callback) => {
       const types = PAYMENT_TYPES;
       switch (options.type) {
         case types.CREATE_SUBSCRIPTION:
@@ -11151,7 +12158,7 @@ class TapGateway {
       writable: true,
       value: PAYMENT_GATEWAYS_ENUM["tap"]
     });
-    _defineProperty$3(this, "execute", (options, callback) => {
+    _defineProperty$4(this, "execute", (options, callback) => {
       const types = PAYMENT_TYPES;
       switch (options.type) {
         case types.CREATE_SUBSCRIPTION:
@@ -11367,7 +12374,7 @@ class CybersourceGateway {
       writable: true,
       value: PAYMENT_GATEWAYS_ENUM["cybersource"]
     });
-    _defineProperty$3(this, "execute", (options, callback) => {
+    _defineProperty$4(this, "execute", (options, callback) => {
       const types = PAYMENT_TYPES;
       switch (options.type) {
         case types.CREATE_SUBSCRIPTION:
@@ -11601,7 +12608,7 @@ class BraintreeGateway {
       writable: true,
       value: PAYMENT_GATEWAYS_ENUM["braintree"]
     });
-    _defineProperty$3(this, "execute", (options, callback) => {
+    _defineProperty$4(this, "execute", (options, callback) => {
       const types = PAYMENT_TYPES;
       switch (options.type) {
         case types.CREATE_SUBSCRIPTION:
@@ -11620,14 +12627,14 @@ class BraintreeGateway {
           console.error("Unsupported payment method: braintree Gateway");
       }
     });
-    _defineProperty$3(this, "createDropin", function (authorization, selector) {
+    _defineProperty$4(this, "createDropin", function (authorization, selector) {
       let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
       return createBraintreeDropin(authorization, selector, options);
     });
-    _defineProperty$3(this, "requestPaymentMethod", instance => {
+    _defineProperty$4(this, "requestPaymentMethod", instance => {
       return requestBraintreePaymentMethod(instance);
     });
-    _defineProperty$3(this, "loadScript", () => {
+    _defineProperty$4(this, "loadScript", () => {
       return loadBraintreeScript();
     });
     _classPrivateFieldInitSpec(this, _createSubscription6, {
@@ -11970,8 +12977,8 @@ const PaymentMethodContainerWithoutStripe = _ref => {
     onFailure = () => {},
     ...props
   } = _ref;
-  const stripe = reactStripeJs.useStripe();
-  const elements = reactStripeJs.useElements();
+  const stripe = useStripe();
+  const elements = useElements();
   const [vantivPaymentRequest, setVantivPaymentRequest] = React.useState(null);
   const [updatedCouponCode, setUpdatedCouponCode] = React.useState("");
   const {
@@ -15398,7 +16405,7 @@ const PaymentMethodContainer = props => {
   const cardProcessor = getSiteCardProcessor();
 
   // Create the Stripe object
-  const stripePromise = cardProcessor === "stripe" ? stripeJs.loadStripe(window.Pelcro.environment.stripe, {
+  const stripePromise = cardProcessor === "stripe" ? loadStripe(window.Pelcro.environment.stripe, {
     stripeAccount: window.Pelcro.site.read().account_id,
     locale: getPageOrDefaultLanguage()
   }) : null;
@@ -15443,7 +16450,7 @@ const PaymentMethodContainer = props => {
   }, []); // eslint-disable-line react-hooks/exhaustive-deps
 
   if (isStripeLoaded) {
-    return /*#__PURE__*/React__default["default"].createElement("div", null, clientSecret || selectedPaymentMethodId ? /*#__PURE__*/React__default["default"].createElement(reactStripeJs.Elements, {
+    return /*#__PURE__*/React__default["default"].createElement("div", null, clientSecret || selectedPaymentMethodId ? /*#__PURE__*/React__default["default"].createElement(Elements, {
       options: options,
       stripe: stripePromise
     }, /*#__PURE__*/React__default["default"].createElement(PaymentMethodContainerWithoutStripe, Object.assign({
@@ -15747,7 +16754,7 @@ const PelcroPaymentRequestButton = _ref => {
     onFailure,
     ...props
   } = _ref;
-  const stripe = reactStripeJs.useStripe();
+  const stripe = useStripe();
   const [isInitializing, setIsInitializing] = React.useState(true);
   const [localPaymentRequest, setLocalPaymentRequest] = React.useState(null);
   const {
@@ -15998,7 +17005,7 @@ const PelcroPaymentRequestButton = _ref => {
   if (isInitializing || !canMakePayment || !localPaymentRequest) {
     return null;
   }
-  return /*#__PURE__*/React__default["default"].createElement(reactStripeJs.PaymentRequestButtonElement, Object.assign({
+  return /*#__PURE__*/React__default["default"].createElement(PaymentRequestButtonElement, Object.assign({
     className: "StripeElement stripe-payment-request-btn",
     options: {
       paymentRequest: localPaymentRequest,
@@ -16139,7 +17146,7 @@ const CheckoutForm = _ref3 => {
         placeholder: "Exp Year *"
       }))));
     }
-    return /*#__PURE__*/React__default["default"].createElement(reactStripeJs.PaymentElement, {
+    return /*#__PURE__*/React__default["default"].createElement(PaymentElement, {
       id: "payment-element",
       options: paymentElementOptions
     });