@forgeroute/ui 0.4.2 → 0.4.4

package/fesm2022/forgeroute-ui-stripe.mjs

@@ -0,0 +1,2762 @@
+import * as i0 from "@angular/core";
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, Injectable, InjectionToken, PLATFORM_ID, computed, effect, inject, input, output, signal, untracked, viewChild } from "@angular/core";
+import { DOCUMENT, isPlatformBrowser } from "@angular/common";
+import { AlertComponent, BadgeComponent, ButtonComponent, FormRowComponent, FormSectionComponent, ModalComponent, SkeletonComponent, TextComponent, TextInputComponent } from "@forgeroute/ui";
+import * as i1 from "@angular/forms";
+import { FormsModule } from "@angular/forms";
+const sdkImporter = { load: () => import("@stripe/stripe-js") };
+const defaultStripeLoader = async (publishableKey, options) => {
+	const sdk = await sdkImporter.load();
+	return options === void 0 ? await sdk.loadStripe(publishableKey) : await sdk.loadStripe(publishableKey, options);
+};
+const STRIPE_LOADER = new InjectionToken("STRIPE_LOADER", {
+	providedIn: "root",
+	factory: () => defaultStripeLoader
+});
+const STRIPE_PAYMENT_DEFAULTS = new InjectionToken("STRIPE_PAYMENT_DEFAULTS", {
+	providedIn: "root",
+	factory: () => ({})
+});
+function provideStripePayment(options = {}) {
+	const { loader, ...defaults } = options;
+	const providers = [{
+		provide: STRIPE_PAYMENT_DEFAULTS,
+		useValue: defaults
+	}];
+	if (loader) providers.push({
+		provide: STRIPE_LOADER,
+		useValue: loader
+	});
+	return providers;
+}
+function buildLoadOptions(stripeAccount, locale, extra) {
+	const options = { ...extra ?? {} };
+	if (locale) options.locale = locale;
+	if (stripeAccount) options.stripeAccount = stripeAccount;
+	return Object.keys(options).length ? options : void 0;
+}
+const STRIPE_ERROR_MESSAGES = {
+	stolen_card: "This card has been reported as stolen. Please use a different payment method.",
+	lost_card: "This card has been reported as lost. Please use a different payment method.",
+	card_declined: "Your card was declined. Please contact your bank or use a different card.",
+	generic_decline: "Your card was declined. Please contact your bank or try a different card.",
+	insufficient_funds: "Your card has insufficient funds. Please use a different card or add funds to your account.",
+	do_not_honor: "Your bank has declined this transaction. Please contact your bank or use a different card.",
+	card_not_supported: "This card does not support this type of purchase. Please use a different card.",
+	currency_not_supported: "This card does not support the requested currency. Please use a different card.",
+	duplicate_transaction: "A duplicate transaction was detected. Please wait a few minutes before trying again.",
+	expired_card: "Your card has expired. Please use a different card.",
+	incorrect_cvc: "The security code (CVC) is incorrect. Please check and try again.",
+	incorrect_number: "The card number is incorrect. Please check and try again.",
+	invalid_cvc: "The security code (CVC) is invalid. Please check and try again.",
+	invalid_expiry_month: "The expiration month is invalid. Please check and try again.",
+	invalid_expiry_year: "The expiration year is invalid. Please check and try again.",
+	invalid_number: "The card number is invalid. Please check and try again.",
+	processing_error: "An error occurred while processing your card. Please try again.",
+	incorrect_zip: "The ZIP/postal code is incorrect. Please check and try again.",
+	card_velocity_exceeded: "You have exceeded the balance or credit limit on your card. Please contact your bank.",
+	withdrawal_count_limit_exceeded: "You have exceeded the allowed number of transactions. Please try again later or use a different card.",
+	authentication_required: "This card requires authentication. Please try again and complete the verification step.",
+	fraudulent: "This transaction has been flagged by your bank. Please contact your bank or use a different card.",
+	merchant_blacklist: "This card cannot be used for this transaction. Please use a different card.",
+	pickup_card: "This card cannot be used. Please contact your bank or use a different card.",
+	restricted_card: "This card has restrictions that prevent this transaction. Please contact your bank or use a different card.",
+	security_violation: "This card has been flagged for a security violation. Please contact your bank.",
+	issuer_not_available: "Your card issuer could not be reached. Please try again later.",
+	new_account_information_available: "Your card details have changed. Please update your card information and try again.",
+	try_again_later: "Your card issuer is temporarily unable to process this transaction. Please try again later.",
+	reenter_transaction: "The transaction could not be processed. Please try again.",
+	approve_with_id: "The payment cannot be authorized. Please contact your bank.",
+	call_issuer: "Your bank has declined this transaction. Please call your bank for more information.",
+	do_not_try_again: "Your bank has permanently declined this card. Please use a different payment method.",
+	no_action_taken: "Your bank could not process this transaction. Please contact your bank.",
+	not_permitted: "This transaction is not permitted on this card. Please contact your bank or use a different card.",
+	revocation_of_all_authorizations: "All authorizations have been revoked for this card. Please contact your bank.",
+	revocation_of_authorization: "The authorization for this card has been revoked. Please contact your bank.",
+	stop_payment_order: "Your bank has stopped this payment. Please contact your bank.",
+	testmode_decline: "This is a test decline. No real charge was attempted.",
+	bank_account_declined: "Your bank account could not be used. Please try a different account.",
+	debit_not_authorized: "The debit was not authorized. Please contact your bank.",
+	payment_intent_unexpected_state: "This payment has already been processed. Please refresh the page and try again.",
+	payment_intent_authentication_failure: "Payment authentication failed. Please try again.",
+	payment_intent_incompatible_payment_method: "This payment method is not compatible. Please use a different payment method.",
+	payment_intent_payment_attempt_failed: "The payment attempt failed. Please try again or use a different payment method.",
+	payment_method_unactivated: "This payment method is not activated. Please use a different payment method.",
+	payment_method_unexpected_state: "There was an issue with your payment method. Please try again.",
+	setup_intent_unexpected_state: "This payment setup has already been completed. Please refresh the page.",
+	amount_too_small: "The payment amount is too small to process. Please contact the business.",
+	amount_too_large: "The payment amount exceeds the maximum allowed. Please contact the business.",
+	balance_insufficient: "Insufficient balance to complete this payment. Please use a different payment method.",
+	resource_missing: "The payment session has expired. Please refresh the page and try again."
+};
+const STRIPE_TECHNICAL_ERROR_MESSAGES = {
+	api_connection_error: "We could not reach the payment service. Please check your connection and try again.",
+	rate_limit_error: "Too many requests. Please wait a moment and try again.",
+	api_error: "Something went wrong while processing the payment. Please try again.",
+	authentication_error: "Something went wrong while processing the payment. Please try again.",
+	invalid_request_error: "Something went wrong while processing the payment. Please try again."
+};
+const STRIPE_DEFAULT_ERROR_MESSAGE = "Payment failed. Please try again.";
+const STRIPE_SESSION_EXPIRED_MESSAGE = "Your payment session has expired. Please refresh the page and try again.";
+function getStripeErrorMessage(error, options = {}) {
+	const fallback = options.fallback ?? "Payment failed. Please try again.";
+	if (!error) return fallback;
+	if (options.display === "stripe") return error.message || fallback;
+	const table = {
+		...STRIPE_ERROR_MESSAGES,
+		...options.overrides ?? {}
+	};
+	if (error.decline_code && table[error.decline_code]) return table[error.decline_code];
+	if (error.code && table[error.code]) return table[error.code];
+	const message = error.message;
+	if (message) {
+		if (message.includes("already succeeded") || message.includes("previously confirmed")) return options.overrides?.["payment_intent_unexpected_state"] ?? "This payment has already been processed. Please refresh the page and try again.";
+		if (message.includes("expired")) return STRIPE_SESSION_EXPIRED_MESSAGE;
+	}
+	const technical = options.display === "table" || !error.type ? void 0 : STRIPE_TECHNICAL_ERROR_MESSAGES[error.type];
+	if (technical) return technical;
+	return message || fallback;
+}
+const MSG_NOT_INITIALIZED = "Payment system not initialized";
+const MSG_INTENT_FAILED = "Failed to create payment intent";
+const MSG_NOT_COMPLETED = "Payment was not completed";
+const MSG_REQUIRES_PAYMENT_METHOD = "Payment failed. Please try a different payment method.";
+const MSG_NO_PAYMENT_METHOD = "No payment method returned from Stripe";
+const MSG_AUTH_FAILED = "Payment authentication failed";
+const MSG_AUTH_NOT_COMPLETED = "Payment authentication was not completed";
+const MSG_KEY_MISSING = "A Stripe publishable key is required";
+const MSG_LOAD_FAILED = "Failed to load Stripe";
+function paymentMethodIdOf(intent) {
+	const pm = intent?.payment_method;
+	if (!pm) return null;
+	return typeof pm === "string" ? pm : pm.id || null;
+}
+function verificationOf(intent) {
+	const action = intent?.next_action;
+	if (action?.type !== "verify_with_microdeposits") return null;
+	const details = action.verify_with_microdeposits ?? {};
+	const arrival = typeof details.arrival_date === "number" ? details.arrival_date : null;
+	const type = details.microdeposit_type === "amounts" || details.microdeposit_type === "descriptor_code" ? details.microdeposit_type : null;
+	const url = typeof details.hosted_verification_url === "string" && details.hosted_verification_url ? details.hosted_verification_url : null;
+	return {
+		type,
+		arrivalDate: arrival,
+		arrivalDateIso: arrival === null ? null : (/* @__PURE__ */ new Date(arrival * 1e3)).toISOString(),
+		hostedVerificationUrl: url
+	};
+}
+function outcomeOf(intent) {
+	switch (intent.status) {
+		case "succeeded": return "succeeded";
+		case "processing": return "processing";
+		case "requires_capture": return "requires_capture";
+		case "requires_action": return intent.next_action?.type === "verify_with_microdeposits" ? "requires_verification" : "requires_action";
+		case "requires_payment_method": return "requires_payment_method";
+		case "canceled": return "canceled";
+		default: return "unknown";
+	}
+}
+function normalizeIntent(kind, intent) {
+	const outcome = outcomeOf(intent);
+	return {
+		kind,
+		status: intent.status,
+		outcome,
+		intent,
+		...kind === "setup" ? { setupIntent: intent } : { paymentIntent: intent },
+		intentId: intent.id,
+		paymentMethodId: paymentMethodIdOf(intent),
+		verification: outcome === "requires_verification" ? verificationOf(intent) : null,
+		actionHandled: false
+	};
+}
+function failureFromError(error, stage, options = {}) {
+	return {
+		code: error?.code || error?.type || "unknown_error",
+		message: getStripeErrorMessage(error, options),
+		stripeMessage: error?.message ?? "",
+		...error?.decline_code ? { declineCode: error.decline_code } : {},
+		...error?.type ? { type: error.type } : {},
+		stage,
+		...error ? { error } : {}
+	};
+}
+function failure(code, message, stage, stripeMessage = "") {
+	return {
+		code,
+		message,
+		stripeMessage,
+		stage
+	};
+}
+function messageOfThrown(err, fallback) {
+	const e = err;
+	if (typeof e?.error?.message === "string" && e.error.message) return e.error.message;
+	if (typeof e?.message === "string" && e.message) return e.message;
+	return fallback;
+}
+function readStripeReturnParams(search) {
+	const params = new URLSearchParams(search.startsWith("?") ? search.slice(1) : search);
+	const payment = params.get("payment_intent_client_secret");
+	const setup = params.get("setup_intent_client_secret");
+	const kind = payment ? "payment" : setup ? "setup" : null;
+	if (!kind) return null;
+	return {
+		kind,
+		clientSecret: payment ?? setup,
+		redirectStatus: params.get("redirect_status")
+	};
+}
+const MSG_VERIFY_FAILED = "Verification failed";
+const MSG_VERIFY_THROWN = "Verification failed. Please check the code and try again.";
+const MSG_RETURN_FAILED = "We could not check the status of this payment. Please contact support before trying again.";
+async function verifyMicrodeposits(stripe, flow, clientSecret, data) {
+	const call = flow === "payment" ? stripe.verifyMicrodepositsForPayment : stripe.verifyMicrodepositsForSetup;
+	if (typeof call !== "function") return {
+		ok: false,
+		outcome: null,
+		intent: null,
+		failure: failure("unsupported", MSG_VERIFY_FAILED, "verify")
+	};
+	try {
+		const result = await call.call(stripe, clientSecret, data);
+		if (result.error) return {
+			ok: false,
+			outcome: null,
+			intent: null,
+			failure: failureFromError(result.error, "verify", {
+				display: "stripe",
+				fallback: MSG_VERIFY_FAILED
+			})
+		};
+		const intent = (flow === "payment" ? result.paymentIntent : result.setupIntent) ?? null;
+		const event = intent ? normalizeIntent(flow, intent) : null;
+		if (event && (event.outcome === "processing" || event.outcome === "succeeded")) return {
+			ok: true,
+			outcome: event.outcome,
+			intent,
+			failure: null
+		};
+		return {
+			ok: false,
+			outcome: event?.outcome ?? null,
+			intent,
+			failure: failure("verification_incomplete", MSG_VERIFY_FAILED, "verify")
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			outcome: null,
+			intent: null,
+			failure: failure("verification_failed", messageOfThrown(err, MSG_VERIFY_THROWN), "verify", messageOfThrown(err, ""))
+		};
+	}
+}
+async function retrieveIntent(stripe, kind, clientSecret) {
+	const call = kind === "payment" ? stripe.retrievePaymentIntent : stripe.retrieveSetupIntent;
+	if (typeof call !== "function") return {
+		event: null,
+		failure: failure("unsupported", MSG_RETURN_FAILED, "return")
+	};
+	try {
+		const result = await call.call(stripe, clientSecret);
+		if (result.error) return {
+			event: null,
+			failure: failureFromError(result.error, "return")
+		};
+		const intent = kind === "payment" ? result.paymentIntent : result.setupIntent;
+		if (!intent) return {
+			event: null,
+			failure: failure("no_intent", MSG_RETURN_FAILED, "return")
+		};
+		return {
+			event: normalizeIntent(kind, intent),
+			failure: null
+		};
+	} catch (err) {
+		return {
+			event: null,
+			failure: failure("return_failed", MSG_RETURN_FAILED, "return", messageOfThrown(err, ""))
+		};
+	}
+}
+var StripePaymentService = class StripePaymentService {
+	constructor() {
+		this.loader = inject(STRIPE_LOADER);
+		this.defaults = inject(STRIPE_PAYMENT_DEFAULTS);
+	}
+	async load(connection = {}) {
+		const key = connection.publishableKey || this.defaults.publishableKey;
+		if (!key) throw new Error(MSG_KEY_MISSING);
+		const stripe = await this.loader(key, buildLoadOptions(connection.stripeAccount, connection.locale ?? this.defaults.locale, connection.options));
+		if (!stripe) throw new Error(MSG_LOAD_FAILED);
+		return stripe;
+	}
+	async verifyMicrodepositsForPayment(clientSecret, data, connection = {}) {
+		return this.verify("payment", clientSecret, data, connection);
+	}
+	async verifyMicrodepositsForSetup(clientSecret, data, connection = {}) {
+		return this.verify("setup", clientSecret, data, connection);
+	}
+	async handleReturn(options = {}) {
+		const fromUrl = options.clientSecret ? null : readStripeReturnParams(options.search ?? (typeof window === "undefined" ? "" : window.location.search));
+		const clientSecret = options.clientSecret ?? fromUrl?.clientSecret;
+		if (!clientSecret) return {
+			event: null,
+			failure: null
+		};
+		const kind = options.kind ?? fromUrl?.kind ?? "payment";
+		let stripe;
+		try {
+			stripe = await this.load(options);
+		} catch (err) {
+			return {
+				event: null,
+				failure: failure("load_error", messageOfThrown(err, MSG_LOAD_FAILED), "load", messageOfThrown(err, ""))
+			};
+		}
+		return retrieveIntent(stripe, kind, clientSecret);
+	}
+	async verify(flow, clientSecret, data, connection) {
+		let stripe;
+		try {
+			stripe = await this.load(connection);
+		} catch (err) {
+			return {
+				ok: false,
+				outcome: null,
+				intent: null,
+				failure: failure("load_error", messageOfThrown(err, MSG_LOAD_FAILED), "load", messageOfThrown(err, ""))
+			};
+		}
+		return verifyMicrodeposits(stripe, flow, clientSecret, data);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: StripePaymentService,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: StripePaymentService,
+			providedIn: "root"
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: StripePaymentService,
+	decorators: [{
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}]
+});
+const TOKENS = [
+	["--ui-stripe-color-primary", "colorPrimary"],
+	["--ui-stripe-color-background", "colorBackground"],
+	["--ui-stripe-color-text", "colorText"],
+	["--ui-stripe-color-danger", "colorDanger"],
+	["--ui-stripe-font-family", "fontFamily"],
+	["--ui-stripe-border-radius", "borderRadius"],
+	["--ui-stripe-font-size-base", "fontSizeBase"]
+];
+function isDarkPage(doc) {
+	const forced = doc.documentElement.getAttribute("data-theme");
+	if (forced === "dark") return true;
+	if (forced === "light") return false;
+	try {
+		return !!doc.defaultView?.matchMedia?.("(prefers-color-scheme: dark)").matches;
+	} catch {
+		return false;
+	}
+}
+function readStripeAppearance(doc, element = doc.documentElement) {
+	const view = doc.defaultView;
+	const variables = {};
+	if (view) {
+		const style = view.getComputedStyle(element);
+		for (const [token, variable] of TOKENS) {
+			const value = style.getPropertyValue(token).trim();
+			if (value) variables[variable] = value;
+		}
+	}
+	return {
+		theme: isDarkPage(doc) ? "night" : "stripe",
+		...Object.keys(variables).length ? { variables } : {}
+	};
+}
+const STRIPE_A11Y_MESSAGES = {
+	loading: "Loading payment form",
+	savingMethod: "Saving payment method",
+	processingPayment: "Processing payment",
+	methodSaved: "Payment method saved",
+	paymentReceived: "Payment received",
+	paymentProcessing: "Payment is processing",
+	paymentAuthorized: "Payment authorized",
+	verificationNeeded: "Bank account added. It needs to be verified with small deposits.",
+	actionRequired: "Further action is required to complete the payment"
+};
+const STRIPE_ACH_NOTICE = "Signing in to your bank account lets you pay right away. Entering your routing and account numbers instead requires verification with two small deposits, which typically take a couple of days to arrive in your account.";
+let nextId = 0;
+const jsonEqual = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+var StripePaymentComponent = class StripePaymentComponent {
+	constructor() {
+		this.loader = inject(STRIPE_LOADER);
+		this.defaults = inject(STRIPE_PAYMENT_DEFAULTS);
+		this.doc = inject(DOCUMENT);
+		this.isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+		this.host = inject(ElementRef);
+		this.mode = input("payment", ...ngDevMode ? [{ debugName: "mode" }] : /* istanbul ignore next */ []);
+		this.publishableKey = input(null, ...ngDevMode ? [{ debugName: "publishableKey" }] : /* istanbul ignore next */ []);
+		this.clientSecret = input(null, ...ngDevMode ? [{ debugName: "clientSecret" }] : /* istanbul ignore next */ []);
+		this.deferred = input(null, ...ngDevMode ? [{ debugName: "deferred" }] : /* istanbul ignore next */ []);
+		this.createIntent = input(null, ...ngDevMode ? [{ debugName: "createIntent" }] : /* istanbul ignore next */ []);
+		this.stripeAccount = input(null, ...ngDevMode ? [{ debugName: "stripeAccount" }] : /* istanbul ignore next */ []);
+		this.locale = input(null, ...ngDevMode ? [{ debugName: "locale" }] : /* istanbul ignore next */ []);
+		this.stripeOptions = input(null, ...ngDevMode ? [{ debugName: "stripeOptions" }] : /* istanbul ignore next */ []);
+		this.paymentMethodTypes = input(null, ...ngDevMode ? [{ debugName: "paymentMethodTypes" }] : /* istanbul ignore next */ []);
+		this.elementsOptions = input(null, ...ngDevMode ? [{ debugName: "elementsOptions" }] : /* istanbul ignore next */ []);
+		this.layout = input("tabs", ...ngDevMode ? [{ debugName: "layout" }] : /* istanbul ignore next */ []);
+		this.paymentMethodOrder = input(null, ...ngDevMode ? [{ debugName: "paymentMethodOrder" }] : /* istanbul ignore next */ []);
+		this.wallets = input(null, ...ngDevMode ? [{ debugName: "wallets" }] : /* istanbul ignore next */ []);
+		this.fields = input(null, ...ngDevMode ? [{ debugName: "fields" }] : /* istanbul ignore next */ []);
+		this.defaultValues = input(null, ...ngDevMode ? [{ debugName: "defaultValues" }] : /* istanbul ignore next */ []);
+		this.business = input(null, ...ngDevMode ? [{ debugName: "business" }] : /* istanbul ignore next */ []);
+		this.terms = input(null, ...ngDevMode ? [{ debugName: "terms" }] : /* istanbul ignore next */ []);
+		this.paymentElementOptions = input(null, ...ngDevMode ? [{ debugName: "paymentElementOptions" }] : /* istanbul ignore next */ []);
+		this.appearance = input(null, ...ngDevMode ? [{ debugName: "appearance" }] : /* istanbul ignore next */ []);
+		this.appearanceFromTokens = input(false, ...ngDevMode ? [{ debugName: "appearanceFromTokens" }] : /* istanbul ignore next */ []);
+		this.returnUrl = input(void 0, ...ngDevMode ? [{ debugName: "returnUrl" }] : /* istanbul ignore next */ []);
+		this.billingDetails = input(null, ...ngDevMode ? [{ debugName: "billingDetails" }] : /* istanbul ignore next */ []);
+		this.confirmParams = input(null, ...ngDevMode ? [{ debugName: "confirmParams" }] : /* istanbul ignore next */ []);
+		this.redirect = input("if_required", ...ngDevMode ? [{ debugName: "redirect" }] : /* istanbul ignore next */ []);
+		this.submitBeforeConfirm = input(null, ...ngDevMode ? [{ debugName: "submitBeforeConfirm" }] : /* istanbul ignore next */ []);
+		this.autoHandleCardAction = input(false, ...ngDevMode ? [{ debugName: "autoHandleCardAction" }] : /* istanbul ignore next */ []);
+		this.submitLabel = input("", ...ngDevMode ? [{ debugName: "submitLabel" }] : /* istanbul ignore next */ []);
+		this.showSubmit = input(true, ...ngDevMode ? [{ debugName: "showSubmit" }] : /* istanbul ignore next */ []);
+		this.disabled = input(false, ...ngDevMode ? [{ debugName: "disabled" }] : /* istanbul ignore next */ []);
+		this.pending = input(false, ...ngDevMode ? [{ debugName: "pending" }] : /* istanbul ignore next */ []);
+		this.label = input("Payment details", ...ngDevMode ? [{ debugName: "label" }] : /* istanbul ignore next */ []);
+		this.mountId = input("", ...ngDevMode ? [{ debugName: "mountId" }] : /* istanbul ignore next */ []);
+		this.mountClass = input("", ...ngDevMode ? [{ debugName: "mountClass" }] : /* istanbul ignore next */ []);
+		this.showAchNotice = input(true, ...ngDevMode ? [{ debugName: "showAchNotice" }] : /* istanbul ignore next */ []);
+		this.achNotice = input(STRIPE_ACH_NOTICE, ...ngDevMode ? [{ debugName: "achNotice" }] : /* istanbul ignore next */ []);
+		this.achNoticeTestId = input("stripe-ach-notice", ...ngDevMode ? [{ debugName: "achNoticeTestId" }] : /* istanbul ignore next */ []);
+		this.initialPaymentMethodType = input("card", ...ngDevMode ? [{ debugName: "initialPaymentMethodType" }] : /* istanbul ignore next */ []);
+		this.showErrors = input(true, ...ngDevMode ? [{ debugName: "showErrors" }] : /* istanbul ignore next */ []);
+		this.errorDisplay = input("friendly", ...ngDevMode ? [{ debugName: "errorDisplay" }] : /* istanbul ignore next */ []);
+		this.errorDisplayByStage = input(null, ...ngDevMode ? [{ debugName: "errorDisplayByStage" }] : /* istanbul ignore next */ []);
+		this.errorFallback = input("", ...ngDevMode ? [{ debugName: "errorFallback" }] : /* istanbul ignore next */ []);
+		this.errorFallbackByStage = input(null, ...ngDevMode ? [{ debugName: "errorFallbackByStage" }] : /* istanbul ignore next */ []);
+		this.errorMessages = input(null, ...ngDevMode ? [{ debugName: "errorMessages" }] : /* istanbul ignore next */ []);
+		this.loadErrorMessage = input("Failed to load the payment form. Please try again.", ...ngDevMode ? [{ debugName: "loadErrorMessage" }] : /* istanbul ignore next */ []);
+		this.a11yMessages = input(null, ...ngDevMode ? [{ debugName: "a11yMessages" }] : /* istanbul ignore next */ []);
+		this.ready = output();
+		this.paymentMethodTypeChange = output();
+		this.elementChange = output();
+		this.confirmed = output();
+		this.failed = output();
+		this.loadError = output();
+		this.loading = signal(false, ...ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []);
+		this.isReady = signal(false, ...ngDevMode ? [{ debugName: "isReady" }] : /* istanbul ignore next */ []);
+		this.submitting = signal(false, ...ngDevMode ? [{ debugName: "submitting" }] : /* istanbul ignore next */ []);
+		this.complete = signal(false, ...ngDevMode ? [{ debugName: "complete" }] : /* istanbul ignore next */ []);
+		this.selectedType = signal(null, ...ngDevMode ? [{ debugName: "selectedType" }] : /* istanbul ignore next */ []);
+		this.errorText = signal("", ...ngDevMode ? [{ debugName: "errorText" }] : /* istanbul ignore next */ []);
+		this.loadErrorText = signal("", ...ngDevMode ? [{ debugName: "loadErrorText" }] : /* istanbul ignore next */ []);
+		this.announcement = signal("", ...ngDevMode ? [{ debugName: "announcement" }] : /* istanbul ignore next */ []);
+		this.errorId = `ui-stripe-error-${nextId++}`;
+		this.mountRef = viewChild("mount", ...ngDevMode ? [{ debugName: "mountRef" }] : /* istanbul ignore next */ []);
+		this.mountHidden = computed(() => this.loading() || this.pending() || !!this.loadErrorText(), ...ngDevMode ? [{ debugName: "mountHidden" }] : /* istanbul ignore next */ []);
+		this.achNoticeVisible = computed(() => this.showAchNotice() && this.selectedType() === "us_bank_account", ...ngDevMode ? [{ debugName: "achNoticeVisible" }] : /* istanbul ignore next */ []);
+		this.effectiveSubmitLabel = computed(() => this.submitLabel() || (this.mode() === "setup" ? "Save payment method" : "Pay"), ...ngDevMode ? [{ debugName: "effectiveSubmitLabel" }] : /* istanbul ignore next */ []);
+		this.submitDisabled = computed(() => this.disabled() || this.loading() || this.pending() || !this.isReady() || !!this.loadErrorText(), ...ngDevMode ? [{ debugName: "submitDisabled" }] : /* istanbul ignore next */ []);
+		this.messages = computed(() => {
+			const given = Object.fromEntries(Object.entries(this.a11yMessages() ?? {}).filter(([, text]) => typeof text === "string"));
+			return {
+				...STRIPE_A11Y_MESSAGES,
+				...given
+			};
+		}, ...ngDevMode ? [{ debugName: "messages" }] : /* istanbul ignore next */ []);
+		this.statusText = computed(() => {
+			if (this.loading()) return this.messages().loading;
+			if (this.submitting()) return this.mode() === "setup" ? this.messages().savingMethod : this.messages().processingPayment;
+			return this.announcement();
+		}, ...ngDevMode ? [{ debugName: "statusText" }] : /* istanbul ignore next */ []);
+		this.connection = computed(() => {
+			return {
+				key: this.publishableKey() || this.defaults.publishableKey || "",
+				options: buildLoadOptions(this.stripeAccount(), this.locale() ?? this.defaults.locale, this.stripeOptions())
+			};
+		}, {
+			...ngDevMode ? { debugName: "connection" } : /* istanbul ignore next */ {},
+			equal: jsonEqual
+		});
+		this.elementsConfig = computed(() => {
+			const secret = this.clientSecret();
+			const deferred = this.deferred();
+			let options;
+			if (secret) options = { clientSecret: secret };
+			else if (deferred) options = {
+				mode: deferred.mode ?? this.mode(),
+				currency: deferred.currency,
+				...deferred.setupFutureUsage ? { setup_future_usage: deferred.setupFutureUsage } : {},
+				...deferred.captureMethod ? { capture_method: deferred.captureMethod } : {},
+				...deferred.onBehalfOf ? { on_behalf_of: deferred.onBehalfOf } : {},
+				...this.paymentMethodTypes() ? { payment_method_types: this.paymentMethodTypes() } : {}
+			};
+			else return null;
+			const appearance = this.appearance();
+			if (appearance) options["appearance"] = appearance;
+			return {
+				...options,
+				...this.elementsOptions() ?? {}
+			};
+		}, {
+			...ngDevMode ? { debugName: "elementsConfig" } : /* istanbul ignore next */ {},
+			equal: jsonEqual
+		});
+		this.elementConfig = computed(() => {
+			const options = {};
+			const layout = this.layout();
+			if (layout) options["layout"] = layout;
+			if (this.paymentMethodOrder()) options["paymentMethodOrder"] = this.paymentMethodOrder();
+			if (this.wallets()) options["wallets"] = this.wallets();
+			if (this.fields()) options["fields"] = this.fields();
+			if (this.business()) options["business"] = this.business();
+			if (this.terms()) options["terms"] = this.terms();
+			return {
+				...options,
+				...this.paymentElementOptions() ?? {}
+			};
+		}, {
+			...ngDevMode ? { debugName: "elementConfig" } : /* istanbul ignore next */ {},
+			equal: jsonEqual
+		});
+		this.stripe = null;
+		this.stripeSignature = "";
+		this.elements = null;
+		this.element = null;
+		this.generation = 0;
+		this.lastType = null;
+		this.lastFailure = null;
+		this.destroyed = false;
+		this.appliedDefaultValues = "";
+		this.appliedDisabled = false;
+		effect(() => {
+			const mount = this.mountRef();
+			const connection = this.connection();
+			const elements = this.elementsConfig();
+			const element = this.elementConfig();
+			if (!mount) return;
+			untracked(() => {
+				this.init(mount.nativeElement, connection, elements, element);
+			});
+		});
+		effect(() => {
+			const amount = this.deferred()?.amount;
+			untracked(() => {
+				if (amount !== void 0 && this.lastAmount !== void 0 && amount !== this.lastAmount && this.elements?.update) this.elements.update({ amount });
+				this.lastAmount = amount;
+			});
+		});
+		effect(() => {
+			const defaultValues = this.defaultValues();
+			untracked(() => this.applyDefaultValues(defaultValues));
+		});
+		effect(() => {
+			const disabled = this.disabled();
+			untracked(() => this.applyDisabled(disabled));
+		});
+		inject(DestroyRef).onDestroy(() => {
+			this.destroyed = true;
+			this.generation++;
+			this.disposeElements();
+			this.stripe = null;
+		});
+	}
+	async confirm(options = {}) {
+		if (this.submitting() || this.disabled()) return null;
+		const stripe = this.stripe;
+		const elements = this.elements;
+		if (!stripe || !elements) {
+			this.fail(failure("not_initialized", MSG_NOT_INITIALIZED, "submit"));
+			return null;
+		}
+		this.submitting.set(true);
+		this.errorText.set("");
+		this.announcement.set("");
+		let stage = "submit";
+		try {
+			const mode = this.mode();
+			const existing = options.useExistingIntent === true;
+			const deferred = !existing && !this.clientSecret() && !!this.deferred();
+			if (!existing && (this.submitBeforeConfirm() ?? deferred)) {
+				const { error } = await elements.submit();
+				if (error) {
+					this.fail(failureFromError(error, "submit", this.errorOptions("submit")));
+					return null;
+				}
+			}
+			let secret = existing ? options.clientSecret : void 0;
+			if (deferred) {
+				stage = "intent";
+				const create = this.createIntent();
+				if (!create) {
+					this.fail(failure("no_intent_factory", MSG_INTENT_FAILED, "intent"));
+					return null;
+				}
+				try {
+					const created = await create({ mode });
+					secret = typeof created === "string" ? created : created?.clientSecret;
+				} catch (err) {
+					this.fail(failure("intent_creation_failed", messageOfThrown(err, STRIPE_DEFAULT_ERROR_MESSAGE), "intent", messageOfThrown(err, "")));
+					return null;
+				}
+				if (!secret) {
+					this.fail(failure("intent_creation_failed", MSG_INTENT_FAILED, "intent"));
+					return null;
+				}
+			}
+			stage = "confirm";
+			const confirmParams = this.buildConfirmParams();
+			const params = {
+				elements,
+				...secret ? { clientSecret: secret } : {},
+				...confirmParams ? { confirmParams } : {},
+				redirect: this.redirect()
+			};
+			const result = mode === "setup" ? await stripe.confirmSetup(params) : await stripe.confirmPayment(params);
+			if (result.error) {
+				this.fail(failureFromError(result.error, "confirm", this.errorOptions("confirm")));
+				return null;
+			}
+			const intent = mode === "setup" ? result.setupIntent : result.paymentIntent;
+			if (!intent) {
+				this.fail(failure("not_completed", mode === "setup" ? "Payment method setup was incomplete. Please try again." : MSG_NOT_COMPLETED, "result"));
+				return null;
+			}
+			let event = normalizeIntent(mode, intent);
+			if (mode === "setup" && !event.paymentMethodId) {
+				this.fail(failure("no_payment_method", MSG_NO_PAYMENT_METHOD, "result"));
+				return null;
+			}
+			if (mode === "payment" && event.outcome === "requires_action" && this.autoHandleCardAction()) {
+				stage = "action";
+				const handled = await this.runCardAction(stripe, intent.client_secret);
+				if (!handled) return null;
+				event = handled;
+			}
+			return this.finish(event);
+		} catch (err) {
+			this.fail(this.thrownFailure(err, stage));
+			return null;
+		} finally {
+			this.submitting.set(false);
+		}
+	}
+	async handleNextAction(clientSecret) {
+		if (this.submitting()) return null;
+		const stripe = this.stripe;
+		if (!stripe) {
+			this.fail(failure("not_initialized", MSG_NOT_INITIALIZED, "action"));
+			return null;
+		}
+		this.submitting.set(true);
+		this.errorText.set("");
+		try {
+			const handled = await this.runCardAction(stripe, clientSecret);
+			return handled ? this.finish(handled) : null;
+		} catch (err) {
+			this.fail(this.thrownFailure(err, "action"));
+			return null;
+		} finally {
+			this.submitting.set(false);
+		}
+	}
+	async fetchUpdates() {
+		const elements = this.elements;
+		if (!elements?.fetchUpdates) return failure("not_initialized", MSG_NOT_INITIALIZED, "submit");
+		try {
+			const { error } = await elements.fetchUpdates();
+			return error ? failureFromError(error, "confirm", this.errorOptions("confirm")) : null;
+		} catch (err) {
+			return this.thrownFailure(err, "confirm");
+		}
+	}
+	updateElements(options) {
+		this.elements?.update?.(options);
+	}
+	updatePaymentElement(options) {
+		this.element?.update?.(options);
+	}
+	destroyElements() {
+		this.disposeElements();
+		this.isReady.set(false);
+	}
+	async verifyMicrodepositsForPayment(clientSecret, data) {
+		return this.verifyWith("payment", clientSecret, data);
+	}
+	async verifyMicrodepositsForSetup(clientSecret, data) {
+		return this.verifyWith("setup", clientSecret, data);
+	}
+	async handleReturn(options = {}) {
+		const fromUrl = options.clientSecret ? null : readStripeReturnParams(options.search ?? this.doc.defaultView?.location.search ?? "");
+		const clientSecret = options.clientSecret ?? fromUrl?.clientSecret;
+		if (!clientSecret) return {
+			event: null,
+			failure: null
+		};
+		const kind = options.kind ?? fromUrl?.kind ?? this.mode();
+		let stripe;
+		try {
+			stripe = await this.ensureStripe();
+		} catch (err) {
+			const f = failure("load_error", messageOfThrown(err, MSG_LOAD_FAILED), "load", messageOfThrown(err, ""));
+			this.fail(f);
+			return {
+				event: null,
+				failure: f
+			};
+		}
+		const result = await retrieveIntent(stripe, kind, clientSecret);
+		if (result.failure) {
+			this.fail(result.failure);
+			return result;
+		}
+		if (result.event && !this.finish(result.event, true)) return {
+			event: null,
+			failure: this.lastFailure
+		};
+		return result;
+	}
+	errorOptions(stage) {
+		return {
+			display: this.errorDisplayByStage()?.[stage] ?? this.errorDisplay(),
+			overrides: this.errorMessages(),
+			...this.errorFallbackByStage()?.[stage] || this.errorFallback() ? { fallback: this.errorFallbackByStage()?.[stage] || this.errorFallback() } : {}
+		};
+	}
+	thrownFailure(err, stage) {
+		const e = err;
+		const error = {
+			...typeof e?.code === "string" ? { code: e.code } : {},
+			...typeof e?.type === "string" ? { type: e.type } : {},
+			...typeof e?.decline_code === "string" ? { decline_code: e.decline_code } : {},
+			...typeof e?.message === "string" && e.message ? { message: e.message } : {}
+		};
+		const code = stage === "submit" ? "submit_failed" : stage === "action" ? "action_failed" : "confirm_failed";
+		const { error: _raw, ...failed } = failureFromError(error, stage, this.errorOptions(stage));
+		return {
+			...failed,
+			code: error.code ?? code,
+			...stage === "action" ? { actionHandled: true } : {}
+		};
+	}
+	buildConfirmParams() {
+		const params = {};
+		const returnUrl = this.returnUrl();
+		if (returnUrl !== null) params["return_url"] = returnUrl ?? this.doc.defaultView?.location.href ?? "";
+		const billing = this.billingDetails();
+		if (billing) params["payment_method_data"] = { billing_details: billing };
+		Object.assign(params, this.confirmParams() ?? {});
+		return Object.keys(params).length ? params : null;
+	}
+	fail(f) {
+		const override = this.errorMessages()?.[f.code];
+		if (override) f = {
+			...f,
+			message: override.split("{status}").join(f.status ?? "")
+		};
+		this.lastFailure = f;
+		if (this.destroyed) return;
+		if (this.showErrors()) this.errorText.set(f.message);
+		this.announcement.set("");
+		this.failed.emit(f);
+	}
+	finish(event, fromReturn = false) {
+		const acted = {
+			...event.actionHandled ? { actionHandled: true } : {},
+			status: event.status
+		};
+		if (event.outcome === "requires_payment_method") {
+			this.fail({
+				...failure("requires_payment_method", MSG_REQUIRES_PAYMENT_METHOD, fromReturn ? "return" : "result"),
+				...acted
+			});
+			return null;
+		}
+		if (event.outcome === "canceled" || event.outcome === "unknown") {
+			this.fail({
+				...failure("not_completed", MSG_NOT_COMPLETED, fromReturn ? "return" : "result"),
+				...acted
+			});
+			return null;
+		}
+		if (this.destroyed) return event;
+		this.announcement.set(this.announce(event));
+		this.confirmed.emit(event);
+		return event;
+	}
+	announce(event) {
+		const m = this.messages();
+		switch (event.outcome) {
+			case "succeeded": return event.kind === "setup" ? m.methodSaved : m.paymentReceived;
+			case "processing": return m.paymentProcessing;
+			case "requires_capture": return m.paymentAuthorized;
+			case "requires_verification": return m.verificationNeeded;
+			default: return m.actionRequired;
+		}
+	}
+	async runCardAction(stripe, clientSecret) {
+		const acted = { actionHandled: true };
+		if (!stripe.handleCardAction || !clientSecret) {
+			this.fail({
+				...failure("action_unavailable", MSG_AUTH_NOT_COMPLETED, "action"),
+				...acted
+			});
+			return null;
+		}
+		const { error, paymentIntent } = await stripe.handleCardAction(clientSecret);
+		if (error) {
+			this.fail({
+				...failureFromError(error, "action", {
+					...this.errorOptions("action"),
+					fallback: MSG_AUTH_FAILED
+				}),
+				...acted
+			});
+			return null;
+		}
+		if (!paymentIntent) {
+			this.fail({
+				...failure("action_incomplete", MSG_AUTH_NOT_COMPLETED, "action"),
+				...acted
+			});
+			return null;
+		}
+		const event = {
+			...normalizeIntent("payment", paymentIntent),
+			...acted
+		};
+		if (event.outcome === "requires_payment_method") {
+			this.fail({
+				...failure("authentication_failed", "Payment authentication failed. Please try a different payment method.", "action"),
+				...acted,
+				status: event.status
+			});
+			return null;
+		}
+		return event;
+	}
+	async ensureStripe() {
+		if (this.stripe) return this.stripe;
+		const { key, options } = this.connection();
+		if (!key) throw new Error(MSG_KEY_MISSING);
+		const stripe = await this.loader(key, options);
+		if (!stripe) throw new Error(MSG_LOAD_FAILED);
+		return stripe;
+	}
+	async verifyWith(flow, clientSecret, data) {
+		let stripe;
+		try {
+			stripe = await this.ensureStripe();
+		} catch (err) {
+			return {
+				ok: false,
+				outcome: null,
+				intent: null,
+				failure: failure("load_error", messageOfThrown(err, MSG_LOAD_FAILED), "load", messageOfThrown(err, ""))
+			};
+		}
+		return verifyMicrodeposits(stripe, flow, clientSecret, data);
+	}
+	disposeElements() {
+		const element = this.element;
+		this.element = null;
+		this.elements = null;
+		this.lastType = null;
+		this.selectedType.set(null);
+		this.complete.set(false);
+		if (element) try {
+			element.destroy();
+		} catch {}
+	}
+	loadFailed(message, stripeMessage) {
+		this.loading.set(false);
+		this.isReady.set(false);
+		this.loadErrorText.set(this.loadErrorMessage());
+		this.loadError.emit(failure("load_error", message, "load", stripeMessage));
+	}
+	async init(container, connection, elementsConfig, elementConfig) {
+		const generation = ++this.generation;
+		this.disposeElements();
+		this.isReady.set(false);
+		this.errorText.set("");
+		this.loadErrorText.set("");
+		this.announcement.set("");
+		if (!this.isBrowser || !elementsConfig) {
+			this.loading.set(false);
+			return;
+		}
+		if (!connection.key) {
+			this.loadFailed(MSG_KEY_MISSING, "");
+			return;
+		}
+		this.loading.set(true);
+		try {
+			const signature = JSON.stringify(connection);
+			if (!this.stripe || this.stripeSignature !== signature) {
+				this.stripe = null;
+				const stripe = await this.loader(connection.key, connection.options);
+				if (generation !== this.generation) return;
+				if (!stripe) {
+					this.loadFailed(MSG_LOAD_FAILED, "");
+					return;
+				}
+				this.stripe = stripe;
+				this.stripeSignature = signature;
+			}
+			const options = { ...elementsConfig };
+			const deferred = this.deferred();
+			if (!options["clientSecret"] && deferred?.amount !== void 0 && options["amount"] === void 0) options["amount"] = deferred.amount;
+			this.lastAmount = deferred?.amount;
+			if (this.appearanceFromTokens() && !options["appearance"]) options["appearance"] = readStripeAppearance(this.doc, this.host.nativeElement);
+			const elements = this.stripe.elements(options);
+			const elementOptions = { ...elementConfig };
+			const defaultValues = this.defaultValues();
+			if (defaultValues) elementOptions["defaultValues"] = defaultValues;
+			if (this.disabled()) elementOptions["readOnly"] = true;
+			this.appliedDefaultValues = JSON.stringify(defaultValues ?? null);
+			this.appliedDisabled = this.disabled();
+			const element = elements.create("payment", elementOptions);
+			this.elements = elements;
+			this.element = element;
+			element.on("change", (event) => {
+				if (generation === this.generation) this.onChange(event);
+			});
+			element.on("ready", () => {
+				if (generation !== this.generation) return;
+				this.loading.set(false);
+				this.isReady.set(true);
+				this.applyDefaultValues(this.defaultValues());
+				this.applyDisabled(this.disabled());
+				this.ready.emit();
+			});
+			element.on("loaderror", (event) => {
+				if (generation !== this.generation) return;
+				const message = event?.error?.message || "Failed to load Stripe";
+				this.loadFailed(message, event?.error?.message ?? "");
+			});
+			element.mount(container);
+		} catch (err) {
+			if (generation !== this.generation) return;
+			this.loadFailed(messageOfThrown(err, MSG_LOAD_FAILED), messageOfThrown(err, ""));
+		}
+	}
+	applyDefaultValues(defaultValues) {
+		const signature = JSON.stringify(defaultValues ?? null);
+		if (!this.element?.update || !this.isReady() || signature === this.appliedDefaultValues) return;
+		this.appliedDefaultValues = signature;
+		this.element.update({ defaultValues: defaultValues ?? {} });
+	}
+	applyDisabled(disabled) {
+		if (!this.element?.update || !this.isReady() || disabled === this.appliedDisabled) return;
+		this.appliedDisabled = disabled;
+		this.element.update({ readOnly: disabled });
+	}
+	onChange(event) {
+		const type = event?.value?.type ?? null;
+		const complete = !!event?.complete;
+		this.complete.set(complete);
+		if (type) this.selectedType.set(type);
+		this.elementChange.emit({
+			complete,
+			empty: !!event?.empty,
+			type,
+			errorMessage: event?.error?.message ?? null
+		});
+		if (type && type !== (this.lastType ?? this.initialPaymentMethodType())) this.paymentMethodTypeChange.emit(type);
+		if (type) this.lastType = type;
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: StripePaymentComponent,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Component
+		});
+	}
+	static {
+		this.ɵcmp = i0.ɵɵngDeclareComponent({
+			minVersion: "17.0.0",
+			version: "22.2.2",
+			type: StripePaymentComponent,
+			isStandalone: true,
+			selector: "ui-stripe-payment",
+			inputs: {
+				mode: {
+					classPropertyName: "mode",
+					publicName: "mode",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				publishableKey: {
+					classPropertyName: "publishableKey",
+					publicName: "publishableKey",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				clientSecret: {
+					classPropertyName: "clientSecret",
+					publicName: "clientSecret",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				deferred: {
+					classPropertyName: "deferred",
+					publicName: "deferred",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				createIntent: {
+					classPropertyName: "createIntent",
+					publicName: "createIntent",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				stripeAccount: {
+					classPropertyName: "stripeAccount",
+					publicName: "stripeAccount",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				locale: {
+					classPropertyName: "locale",
+					publicName: "locale",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				stripeOptions: {
+					classPropertyName: "stripeOptions",
+					publicName: "stripeOptions",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				paymentMethodTypes: {
+					classPropertyName: "paymentMethodTypes",
+					publicName: "paymentMethodTypes",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				elementsOptions: {
+					classPropertyName: "elementsOptions",
+					publicName: "elementsOptions",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				layout: {
+					classPropertyName: "layout",
+					publicName: "layout",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				paymentMethodOrder: {
+					classPropertyName: "paymentMethodOrder",
+					publicName: "paymentMethodOrder",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				wallets: {
+					classPropertyName: "wallets",
+					publicName: "wallets",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				fields: {
+					classPropertyName: "fields",
+					publicName: "fields",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				defaultValues: {
+					classPropertyName: "defaultValues",
+					publicName: "defaultValues",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				business: {
+					classPropertyName: "business",
+					publicName: "business",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				terms: {
+					classPropertyName: "terms",
+					publicName: "terms",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				paymentElementOptions: {
+					classPropertyName: "paymentElementOptions",
+					publicName: "paymentElementOptions",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				appearance: {
+					classPropertyName: "appearance",
+					publicName: "appearance",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				appearanceFromTokens: {
+					classPropertyName: "appearanceFromTokens",
+					publicName: "appearanceFromTokens",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				returnUrl: {
+					classPropertyName: "returnUrl",
+					publicName: "returnUrl",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				billingDetails: {
+					classPropertyName: "billingDetails",
+					publicName: "billingDetails",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				confirmParams: {
+					classPropertyName: "confirmParams",
+					publicName: "confirmParams",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				redirect: {
+					classPropertyName: "redirect",
+					publicName: "redirect",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				submitBeforeConfirm: {
+					classPropertyName: "submitBeforeConfirm",
+					publicName: "submitBeforeConfirm",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				autoHandleCardAction: {
+					classPropertyName: "autoHandleCardAction",
+					publicName: "autoHandleCardAction",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				submitLabel: {
+					classPropertyName: "submitLabel",
+					publicName: "submitLabel",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				showSubmit: {
+					classPropertyName: "showSubmit",
+					publicName: "showSubmit",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				disabled: {
+					classPropertyName: "disabled",
+					publicName: "disabled",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				pending: {
+					classPropertyName: "pending",
+					publicName: "pending",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				label: {
+					classPropertyName: "label",
+					publicName: "label",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				mountId: {
+					classPropertyName: "mountId",
+					publicName: "mountId",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				mountClass: {
+					classPropertyName: "mountClass",
+					publicName: "mountClass",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				showAchNotice: {
+					classPropertyName: "showAchNotice",
+					publicName: "showAchNotice",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				achNotice: {
+					classPropertyName: "achNotice",
+					publicName: "achNotice",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				achNoticeTestId: {
+					classPropertyName: "achNoticeTestId",
+					publicName: "achNoticeTestId",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				initialPaymentMethodType: {
+					classPropertyName: "initialPaymentMethodType",
+					publicName: "initialPaymentMethodType",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				showErrors: {
+					classPropertyName: "showErrors",
+					publicName: "showErrors",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				errorDisplay: {
+					classPropertyName: "errorDisplay",
+					publicName: "errorDisplay",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				errorDisplayByStage: {
+					classPropertyName: "errorDisplayByStage",
+					publicName: "errorDisplayByStage",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				errorFallback: {
+					classPropertyName: "errorFallback",
+					publicName: "errorFallback",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				errorFallbackByStage: {
+					classPropertyName: "errorFallbackByStage",
+					publicName: "errorFallbackByStage",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				errorMessages: {
+					classPropertyName: "errorMessages",
+					publicName: "errorMessages",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				loadErrorMessage: {
+					classPropertyName: "loadErrorMessage",
+					publicName: "loadErrorMessage",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				a11yMessages: {
+					classPropertyName: "a11yMessages",
+					publicName: "a11yMessages",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				}
+			},
+			outputs: {
+				ready: "ready",
+				paymentMethodTypeChange: "paymentMethodTypeChange",
+				elementChange: "elementChange",
+				confirmed: "confirmed",
+				failed: "failed",
+				loadError: "loadError"
+			},
+			host: { properties: { "attr.aria-busy": "loading() || submitting() ? \"true\" : null" } },
+			viewQueries: [{
+				propertyName: "mountRef",
+				first: true,
+				predicate: ["mount"],
+				descendants: true,
+				isSignal: true
+			}],
+			ngImport: i0,
+			template: `
+    <div class="sp">
+      <div class="sp-sr" role="status" aria-live="polite" data-testid="stripe-status">{{ statusText() }}</div>
+      @if (loading() || pending()) {
+        <div class="sp-skeleton" data-testid="stripe-skeleton" aria-hidden="true">
+          <ui-skeleton [height]="44" [mb]="10" />
+          <ui-skeleton [height]="44" [mb]="10" />
+          <ui-skeleton [height]="44" width="60%" />
+        </div>
+      }
+      @if (loadErrorText(); as text) {
+        <div class="sp-block" data-testid="stripe-load-error"><ui-alert variant="danger">{{ text }}</ui-alert></div>
+      }
+      <div #mount class="sp-mount" [attr.id]="mountId() || null" [class]="mountClass()" [class.sp-mount--hidden]="mountHidden()" [attr.aria-hidden]="mountHidden() ? 'true' : null" [attr.inert]="mountHidden() ? '' : null"
+        role="group" [attr.aria-label]="label()" data-testid="stripe-mount"></div>
+      @if (achNoticeVisible()) {
+        <div class="sp-block" [attr.data-testid]="achNoticeTestId()"><ui-alert variant="info">{{ achNotice() }}</ui-alert></div>
+      }
+      @if (errorText(); as text) {
+        <div class="sp-block" [id]="errorId" data-testid="stripe-error"><ui-alert variant="danger">{{ text }}</ui-alert></div>
+      }
+      @if (showSubmit()) {
+        <div class="sp-actions">
+          <ui-button variant="primary" type="button" [loading]="submitting()" [disabled]="submitDisabled()" [ariaDescribedBy]="errorText() ? errorId : undefined"
+            data-testid="stripe-submit" (click)="confirm()">{{ effectiveSubmitLabel() }}</ui-button>
+        </div>
+      }
+    </div>
+  `,
+			isInline: true,
+			styles: [":host{display:block;min-width:0}.sp-sr{position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.sp-block{margin-top:12px}.sp-actions{margin-top:16px;display:flex;justify-content:flex-end}.sp{position:relative}.sp-mount--hidden{position:absolute;top:0;left:0;right:0;opacity:0;pointer-events:none}@media(max-width:480px){.sp-actions{display:block}.sp-actions ui-button{display:flex}.sp-actions ::ng-deep .btn{width:100%}}\n"],
+			dependencies: [
+				{
+					kind: "component",
+					type: AlertComponent,
+					selector: "ui-alert",
+					inputs: [
+						"variant",
+						"title",
+						"dismissible",
+						"quiet",
+						"compact"
+					],
+					outputs: ["dismissed"]
+				},
+				{
+					kind: "component",
+					type: ButtonComponent,
+					selector: "ui-button",
+					inputs: [
+						"variant",
+						"routerLink",
+						"queryParams",
+						"href",
+						"target",
+						"rel",
+						"color",
+						"active",
+						"size",
+						"type",
+						"disabled",
+						"loading",
+						"fullWidth",
+						"ariaLabel",
+						"ariaExpanded",
+						"ariaPressed",
+						"ariaDescribedBy",
+						"modal-footer-left",
+						"modal-footer-right"
+					]
+				},
+				{
+					kind: "component",
+					type: SkeletonComponent,
+					selector: "ui-skeleton",
+					inputs: [
+						"height",
+						"width",
+						"radius",
+						"mb",
+						"ariaLabel"
+					]
+				}
+			],
+			changeDetection: i0.ChangeDetectionStrategy.OnPush
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: StripePaymentComponent,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "ui-stripe-payment",
+			standalone: true,
+			changeDetection: ChangeDetectionStrategy.OnPush,
+			imports: [
+				AlertComponent,
+				ButtonComponent,
+				SkeletonComponent
+			],
+			host: { "[attr.aria-busy]": "loading() || submitting() ? \"true\" : null" },
+			template: `
+    <div class="sp">
+      <div class="sp-sr" role="status" aria-live="polite" data-testid="stripe-status">{{ statusText() }}</div>
+      @if (loading() || pending()) {
+        <div class="sp-skeleton" data-testid="stripe-skeleton" aria-hidden="true">
+          <ui-skeleton [height]="44" [mb]="10" />
+          <ui-skeleton [height]="44" [mb]="10" />
+          <ui-skeleton [height]="44" width="60%" />
+        </div>
+      }
+      @if (loadErrorText(); as text) {
+        <div class="sp-block" data-testid="stripe-load-error"><ui-alert variant="danger">{{ text }}</ui-alert></div>
+      }
+      <div #mount class="sp-mount" [attr.id]="mountId() || null" [class]="mountClass()" [class.sp-mount--hidden]="mountHidden()" [attr.aria-hidden]="mountHidden() ? 'true' : null" [attr.inert]="mountHidden() ? '' : null"
+        role="group" [attr.aria-label]="label()" data-testid="stripe-mount"></div>
+      @if (achNoticeVisible()) {
+        <div class="sp-block" [attr.data-testid]="achNoticeTestId()"><ui-alert variant="info">{{ achNotice() }}</ui-alert></div>
+      }
+      @if (errorText(); as text) {
+        <div class="sp-block" [id]="errorId" data-testid="stripe-error"><ui-alert variant="danger">{{ text }}</ui-alert></div>
+      }
+      @if (showSubmit()) {
+        <div class="sp-actions">
+          <ui-button variant="primary" type="button" [loading]="submitting()" [disabled]="submitDisabled()" [ariaDescribedBy]="errorText() ? errorId : undefined"
+            data-testid="stripe-submit" (click)="confirm()">{{ effectiveSubmitLabel() }}</ui-button>
+        </div>
+      }
+    </div>
+  `,
+			styles: [":host{display:block;min-width:0}.sp-sr{position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.sp-block{margin-top:12px}.sp-actions{margin-top:16px;display:flex;justify-content:flex-end}.sp{position:relative}.sp-mount--hidden{position:absolute;top:0;left:0;right:0;opacity:0;pointer-events:none}@media(max-width:480px){.sp-actions{display:block}.sp-actions ui-button{display:flex}.sp-actions ::ng-deep .btn{width:100%}}\n"]
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: {
+		mode: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "mode",
+				required: false
+			}]
+		}],
+		publishableKey: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "publishableKey",
+				required: false
+			}]
+		}],
+		clientSecret: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "clientSecret",
+				required: false
+			}]
+		}],
+		deferred: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "deferred",
+				required: false
+			}]
+		}],
+		createIntent: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "createIntent",
+				required: false
+			}]
+		}],
+		stripeAccount: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "stripeAccount",
+				required: false
+			}]
+		}],
+		locale: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "locale",
+				required: false
+			}]
+		}],
+		stripeOptions: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "stripeOptions",
+				required: false
+			}]
+		}],
+		paymentMethodTypes: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "paymentMethodTypes",
+				required: false
+			}]
+		}],
+		elementsOptions: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "elementsOptions",
+				required: false
+			}]
+		}],
+		layout: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "layout",
+				required: false
+			}]
+		}],
+		paymentMethodOrder: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "paymentMethodOrder",
+				required: false
+			}]
+		}],
+		wallets: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "wallets",
+				required: false
+			}]
+		}],
+		fields: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "fields",
+				required: false
+			}]
+		}],
+		defaultValues: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "defaultValues",
+				required: false
+			}]
+		}],
+		business: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "business",
+				required: false
+			}]
+		}],
+		terms: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "terms",
+				required: false
+			}]
+		}],
+		paymentElementOptions: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "paymentElementOptions",
+				required: false
+			}]
+		}],
+		appearance: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "appearance",
+				required: false
+			}]
+		}],
+		appearanceFromTokens: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "appearanceFromTokens",
+				required: false
+			}]
+		}],
+		returnUrl: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "returnUrl",
+				required: false
+			}]
+		}],
+		billingDetails: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "billingDetails",
+				required: false
+			}]
+		}],
+		confirmParams: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "confirmParams",
+				required: false
+			}]
+		}],
+		redirect: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "redirect",
+				required: false
+			}]
+		}],
+		submitBeforeConfirm: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "submitBeforeConfirm",
+				required: false
+			}]
+		}],
+		autoHandleCardAction: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "autoHandleCardAction",
+				required: false
+			}]
+		}],
+		submitLabel: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "submitLabel",
+				required: false
+			}]
+		}],
+		showSubmit: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "showSubmit",
+				required: false
+			}]
+		}],
+		disabled: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "disabled",
+				required: false
+			}]
+		}],
+		pending: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "pending",
+				required: false
+			}]
+		}],
+		label: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "label",
+				required: false
+			}]
+		}],
+		mountId: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "mountId",
+				required: false
+			}]
+		}],
+		mountClass: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "mountClass",
+				required: false
+			}]
+		}],
+		showAchNotice: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "showAchNotice",
+				required: false
+			}]
+		}],
+		achNotice: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "achNotice",
+				required: false
+			}]
+		}],
+		achNoticeTestId: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "achNoticeTestId",
+				required: false
+			}]
+		}],
+		initialPaymentMethodType: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "initialPaymentMethodType",
+				required: false
+			}]
+		}],
+		showErrors: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "showErrors",
+				required: false
+			}]
+		}],
+		errorDisplay: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "errorDisplay",
+				required: false
+			}]
+		}],
+		errorDisplayByStage: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "errorDisplayByStage",
+				required: false
+			}]
+		}],
+		errorFallback: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "errorFallback",
+				required: false
+			}]
+		}],
+		errorFallbackByStage: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "errorFallbackByStage",
+				required: false
+			}]
+		}],
+		errorMessages: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "errorMessages",
+				required: false
+			}]
+		}],
+		loadErrorMessage: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "loadErrorMessage",
+				required: false
+			}]
+		}],
+		a11yMessages: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "a11yMessages",
+				required: false
+			}]
+		}],
+		ready: [{
+			type: i0.Output,
+			args: ["ready"]
+		}],
+		paymentMethodTypeChange: [{
+			type: i0.Output,
+			args: ["paymentMethodTypeChange"]
+		}],
+		elementChange: [{
+			type: i0.Output,
+			args: ["elementChange"]
+		}],
+		confirmed: [{
+			type: i0.Output,
+			args: ["confirmed"]
+		}],
+		failed: [{
+			type: i0.Output,
+			args: ["failed"]
+		}],
+		loadError: [{
+			type: i0.Output,
+			args: ["loadError"]
+		}],
+		mountRef: [{
+			type: i0.ViewChild,
+			args: ["mount", { isSignal: true }]
+		}]
+	}
+});
+const MICRODEPOSIT_COPY = {
+	title: "Bank account waiting for verification",
+	processingTitle: "Bank account being confirmed",
+	processing: "Your bank is confirming this account; this usually takes up to a few business days. We will email you when it is ready.",
+	cannotPay: "Until then this account can't be used to pay invoices.",
+	readOnly: "An administrator of your organization can finish the verification.",
+	keepsActive: "Your current payment method stays active until the new bank account is verified.",
+	cancelTitle: "Cancel verification",
+	verifyLabel: "Verify bank account",
+	cancelBase: "Cancel the verification of this bank account? It will not be saved as a payment method and you can add it again later.",
+	cancelKeepsActive: " Your current payment method stays active.",
+	cancelNoOther: " You have no other payment method saved.",
+	tooManyAttempts: "Too many failed attempts. Please try again later or contact support.",
+	codeRequired: "Enter the 6-character code."
+};
+function microdepositArrivalText(iso) {
+	if (!iso) return "";
+	const date = new Date(iso);
+	return Number.isNaN(date.getTime()) ? "" : date.toLocaleDateString("en-US", {
+		month: "long",
+		day: "numeric",
+		year: "numeric",
+		timeZone: "UTC"
+	});
+}
+function depositAmountError(value) {
+	if (value === "" || value === null || value === void 0) return "";
+	const n = Number(value);
+	if (!Number.isInteger(n)) return "Enter whole cents, for example 32.";
+	if (n < 1 || n > 99) return "Enter a number of cents from 1 to 99.";
+	return "";
+}
+const normalizeDescriptorCode = (value) => (value ?? "").trim().toUpperCase();
+function descriptorCodeError(value, requireSmPrefix = false) {
+	const code = normalizeDescriptorCode(value);
+	if (!code) return "";
+	if (!/^[A-Z0-9]{6}$/.test(code)) return "The code has 6 letters or numbers.";
+	if (requireSmPrefix && !/^SM[A-Z0-9]{4}$/.test(code)) return "Descriptor code must start with \"SM\" followed by 4 characters (e.g., SMXXXX)";
+	return "";
+}
+function safeHostedUrl(url) {
+	return /^https:\/\//.test(url ?? "") ? url : null;
+}
+const arrivalClause = (iso) => {
+	const text = microdepositArrivalText(iso);
+	return text ? ` (by ${text})` : "";
+};
+function microdepositStepsText(ctx) {
+	const partner = ctx.partnerName ?? "";
+	const holder = partner ? `${partner}'s account` : "your account";
+	const clause = arrivalClause(ctx.arrivalDate);
+	const deposits = ctx.type === "descriptor_code" ? `Stripe sent one small deposit to ${holder}${clause}, with a description that starts with SM followed by a 6-character code. ` : `Stripe sent two small deposits to ${holder}; they appear in 1-2 business days${clause}, with the description SMXXXX. `;
+	if (ctx.readOnly) return `${deposits}${ctx.readOnlyText ?? (ctx.startedBy === "partner" ? `This bank account was started by ${partner}; it can be finished by them.` : ctx.startedBy === "other" ? "This bank account was started by another crematory; it can be finished by them." : partner ? `${partner} or the crematory that set it up can finish the verification.` : MICRODEPOSIT_COPY.readOnly)} ${MICRODEPOSIT_COPY.cannotPay}`;
+	return `${deposits}${ctx.type === "descriptor_code" ? partner ? `Ask ${partner} for the code and enter it below to finish. ` : "When it arrives, enter that code below to finish. " : partner ? `Ask ${partner} for the two deposit amounts and enter them below to finish. ` : "When they arrive, enter the two amounts below to finish. "}${MICRODEPOSIT_COPY.cannotPay}`;
+}
+function microdepositProcessingText(partnerName = "") {
+	return partnerName ? `${partnerName}'s bank is confirming this account; this usually takes up to a few business days. We will email you when it is ready.` : MICRODEPOSIT_COPY.processing;
+}
+function microdepositKeepsActiveText(partnerName = "") {
+	return partnerName ? `${partnerName}'s current payment method stays active until the new bank account is verified.` : MICRODEPOSIT_COPY.keepsActive;
+}
+function microdepositCancelMessage(options = {}) {
+	const partner = options.partnerName ?? "";
+	if (partner) return `${MICRODEPOSIT_COPY.cancelBase} ${options.hasSavedMethod ? `${partner}'s current payment method stays active.` : `${partner} has no other payment method saved.`}`;
+	return MICRODEPOSIT_COPY.cancelBase + (options.hasSavedMethod ? MICRODEPOSIT_COPY.cancelKeepsActive : MICRODEPOSIT_COPY.cancelNoOther);
+}
+var MicrodepositVerifyComponent = class MicrodepositVerifyComponent {
+	constructor() {
+		this.service = inject(StripePaymentService);
+		this.type = input("amounts", ...ngDevMode ? [{ debugName: "type" }] : /* istanbul ignore next */ []);
+		this.bankName = input("", ...ngDevMode ? [{ debugName: "bankName" }] : /* istanbul ignore next */ []);
+		this.last4 = input("", ...ngDevMode ? [{ debugName: "last4" }] : /* istanbul ignore next */ []);
+		this.arrivalDate = input(null, ...ngDevMode ? [{ debugName: "arrivalDate" }] : /* istanbul ignore next */ []);
+		this.hostedVerificationUrl = input(null, ...ngDevMode ? [{ debugName: "hostedVerificationUrl" }] : /* istanbul ignore next */ []);
+		this.readOnly = input(false, ...ngDevMode ? [{ debugName: "readOnly" }] : /* istanbul ignore next */ []);
+		this.statusOnly = input(false, ...ngDevMode ? [{ debugName: "statusOnly" }] : /* istanbul ignore next */ []);
+		this.title = input("", ...ngDevMode ? [{ debugName: "title" }] : /* istanbul ignore next */ []);
+		this.stepsText = input("", ...ngDevMode ? [{ debugName: "stepsText" }] : /* istanbul ignore next */ []);
+		this.readOnlyText = input(MICRODEPOSIT_COPY.readOnly, ...ngDevMode ? [{ debugName: "readOnlyText" }] : /* istanbul ignore next */ []);
+		this.hideHostedLink = input(false, ...ngDevMode ? [{ debugName: "hideHostedLink" }] : /* istanbul ignore next */ []);
+		this.cancelLabel = input("", ...ngDevMode ? [{ debugName: "cancelLabel" }] : /* istanbul ignore next */ []);
+		this.verifyLabel = input("", ...ngDevMode ? [{ debugName: "verifyLabel" }] : /* istanbul ignore next */ []);
+		this.keepsActiveText = input("", ...ngDevMode ? [{ debugName: "keepsActiveText" }] : /* istanbul ignore next */ []);
+		this.cancelMessageText = input("", ...ngDevMode ? [{ debugName: "cancelMessageText" }] : /* istanbul ignore next */ []);
+		this.hasSavedMethod = input(false, ...ngDevMode ? [{ debugName: "hasSavedMethod" }] : /* istanbul ignore next */ []);
+		this.verifying = input(false, ...ngDevMode ? [{ debugName: "verifying" }] : /* istanbul ignore next */ []);
+		this.cancelling = input(false, ...ngDevMode ? [{ debugName: "cancelling" }] : /* istanbul ignore next */ []);
+		this.errorText = input("", ...ngDevMode ? [{ debugName: "errorText" }] : /* istanbul ignore next */ []);
+		this.allowCancel = input(true, ...ngDevMode ? [{ debugName: "allowCancel" }] : /* istanbul ignore next */ []);
+		this.requireSmPrefix = input(false, ...ngDevMode ? [{ debugName: "requireSmPrefix" }] : /* istanbul ignore next */ []);
+		this.clientSecret = input(null, ...ngDevMode ? [{ debugName: "clientSecret" }] : /* istanbul ignore next */ []);
+		this.publishableKey = input(null, ...ngDevMode ? [{ debugName: "publishableKey" }] : /* istanbul ignore next */ []);
+		this.stripeAccount = input(null, ...ngDevMode ? [{ debugName: "stripeAccount" }] : /* istanbul ignore next */ []);
+		this.flow = input("payment", ...ngDevMode ? [{ debugName: "flow" }] : /* istanbul ignore next */ []);
+		this.maxAttempts = input(0, ...ngDevMode ? [{ debugName: "maxAttempts" }] : /* istanbul ignore next */ []);
+		this.verify$ = output({ alias: "verify" });
+		this.cancelVerification = output();
+		this.verified = output();
+		this.verifyFailed = output();
+		this.copy = MICRODEPOSIT_COPY;
+		this.first = signal("", ...ngDevMode ? [{ debugName: "first" }] : /* istanbul ignore next */ []);
+		this.second = signal("", ...ngDevMode ? [{ debugName: "second" }] : /* istanbul ignore next */ []);
+		this.code = signal("", ...ngDevMode ? [{ debugName: "code" }] : /* istanbul ignore next */ []);
+		this.touched = signal(false, ...ngDevMode ? [{ debugName: "touched" }] : /* istanbul ignore next */ []);
+		this.showCancelConfirm = signal(false, ...ngDevMode ? [{ debugName: "showCancelConfirm" }] : /* istanbul ignore next */ []);
+		this.stripeBusy = signal(false, ...ngDevMode ? [{ debugName: "stripeBusy" }] : /* istanbul ignore next */ []);
+		this.stripeError = signal("", ...ngDevMode ? [{ debugName: "stripeError" }] : /* istanbul ignore next */ []);
+		this.failedAttempts = 0;
+		this.formHidden = computed(() => this.readOnly() || this.statusOnly(), ...ngDevMode ? [{ debugName: "formHidden" }] : /* istanbul ignore next */ []);
+		this.heading = computed(() => this.title() || (this.isProcessing() ? this.copy.processingTitle : this.copy.title), ...ngDevMode ? [{ debugName: "heading" }] : /* istanbul ignore next */ []);
+		this.bankLine = computed(() => {
+			const bank = this.bankName().trim();
+			const last4 = this.last4().trim();
+			if (!bank && !last4) return "";
+			return `${bank || "Bank account"}${last4 ? ` ····${last4}` : ""}`;
+		}, ...ngDevMode ? [{ debugName: "bankLine" }] : /* istanbul ignore next */ []);
+		this.busy = computed(() => this.verifying() || this.stripeBusy(), ...ngDevMode ? [{ debugName: "busy" }] : /* istanbul ignore next */ []);
+		this.shownError = computed(() => this.stripeError() || this.errorText(), ...ngDevMode ? [{ debugName: "shownError" }] : /* istanbul ignore next */ []);
+		this.isProcessing = computed(() => this.type() === "processing", ...ngDevMode ? [{ debugName: "isProcessing" }] : /* istanbul ignore next */ []);
+		this.safeUrl = computed(() => safeHostedUrl(this.hostedVerificationUrl()), ...ngDevMode ? [{ debugName: "safeUrl" }] : /* istanbul ignore next */ []);
+		this.defaultSteps = computed(() => microdepositStepsText({
+			type: this.type() === "descriptor_code" ? "descriptor_code" : "amounts",
+			arrivalDate: this.arrivalDate(),
+			readOnly: this.formHidden(),
+			readOnlyText: this.readOnlyText()
+		}), ...ngDevMode ? [{ debugName: "defaultSteps" }] : /* istanbul ignore next */ []);
+		this.amountError = depositAmountError;
+		this.codeError = computed(() => this.code().trim() ? descriptorCodeError(this.code(), this.requireSmPrefix()) : this.copy.codeRequired, ...ngDevMode ? [{ debugName: "codeError" }] : /* istanbul ignore next */ []);
+		this.hasInvalid = computed(() => this.type() === "descriptor_code" ? !!this.codeError() : !!depositAmountError(this.first()) || !!depositAmountError(this.second()) || this.first() === "" || this.second() === "" || this.first() === null || this.second() === null, ...ngDevMode ? [{ debugName: "hasInvalid" }] : /* istanbul ignore next */ []);
+		this.cancelMessage = computed(() => this.cancelMessageText() || this.copy.cancelBase + (this.hasSavedMethod() ? this.copy.cancelKeepsActive : this.copy.cancelNoOther), ...ngDevMode ? [{ debugName: "cancelMessage" }] : /* istanbul ignore next */ []);
+	}
+	async verify() {
+		if (this.busy()) return;
+		this.touched.set(true);
+		if (this.hasInvalid()) return;
+		const secret = this.clientSecret();
+		if (!secret) {
+			this.verify$.emit(this.type() === "descriptor_code" ? { descriptorCode: normalizeDescriptorCode(this.code()) } : { amounts: [Number(this.first()), Number(this.second())] });
+			return;
+		}
+		const max = this.maxAttempts();
+		if (max > 0 && this.failedAttempts >= max) {
+			this.stripeError.set(this.copy.tooManyAttempts);
+			return;
+		}
+		this.stripeBusy.set(true);
+		this.stripeError.set("");
+		const data = this.type() === "descriptor_code" ? { descriptor_code: normalizeDescriptorCode(this.code()) } : { amounts: [Number(this.first()), Number(this.second())] };
+		const connection = {
+			publishableKey: this.publishableKey(),
+			stripeAccount: this.stripeAccount()
+		};
+		const result = this.flow() === "setup" ? await this.service.verifyMicrodepositsForSetup(secret, data, connection) : await this.service.verifyMicrodepositsForPayment(secret, data, connection);
+		this.stripeBusy.set(false);
+		if (result.ok) {
+			this.verified.emit(result);
+			return;
+		}
+		this.failedAttempts++;
+		const message = result.failure?.message ?? "Verification failed";
+		const remaining = max - this.failedAttempts;
+		this.stripeError.set(max > 0 && remaining > 0 ? `${message} (${remaining} attempt${remaining === 1 ? "" : "s"} remaining)` : message);
+		this.verifyFailed.emit(result);
+	}
+	confirmCancel() {
+		if (this.cancelling()) return;
+		this.showCancelConfirm.set(false);
+		this.cancelVerification.emit();
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.2",
+			ngImport: i0,
+			type: MicrodepositVerifyComponent,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Component
+		});
+	}
+	static {
+		this.ɵcmp = i0.ɵɵngDeclareComponent({
+			minVersion: "17.0.0",
+			version: "22.2.2",
+			type: MicrodepositVerifyComponent,
+			isStandalone: true,
+			selector: "ui-microdeposit-verify",
+			inputs: {
+				type: {
+					classPropertyName: "type",
+					publicName: "type",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				bankName: {
+					classPropertyName: "bankName",
+					publicName: "bankName",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				last4: {
+					classPropertyName: "last4",
+					publicName: "last4",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				arrivalDate: {
+					classPropertyName: "arrivalDate",
+					publicName: "arrivalDate",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				hostedVerificationUrl: {
+					classPropertyName: "hostedVerificationUrl",
+					publicName: "hostedVerificationUrl",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				readOnly: {
+					classPropertyName: "readOnly",
+					publicName: "readOnly",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				statusOnly: {
+					classPropertyName: "statusOnly",
+					publicName: "statusOnly",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				title: {
+					classPropertyName: "title",
+					publicName: "title",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				stepsText: {
+					classPropertyName: "stepsText",
+					publicName: "stepsText",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				readOnlyText: {
+					classPropertyName: "readOnlyText",
+					publicName: "readOnlyText",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				hideHostedLink: {
+					classPropertyName: "hideHostedLink",
+					publicName: "hideHostedLink",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				cancelLabel: {
+					classPropertyName: "cancelLabel",
+					publicName: "cancelLabel",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				verifyLabel: {
+					classPropertyName: "verifyLabel",
+					publicName: "verifyLabel",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				keepsActiveText: {
+					classPropertyName: "keepsActiveText",
+					publicName: "keepsActiveText",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				cancelMessageText: {
+					classPropertyName: "cancelMessageText",
+					publicName: "cancelMessageText",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				hasSavedMethod: {
+					classPropertyName: "hasSavedMethod",
+					publicName: "hasSavedMethod",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				verifying: {
+					classPropertyName: "verifying",
+					publicName: "verifying",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				cancelling: {
+					classPropertyName: "cancelling",
+					publicName: "cancelling",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				errorText: {
+					classPropertyName: "errorText",
+					publicName: "errorText",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				allowCancel: {
+					classPropertyName: "allowCancel",
+					publicName: "allowCancel",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				requireSmPrefix: {
+					classPropertyName: "requireSmPrefix",
+					publicName: "requireSmPrefix",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				clientSecret: {
+					classPropertyName: "clientSecret",
+					publicName: "clientSecret",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				publishableKey: {
+					classPropertyName: "publishableKey",
+					publicName: "publishableKey",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				stripeAccount: {
+					classPropertyName: "stripeAccount",
+					publicName: "stripeAccount",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				flow: {
+					classPropertyName: "flow",
+					publicName: "flow",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				maxAttempts: {
+					classPropertyName: "maxAttempts",
+					publicName: "maxAttempts",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				}
+			},
+			outputs: {
+				verify$: "verify",
+				cancelVerification: "cancelVerification",
+				verified: "verified",
+				verifyFailed: "verifyFailed"
+			},
+			ngImport: i0,
+			template: `
+    <div data-testid="bank-pending-card">
+      <ui-form-section [label]="heading()">
+        <ui-alert variant="info" data-testid="bank-pending-alert">
+          <div data-testid="bank-pending-summary">
+            @if (bankLine(); as line) { <strong data-testid="bank-pending-bank">{{ line }}</strong> }
+            <ui-badge label="Pending" variant="yellow" data-testid="bank-pending-badge" />
+          </div>
+          @if (stepsText().trim()) {
+            <ui-text size="sm" [text]="stepsText()" data-testid="bank-pending-steps" />
+          } @else if (isProcessing()) {
+            <ui-text size="sm" [text]="copy.processing" data-testid="bank-pending-steps" />
+          } @else {
+            <ui-text size="sm" data-testid="bank-pending-steps" [text]="defaultSteps()" />
+          }
+          @if (hasSavedMethod()) {
+            <ui-text size="sm" tone="muted" [text]="keepsActiveText() || copy.keepsActive" data-testid="bank-pending-keeps-active" />
+          }
+          <!-- Finishing the verification on Stripe's page saves the payment method (a write): never offered to a read-only user -->
+          @if (!formHidden() && !hideHostedLink() && safeUrl(); as url) {
+            <div><ui-button variant="link" size="sm" [href]="url" target="_blank" data-testid="bank-hosted-link">Open Stripe's verification page</ui-button></div>
+          }
+        </ui-alert>
+
+        @if (!formHidden() && !isProcessing()) {
+          @if (type() === 'descriptor_code') {
+            <ui-text-input label="Verification code" hint="6 letters or numbers from the deposit description" [maxlength]="6" [required]="true" [showErrors]="touched()"
+              [error]="touched() ? codeError() : ''" data-testid="bank-code-input" [ngModel]="code()" (ngModelChange)="code.set($event)" />
+          } @else {
+            <ui-form-row data-testid="bank-amounts-row">
+              <ui-text-input label="First deposit (cents)" type="number" [min]="1" [max]="99" [maxDecimals]="0" [required]="true" [showErrors]="touched()"
+                [error]="touched() ? amountError(first()) : ''" data-testid="bank-amount-first" [ngModel]="first()" (ngModelChange)="first.set($event)" />
+              <ui-text-input label="Second deposit (cents)" type="number" [min]="1" [max]="99" [maxDecimals]="0" [required]="true" [showErrors]="touched()"
+                [error]="touched() ? amountError(second()) : ''" data-testid="bank-amount-second" [ngModel]="second()" (ngModelChange)="second.set($event)" />
+            </ui-form-row>
+          }
+          @if (shownError(); as text) {
+            <ui-alert variant="danger" data-testid="bank-verify-error">{{ text }}</ui-alert>
+          }
+          <ui-button variant="primary" size="sm" data-testid="bank-verify-button" [loading]="busy()" [disabled]="busy() || cancelling()" (click)="verify()">{{ verifyLabel() || copy.verifyLabel }}</ui-button>
+        }
+
+        @if (!formHidden() && allowCancel()) {
+          <ui-button variant="secondary" size="sm" data-testid="bank-cancel-button" [disabled]="busy() || cancelling()" (click)="showCancelConfirm.set(true)">{{ cancelLabel() || copy.cancelTitle }}</ui-button>
+        }
+      </ui-form-section>
+
+      <ui-modal [open]="showCancelConfirm()" [title]="cancelLabel() || copy.cancelTitle" maxWidth="460px" (close)="showCancelConfirm.set(false)">
+        <ui-text size="sm" data-testid="bank-cancel-message" [text]="cancelMessage()" />
+        <ui-button modal-footer-left variant="secondary" size="sm" data-testid="bank-cancel-keep" (click)="showCancelConfirm.set(false)">Keep waiting</ui-button>
+        <ui-button modal-footer-right variant="danger" size="sm" data-testid="bank-cancel-confirm" [loading]="cancelling()" (click)="confirmCancel()">{{ cancelLabel() || copy.cancelTitle }}</ui-button>
+      </ui-modal>
+    </div>
+  `,
+			isInline: true,
+			dependencies: [
+				{
+					kind: "ngmodule",
+					type: FormsModule
+				},
+				{
+					kind: "directive",
+					type: i1.NgControlStatus,
+					selector: "[formControlName],[ngModel],[formControl]"
+				},
+				{
+					kind: "directive",
+					type: i1.RequiredValidator,
+					selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]",
+					inputs: ["required"]
+				},
+				{
+					kind: "directive",
+					type: i1.MaxLengthValidator,
+					selector: "[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]",
+					inputs: ["maxlength"]
+				},
+				{
+					kind: "directive",
+					type: i1.NgModel,
+					selector: "[ngModel]:not([formControlName]):not([formControl])",
+					inputs: [
+						"name",
+						"disabled",
+						"ngModel",
+						"ngModelOptions"
+					],
+					outputs: ["ngModelChange"],
+					exportAs: ["ngModel"]
+				},
+				{
+					kind: "component",
+					type: AlertComponent,
+					selector: "ui-alert",
+					inputs: [
+						"variant",
+						"title",
+						"dismissible",
+						"quiet",
+						"compact"
+					],
+					outputs: ["dismissed"]
+				},
+				{
+					kind: "component",
+					type: BadgeComponent,
+					selector: "ui-badge",
+					inputs: ["label", "variant"]
+				},
+				{
+					kind: "component",
+					type: ButtonComponent,
+					selector: "ui-button",
+					inputs: [
+						"variant",
+						"routerLink",
+						"queryParams",
+						"href",
+						"target",
+						"rel",
+						"color",
+						"active",
+						"size",
+						"type",
+						"disabled",
+						"loading",
+						"fullWidth",
+						"ariaLabel",
+						"ariaExpanded",
+						"ariaPressed",
+						"ariaDescribedBy",
+						"modal-footer-left",
+						"modal-footer-right"
+					]
+				},
+				{
+					kind: "component",
+					type: FormRowComponent,
+					selector: "ui-form-row",
+					inputs: ["cols"]
+				},
+				{
+					kind: "component",
+					type: FormSectionComponent,
+					selector: "ui-form-section",
+					inputs: ["label", "divider"]
+				},
+				{
+					kind: "component",
+					type: ModalComponent,
+					selector: "ui-modal",
+					inputs: [
+						"open",
+						"title",
+						"description",
+						"maxWidth",
+						"bodyOverflow"
+					],
+					outputs: ["close"]
+				},
+				{
+					kind: "component",
+					type: TextComponent,
+					selector: "ui-text",
+					inputs: [
+						"text",
+						"size",
+						"tone"
+					]
+				},
+				{
+					kind: "component",
+					type: TextInputComponent,
+					selector: "ui-text-input",
+					inputs: [
+						"label",
+						"ariaLabel",
+						"placeholder",
+						"type",
+						"maxlength",
+						"required",
+						"autocomplete",
+						"inputmode",
+						"readonly",
+						"hint",
+						"error",
+						"phoneFormat",
+						"min",
+						"max",
+						"maxDecimals",
+						"step",
+						"valueType",
+						"showErrors",
+						"disabled"
+					],
+					outputs: [
+						"focused",
+						"blurred",
+						"invalidChange"
+					]
+				}
+			],
+			changeDetection: i0.ChangeDetectionStrategy.OnPush
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.2",
+	ngImport: i0,
+	type: MicrodepositVerifyComponent,
+	decorators: [{
+		type: Component,
+		args: [{
+			selector: "ui-microdeposit-verify",
+			standalone: true,
+			changeDetection: ChangeDetectionStrategy.OnPush,
+			imports: [
+				FormsModule,
+				AlertComponent,
+				BadgeComponent,
+				ButtonComponent,
+				FormRowComponent,
+				FormSectionComponent,
+				ModalComponent,
+				TextComponent,
+				TextInputComponent
+			],
+			template: `
+    <div data-testid="bank-pending-card">
+      <ui-form-section [label]="heading()">
+        <ui-alert variant="info" data-testid="bank-pending-alert">
+          <div data-testid="bank-pending-summary">
+            @if (bankLine(); as line) { <strong data-testid="bank-pending-bank">{{ line }}</strong> }
+            <ui-badge label="Pending" variant="yellow" data-testid="bank-pending-badge" />
+          </div>
+          @if (stepsText().trim()) {
+            <ui-text size="sm" [text]="stepsText()" data-testid="bank-pending-steps" />
+          } @else if (isProcessing()) {
+            <ui-text size="sm" [text]="copy.processing" data-testid="bank-pending-steps" />
+          } @else {
+            <ui-text size="sm" data-testid="bank-pending-steps" [text]="defaultSteps()" />
+          }
+          @if (hasSavedMethod()) {
+            <ui-text size="sm" tone="muted" [text]="keepsActiveText() || copy.keepsActive" data-testid="bank-pending-keeps-active" />
+          }
+          <!-- Finishing the verification on Stripe's page saves the payment method (a write): never offered to a read-only user -->
+          @if (!formHidden() && !hideHostedLink() && safeUrl(); as url) {
+            <div><ui-button variant="link" size="sm" [href]="url" target="_blank" data-testid="bank-hosted-link">Open Stripe's verification page</ui-button></div>
+          }
+        </ui-alert>
+
+        @if (!formHidden() && !isProcessing()) {
+          @if (type() === 'descriptor_code') {
+            <ui-text-input label="Verification code" hint="6 letters or numbers from the deposit description" [maxlength]="6" [required]="true" [showErrors]="touched()"
+              [error]="touched() ? codeError() : ''" data-testid="bank-code-input" [ngModel]="code()" (ngModelChange)="code.set($event)" />
+          } @else {
+            <ui-form-row data-testid="bank-amounts-row">
+              <ui-text-input label="First deposit (cents)" type="number" [min]="1" [max]="99" [maxDecimals]="0" [required]="true" [showErrors]="touched()"
+                [error]="touched() ? amountError(first()) : ''" data-testid="bank-amount-first" [ngModel]="first()" (ngModelChange)="first.set($event)" />
+              <ui-text-input label="Second deposit (cents)" type="number" [min]="1" [max]="99" [maxDecimals]="0" [required]="true" [showErrors]="touched()"
+                [error]="touched() ? amountError(second()) : ''" data-testid="bank-amount-second" [ngModel]="second()" (ngModelChange)="second.set($event)" />
+            </ui-form-row>
+          }
+          @if (shownError(); as text) {
+            <ui-alert variant="danger" data-testid="bank-verify-error">{{ text }}</ui-alert>
+          }
+          <ui-button variant="primary" size="sm" data-testid="bank-verify-button" [loading]="busy()" [disabled]="busy() || cancelling()" (click)="verify()">{{ verifyLabel() || copy.verifyLabel }}</ui-button>
+        }
+
+        @if (!formHidden() && allowCancel()) {
+          <ui-button variant="secondary" size="sm" data-testid="bank-cancel-button" [disabled]="busy() || cancelling()" (click)="showCancelConfirm.set(true)">{{ cancelLabel() || copy.cancelTitle }}</ui-button>
+        }
+      </ui-form-section>
+
+      <ui-modal [open]="showCancelConfirm()" [title]="cancelLabel() || copy.cancelTitle" maxWidth="460px" (close)="showCancelConfirm.set(false)">
+        <ui-text size="sm" data-testid="bank-cancel-message" [text]="cancelMessage()" />
+        <ui-button modal-footer-left variant="secondary" size="sm" data-testid="bank-cancel-keep" (click)="showCancelConfirm.set(false)">Keep waiting</ui-button>
+        <ui-button modal-footer-right variant="danger" size="sm" data-testid="bank-cancel-confirm" [loading]="cancelling()" (click)="confirmCancel()">{{ cancelLabel() || copy.cancelTitle }}</ui-button>
+      </ui-modal>
+    </div>
+  `
+		}]
+	}],
+	propDecorators: {
+		type: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "type",
+				required: false
+			}]
+		}],
+		bankName: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "bankName",
+				required: false
+			}]
+		}],
+		last4: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "last4",
+				required: false
+			}]
+		}],
+		arrivalDate: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "arrivalDate",
+				required: false
+			}]
+		}],
+		hostedVerificationUrl: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "hostedVerificationUrl",
+				required: false
+			}]
+		}],
+		readOnly: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "readOnly",
+				required: false
+			}]
+		}],
+		statusOnly: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "statusOnly",
+				required: false
+			}]
+		}],
+		title: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "title",
+				required: false
+			}]
+		}],
+		stepsText: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "stepsText",
+				required: false
+			}]
+		}],
+		readOnlyText: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "readOnlyText",
+				required: false
+			}]
+		}],
+		hideHostedLink: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "hideHostedLink",
+				required: false
+			}]
+		}],
+		cancelLabel: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "cancelLabel",
+				required: false
+			}]
+		}],
+		verifyLabel: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "verifyLabel",
+				required: false
+			}]
+		}],
+		keepsActiveText: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "keepsActiveText",
+				required: false
+			}]
+		}],
+		cancelMessageText: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "cancelMessageText",
+				required: false
+			}]
+		}],
+		hasSavedMethod: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "hasSavedMethod",
+				required: false
+			}]
+		}],
+		verifying: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "verifying",
+				required: false
+			}]
+		}],
+		cancelling: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "cancelling",
+				required: false
+			}]
+		}],
+		errorText: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "errorText",
+				required: false
+			}]
+		}],
+		allowCancel: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "allowCancel",
+				required: false
+			}]
+		}],
+		requireSmPrefix: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "requireSmPrefix",
+				required: false
+			}]
+		}],
+		clientSecret: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "clientSecret",
+				required: false
+			}]
+		}],
+		publishableKey: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "publishableKey",
+				required: false
+			}]
+		}],
+		stripeAccount: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "stripeAccount",
+				required: false
+			}]
+		}],
+		flow: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "flow",
+				required: false
+			}]
+		}],
+		maxAttempts: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "maxAttempts",
+				required: false
+			}]
+		}],
+		verify$: [{
+			type: i0.Output,
+			args: ["verify"]
+		}],
+		cancelVerification: [{
+			type: i0.Output,
+			args: ["cancelVerification"]
+		}],
+		verified: [{
+			type: i0.Output,
+			args: ["verified"]
+		}],
+		verifyFailed: [{
+			type: i0.Output,
+			args: ["verifyFailed"]
+		}]
+	}
+});
+export { MICRODEPOSIT_COPY, MicrodepositVerifyComponent, STRIPE_A11Y_MESSAGES, STRIPE_ACH_NOTICE, STRIPE_DEFAULT_ERROR_MESSAGE, STRIPE_ERROR_MESSAGES, STRIPE_LOADER, STRIPE_PAYMENT_DEFAULTS, STRIPE_TECHNICAL_ERROR_MESSAGES, StripePaymentComponent, StripePaymentService, buildLoadOptions, defaultStripeLoader, depositAmountError, descriptorCodeError, getStripeErrorMessage, isDarkPage, microdepositArrivalText, microdepositCancelMessage, microdepositKeepsActiveText, microdepositProcessingText, microdepositStepsText, normalizeDescriptorCode, normalizeIntent, outcomeOf, paymentMethodIdOf, provideStripePayment, readStripeAppearance, readStripeReturnParams, retrieveIntent, verificationOf, verifyMicrodeposits };
+
+//# sourceMappingURL=forgeroute-ui-stripe.mjs.map