@agent-cards/sdk 0.21.0 → 0.22.0

package/dist/cse-body.js

@@ -3,6 +3,7 @@
 import { substituteEncryptedFields } from './substitute.js';
 import { substituteMerchantHostedBody } from './merchant-hosted.js';
 import { fiservCapturePinId, isFiservCaptureHost, substituteFiservEnvelope } from './fiserv.js';
+import { substituteVerifoneBody } from './verifone.js';
 /**
  * The cse continuation: the paused body with the vault's ciphertext in place
  * of the dummy blobs. The adapters send it as postData ALONE. Chromium
@@ -25,8 +26,17 @@ import { fiservCapturePinId, isFiservCaptureHost, substituteFiservEnvelope } fro
  * a Fiserv capture host. Every refusal throws before anything is sent.
  */
 export function cseBody(body, replay, url, preparation) {
+    // A Verifone approval is always a prepared one for the profile it pays, and continues only the
+    // leg that profile reviewed, with the device's blob written into the LIVE paused body, which
+    // must still be the body the API checked at create (verifone.ts).
+    if (preparation?.psp === 'verifone' || replay.kind === 'verifone') {
+        if (replay.kind !== 'verifone' || preparation?.psp !== 'verifone' || preparation.merchantProfile !== replay.profile) {
+            throw new Error('Refusing to substitute: the paused request is not the Verifone card request the cardholder approved.');
+        }
+        return substituteVerifoneBody({ url, method: 'POST', body }, replay);
+    }
     if (preparation?.psp === 'fiserv') {
-        if (replay.kind === 'merchant_hosted' || !isFiservCaptureHost(url) || fiservCapturePinId(url, body) !== preparation.merchantProfile) {
+        if (replay.kind !== undefined || !isFiservCaptureHost(url) || fiservCapturePinId(url, body) !== preparation.merchantProfile) {
             throw new Error('Refusing to substitute: the paused request is not a Fiserv capture under the key pin the cardholder approved.');
         }
         return substituteFiservEnvelope(body, replay.substitutions);

package/dist/datatrans.d.ts

@@ -0,0 +1,96 @@
+import { DATATRANS_CARD_ON_FILE_REFUSED, DATATRANS_INVALID_REQUEST } from './datatrans.generated.js';
+import type { ReplayResponse } from './client.js';
+export declare const DATATRANS_PSP = "datatrans";
+/** The dark-launch capability the API serves the datatrans recognizer behind. */
+export declare const DATATRANS_CAPABILITY = "datatrans_secure_fields_tokenize";
+/**
+ * Why the SDK refuses a Datatrans card post before anything is claimed, created or prompted. The
+ * API answers the same two codes at create, so a refusal here only saves the round trip:
+ *   - `invalid_datatrans_request`: not a sound Secure Fields TOKENIZE card post. That covers
+ *     another mode, a payment or 3-D Secure post (`transactionId`, `3D`, `dccSelected`), a key
+ *     field.js never sends, a URL variant (a query, a case or dot spelling) or a content type that
+ *     is not jQuery's form type. The cardholder's device could never fill it.
+ *   - `datatrans_card_on_file_refused`: a sound post that asks PCI Proxy to keep the card on file
+ *     (usage=REGISTRATION: a reusable alias plus a network token, so the merchant could charge the
+ *     card again later), while the card-on-file policy the API served refuses that
+ *     (datatransCardOnFilePolicy). British Airways's Nexus checkout sends it for every new card.
+ */
+export type DatatransRefusalReason = typeof DATATRANS_INVALID_REQUEST | typeof DATATRANS_CARD_ON_FILE_REFUSED;
+/** True when the URL's host is one of Datatrans's two pay hosts. */
+export declare function isDatatransHost(url: string): boolean;
+/**
+ * The card-on-file policy this build applies to a Datatrans card post: the one the API served with
+ * the datatrans recognizer (Recognizer.cardOnFile, VaultClient.cardOnFilePolicy) when payment-core
+ * defines it (`refuse`, `disclose`, `agentcard_single_use`), and `refuse` for anything else, an entry
+ * that names none included. The decision is payment-core's DATATRANS_REGISTRATION_POLICY, which the
+ * API reads each time it serves the catalog and again at create, so a change to that one line
+ * reaches every build already published at its next syncRegistry(), with no SDK release.
+ */
+export declare function datatransCardOnFilePolicy(served: unknown): string;
+/**
+ * The pause decision for a POST the registry recognized on a Datatrans pay host, by payment-core's
+ * classifyDatatransRequest under the card-on-file policy the API served (datatransCardOnFilePolicy):
+ *   'card'  the exact card URL with jQuery's form type and a sound TOKENIZE card body: it pauses. A
+ *           usage=REGISTRATION post is one too once the served policy allows card on file, and the
+ *           API and the cardholder's device then apply that policy;
+ *   a DatatransRefusalReason: it is refused in the browser;
+ *   null    no card in the body (a wallet, bank-account or CVV-only post) or not the card path:
+ *           the SDK's ordinary handling decides, and such a post continues untouched.
+ */
+export declare function datatransPauseDecision(request: {
+    url: string;
+    headers: Record<string, string>;
+    body: string | null;
+}, servedPolicy?: unknown): 'card' | DatatransRefusalReason | null;
+/**
+ * How long an approved Datatrans answer is replayed to its own frame: the token's own lifetime
+ * (PCI Proxy keeps a tokenization readable for 30 minutes). Past it the stored transactionId names a
+ * token the merchant can no longer read, so a later post is a new question.
+ */
+export declare const DATATRANS_REPEAT_WINDOW_MS: number;
+/**
+ * How long a stored answer waits for its form's next post. British Airways re-submits while the agent
+ * finishes the card form, right after the approved answer. A form that posts nothing for this long has
+ * moved on: the order was placed or abandoned, which the SDK cannot tell apart without reconcile(). Its
+ * next post is a new approval. Each answered re-submit restarts the wait, and the token's lifetime
+ * still ends every answer.
+ */
+export declare const DATATRANS_REPEAT_IDLE_MS: number;
+/** A stored answer handed to a repeat, with the approval it came from. */
+export interface DatatransRepeatAnswer {
+    authorizationId: string;
+    response: {
+        status: number;
+        headers: Record<string, string>;
+        body: string;
+    };
+}
+/**
+ * The approved Datatrans answers one attachment handed to a card post, per frame. `frame` is the
+ * adapter's identity for the request's frame (the CDP frameId, the Playwright Frame); a request
+ * whose frame is unknown is never remembered and never answered. Only an answer payment-core reads
+ * as approved ({transactionId, cardInfo}) is kept: an error answer leaves the next post a new
+ * question, so the page can try again.
+ */
+export declare class DatatransRepeats {
+    private readonly windowMs;
+    private readonly now;
+    private readonly idleMs;
+    private remembered;
+    constructor(windowMs?: number, now?: () => number, idleMs?: number);
+    /**
+     * Keep the answer a token replay handed to this card post, when Datatrans 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 a repeat of an answered card post from the same frame, 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. An answer whose form stayed quiet past the idle bound is dropped too, and
+     * handing one out restarts that bound.
+     */
+    answerFor(frame: unknown, url: string, body: string | null, authorizationId: string | null): DatatransRepeatAnswer | null;
+    private prune;
+}

package/dist/datatrans.generated.d.ts

@@ -0,0 +1,64 @@
+declare var DATATRANS_HOSTS: readonly string[];
+declare var DATATRANS_TOKENIZE_PATH: string;
+declare var DATATRANS_REFUSAL_REASONS: readonly string[];
+declare var DATATRANS_INVALID_REQUEST: string;
+declare var DATATRANS_CARD_ON_FILE_REFUSED: string;
+declare var DATATRANS_REGISTRATION_POLICIES: readonly string[];
+declare var DATATRANS_REGISTRATION_POLICY: string;
+declare var DATATRANS_REVIEWED_MERCHANT_IDS: Readonly<{
+    "pay.datatrans.com": readonly never[];
+    "pay.sandbox.datatrans.com": readonly string[];
+}>;
+declare var DATATRANS_PAYMENT_METHODS: readonly string[];
+declare var DATATRANS_TEST_PANS: readonly string[];
+declare function encodeDatatransFormValue(value: any): string;
+declare function parseDatatransForm(body: any): {
+    key: string;
+    value: string;
+    rawKey: string;
+    raw: string;
+}[] | null;
+declare function serializeDatatransForm(pairs: any): any;
+declare function isDatatransTokenizeUrl(url: any, method?: string): boolean;
+declare function datatransRegistrationRefusal(usage: any, card: any, policy?: string): "card_on_file" | null;
+declare function datatransCardOnFileDisclosure(body: any, policy?: string): boolean;
+declare function datatransBodyRefusal(body: any, card: any, policy?: string): "unsupported" | "card_on_file" | null;
+declare function datatransMerchantId(body: any): string | null | undefined;
+declare function classifyDatatransRequest(url: any, method: any, body: any, headers: any, policy?: string): "card" | "unsupported" | "card_on_file" | null;
+declare function datatransTokenizeRefusal(request: any, card: any, policy?: string): "unsupported" | "card_on_file" | null;
+declare function isDatatransTokenizeRequest(request: any, card: any): boolean;
+declare function datatransMerchantRefusal(url: any, body: any, merchants?: Readonly<{
+    "pay.datatrans.com": readonly never[];
+    "pay.sandbox.datatrans.com": readonly string[];
+}>): "unregistered_merchant" | null;
+declare function datatransDeviceRefusal(request: any, card: any, policy?: string, merchants?: Readonly<{
+    "pay.datatrans.com": readonly never[];
+    "pay.sandbox.datatrans.com": readonly string[];
+}>): "unsupported" | "card_on_file" | "brand_mismatch" | "unregistered_merchant" | null;
+declare function datatransRefusalMessage(reason: any): string;
+declare function datatransCardBrand(number: any): "VIS" | "ECA" | "AMX" | null;
+declare function datatransBrandRefusal(body: any, card: any): "unsupported" | "brand_mismatch" | null;
+declare function injectDatatransCard(body: any, card: any, policy?: string): {
+    body: string;
+    where: string[];
+};
+declare function datatransErrorCode(message: any): string | RegExp;
+declare function datatransResponseOutcome(status: any, body: any, card: any): {
+    outcome: string;
+    reason: string;
+    code?: undefined;
+} | {
+    outcome: string;
+    code: string | RegExp;
+    reason?: undefined;
+} | {
+    outcome: string;
+    reason?: undefined;
+    code?: undefined;
+};
+declare function sanitizeDatatransTokenResponse(body: any): string;
+declare function datatransFacts(status: any, body: any): {
+    outcome: string;
+    refusalCode: string | RegExp | null | undefined;
+};
+export { DATATRANS_CARD_ON_FILE_REFUSED, DATATRANS_HOSTS, DATATRANS_INVALID_REQUEST, DATATRANS_PAYMENT_METHODS, DATATRANS_REFUSAL_REASONS, DATATRANS_REGISTRATION_POLICIES, DATATRANS_REGISTRATION_POLICY, DATATRANS_REVIEWED_MERCHANT_IDS, DATATRANS_TEST_PANS, DATATRANS_TOKENIZE_PATH, classifyDatatransRequest, datatransBodyRefusal, datatransBrandRefusal, datatransCardBrand, datatransCardOnFileDisclosure, datatransDeviceRefusal, datatransErrorCode, datatransFacts, datatransMerchantId, datatransMerchantRefusal, datatransRefusalMessage, datatransRegistrationRefusal, datatransResponseOutcome, datatransTokenizeRefusal, encodeDatatransFormValue, injectDatatransCard, isDatatransTokenizeRequest, isDatatransTokenizeUrl, parseDatatransForm, sanitizeDatatransTokenResponse, serializeDatatransForm };

package/dist/datatrans.generated.js

@@ -0,0 +1,426 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: 0179250ba6f44c33967a08dc4ce3a891d8b73f0f7eb60e9cab34f801dc2a4c57
+// src/datatrans.js
+var DATATRANS_HOSTS = Object.freeze(["pay.datatrans.com", "pay.sandbox.datatrans.com"]);
+var DATATRANS_TOKENIZE_PATH = "/upp/payment/SecureFields/paymentField";
+var DATATRANS_REFUSAL_REASONS = Object.freeze(["unsupported", "card_on_file", "brand_mismatch", "unregistered_merchant"]);
+var DATATRANS_INVALID_REQUEST = "invalid_datatrans_request";
+var DATATRANS_CARD_ON_FILE_REFUSED = "datatrans_card_on_file_refused";
+var DATATRANS_REGISTRATION_POLICIES = Object.freeze(["refuse", "disclose", "agentcard_single_use"]);
+var DATATRANS_REGISTRATION_POLICY = "refuse";
+var DATATRANS_REVIEWED_MERCHANT_IDS = Object.freeze({
+    "pay.datatrans.com": Object.freeze([]),
+    "pay.sandbox.datatrans.com": Object.freeze(["1110022968", "1100007006"])
+});
+var DATATRANS_PAYMENT_METHODS = Object.freeze(["VIS", "ECA", "AMX", "DIN", "DIS", "JCB", "CUP", "MAU", "UAP", "DNK"]);
+var DATATRANS_TEST_PANS = Object.freeze([
+    "4242424242424242",
+    "4900000000000086",
+    "4900000000000003",
+    "5404000000000001",
+    "5200000000000007",
+    "5200000000000080",
+    "375811111111115",
+    "375000000000007",
+    "375811111111123",
+    "36168002586009",
+    "36167719110012",
+    "6011000000000004",
+    "3569990010030442",
+    "3569990010030400",
+    "6362970000457013",
+    "3841000000000007",
+    "6200104444444447",
+    "6210946888060008",
+    "6759000000000018",
+    "6759000000000026",
+    "4000001000000034",
+    "4000001000000018",
+    "4000001000000042",
+    "4000001000000026",
+    "5100001000000022",
+    "5100001000000048",
+    "5100001000000014",
+    "5100001000000030",
+    "340000100000024",
+    "340000100000040",
+    "340000100000016",
+    "340000100000032",
+    "36000010000022",
+    "3550998599961037"
+]);
+var UNSUPPORTED_REFUSAL = "Refusing to pay: unsupported Datatrans card request.";
+var CARD_ON_FILE_REFUSAL = "Refusing to pay: this Datatrans payment would let the merchant keep your card on file, which needs your consent first. Nothing was sent.";
+var BRAND_MISMATCH_REFUSAL = "Refusing to pay: this Datatrans payment names a card brand that is not your card's. Nothing was sent.";
+var UNREGISTERED_MERCHANT_REFUSAL = "Refusing to pay: this Datatrans payment goes to a merchant account Agentcard has not reviewed. Nothing was sent.";
+var FILL_REFUSAL = "Could not fill the card fields for Datatrans. Nothing was sent.";
+var BODY_LIMIT = 8192;
+var RESPONSE_LIMIT = 4096;
+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);
+function encodeDatatransFormValue(value) {
+    return encodeURIComponent(String(value)).replace(/%20/g, "+");
+}
+function decodeFormComponent(raw) {
+    try {
+        return decodeURIComponent(raw.replace(/\+/g, " "));
+    }
+    catch {
+        return null;
+    }
+}
+function parseDatatransForm(body) {
+    if (typeof body !== "string" || body === "" || body.length > BODY_LIMIT)
+        return null;
+    const pairs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const chunk of body.split("&")) {
+        const eq = chunk.indexOf("=");
+        if (eq < 1)
+            return null;
+        const rawKey = chunk.slice(0, eq), raw = chunk.slice(eq + 1);
+        const key = decodeFormComponent(rawKey), value = decodeFormComponent(raw);
+        if (key === null || value === null || seen.has(key))
+            return null;
+        try {
+            if (encodeDatatransFormValue(key) !== rawKey || encodeDatatransFormValue(value) !== raw)
+                return null;
+        }
+        catch {
+            return null;
+        }
+        seen.add(key);
+        pairs.push({ key, value, rawKey, raw });
+    }
+    return pairs;
+}
+function serializeDatatransForm(pairs) {
+    return pairs.map(({ key, value }) => `${encodeDatatransFormValue(key)}=${encodeDatatransFormValue(value)}`).join("&");
+}
+function isDatatransTokenizeUrl(url, method = "POST") {
+    if (method !== "POST" || typeof url !== "string" || url.length > 256 || url.includes("?") || url.includes("#"))
+        return false;
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    return parsed.href === url && parsed.protocol === "https:" && !parsed.port && !parsed.username && !parsed.password && DATATRANS_HOSTS.includes(parsed.hostname) && parsed.pathname === DATATRANS_TOKENIZE_PATH;
+}
+function onPaymentFieldPath(url) {
+    if (typeof url !== "string" || url.length > 2048)
+        return false;
+    try {
+        const parsed = new URL(url);
+        return DATATRANS_HOSTS.includes(parsed.hostname.replace(/\.$/, "")) && parsed.pathname.toLowerCase() === DATATRANS_TOKENIZE_PATH.toLowerCase();
+    }
+    catch {
+        return false;
+    }
+}
+var KEYS = /* @__PURE__ */ new Set([
+    "mode",
+    "formId",
+    "cardNumber",
+    "cvv",
+    "iban",
+    "accountNumber",
+    "branchCode",
+    "paymentMethod",
+    "countryCode",
+    "merchantId",
+    "expy",
+    "expm",
+    "email",
+    "phoneNumber",
+    "usage",
+    "3D",
+    "browserUserAgent",
+    "browserJavaEnabled",
+    "browserLanguage",
+    "browserColorDepth",
+    "browserScreenHeight",
+    "browserScreenWidth",
+    "browserTZ"
+]);
+var REQUIRED = ["mode", "formId", "cardNumber", "paymentMethod", "merchantId", "expy", "expm"];
+var EMPTY_ONLY = /* @__PURE__ */ new Set(["iban", "accountNumber", "branchCode", "countryCode", "3D"]);
+var RULES = {
+    mode: (value) => value === "TOKENIZE",
+    formId: (value) => exact(/^[0-9]{18}$/, value),
+    cardNumber: (value) => digits(value, 12, 19),
+    cvv: (value) => value === "" || digits(value, 3, 4),
+    paymentMethod: (value) => DATATRANS_PAYMENT_METHODS.includes(value),
+    merchantId: (value) => exact(/^[0-9]{10}$/, value),
+    expm: (value) => exact(/^(?:0?[1-9]|1[0-2])$/, value),
+    expy: (value) => exact(/^(?:[0-9]{2}|20[0-9]{2})$/, value),
+    usage: (value) => value === "" || value === "SIMPLE" || value === "REGISTRATION",
+    email: (value) => value === "" || text(value, 254) && exact(/^[^\s@]{1,64}@[^\s@]{1,189}$/, value),
+    phoneNumber: (value) => value === "" || exact(/^\+?[0-9 ()./-]{1,32}$/, value),
+    browserUserAgent: (value) => value !== "" && text(value, 1024),
+    browserJavaEnabled: (value) => value === "true" || value === "false",
+    browserLanguage: (value) => value === "" || exact(/^[A-Za-z]{1,8}(?:-[A-Za-z0-9]{1,8}){0,4}$/, value),
+    browserColorDepth: (value) => exact(/^[0-9]{1,3}$/, value),
+    browserScreenHeight: (value) => exact(/^[0-9]{1,5}$/, value),
+    browserScreenWidth: (value) => exact(/^[0-9]{1,5}$/, value),
+    browserTZ: (value) => exact(/^-?[0-9]{1,4}$/, value)
+};
+function judgeBody(body) {
+    const pairs = parseDatatransForm(body);
+    if (!pairs)
+        return null;
+    const fields = new Map(pairs.map(({ key, value }) => [key, value]));
+    for (const [key, value] of fields) {
+        if (!KEYS.has(key))
+            return null;
+        if (EMPTY_ONLY.has(key) ? value !== "" : !RULES[key](value))
+            return null;
+    }
+    if (!REQUIRED.every((key) => fields.has(key)))
+        return null;
+    return { pairs, fields, usage: fields.get("usage") ?? "" };
+}
+function datatransRegistrationRefusal(usage, card, policy = DATATRANS_REGISTRATION_POLICY) {
+    if (usage !== "REGISTRATION")
+        return null;
+    if (policy !== "disclose" && policy !== "agentcard_single_use")
+        return "card_on_file";
+    if (card === void 0)
+        return null;
+    if (!record(card) || card.cardOnFileConsent !== true)
+        return "card_on_file";
+    return policy === "agentcard_single_use" && card.agentcardSingleUse !== true ? "card_on_file" : null;
+}
+function datatransCardOnFileDisclosure(body, policy = DATATRANS_REGISTRATION_POLICY) {
+    const judged = judgeBody(body);
+    return judged !== null && judged.usage === "REGISTRATION" && (policy === "disclose" || policy === "agentcard_single_use");
+}
+function datatransBodyRefusal(body, card, policy = DATATRANS_REGISTRATION_POLICY) {
+    const judged = judgeBody(body);
+    if (!judged)
+        return "unsupported";
+    return datatransRegistrationRefusal(judged.usage, card, policy);
+}
+function datatransMerchantId(body) {
+    const judged = judgeBody(body);
+    return judged ? judged.fields.get("merchantId") : null;
+}
+function carriesCard(body) {
+    if (typeof body !== "string" || body === "")
+        return false;
+    for (const chunk of body.split("&")) {
+        const eq = chunk.indexOf("=");
+        if (eq <= 0 || eq === chunk.length - 1)
+            continue;
+        if (decodeFormComponent(chunk.slice(0, eq)) === "cardNumber")
+            return true;
+    }
+    return false;
+}
+var CONTENT_TYPE = /^application\/x-www-form-urlencoded(?:;\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 classifyDatatransRequest(url, method, body, headers, policy = DATATRANS_REGISTRATION_POLICY) {
+    if (method !== "POST" || !onPaymentFieldPath(url) || !carriesCard(body))
+        return null;
+    if (!isDatatransTokenizeUrl(url))
+        return "unsupported";
+    return headersRefusal(headers) ?? datatransBodyRefusal(body, void 0, policy) ?? "card";
+}
+function datatransTokenizeRefusal(request, card, policy = DATATRANS_REGISTRATION_POLICY) {
+    if (!record(request) || request.method !== "POST" || !isDatatransTokenizeUrl(request.url))
+        return "unsupported";
+    return headersRefusal(request.headers) ?? datatransBodyRefusal(request.body, card, policy);
+}
+function isDatatransTokenizeRequest(request, card) {
+    return datatransTokenizeRefusal(request, card) === null;
+}
+function datatransMerchantRefusal(url, body, merchants = DATATRANS_REVIEWED_MERCHANT_IDS) {
+    const merchantId = datatransMerchantId(body);
+    let host = "";
+    try {
+        host = new URL(url).hostname;
+    }
+    catch {
+        return "unregistered_merchant";
+    }
+    const listed = record(merchants) && owns(merchants, host) && Array.isArray(merchants[host]) ? merchants[host] : [];
+    return merchantId !== null && listed.includes(merchantId) ? null : "unregistered_merchant";
+}
+function datatransDeviceRefusal(request, card, policy = DATATRANS_REGISTRATION_POLICY, merchants = DATATRANS_REVIEWED_MERCHANT_IDS) {
+    const refusal = datatransTokenizeRefusal(request, card, policy);
+    if (refusal)
+        return refusal;
+    if (record(card) && digits(card.number, 12, 19) && datatransBrandRefusal(request.body, card) !== null)
+        return "brand_mismatch";
+    return datatransMerchantRefusal(request.url, request.body, merchants);
+}
+function datatransRefusalMessage(reason) {
+    if (reason === "card_on_file")
+        return CARD_ON_FILE_REFUSAL;
+    if (reason === "brand_mismatch")
+        return BRAND_MISMATCH_REFUSAL;
+    if (reason === "unregistered_merchant")
+        return UNREGISTERED_MERCHANT_REFUSAL;
+    return UNSUPPORTED_REFUSAL;
+}
+function datatransCardBrand(number) {
+    if (!digits(number, 12, 19))
+        return null;
+    const two = Number(number.slice(0, 2));
+    const four = Number(number.slice(0, 4));
+    if (number[0] === "4")
+        return "VIS";
+    if (two >= 51 && two <= 55 || four >= 2221 && four <= 2720)
+        return "ECA";
+    if (two === 34 || two === 37)
+        return "AMX";
+    return null;
+}
+function datatransBrandRefusal(body, card) {
+    const judged = judgeBody(body);
+    if (!judged)
+        return "unsupported";
+    const brand = datatransCardBrand(card && card.number);
+    return brand !== null && brand === judged.fields.get("paymentMethod") ? null : "brand_mismatch";
+}
+function injectDatatransCard(body, card, policy = DATATRANS_REGISTRATION_POLICY) {
+    const judged = judgeBody(body);
+    if (!judged)
+        throw new Error(UNSUPPORTED_REFUSAL);
+    if (datatransRegistrationRefusal(judged.usage, card ?? null, policy) !== null)
+        throw new Error(CARD_ON_FILE_REFUSAL);
+    const month = card && (Number.isInteger(card.month) || digits(card.month, 1, 2)) ? Number(card.month) : NaN;
+    const year = card && (Number.isInteger(card.year) || digits(card.year, 2, 4)) ? Number(card.year) : NaN;
+    if (!card || !digits(card.number, 12, 19) || !(month >= 1 && month <= 12) || !(year >= 0 && year <= 99 || year >= 2e3 && year <= 2099)) {
+        throw new Error(FILL_REFUSAL);
+    }
+    if (datatransBrandRefusal(body, card) !== null)
+        throw new Error(BRAND_MISMATCH_REFUSAL);
+    const fields = judged.fields;
+    if (!fields.get("cvv") || !digits(card.cvc, 3, 4))
+        throw new Error(FILL_REFUSAL);
+    const yy = String(year % 100).padStart(2, "0");
+    const values = {
+        cardNumber: card.number,
+        cvv: card.cvc,
+        expm: fields.get("expm").length === 2 ? String(month).padStart(2, "0") : String(month),
+        expy: fields.get("expy").length === 4 ? `20${yy}` : yy
+    };
+    const written = judged.pairs.map((pair) => owns(values, pair.key) ? `${pair.rawKey}=${encodeDatatransFormValue(values[pair.key])}` : `${pair.rawKey}=${pair.raw}`);
+    return { body: written.join("&"), where: ["cardNumber", "cvv", "expm", "expy"] };
+}
+var TRANSACTION_ID = /^[0-9]{18}$/;
+var CARD_WORD = /^[A-Za-z][A-Za-z _-]{0,31}$/;
+var COUNTRY = /^[A-Z]{2}$/;
+var CARD_INFO_KEYS = ["brand", "type", "usage", "country", "issuer", "coBrand"];
+var UNFOLLOWED_KEYS = ["tds2EnrollmentResult", "redirect", "dcc", "mcp"];
+var ERROR_CODES = [
+    [/^Invalid merchantId$/, "invalid_merchant_id"],
+    [/^Invalid merchant setup\b/, "invalid_merchant_setup"],
+    [/^Invalid field$/, "invalid_field"],
+    [/^Field .{1,64} not allowed for (?:alias version|mode) /, "field_not_allowed"],
+    [/^Invalid session$/, "invalid_session"],
+    [/^Too many requests$/, "too_many_requests"]
+];
+function readAnswer(body) {
+    if (typeof body !== "string" || body === "" || body.length > RESPONSE_LIMIT)
+        return null;
+    try {
+        const value = JSON.parse(body);
+        return record(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+var optionalText = (value, pattern) => value === null || exact(pattern, value);
+function rebuildCardInfo(info) {
+    if (!record(info) || !Object.keys(info).every((key) => CARD_INFO_KEYS.includes(key)) || !exact(CARD_WORD, info.brand))
+        return null;
+    if (owns(info, "type") && !optionalText(info.type, CARD_WORD) || owns(info, "usage") && !optionalText(info.usage, CARD_WORD) || owns(info, "country") && !optionalText(info.country, COUNTRY) || owns(info, "issuer") && info.issuer !== null && !plain(info.issuer, 128) || owns(info, "coBrand") && info.coBrand !== null && !plain(info.coBrand, 64))
+        return null;
+    const safe = {};
+    for (const key of CARD_INFO_KEYS)
+        if (owns(info, key))
+            safe[key] = info[key];
+    return safe;
+}
+function rebuildSuccess(value) {
+    if (Object.keys(value).length !== 2 || !exact(TRANSACTION_ID, value.transactionId))
+        return null;
+    const cardInfo = rebuildCardInfo(value.cardInfo);
+    return cardInfo ? { transactionId: value.transactionId, cardInfo } : null;
+}
+function rebuildError(value) {
+    return Object.keys(value).length === 1 && plain(value.error, 256) && value.error.trim() !== "" ? { error: value.error } : null;
+}
+function datatransErrorCode(message) {
+    for (const [pattern, code] of ERROR_CODES)
+        if (typeof message === "string" && pattern.test(message))
+            return code;
+    return "datatrans_error";
+}
+function datatransResponseOutcome(status, body, card) {
+    if (status === 408 || status === 429)
+        return { outcome: "unknown", reason: "datatrans_status_unconfirmed" };
+    if (status >= 400 && status < 500)
+        return { outcome: "refused", code: `http_${status}` };
+    if (status !== 200)
+        return { outcome: "unknown", reason: "datatrans_status_unconfirmed" };
+    const value = readAnswer(body);
+    if (!value)
+        return { outcome: "unknown", reason: "datatrans_unreadable" };
+    if (owns(value, "error")) {
+        const error = rebuildError(value);
+        if (!error)
+            return { outcome: "unknown", reason: "datatrans_unexpected_response" };
+        const code = datatransErrorCode(error.error);
+        return code === "too_many_requests" ? { outcome: "unknown", reason: "datatrans_repeat_request" } : { outcome: "refused", code };
+    }
+    if (UNFOLLOWED_KEYS.some((key) => owns(value, key)))
+        return { outcome: "unknown", reason: "datatrans_unsupported_flow" };
+    const safe = rebuildSuccess(value);
+    if (!safe)
+        return { outcome: "unknown", reason: "datatrans_unexpected_response" };
+    if (card && digits(card.number, 12, 19) && safe.transactionId.includes(card.number)) {
+        return { outcome: "unknown", reason: "datatrans_token_mismatch" };
+    }
+    return { outcome: "approved" };
+}
+function sanitizeDatatransTokenResponse(body) {
+    const value = readAnswer(body);
+    const fail = () => {
+        throw new Error("Invalid Datatrans tokenization response.");
+    };
+    if (!value)
+        return fail();
+    if (owns(value, "error"))
+        return JSON.stringify(rebuildError(value) ?? fail());
+    if (UNFOLLOWED_KEYS.some((key) => owns(value, key)))
+        return fail();
+    return JSON.stringify(rebuildSuccess(value) ?? fail());
+}
+function datatransFacts(status, body) {
+    const verdict = datatransResponseOutcome(status, body);
+    return { outcome: verdict.outcome, refusalCode: verdict.outcome === "refused" ? verdict.code : null };
+}
+export { DATATRANS_CARD_ON_FILE_REFUSED, DATATRANS_HOSTS, DATATRANS_INVALID_REQUEST, DATATRANS_PAYMENT_METHODS, DATATRANS_REFUSAL_REASONS, DATATRANS_REGISTRATION_POLICIES, DATATRANS_REGISTRATION_POLICY, DATATRANS_REVIEWED_MERCHANT_IDS, DATATRANS_TEST_PANS, DATATRANS_TOKENIZE_PATH, classifyDatatransRequest, datatransBodyRefusal, datatransBrandRefusal, datatransCardBrand, datatransCardOnFileDisclosure, datatransDeviceRefusal, datatransErrorCode, datatransFacts, datatransMerchantId, datatransMerchantRefusal, datatransRefusalMessage, datatransRegistrationRefusal, datatransResponseOutcome, datatransTokenizeRefusal, encodeDatatransFormValue, injectDatatransCard, isDatatransTokenizeRequest, isDatatransTokenizeUrl, parseDatatransForm, sanitizeDatatransTokenResponse, serializeDatatransForm };