@verbb/formie-browser 1.0.0

package/dist/chunks/moneris-B_IFZFTx.js

@@ -0,0 +1,159 @@
+import { t as definePaymentModule } from "./api-DE7LfK-R.js";
+//#region src/js/modules/payments/moneris.ts
+var MONERIS_RESPONSE_MESSAGES = {
+	"940": "Invalid profile ID (tokenization request).",
+	"941": "Error generating token.",
+	"942": "Invalid Profile ID or source URL.",
+	"943": "Card data is invalid.",
+	"944": "Invalid expiration date.",
+	"945": "Invalid CVD."
+};
+var extractMonerisToken = (payload) => {
+	const fromObject = (value) => {
+		const token = String(value.dataKey ?? value.data_key ?? "").trim();
+		const responseCode = String(value.responseCode ?? value.response_code ?? "").trim();
+		const responseMessage = String(value.responseMessage ?? value.response_message ?? "").trim();
+		const error = String(value.error ?? value.errorMessage ?? value.message ?? "").trim();
+		if (token) return {
+			token,
+			error: ""
+		};
+		if (responseCode && responseCode !== "001") {
+			const codeMessage = MONERIS_RESPONSE_MESSAGES[responseCode] || `Moneris response code ${responseCode}.`;
+			return {
+				token: "",
+				error: responseMessage || codeMessage
+			};
+		}
+		return {
+			token: "",
+			error
+		};
+	};
+	if (payload && typeof payload === "object") return fromObject(payload);
+	if (typeof payload !== "string") return {
+		token: "",
+		error: ""
+	};
+	const value = payload.trim();
+	if (!value) return {
+		token: "",
+		error: ""
+	};
+	try {
+		const decoded = JSON.parse(value);
+		if (decoded && typeof decoded === "object") return fromObject(decoded);
+	} catch {}
+	if (value.includes("=")) {
+		const params = new URLSearchParams(value);
+		const token = (params.get("dataKey") || params.get("data_key") || "").trim();
+		const responseCode = (params.get("responseCode") || params.get("response_code") || "").trim();
+		const responseMessage = (params.get("responseMessage") || params.get("response_message") || "").trim();
+		const error = (params.get("error") || params.get("message") || "").trim();
+		if (token) return {
+			token,
+			error: ""
+		};
+		if (responseCode && responseCode !== "001") {
+			const codeMessage = MONERIS_RESPONSE_MESSAGES[responseCode] || `Moneris response code ${responseCode}.`;
+			return {
+				token: "",
+				error: responseMessage || codeMessage
+			};
+		}
+		return {
+			token: "",
+			error
+		};
+	}
+	if (/^[A-Za-z0-9._-]{8,}$/.test(value)) return {
+		token: value,
+		error: ""
+	};
+	return {
+		token: "",
+		error: ""
+	};
+};
+var monerisModule = definePaymentModule({
+	id: "moneris",
+	defaultRequiredInputSuffixes: ["monerisTokenId"],
+	load: async () => null,
+	onBeforeAuthorize: async (args) => {
+		const { field, services, options } = args;
+		const fieldState = field;
+		const endpointUrl = (options.provider.endpointUrl || "").trim();
+		const iframe = field.querySelector("[data-formie-moneris-frame]");
+		let endpointOrigin = "";
+		try {
+			endpointOrigin = new URL(endpointUrl, window.location.origin).origin;
+		} catch {
+			endpointOrigin = "";
+		}
+		if (!iframe?.contentWindow || !endpointOrigin) {
+			services.addError("Moneris frame or endpoint is missing.");
+			return false;
+		}
+		fieldState.__formieMonerisAuthorizeCleanup?.();
+		const requestId = (fieldState.__formieMonerisAuthorizeRequestId || 0) + 1;
+		fieldState.__formieMonerisAuthorizeRequestId = requestId;
+		return new Promise((resolve) => {
+			let resolved = false;
+			let lastError = "";
+			let timeout = 0;
+			const cleanup = () => {
+				window.removeEventListener("message", messageHandler);
+				window.clearTimeout(timeout);
+				if (fieldState.__formieMonerisAuthorizeCleanup === cleanup) fieldState.__formieMonerisAuthorizeCleanup = null;
+			};
+			const messageHandler = (event) => {
+				if (resolved || requestId !== fieldState.__formieMonerisAuthorizeRequestId) return;
+				if (event.origin !== endpointOrigin) return;
+				const result = extractMonerisToken(event.data);
+				if (result.token) {
+					resolved = true;
+					cleanup();
+					services.updateInputs("monerisTokenId", result.token);
+					resolve(true);
+				} else if (result.error) lastError = result.error;
+			};
+			fieldState.__formieMonerisAuthorizeCleanup = cleanup;
+			timeout = window.setTimeout(() => {
+				if (resolved) return;
+				resolved = true;
+				cleanup();
+				services.addError(lastError || "Moneris tokenization timed out. Please try again.");
+				resolve(false);
+			}, 1e4);
+			window.addEventListener("message", messageHandler);
+			try {
+				iframe.contentWindow?.postMessage("tokenize", endpointOrigin);
+			} catch {
+				resolved = true;
+				cleanup();
+				services.addError("Moneris tokenization could not be started.");
+				resolve(false);
+			}
+		});
+	},
+	setup: async (ctx) => {
+		const { services } = ctx;
+		const messageHandler = (event) => {
+			if (!event.origin.includes("moneris")) return;
+			const result = extractMonerisToken(event.data);
+			if (result.token) services.updateInputs("monerisTokenId", result.token);
+		};
+		const unbind = services.events.onRoot("message", messageHandler);
+		return { destroy: () => {
+			unbind();
+			const fieldState = ctx.target;
+			fieldState.__formieMonerisAuthorizeCleanup?.();
+			fieldState.__formieMonerisAuthorizeCleanup = null;
+		} };
+	},
+	onAfterSubmit: async ({ services }) => {
+		services.updateInputs("monerisTokenId", "");
+	}
+});
+//#endregion
+export { monerisModule };

package/dist/chunks/opayo-U2x_TOII.js

@@ -0,0 +1,192 @@
+import { s as getPaymentProviderActionEventName } from "./event-names-DamGPtXR.js";
+import { t as createDebug } from "./debug-KnZeKYBI.js";
+import { t as definePaymentModule } from "./api-DE7LfK-R.js";
+import { r as loadScriptAndEnsureGlobal } from "./scripts-BGD_iU_6.js";
+//#region src/js/modules/payments/opayo.ts
+var SCRIPT_ID = "FORMIE_OPAYO_SCRIPT";
+var SCRIPT_SRC_LIVE = "https://live.opayo.eu.elavon.com/api/v1/js/sagepay.js";
+var SCRIPT_SRC_SANDBOX = "https://sandbox.opayo.eu.elavon.com/api/v1/js/sagepay.js";
+var debug = createDebug("payments", "opayo");
+var CHALLENGE_EVENT = getPaymentProviderActionEventName("opayo", "challenge");
+var CHALLENGE_RESPONSE_MESSAGE = "formie:payment:opayo:challenge:response";
+var opayoModule = definePaymentModule({
+	id: "opayo",
+	defaultRequiredInputSuffixes: ["opayoTokenId"],
+	load: async (ctx) => {
+		const { provider } = ctx.options;
+		await loadScriptAndEnsureGlobal("sagepayOwnForm", {
+			id: SCRIPT_ID,
+			src: Boolean(provider.useSandbox) ? SCRIPT_SRC_SANDBOX : SCRIPT_SRC_LIVE,
+			timeoutMs: 1e4
+		});
+		return null;
+	},
+	onBeforeAuthorize: async (args) => {
+		const { field, services, options } = args;
+		const provider = options.provider;
+		const handle = provider.handle || "opayo";
+		const form = services.form;
+		if (!form?.action) {
+			services.addError("Form action is missing.");
+			debug.warn("Missing form action before authorize.");
+			return false;
+		}
+		const sagepayOwnForm = window.sagepayOwnForm;
+		if (!sagepayOwnForm) {
+			services.addError("Opayo script failed to load.");
+			debug.warn("sagepayOwnForm global not available.");
+			return false;
+		}
+		const cardholderName = field.querySelector("[data-opayo-card=\"cardholder-name\"]")?.value ?? "";
+		let cardNumber = field.querySelector("[data-opayo-card=\"card-number\"]")?.value ?? "";
+		let expiryDate = field.querySelector("[data-opayo-card=\"expiry-date\"]")?.value ?? "";
+		const securityCode = field.querySelector("[data-opayo-card=\"security-code\"]")?.value ?? "";
+		cardNumber = cardNumber.replace(/[\s/]/g, "");
+		expiryDate = expiryDate.replace(/[\s/]/g, "");
+		return new Promise((resolve) => {
+			const formData = new FormData();
+			formData.append("action", "formie/payment-webhooks/process-callback");
+			formData.append("merchantSessionKey", "true");
+			formData.append("handle", handle);
+			formData.append("sessionToken", provider.sessionToken || "");
+			fetch(form.action, {
+				method: "POST",
+				body: formData
+			}).then(async (res) => {
+				if (res.status < 200 || res.status >= 300) {
+					services.addError(`${res.status}: ${res.statusText}`);
+					debug.warn("Merchant session request failed.", {
+						status: res.status,
+						statusText: res.statusText
+					});
+					resolve(false);
+					return;
+				}
+				try {
+					const merchantSessionKey = (await res.json()).merchantSessionKey;
+					if (!merchantSessionKey) {
+						services.addError("Unable to get merchant session.");
+						debug.warn("merchantSessionKey missing in callback response.");
+						resolve(false);
+						return;
+					}
+					sagepayOwnForm({ merchantSessionKey }).tokeniseCardDetails({
+						cardDetails: {
+							cardholderName,
+							cardNumber,
+							expiryDate,
+							securityCode
+						},
+						onTokenised: (result) => {
+							if (result.success && result.cardIdentifier) {
+								services.updateInputs("opayoTokenId", result.cardIdentifier);
+								services.updateInputs("opayoSessionKey", merchantSessionKey);
+								debug.log("Tokenization succeeded.", { hasCardIdentifier: !!result.cardIdentifier });
+								resolve(true);
+							} else {
+								services.addError(result.errors?.[0]?.message || "Tokenization failed.");
+								debug.warn("Tokenization failed.", result);
+								resolve(false);
+							}
+						}
+					});
+				} catch {
+					services.addError("Unable to parse merchant session response.");
+					debug.warn("Failed to parse merchant session response.");
+					resolve(false);
+				}
+			}).catch(() => {
+				services.addError("Network error. Please try again.");
+				debug.warn("Network error requesting merchant session.");
+				resolve(false);
+			});
+		});
+	},
+	setup: async (ctx) => {
+		const { services } = ctx;
+		ctx.target;
+		let activeDialog = null;
+		let handling3DSResponse = false;
+		const closeDialog = () => {
+			if (activeDialog?.parentNode) activeDialog.parentNode.removeChild(activeDialog);
+			activeDialog = null;
+		};
+		const unbind3DS = services.events.onForm(CHALLENGE_EVENT, ((event) => {
+			const data = event.detail?.data;
+			if (!data?.acsUrl || !data?.creq) return;
+			handling3DSResponse = false;
+			debug.log("Received payment challenge event.", {
+				hasAcsUrl: !!data.acsUrl,
+				hasCreq: !!data.creq
+			});
+			const md = (services.form?.querySelector("input[name*=\"opayoSessionKey\"]"))?.value || "";
+			const dialog = document.createElement("div");
+			dialog.className = "formie-modal";
+			dialog.id = `formie-opayo-dialog-${Math.random().toString(36).slice(2, 9)}`;
+			dialog.innerHTML = `
+                <div class="formie-modal-backdrop" data-dialog-close></div>
+                <div class="formie-modal-content">
+                    <div class="formie-loading formie-loading-large" style="--formie-loading-width: 3rem; --formie-loading-height: 3rem; top: 50%; margin-top: -1.5rem;"></div>
+                    <iframe width="100%" height="100%" style="width: 100%; height: 100%; position: relative; z-index: 1;"></iframe>
+                </div>
+            `;
+			const iframe = dialog.querySelector("iframe");
+			const esc = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+			const callbackUrl = data.returnUrl || data.redirectUrl || "";
+			const html = `<form action="${esc(data.acsUrl)}" method="post">
+                <input type="hidden" name="creq" value="${esc(data.creq || "")}" />
+                <input type="hidden" name="threeDSSessionData" value="${esc(data.threeDSSessionData || "")}" />
+                <input type="hidden" name="MD" value="${esc(md)}" />
+                <input type="hidden" name="TermUrl" value="${esc(callbackUrl)}" />
+                <input type="hidden" name="ThreeDSNotificationURL" value="${esc(callbackUrl)}" />
+            </form><script>document.forms[0].submit();<\/script>`;
+			closeDialog();
+			document.body.appendChild(dialog);
+			activeDialog = dialog;
+			if (iframe?.contentWindow) {
+				iframe.contentWindow.document.open();
+				iframe.contentWindow.document.write(html);
+				iframe.contentWindow.document.close();
+			}
+		}));
+		const messageHandler = (event) => {
+			if (event.data?.message !== CHALLENGE_RESPONSE_MESSAGE) return;
+			if (!activeDialog) {
+				debug.log("Ignoring 3DS response without active dialog.");
+				return;
+			}
+			if (handling3DSResponse) {
+				debug.warn("Ignoring duplicate 3DS response while processing.");
+				return;
+			}
+			handling3DSResponse = true;
+			debug.log("Received payment challenge response message.", event.data?.value);
+			closeDialog();
+			services.removeError();
+			if (event.data?.value?.error) {
+				services.addError(event.data.value.error.message);
+				services.releaseSubmitLoading();
+				handling3DSResponse = false;
+				return;
+			}
+			services.updateInputs("opayo3DSComplete", event.data.value?.transactionId ?? "");
+			services.triggerSubmit();
+		};
+		window.addEventListener("message", messageHandler);
+		return { destroy: () => {
+			unbind3DS();
+			window.removeEventListener("message", messageHandler);
+			closeDialog();
+			handling3DSResponse = false;
+		} };
+	},
+	onAfterSubmit: async ({ services }) => {
+		services.updateInputs([
+			"opayoTokenId",
+			"opayoSessionKey",
+			"opayo3DSComplete"
+		], "");
+	}
+});
+//#endregion
+export { opayoModule };

package/dist/chunks/paddle-BqXFrc79.js

@@ -0,0 +1,75 @@
+import { s as getPaymentProviderActionEventName } from "./event-names-DamGPtXR.js";
+import { t as definePaymentModule } from "./api-DE7LfK-R.js";
+import { r as loadScriptAndEnsureGlobal } from "./scripts-BGD_iU_6.js";
+//#region src/js/modules/payments/paddle.ts
+var SCRIPT_ID = "FORMIE_PADDLE_SCRIPT";
+var CHECKOUT_EVENT = getPaymentProviderActionEventName("paddle", "initialize");
+var paddleModule = definePaymentModule({
+	id: "paddle",
+	defaultRequiredInputSuffixes: ["paddleCheckoutData"],
+	load: async () => null,
+	setup: async (ctx) => {
+		const { services } = ctx;
+		ctx.target;
+		const provider = ctx.options.provider;
+		const clientSideToken = provider.clientSideToken;
+		if (!clientSideToken?.trim()) {
+			services.addError("Missing clientSideToken for Paddle.");
+			return {};
+		}
+		let paddle;
+		try {
+			paddle = await loadScriptAndEnsureGlobal("Paddle", {
+				id: SCRIPT_ID,
+				src: "https://cdn.paddle.com/paddle/v2/paddle.js"
+			});
+			paddle.Environment.set(provider.environment || "production");
+		} catch (error) {
+			services.addError(error instanceof Error ? error.message : "Failed to load Paddle SDK.");
+			return {};
+		}
+		paddle.Initialize({
+			token: clientSideToken,
+			checkout: { settings: {
+				displayMode: "overlay",
+				variant: "multi-page"
+			} },
+			eventCallback: (e) => {
+				if (e.name === "checkout.completed") {
+					services.updateInputs("paddleCheckoutInit", "");
+					services.updateInputs("paddleCheckoutData", JSON.stringify(e.data || {}));
+					setTimeout(() => {
+						paddle.Checkout.close();
+						services.triggerSubmit();
+					}, 500);
+				}
+			}
+		});
+		const openCheckout = (data) => {
+			if (!data?.items) {
+				services.addError("Missing Paddle checkout items.");
+				return false;
+			}
+			try {
+				services.releaseSubmitLoading();
+				paddle.Checkout.open(data);
+			} catch (error) {
+				services.addError(error instanceof Error ? error.message : "Unable to open Paddle checkout.");
+				return false;
+			}
+			return true;
+		};
+		const unbindCheckout = services.events.onForm(CHECKOUT_EVENT, ((event) => {
+			openCheckout(event.detail?.data);
+		}));
+		return { destroy: () => {
+			unbindCheckout();
+		} };
+	},
+	onAfterSubmit: async ({ services }) => {
+		services.updateInputs("paddleCheckoutInit", "true");
+		services.updateInputs("paddleCheckoutData", "");
+	}
+});
+//#endregion
+export { paddleModule };

package/dist/chunks/paypal-Cn_DYGDb.js

@@ -0,0 +1,121 @@
+import { t as definePaymentModule } from "./api-DE7LfK-R.js";
+import { r as loadScriptAndEnsureGlobal } from "./scripts-BGD_iU_6.js";
+import { t as ensureModuleStyles } from "./styles-BIh6g7V_.js";
+//#endregion
+//#region src/js/modules/payments/paypal.ts
+ensureModuleStyles("paypal", ["@layer formie-theme{.formie-paypal-button{border:var(--formie-border-width) solid var(--formie-color-border);border-radius:var(--formie-radius-sm);background:var(--formie-color-surface);box-sizing:border-box;min-height:var(--formie-control-height);padding:var(--formie-space-2)}}"]);
+var SCRIPT_ID = "FORMIE_PAYPAL_SCRIPT";
+function extractAuthIdFromAuthorization(result) {
+	if (!result) return "";
+	const payments = (result.purchase_units || [])[0]?.payments || {};
+	const authorizations = payments.authorizations || [];
+	const captures = payments.captures || [];
+	return String(authorizations[0]?.id || captures[0]?.id || "").trim();
+}
+function getScriptUrl(clientId, currency) {
+	return `https://www.paypal.com/sdk/js?${[
+		"intent=authorize",
+		`currency=${encodeURIComponent(currency)}`,
+		`client-id=${encodeURIComponent(clientId)}`
+	].join("&")}`;
+}
+var paypalModule = definePaymentModule({
+	id: "paypal",
+	defaultRequiredInputSuffixes: ["paypalOrderId", "paypalAuthId"],
+	load: async (ctx) => {
+		const { provider } = ctx.options;
+		const clientId = provider.clientId;
+		if (!clientId?.trim()) {
+			console.error("[formie] Missing clientId for PayPal.");
+			return null;
+		}
+		await loadScriptAndEnsureGlobal("paypal", {
+			id: SCRIPT_ID,
+			src: getScriptUrl(clientId, provider.currency || "AUD")
+		});
+		return window.paypal;
+	},
+	mount: async (args) => {
+		const { api, field, services, options, provider } = args;
+		const placeholder = field.querySelector("[data-formie-paypal-button]");
+		if (!placeholder || !api) return null;
+		if (placeholder.getAttribute("data-formie-paypal-rendered") === "true") return null;
+		placeholder.innerHTML = "";
+		const useSandbox = Boolean(provider.useSandbox);
+		const currencyResult = services.resolveCurrency({
+			value: provider.currency,
+			defaultCurrency: "AUD"
+		});
+		if (!currencyResult.ok) {
+			services.addError("error" in currencyResult ? currencyResult.error : "Invalid PayPal currency.");
+			return null;
+		}
+		const currency = currencyResult.value;
+		const style = {
+			layout: provider.buttonLayout || "vertical",
+			color: provider.buttonColor || "gold",
+			shape: provider.buttonShape || "rect",
+			label: provider.buttonLabel || "paypal",
+			width: provider.buttonWidth || 250,
+			height: provider.buttonHeight || 35
+		};
+		if (style.layout === "horizontal") style.tagline = provider.buttonTagline ?? true;
+		const paypalOptions = {
+			env: useSandbox ? "sandbox" : "production",
+			style,
+			createOrder: (_data, actions) => {
+				services.removeError();
+				const amountResult = services.resolveAmount({
+					type: provider.amountType,
+					fixed: provider.amountFixed,
+					variable: provider.amountVariable
+				});
+				if (!amountResult.ok) {
+					const errorMessage = "error" in amountResult ? amountResult.error : "Invalid PayPal amount.";
+					services.addError(errorMessage);
+					throw new Error(errorMessage);
+				}
+				return actions.order.create({
+					intent: "AUTHORIZE",
+					application_context: { user_action: "CONTINUE" },
+					purchase_units: [{ amount: {
+						currency_code: currency,
+						value: String(amountResult.value)
+					} }]
+				});
+			},
+			onError: (err) => {
+				services.addError(err?.message || "PayPal error.");
+			},
+			onApprove: async (data, actions) => {
+				try {
+					const authId = extractAuthIdFromAuthorization(await actions.order.authorize());
+					services.updateInputs("paypalOrderId", data.orderID);
+					services.updateInputs("paypalAuthId", authId || "");
+					if (authId) services.addSuccess("Payment authorized. Finalize the form to complete payment.");
+					else services.addSuccess("PayPal approval received. Finalizing payment on submit.");
+				} catch {
+					services.addError("Unable to authorize payment. Please try again.");
+				}
+			}
+		};
+		const buttons = api.Buttons(paypalOptions);
+		placeholder.setAttribute("data-formie-paypal-rendered", "true");
+		return buttons.render(placeholder);
+	},
+	unmount: async (args) => {
+		if (args.widget?.close) args.widget.close();
+		const placeholder = args.field.querySelector("[data-formie-paypal-button]");
+		if (placeholder) {
+			placeholder.removeAttribute("data-formie-paypal-rendered");
+			placeholder.innerHTML = "";
+		}
+	},
+	onAfterSubmit: async ({ services }) => {
+		services.updateInputs(["paypalOrderId", "paypalAuthId"], "");
+		services.removeSuccess();
+		services.removeError();
+	}
+});
+//#endregion
+export { paypalModule };

package/dist/chunks/payway-Rnq796eC.js

@@ -0,0 +1,75 @@
+import { t as definePaymentModule } from "./api-DE7LfK-R.js";
+import { r as loadScriptAndEnsureGlobal } from "./scripts-BGD_iU_6.js";
+import { t as ensureModuleStyles } from "./styles-BIh6g7V_.js";
+//#endregion
+//#region src/js/modules/payments/payway.ts
+ensureModuleStyles("payway", ["@layer formie-theme{.formie-payway-button{border:var(--formie-border-width) solid var(--formie-color-border);border-radius:var(--formie-radius-sm);background:var(--formie-color-surface);box-sizing:border-box;min-height:var(--formie-control-height);padding:var(--formie-space-2)}}"]);
+var SCRIPT_ID = "FORMIE_PAYWAY_SCRIPT";
+var paywayModule = definePaymentModule({
+	id: "payway",
+	defaultRequiredInputSuffixes: ["paywayTokenId"],
+	load: async (ctx) => {
+		const { provider } = ctx.options;
+		if (!provider.publishableKey?.trim()) {
+			console.error("[formie] Missing publishableKey for PayWay.");
+			return null;
+		}
+		await loadScriptAndEnsureGlobal("payway", {
+			id: SCRIPT_ID,
+			src: "https://api.payway.com.au/rest/v1/payway.js"
+		});
+		return null;
+	},
+	mount: async (args) => {
+		const { field, services, options } = args;
+		const provider = options.provider;
+		if (!field.querySelector("[data-formie-payway-button]")) return null;
+		const payway = window.payway;
+		if (!payway) return null;
+		return new Promise((resolve) => {
+			payway.createCreditCardFrame({
+				layout: "wide",
+				publishableApiKey: provider.publishableKey || "",
+				tokenMode: "callback"
+			}, (err, frame) => {
+				if (err || !frame) {
+					services.addError(err?.message || "PayWay frame failed to load.");
+					resolve(null);
+					return;
+				}
+				resolve(frame);
+			});
+		});
+	},
+	unmount: async (args) => {
+		args.widget?.destroy();
+	},
+	onBeforeAuthorize: async (args) => {
+		const { widget, services } = args;
+		if (!widget) {
+			services.addError("PayWay card frame is not ready.");
+			return false;
+		}
+		return new Promise((resolve) => {
+			widget.getToken((err, data) => {
+				if (err) {
+					services.addError(err.message);
+					resolve(false);
+					return;
+				}
+				if (data?.singleUseTokenId) {
+					services.updateInputs("paywayTokenId", data.singleUseTokenId);
+					resolve(true);
+				} else {
+					services.addError("Tokenization failed.");
+					resolve(false);
+				}
+			});
+		});
+	},
+	onAfterSubmit: async ({ services }) => {
+		services.updateInputs("paywayTokenId", "");
+	}
+});
+//#endregion
+export { paywayModule };