@agent-cards/sdk 0.23.20 → 0.23.21

package/dist/tokenex-iframe.d.ts

@@ -0,0 +1,93 @@
+import type { ReplayResponse } from './client.js';
+/** The PSP id the API and the recognizer name this lane. */
+export declare const TOKENEX_IFRAME_PSP: string;
+/** The dark-launch capability the API serves the tokenex_iframe recognizer behind. */
+export declare const TOKENEX_IFRAME_CAPABILITY: string;
+/**
+ * Why the SDK refuses a TokenEx card post before anything is claimed, created or prompted: a post on the frame's
+ * /iframe/v3 path that carries a value in Data and is not the PCI card-number frame's own card post (a cvvOnly or
+ * PCI-only frame, a Token key, another key, order or type, a query this lane has not read or that names another
+ * account than the body, a URL variant or one longer than the recognizer reads, a content type other than JSON).
+ * The API answers the same code at create, so the refusal here only keeps the agent's placeholder from reaching
+ * TokenEx and saves the round trip.
+ */
+export type TokenexIframeRefusalReason = 'invalid_tokenex_iframe_request';
+export declare const INVALID_TOKENEX_IFRAME_REQUEST: TokenexIframeRefusalReason;
+/** True when the URL parses onto one of TokenEx's two iframe hosts and the /iframe/v3 path, however it is spelled or queried. */
+export declare function isTokenexIframePath(url: string): boolean;
+/** Whether this build's registry serves the TokenEx iframe: a company Agentcard turned it on for, on a build that declares it. */
+export declare function servesTokenexIframe(vault: {
+    recognizesProcessor?(psp: string): boolean;
+} | undefined): boolean;
+/**
+ * Whether an adapter must hand this request to the pre-claim gates: it is on the frame's /iframe/v3 path and this
+ * build's registry serves the TokenEx iframe. The recognizer matches only the exact card URL, so a variant (another
+ * query, a case or dot spelling) would otherwise never reach the gate that refuses it. attachToPlaywright's route
+ * predicate asks this; attachToCdp arms the two hosts from the recognizer's own host list.
+ */
+export declare function isArmedTokenexIframeUrl(vault: {
+    recognizesProcessor?(psp: string): boolean;
+} | undefined, url: string): boolean;
+/**
+ * The pause decision for a POST on the frame's path, by payment-core's classifyTokenexIframeRequest:
+ *   'card'  the exact card URL with the JSON content type and the sound pcicvv card post bound to its query: it pauses;
+ *   'invalid_tokenex_iframe_request'  a post with a value in Data that is not that: it is refused in the browser;
+ *   null    not a card post (no value in Data, another path, BinLookup, Forter): the SDK's ordinary handling
+ *           decides, and an empty-Data post continues untouched through the recognizer's passWithoutCard.
+ * A URL longer than payment-core reads (over 2,048 characters) classifies as null, as an unrelated request does, and
+ * the exact recognizer refuses it too, so a post on the frame's own path that carries a value in Data is refused here
+ * rather than sent to TokenEx with the agent's placeholder.
+ */
+export declare function tokenexIframePauseDecision(request: {
+    url: string;
+    headers: Record<string, string>;
+    body: string | null;
+}): 'card' | TokenexIframeRefusalReason | null;
+/**
+ * The answer the paused card post may receive, rebuilt from payment-core's allow-list under a JSON content type:
+ * only TokenEx's 200 with a sound sixTOKENfour token (tokenexIframeResponseOutcome reads it as approved), keys TokenEx
+ * documents for a success and nothing else (sanitizeTokenexIframeResponse). Null for anything else: an error answer,
+ * another status, a body out of bounds. The frame adds its own `cardType` before the page reads the answer.
+ */
+export declare function tokenexIframePageAnswer(status: number, body: string): {
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+} | null;
+/** Whether the frame reads `number` as the network `brand` (lowercase, as GET /api/v2/vault_cards names it). */
+export declare function tokenexIframePlaceholderFits(brand: string, number: string): boolean;
+/** The longest an iframe key lives, and so the longest a stored answer is handed out: TokenEx's ExpiresInSeconds maximum. */
+export declare const TOKENEX_IFRAME_REPEAT_WINDOW_MS = 1200000;
+/** A stored answer handed to a repeat, with the approval it came from. */
+export interface TokenexIframeRepeatAnswer {
+    authorizationId: string;
+    response: {
+        status: number;
+        headers: Record<string, string>;
+        body: string;
+    };
+}
+/**
+ * The approved TokenEx answers one attachment handed to a card post, per frame. `frame` is the adapter's identity
+ * for the request's frame (the CDP frameId of the out-of-process iframe, the Playwright Frame); a request whose
+ * frame is unknown is never remembered and never answered. Only an answer payment-core reads as approved (a sound
+ * sixTOKENfour token) to the sound card post is kept: an error answer leaves the next post a new question, so the
+ * page can try again.
+ */
+export declare class TokenexIframeRepeats {
+    private readonly now;
+    private remembered;
+    constructor(now?: () => number);
+    /**
+     * Keep the answer a token replay handed to this card post, when TokenEx approved it. Called after the answer
+     * reached the browser, so it never throws: a failure here only leaves the page's next post a new question.
+     */
+    remember(frame: unknown, url: string, body: string | null, replay: ReplayResponse): void;
+    /**
+     * The stored answer for the same frame's same post, byte for byte, or null. Only an answer from `authorizationId`,
+     * the approval the attachment is handing off now, is handed out, and every answer from another approval is
+     * dropped: a later authorization ends the window of every earlier one.
+     */
+    answerFor(frame: unknown, url: string, body: string | null, authorizationId: string | null): TokenexIframeRepeatAnswer | null;
+    private prune;
+}

package/dist/tokenex-iframe.generated.d.ts

@@ -0,0 +1,81 @@
+declare var TOKENEX_IFRAME_PSP: string;
+declare var TOKENEX_IFRAME_CAPABILITY: string;
+declare var TOKENEX_IFRAME_OPERATION: string;
+declare var TOKENEX_IFRAME_HOSTS: readonly string[];
+declare var TOKENEX_IFRAME_PATH: string;
+declare var TOKENEX_IFRAME_REFUSAL_REASONS: readonly string[];
+declare var TOKENEX_IFRAME_BODY_KEYS: readonly string[];
+declare var TOKENEX_IFRAME_TOKEN_SCHEMES: readonly string[];
+declare var TOKENEX_IFRAME_REVIEWED_ACCOUNTS: Readonly<{
+    "htp.tokenex.com": Readonly<{}>;
+    "test-htp.tokenex.com": Readonly<{}>;
+}>;
+declare var TOKENEX_IFRAME_ACCOUNT_NAMES: Readonly<{
+    "htp.tokenex.com": Readonly<{}>;
+    "test-htp.tokenex.com": Readonly<{}>;
+}>;
+declare function tokenexIframeTarget(url: any): {
+    host: string;
+    query: Map<any, any>;
+} | null;
+declare function isTokenexIframeUrl(url: any, method?: string): boolean;
+declare function tokenexIframeBodyRefusal(body: any): "unsupported" | null;
+declare function tokenexIframeRequestRefusal(request: any): "unsupported" | null;
+declare function isTokenexIframeRequest(request: any): boolean;
+declare var TOKENEX_IFRAME_GATE_CODES: readonly string[];
+declare function tokenexIframeBodyVerdict(body: any, url: any): {
+    verdict: string;
+    code?: undefined;
+} | {
+    verdict: string;
+    code: string;
+};
+declare function classifyTokenexIframeRequest(url: any, method: any, body: any, headers: any): "card" | "unsupported" | null;
+declare function tokenexIframeAccount(request: any): {
+    host: string;
+    tokenExId: any;
+    origin: any;
+} | null;
+declare function tokenexIframeAccountRefusal(request: any, accounts?: Readonly<{
+    "htp.tokenex.com": Readonly<{}>;
+    "test-htp.tokenex.com": Readonly<{}>;
+}>): "unreviewed_account" | null;
+declare function tokenexIframeAccountName(request: any, accounts?: Readonly<{
+    "htp.tokenex.com": Readonly<{}>;
+    "test-htp.tokenex.com": Readonly<{}>;
+}>, names?: Readonly<{
+    "htp.tokenex.com": Readonly<{}>;
+    "test-htp.tokenex.com": Readonly<{}>;
+}>): string | null;
+declare function tokenexIframeCardType(number: any): string | RegExp | null;
+declare function tokenexIframeBrandRefusal(body: any, card: any): "unsupported" | "brand_mismatch" | null;
+declare function tokenexIframeDeviceRefusal(request: any, card: any, accounts?: Readonly<{
+    "htp.tokenex.com": Readonly<{}>;
+    "test-htp.tokenex.com": Readonly<{}>;
+}>): "unsupported" | "brand_mismatch" | "unreviewed_account" | null;
+declare function tokenexIframeRefusalMessage(reason: any): string;
+declare function injectTokenexIframeCard(body: any, card: any): {
+    body: string;
+    where: string[];
+};
+declare function isTokenexIframeDeviceRequest(templateBody: any, deviceBody: any): boolean;
+declare function tokenexIframeErrorCode(message: any): string | RegExp;
+declare function tokenexIframeResponseOutcome(status: any, body: any, card: any): {
+    outcome: string;
+    code: string | RegExp;
+    reason?: undefined;
+} | {
+    outcome: string;
+    reason: string | undefined;
+    code?: undefined;
+} | {
+    outcome: string;
+    code?: undefined;
+    reason?: undefined;
+};
+declare function sanitizeTokenexIframeResponse(body: any): string;
+declare function tokenexIframeFacts(status: any, body: any): {
+    outcome: string;
+    refusalCode: string | RegExp | null | undefined;
+};
+export { TOKENEX_IFRAME_ACCOUNT_NAMES, TOKENEX_IFRAME_BODY_KEYS, TOKENEX_IFRAME_CAPABILITY, TOKENEX_IFRAME_GATE_CODES, TOKENEX_IFRAME_HOSTS, TOKENEX_IFRAME_OPERATION, TOKENEX_IFRAME_PATH, TOKENEX_IFRAME_PSP, TOKENEX_IFRAME_REFUSAL_REASONS, TOKENEX_IFRAME_REVIEWED_ACCOUNTS, TOKENEX_IFRAME_TOKEN_SCHEMES, classifyTokenexIframeRequest, injectTokenexIframeCard, isTokenexIframeDeviceRequest, isTokenexIframeRequest, isTokenexIframeUrl, sanitizeTokenexIframeResponse, tokenexIframeAccount, tokenexIframeAccountName, tokenexIframeAccountRefusal, tokenexIframeBodyRefusal, tokenexIframeBodyVerdict, tokenexIframeBrandRefusal, tokenexIframeCardType, tokenexIframeDeviceRefusal, tokenexIframeErrorCode, tokenexIframeFacts, tokenexIframeRefusalMessage, tokenexIframeRequestRefusal, tokenexIframeResponseOutcome, tokenexIframeTarget };

package/dist/tokenex-iframe.generated.js

@@ -0,0 +1,403 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: 79eec39d9ea40ae7687f24e640623f854bc1c0754a2553663c0662bd6cb86218
+// src/tokenex-iframe.js
+var TOKENEX_IFRAME_PSP = "tokenex_iframe";
+var TOKENEX_IFRAME_CAPABILITY = "tokenex_iframe_tokenize";
+var TOKENEX_IFRAME_OPERATION = "tokenex_iframe.card_request";
+var TOKENEX_IFRAME_HOSTS = Object.freeze(["htp.tokenex.com", "test-htp.tokenex.com"]);
+var TOKENEX_IFRAME_PATH = "/iframe/v3";
+var TOKENEX_IFRAME_REFUSAL_REASONS = Object.freeze(["unsupported", "brand_mismatch", "unreviewed_account"]);
+var TOKENEX_IFRAME_BODY_KEYS = Object.freeze([
+    "TokenExID",
+    "Origin",
+    "AuthenticationKey",
+    "Timestamp",
+    "Data",
+    "CvvValue",
+    "TokenScheme",
+    "CvvOnly",
+    "PCI",
+    "ReturnHash",
+    "use3DS",
+    "ThreeDSMethodNotificationUrl",
+    "kountSessionId",
+    "fraudMerchantId",
+    "UseKount",
+    "kountMode",
+    "kountAnId",
+    "FraudServicesRiskRequestModel",
+    "EnforceLuhnCompliance",
+    "CustomDataLuhnCheck"
+]);
+var TOKENEX_IFRAME_TOKEN_SCHEMES = Object.freeze(["sixTOKENfour"]);
+var TOKENEX_IFRAME_REVIEWED_ACCOUNTS = Object.freeze({
+    "htp.tokenex.com": Object.freeze({}),
+    "test-htp.tokenex.com": Object.freeze({})
+});
+var TOKENEX_IFRAME_ACCOUNT_NAMES = Object.freeze({
+    "htp.tokenex.com": Object.freeze({}),
+    "test-htp.tokenex.com": Object.freeze({})
+});
+var UNSUPPORTED_REFUSAL = "Refusing to pay: unsupported TokenEx card request.";
+var BRAND_MISMATCH_REFUSAL = "Refusing to pay: this TokenEx payment was started with a card of another brand than yours. Nothing was sent.";
+var UNREVIEWED_ACCOUNT_REFUSAL = "Refusing to pay: this TokenEx payment goes to an account Agentcard has not reviewed. Nothing was sent.";
+var FILL_REFUSAL = "Could not fill the card fields for TokenEx. Nothing was sent.";
+var BODY_LIMIT = 8192;
+var RESPONSE_LIMIT = 4096;
+var URL_LIMIT = 2048;
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var owns = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var exact = (pattern, value) => typeof value === "string" && pattern.exec(value)?.[0] === value;
+var text = (value, max) => typeof value === "string" && value.length <= max && !/[\u0000-\u001f\u007f]/.test(value);
+var digits = (value, min, max) => typeof value === "string" && value.length >= min && value.length <= max && !/[^0-9]/.test(value);
+var panLike = (value) => (value.match(/\p{Nd}/gu) ?? []).length >= 12;
+var plain = (value, max) => text(value, max) && !panLike(value);
+var TOKENEX_ID = /^[0-9]{16}$/;
+var AUTHENTICATION_KEY = /^[A-Za-z0-9+/]{43}=$/;
+var TIMESTAMP = /^20[0-9]{2}(?:0[1-9]|1[0-2])(?:0[1-9]|[12][0-9]|3[01])(?:[01][0-9]|2[0-3])[0-5][0-9][0-5][0-9]$/;
+function isOrigin(value) {
+    if (typeof value !== "string" || value.length > 255 || !value.startsWith("https://"))
+        return false;
+    try {
+        return new URL(value).origin === value;
+    }
+    catch {
+        return false;
+    }
+}
+var BOUND = {
+    TokenExID: (value) => exact(TOKENEX_ID, value),
+    Origin: isOrigin,
+    AuthenticationKey: (value) => exact(AUTHENTICATION_KEY, value),
+    Timestamp: (value) => exact(TIMESTAMP, value),
+    TokenScheme: (value) => TOKENEX_IFRAME_TOKEN_SCHEMES.includes(value)
+};
+var BOUND_KEYS = Object.keys(BOUND);
+var BOOLEAN = /^(?:true|false)$/i;
+var QUERY_RULES = {
+    ...BOUND,
+    Mode: (value) => value === "Data",
+    PCI: (value) => exact(/^true$/i, value),
+    CVV: (value) => exact(/^true$/i, value),
+    Container: (value) => exact(/^[A-Za-z][A-Za-z0-9_-]{0,63}$/, value),
+    CvvContainer: (value) => exact(/^[A-Za-z][A-Za-z0-9_-]{0,63}$/, value),
+    EnforceLuhnCompliance: (value) => exact(BOOLEAN, value),
+    CustomDataLabel: (value) => plain(value, 64),
+    CustomCvvDataLabel: (value) => plain(value, 64),
+    ExpiresInSeconds: (value) => exact(/^[1-9][0-9]{0,3}$/, value),
+    ReturnAutoCompleteValues: (value) => exact(BOOLEAN, value)
+};
+var QUERY_REQUIRED = [...BOUND_KEYS, "Mode", "PCI", "CVV"];
+function readQuery(search) {
+    if (typeof search !== "string" || !search.startsWith("?") || search.length < 2)
+        return null;
+    const query = /* @__PURE__ */ new Map();
+    for (const chunk of search.slice(1).split("&")) {
+        const eq = chunk.indexOf("=");
+        if (eq < 1)
+            return null;
+        let key, value;
+        try {
+            key = decodeURIComponent(chunk.slice(0, eq));
+            value = decodeURIComponent(chunk.slice(eq + 1));
+        }
+        catch {
+            return null;
+        }
+        if (query.has(key) || !owns(QUERY_RULES, key) || !QUERY_RULES[key](value))
+            return null;
+        query.set(key, value);
+    }
+    return QUERY_REQUIRED.every((key) => query.has(key)) ? query : null;
+}
+function tokenexIframeTarget(url) {
+    if (typeof url !== "string" || url.length > URL_LIMIT || url.includes("#"))
+        return null;
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return null;
+    }
+    if (parsed.href !== url || parsed.protocol !== "https:" || parsed.port || parsed.username || parsed.password)
+        return null;
+    if (!TOKENEX_IFRAME_HOSTS.includes(parsed.hostname) || parsed.pathname !== TOKENEX_IFRAME_PATH)
+        return null;
+    const query = readQuery(parsed.search);
+    return query ? { host: parsed.hostname, query } : null;
+}
+function isTokenexIframeUrl(url, method = "POST") {
+    return method === "POST" && tokenexIframeTarget(url) !== null;
+}
+function onIframePath(url) {
+    if (typeof url !== "string" || url.length > URL_LIMIT)
+        return false;
+    try {
+        const parsed = new URL(url);
+        return TOKENEX_IFRAME_HOSTS.includes(parsed.hostname.replace(/\.$/, "")) && parsed.pathname.toLowerCase() === TOKENEX_IFRAME_PATH;
+    }
+    catch {
+        return false;
+    }
+}
+var PLACEHOLDER = /^[0-9]{1,19}(?: [0-9]{1,19}){0,5}$/;
+var placeholderDigits = (value) => exact(PLACEHOLDER, value) && value.length <= 23 ? value.replace(/ /g, "") : null;
+var RULES = {
+    ...BOUND,
+    Data: (value) => {
+        const pan = placeholderDigits(value);
+        return pan !== null && pan.length >= 13 && pan.length <= 19;
+    },
+    CvvValue: (value) => digits(value, 3, 4),
+    CvvOnly: (value) => value === "False",
+    PCI: (value) => value === "True",
+    ReturnHash: (value) => value === null,
+    use3DS: (value) => value === "False",
+    ThreeDSMethodNotificationUrl: (value) => value === "",
+    kountSessionId: (value) => value === "",
+    fraudMerchantId: (value) => value === "",
+    UseKount: (value) => value === "False",
+    kountMode: (value) => value === "",
+    kountAnId: (value) => value === "",
+    FraudServicesRiskRequestModel: (value) => value === "",
+    EnforceLuhnCompliance: (value) => value === "true" || value === "false",
+    CustomDataLuhnCheck: (value) => value === true
+};
+function readJson(body, limit) {
+    if (typeof body !== "string" || body === "" || body.length > limit)
+        return null;
+    try {
+        const value = JSON.parse(body);
+        return record(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function judgeBody(body) {
+    const value = readJson(body, BODY_LIMIT);
+    if (!value || JSON.stringify(value) !== body)
+        return null;
+    const keys = Object.keys(value);
+    if (keys.length !== TOKENEX_IFRAME_BODY_KEYS.length || keys.some((key, index) => key !== TOKENEX_IFRAME_BODY_KEYS[index]))
+        return null;
+    return keys.every((key) => RULES[key](value[key])) ? value : null;
+}
+function tokenexIframeBodyRefusal(body) {
+    return judgeBody(body) ? null : "unsupported";
+}
+function carriesCard(body) {
+    const value = readJson(body, BODY_LIMIT * 4);
+    return value !== null && typeof value.Data === "string" && value.Data !== "";
+}
+var CONTENT_TYPE = /^application\/json(?:;\s*charset=utf-8)?$/i;
+function headersRefusal(headers) {
+    if (!record(headers))
+        return "unsupported";
+    const folded = /* @__PURE__ */ new Map();
+    for (const [name, value] of Object.entries(headers)) {
+        const lower = name.toLowerCase();
+        if (folded.has(lower) || typeof value !== "string")
+            return "unsupported";
+        folded.set(lower, value);
+    }
+    return exact(CONTENT_TYPE, folded.get("content-type")) ? null : "unsupported";
+}
+function bindingRefusal(target, value) {
+    return BOUND_KEYS.every((key) => target.query.get(key) === value[key]) ? null : "unsupported";
+}
+function tokenexIframeRequestRefusal(request) {
+    if (!record(request) || request.method !== "POST")
+        return "unsupported";
+    const target = tokenexIframeTarget(request.url);
+    if (!target)
+        return "unsupported";
+    const headers = headersRefusal(request.headers);
+    if (headers)
+        return headers;
+    const value = judgeBody(request.body);
+    return value ? bindingRefusal(target, value) : "unsupported";
+}
+function isTokenexIframeRequest(request) {
+    return tokenexIframeRequestRefusal(request) === null;
+}
+var TOKENEX_IFRAME_GATE_CODES = Object.freeze(["tokenex_iframe_url_refused", "tokenex_iframe_body_unsupported", "tokenex_iframe_query_mismatch"]);
+function tokenexIframeBodyVerdict(body, url) {
+    if (!carriesCard(body))
+        return { verdict: "continue" };
+    const target = url !== void 0 ? tokenexIframeTarget(url) : null;
+    if (url !== void 0 && !target)
+        return { verdict: "refuse", code: "tokenex_iframe_url_refused" };
+    const value = judgeBody(body);
+    if (!value)
+        return { verdict: "refuse", code: "tokenex_iframe_body_unsupported" };
+    if (target && bindingRefusal(target, value))
+        return { verdict: "refuse", code: "tokenex_iframe_query_mismatch" };
+    return { verdict: "card" };
+}
+function classifyTokenexIframeRequest(url, method, body, headers) {
+    if (method !== "POST" || !onIframePath(url) || !carriesCard(body))
+        return null;
+    return tokenexIframeRequestRefusal({ url, method, body, headers }) ?? "card";
+}
+function tokenexIframeAccount(request) {
+    if (tokenexIframeRequestRefusal(request) !== null)
+        return null;
+    const value = judgeBody(request.body);
+    return { host: tokenexIframeTarget(request.url).host, tokenExId: value.TokenExID, origin: value.Origin };
+}
+function tokenexIframeAccountRefusal(request, accounts = TOKENEX_IFRAME_REVIEWED_ACCOUNTS) {
+    const account = tokenexIframeAccount(request);
+    if (!account)
+        return "unreviewed_account";
+    const listed = record(accounts) && owns(accounts, account.host) && record(accounts[account.host]) ? accounts[account.host] : null;
+    return listed && owns(listed, account.tokenExId) && listed[account.tokenExId] === account.origin ? null : "unreviewed_account";
+}
+function tokenexIframeAccountName(request, accounts = TOKENEX_IFRAME_REVIEWED_ACCOUNTS, names = TOKENEX_IFRAME_ACCOUNT_NAMES) {
+    if (tokenexIframeAccountRefusal(request, accounts) !== null)
+        return null;
+    const { host, tokenExId } = tokenexIframeAccount(request);
+    const named = record(names) && owns(names, host) && record(names[host]) ? names[host] : null;
+    const name = named && owns(named, tokenExId) ? named[tokenExId] : null;
+    return typeof name === "string" && name.trim() !== "" && plain(name, 64) ? name : null;
+}
+var CARD_TYPES = [
+    ["visa", /^4\d{12}(\d{3})?(\d{3})?$/],
+    ["masterCard", /^(5[1-5]\d{4}|677189|222[1-9]\d{2}|22[3-9]\d{3}|2[3-6]\d{4}|27[01]\d{3}|2720\d{2})\d{10,13}$/],
+    ["americanExpress", /^3[47]\d{13,17}$/]
+];
+var CVV_LENGTH = { visa: 3, masterCard: 3, americanExpress: 4 };
+function tokenexIframeCardType(number) {
+    if (!digits(number, 13, 19))
+        return null;
+    for (const [type, pattern] of CARD_TYPES)
+        if (pattern.test(number))
+            return type;
+    return null;
+}
+function tokenexIframeBrandRefusal(body, card) {
+    const value = judgeBody(body);
+    if (!value)
+        return "unsupported";
+    const placeholder = tokenexIframeCardType(placeholderDigits(value.Data));
+    const real = tokenexIframeCardType(card && card.number);
+    return placeholder !== null && placeholder === real ? null : "brand_mismatch";
+}
+function tokenexIframeDeviceRefusal(request, card, accounts = TOKENEX_IFRAME_REVIEWED_ACCOUNTS) {
+    const refusal = tokenexIframeRequestRefusal(request);
+    if (refusal)
+        return refusal;
+    if (record(card) && digits(card.number, 13, 19) && tokenexIframeBrandRefusal(request.body, card) !== null)
+        return "brand_mismatch";
+    return tokenexIframeAccountRefusal(request, accounts);
+}
+function tokenexIframeRefusalMessage(reason) {
+    if (reason === "brand_mismatch")
+        return BRAND_MISMATCH_REFUSAL;
+    if (reason === "unreviewed_account")
+        return UNREVIEWED_ACCOUNT_REFUSAL;
+    return UNSUPPORTED_REFUSAL;
+}
+function injectTokenexIframeCard(body, card) {
+    const value = judgeBody(body);
+    if (!value)
+        throw new Error(UNSUPPORTED_REFUSAL);
+    if (!record(card) || !digits(card.number, 13, 19))
+        throw new Error(FILL_REFUSAL);
+    if (tokenexIframeBrandRefusal(body, card) !== null)
+        throw new Error(BRAND_MISMATCH_REFUSAL);
+    if (!digits(card.cvc, 3, 4) || card.cvc.length !== CVV_LENGTH[tokenexIframeCardType(card.number)])
+        throw new Error(FILL_REFUSAL);
+    return { body: JSON.stringify({ ...value, Data: card.number, CvvValue: card.cvc }), where: ["Data", "CvvValue"] };
+}
+function isTokenexIframeDeviceRequest(templateBody, deviceBody) {
+    const template = judgeBody(templateBody);
+    const device = judgeBody(deviceBody);
+    if (!template || !device || device.Data === placeholderDigits(template.Data))
+        return false;
+    try {
+        return injectTokenexIframeCard(templateBody, { number: device.Data, cvc: device.CvvValue }).body === deviceBody;
+    }
+    catch {
+        return false;
+    }
+}
+var SUCCESS_RULES = {
+    token: (value) => digits(value, 13, 19),
+    firstSix: (value) => digits(value, 6, 6),
+    lastFour: (value) => digits(value, 4, 4),
+    referenceNumber: (value) => exact(/^[A-Za-z0-9-]{1,64}$/, value),
+    tokenHMAC: (value) => exact(/^[A-Za-z0-9+/]{1,128}={0,2}$/, value),
+    cvvIncluded: (value) => typeof value === "boolean"
+};
+var SUCCESS_KEYS = Object.keys(SUCCESS_RULES);
+var ERROR_CODES = [
+    [/^Invalid Card Number\b/, "invalid_card_number"],
+    [/^Invalid Authentication Key\b/, "invalid_authentication_key"]
+];
+function rebuildSuccess(value) {
+    if (!owns(value, "token"))
+        return { reason: "tokenex_iframe_no_token" };
+    const answer = {};
+    for (const key of SUCCESS_KEYS) {
+        if (!owns(value, key))
+            continue;
+        if (!SUCCESS_RULES[key](value[key]))
+            return { reason: key === "token" ? "tokenex_iframe_unexpected_token" : "tokenex_iframe_unexpected_field" };
+        answer[key] = value[key];
+    }
+    return { answer };
+}
+function rebuildError(value) {
+    if (owns(value, "token") || !plain(value.error, 256) || value.error.trim() === "")
+        return null;
+    if (owns(value, "referenceNumber") && !SUCCESS_RULES.referenceNumber(value.referenceNumber))
+        return null;
+    return owns(value, "referenceNumber") ? { error: value.error, referenceNumber: value.referenceNumber } : { error: value.error };
+}
+function tokenexIframeErrorCode(message) {
+    for (const [pattern, code] of ERROR_CODES)
+        if (typeof message === "string" && pattern.test(message))
+            return code;
+    return "tokenex_iframe_error";
+}
+function tokenexIframeResponseOutcome(status, body, card) {
+    if (status !== 200)
+        return { outcome: "unknown", reason: "tokenex_iframe_status_unconfirmed" };
+    const value = readJson(body, RESPONSE_LIMIT);
+    if (!value)
+        return { outcome: "unknown", reason: "tokenex_iframe_unreadable" };
+    if (owns(value, "error")) {
+        const error = rebuildError(value);
+        return error ? { outcome: "refused", code: tokenexIframeErrorCode(error.error) } : { outcome: "unknown", reason: "tokenex_iframe_unexpected_error" };
+    }
+    const { answer, reason } = rebuildSuccess(value);
+    if (!answer)
+        return { outcome: "unknown", reason };
+    if (record(card) && digits(card.number, 13, 19)) {
+        const number = card.number;
+        const sixTokenFour = answer.token.length === number.length && answer.token.startsWith(number.slice(0, 6)) && answer.token.endsWith(number.slice(-4));
+        if (!sixTokenFour || answer.token.includes(number) || (answer.referenceNumber ?? "").includes(number) || owns(answer, "firstSix") && answer.firstSix !== number.slice(0, 6) || owns(answer, "lastFour") && answer.lastFour !== number.slice(-4)) {
+            return { outcome: "unknown", reason: "tokenex_iframe_token_mismatch" };
+        }
+    }
+    return { outcome: "approved" };
+}
+function sanitizeTokenexIframeResponse(body) {
+    const value = readJson(body, RESPONSE_LIMIT);
+    const fail = () => {
+        throw new Error("Invalid TokenEx tokenization response.");
+    };
+    if (!value)
+        return fail();
+    if (owns(value, "error"))
+        return JSON.stringify(rebuildError(value) ?? fail());
+    return JSON.stringify(rebuildSuccess(value).answer ?? fail());
+}
+function tokenexIframeFacts(status, body) {
+    const verdict = tokenexIframeResponseOutcome(status, body);
+    return { outcome: verdict.outcome, refusalCode: verdict.outcome === "refused" ? verdict.code : null };
+}
+export { TOKENEX_IFRAME_ACCOUNT_NAMES, TOKENEX_IFRAME_BODY_KEYS, TOKENEX_IFRAME_CAPABILITY, TOKENEX_IFRAME_GATE_CODES, TOKENEX_IFRAME_HOSTS, TOKENEX_IFRAME_OPERATION, TOKENEX_IFRAME_PATH, TOKENEX_IFRAME_PSP, TOKENEX_IFRAME_REFUSAL_REASONS, TOKENEX_IFRAME_REVIEWED_ACCOUNTS, TOKENEX_IFRAME_TOKEN_SCHEMES, classifyTokenexIframeRequest, injectTokenexIframeCard, isTokenexIframeDeviceRequest, isTokenexIframeRequest, isTokenexIframeUrl, sanitizeTokenexIframeResponse, tokenexIframeAccount, tokenexIframeAccountName, tokenexIframeAccountRefusal, tokenexIframeBodyRefusal, tokenexIframeBodyVerdict, tokenexIframeBrandRefusal, tokenexIframeCardType, tokenexIframeDeviceRefusal, tokenexIframeErrorCode, tokenexIframeFacts, tokenexIframeRefusalMessage, tokenexIframeRequestRefusal, tokenexIframeResponseOutcome, tokenexIframeTarget };