@agent-cards/sdk 0.21.0 → 0.22.0

package/dist/primer.generated.js

@@ -0,0 +1,624 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: 6dfbdbf520cb1656f338b88088dde209111190a2cbd3e7767e0e1b6d5e15e5ed
+// src/card-number-key.js
+var CARD_NUMBER_KEY = /^(number|card_number|cardnumber|cardNum|card_num|pan)$/i;
+// src/json-path.js
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isPlainObject(v) {
+    return !!v && typeof v === "object" && !Array.isArray(v);
+}
+var MAX_PATH_STEPS = 16;
+function isJsonPath(path) {
+    return Array.isArray(path) && path.length <= MAX_PATH_STEPS && path.every((step) => typeof step === "string" ? step.length > 0 && !FORBIDDEN_KEYS.has(step) : Number.isSafeInteger(step) && step >= 0);
+}
+function jsonAt(root, path) {
+    let node = root;
+    for (const step of path) {
+        if (typeof step === "string") {
+            if (!isPlainObject(node) || FORBIDDEN_KEYS.has(step) || !Object.prototype.hasOwnProperty.call(node, step))
+                return { found: false };
+        }
+        else if (!Array.isArray(node) || !Number.isSafeInteger(step) || step < 0 || step >= node.length) {
+            return { found: false };
+        }
+        node = node[step];
+    }
+    return { found: true, value: node };
+}
+function roundTrips(parsed, body) {
+    try {
+        return JSON.stringify(parsed) === body;
+    }
+    catch {
+        return false;
+    }
+}
+// src/elavon-converge.js
+var CONVERGE_PROCESS_URLS = /* @__PURE__ */ Object.freeze([
+    "https://api.convergepay.com/hosted-payments/service/payment/hpp/process",
+    "https://api.demo.convergepay.com/hosted-payments/service/payment/hpp/process"
+]);
+var TOP_LEVEL_KEYS = /* @__PURE__ */ Object.freeze(["paymentType", "paymentData", "context", "captchaToken", "shippingSameAsBilling"]);
+var WALLET_FIELDS = /* @__PURE__ */ Object.freeze([
+    "ssl_ewallet",
+    "googlepay_authmethod",
+    "ssl_google_pay",
+    "ssl_applepay_web",
+    "ssl_dsrp_cryptogram",
+    "ssl_visapayload",
+    "ssl_ewallet_shipping"
+]);
+var SERVICE_FEE_FIELDS = /* @__PURE__ */ Object.freeze(["ssl_service_fee_agree", "ssl_service_fee_amount", "ssl_service_fee_percent"]);
+var THREE_DS_FIELDS = /* @__PURE__ */ Object.freeze([
+    "ssl_transaction_type",
+    "ssl_eci_ind",
+    "ssl_3dsecure_value",
+    "ssl_dir_server_tran_id",
+    "ssl_xid",
+    "ssl_program_protocol"
+]);
+var THREE_DS_PREFIXES = /* @__PURE__ */ Object.freeze(["ssl_3ds_", "ssl_fsg_"]);
+var SURCHARGE_FIELDS = /* @__PURE__ */ Object.freeze([
+    "ssl_credit_surcharge_agree",
+    "ssl_credit_surcharge_amount",
+    "bypass_credit_surcharge",
+    "ssl_amount_subtotal",
+    "ssl_total_amount",
+    "ssl_surcharge_fee_total"
+]);
+var RECURRING_FIELDS = /* @__PURE__ */ Object.freeze([
+    "recurring",
+    "installment",
+    "ssl_billing_cycle",
+    "ssl_next_payment_date",
+    "ssl_total_installments",
+    "ssl_skip_payment",
+    "ssl_recurring_id",
+    "ssl_recurring_batch_count",
+    "ssl_installment_id"
+]);
+var CARD_SAVING_FLAGS = /* @__PURE__ */ Object.freeze(["ssl_get_token", "ssl_add_token"]);
+var CREDENTIAL_FIELDS = /* @__PURE__ */ Object.freeze(["ssl_account_id", "ssl_merchant_id", "ssl_user_id", "ssl_pin", "ssl_vendor_id"]);
+var AMOUNT_ADD_ON_FIELDS = /* @__PURE__ */ Object.freeze(["ssl_tip_amount", "ssl_cashback_amount"]);
+var CARD_NUMBER = /^\d{12,19}$/;
+var EXPIRY_MMYY = /^(0[1-9]|1[0-2])\d{2}$/;
+var CVC = /^\d{3,4}$/;
+var AMOUNT = /^(\d{1,13})(?:\.(\d{1,2}))?$/;
+var isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var owns = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var refuse = (code) => Object.freeze({ verdict: "refuse", code });
+var CARD = /* @__PURE__ */ Object.freeze({ verdict: "card" });
+var CONTINUE = /* @__PURE__ */ Object.freeze({ verdict: "continue" });
+function parseConvergeBody(body) {
+    if (typeof body !== "string" || body === "" || body.length > 131072)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(parsed) || JSON.stringify(parsed) !== body)
+        return null;
+    return parsed;
+}
+function convergeAmountCents(value) {
+    const text2 = typeof value === "number" && Number.isFinite(value) ? String(value) : value;
+    const m = typeof text2 === "string" ? AMOUNT.exec(text2) : null;
+    if (!m)
+        return null;
+    const cents = Number(m[1]) * 100 + Number(((m[2] ?? "") + "00").slice(0, 2));
+    return Number.isSafeInteger(cents) && cents > 0 ? cents : null;
+}
+function convergeBodyVerdict(body) {
+    const parsed = parseConvergeBody(body);
+    if (parsed === null || !Object.keys(parsed).every((key) => TOP_LEVEL_KEYS.includes(key)))
+        return refuse("converge_body_malformed");
+    const data = parsed.paymentData;
+    if (!isRecord(data))
+        return refuse("converge_body_malformed");
+    const type = parsed.paymentType;
+    if (type === "ELECTRONICCHECK" || type === "FINANCING") {
+        return owns(data, "ssl_card_number") ? refuse("converge_payment_type_refused") : CONTINUE;
+    }
+    if (type === "DEBITCARD") {
+        return refuse(typeof data.ssl_transaction_type === "string" && /DISBURSEMENT/i.test(data.ssl_transaction_type) ? "converge_push_to_card_refused" : "converge_debit_card_refused");
+    }
+    if (type === "GIFTCARD")
+        return refuse("converge_gift_card_refused");
+    if (type !== "CREDITCARD")
+        return refuse("converge_payment_type_refused");
+    const keys = Object.keys(data);
+    if (CREDENTIAL_FIELDS.some((key) => owns(data, key)))
+        return refuse("converge_credential_refused");
+    if (WALLET_FIELDS.some((key) => owns(data, key)))
+        return refuse("converge_wallet_refused");
+    if (owns(parsed, "captchaToken"))
+        return refuse("converge_captcha_refused");
+    if (SERVICE_FEE_FIELDS.some((key) => owns(data, key)))
+        return refuse("converge_service_fee_refused");
+    if (THREE_DS_FIELDS.some((key) => owns(data, key)) || keys.some((key) => THREE_DS_PREFIXES.some((prefix) => key.startsWith(prefix))))
+        return refuse("converge_3ds_follow_up_refused");
+    if (SURCHARGE_FIELDS.some((key) => owns(data, key)))
+        return refuse("converge_surcharge_refused");
+    if (AMOUNT_ADD_ON_FIELDS.some((key) => owns(data, key)))
+        return refuse("converge_amount_add_on_refused");
+    if (owns(data, "ssl_token") || CARD_SAVING_FLAGS.some((key) => owns(data, key) && !(typeof data[key] === "string" && /^n$/i.test(data[key])))) {
+        return refuse("converge_card_saving_refused");
+    }
+    if (RECURRING_FIELDS.some((key) => owns(data, key)))
+        return refuse("converge_recurring_refused");
+    if (owns(data, "ssl_transaction_currency") && !(typeof data.ssl_transaction_currency === "string" && /^usd$/i.test(data.ssl_transaction_currency))) {
+        return refuse("converge_currency_refused");
+    }
+    if (convergeAmountCents(data.ssl_amount) === null)
+        return refuse("converge_amount_missing");
+    if (typeof parsed.context !== "string" || parsed.context === "")
+        return refuse("converge_context_missing");
+    if (owns(parsed, "shippingSameAsBilling") && typeof parsed.shippingSameAsBilling !== "boolean")
+        return refuse("converge_body_malformed");
+    if (!owns(data, "ssl_card_number") || data.ssl_card_number === "" || data.ssl_card_number === null)
+        return refuse("converge_card_missing");
+    if (typeof data.ssl_card_number !== "string" || !CARD_NUMBER.test(data.ssl_card_number) || typeof data.ssl_exp_date !== "string" || !EXPIRY_MMYY.test(data.ssl_exp_date) || typeof data.ssl_cvv2cvc2 !== "string" || !CVC.test(data.ssl_cvv2cvc2))
+        return refuse("converge_card_malformed");
+    return CARD;
+}
+function isConvergeProcessUrl(url) {
+    if (typeof url !== "string")
+        return false;
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    return parsed.href === url && CONVERGE_PROCESS_URLS.includes(parsed.href);
+}
+// src/amadeus-body.js
+var AMADEUS_CARD_MOPID = /^creditcard[0-9]*$/;
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var owns2 = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var holdsPan = (mopdata) => record(mopdata) && owns2(mopdata, "pan") && mopdata.pan !== null && mopdata.pan !== "";
+function amadeusBodyKind(body) {
+    let value;
+    try {
+        value = typeof body === "string" ? JSON.parse(body) : void 0;
+    }
+    catch {
+        return "card";
+    }
+    if (!record(value))
+        return "card";
+    if (value.action === "add") {
+        const entries = Array.isArray(value.data) ? value.data : [value.data];
+        return entries.some((entry) => record(entry) && typeof entry.mopid === "string" && AMADEUS_CARD_MOPID.test(entry.mopid) && holdsPan(entry.mopdata)) ? "card" : "other";
+    }
+    if (value.action === "store")
+        return record(value.data) && holdsPan(value.data.mopdata) ? "card" : "other";
+    return "other";
+}
+// src/card-fields.js
+function processorGate(recognizer, url, body) {
+    if (!recognizer || recognizer.psp !== "elavon_converge")
+        return null;
+    if (url !== void 0 && !isConvergeProcessUrl(url))
+        return { verdict: "refuse", code: "converge_url_refused" };
+    return convergeBodyVerdict(body);
+}
+function carriesCardFields(recognizer, body) {
+    const gate = processorGate(recognizer, void 0, body);
+    if (gate !== null)
+        return gate.verdict === "card";
+    if (recognizer && recognizer.encoding === "json") {
+        const claimed = carriesJsonCardFields(recognizer.jsonCardFields, body, DECLARED_PATHS_ONLY.has(recognizer.psp));
+        return claimed && recognizer.psp === "amadeus_checkout" ? amadeusBodyKind(body) === "card" : claimed;
+    }
+    const fields = recognizer && recognizer.cardFields;
+    if (!Array.isArray(fields) || fields.length === 0)
+        return true;
+    if (recognizer.encoding !== "form")
+        return true;
+    if (typeof body !== "string" || body === "")
+        return false;
+    const anyCase = recognizer.caseInsensitiveFormKeys === true;
+    const wanted = anyCase ? fields.map((field) => String(field).toLowerCase()) : fields;
+    for (const chunk of body.split("&")) {
+        const eq = chunk.indexOf("=");
+        if (eq <= 0 || eq === chunk.length - 1)
+            continue;
+        let key;
+        try {
+            key = decodeURIComponent(chunk.slice(0, eq).replace(/\+/g, " "));
+        }
+        catch {
+            continue;
+        }
+        if (wanted.includes(anyCase ? key.trim().toLowerCase() : key))
+            return true;
+    }
+    return false;
+}
+var DECLARED_PATHS_ONLY = /* @__PURE__ */ new Set(["primer", "pelecard", "creditguard", "payrails"]);
+function carriesJsonCardFields(paths, body, declaredOnly) {
+    if (!Array.isArray(paths) || paths.length === 0 || !paths.every((path) => isJsonPath(path) && path.length > 0))
+        return true;
+    if (declaredOnly)
+        return declaredPathHoldsCard(paths, body);
+    let parsed;
+    try {
+        parsed = typeof body === "string" ? JSON.parse(body) : void 0;
+    }
+    catch {
+        return true;
+    }
+    if (!isPlainObject(parsed))
+        return true;
+    if (paths.some((path) => {
+        const at = jsonAt(parsed, path);
+        return at.found && (typeof at.value === "string" && at.value !== "" || typeof at.value === "number");
+    }))
+        return true;
+    const declared = /* @__PURE__ */ new Set();
+    for (const path of paths) {
+        const last = path[path.length - 1];
+        if (typeof last === "string")
+            declared.add(last.toLowerCase());
+    }
+    return namesCardNumber(parsed, declared);
+}
+function declaredPathHoldsCard(paths, body) {
+    if (typeof body !== "string" || body === "")
+        return false;
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return false;
+    }
+    return paths.some((path) => {
+        const at = jsonAt(parsed, path);
+        return at.found && (typeof at.value === "string" && at.value !== "" || typeof at.value === "number");
+    });
+}
+function namesCardNumber(root, declared) {
+    const pending = [root];
+    while (pending.length > 0) {
+        const node = pending.pop();
+        const named = !Array.isArray(node);
+        for (const key of Object.keys(node)) {
+            if (named) {
+                const name = key.slice(key.lastIndexOf(".") + 1).toLowerCase();
+                if (declared.has(name) || CARD_NUMBER_KEY.test(name) || name.endsWith("cardnumber"))
+                    return true;
+            }
+            const value = node[key];
+            if (value !== null && typeof value === "object")
+                pending.push(value);
+        }
+    }
+    return false;
+}
+// src/primer.js
+var PRIMER_PCI_HOSTS = /* @__PURE__ */ Object.freeze(["sdk.api.primer.io", "sdk.api.sandbox.primer.io"]);
+var PRIMER_TOKENIZE_PATH = "/payment-instruments";
+var PRIMER_REFUSAL_REASONS = /* @__PURE__ */ Object.freeze(["unsupported", "keep_on_file", "unsupported_sdk", "network_mismatch"]);
+var PRIMER_PROVABLE_NETWORKS = /* @__PURE__ */ Object.freeze(["VISA", "MASTERCARD", "AMEX"]);
+var UNSUPPORTED_REFUSAL = "Refusing to pay: unsupported Primer card request.";
+var KEEP_ON_FILE_REFUSAL = "Refusing to pay: this Primer payment would keep the card on file without your consent. Nothing was sent.";
+var UNSUPPORTED_SDK_REFUSAL = "Refusing to pay: this checkout uses a Primer SDK Agentcard does not support yet. Nothing was sent.";
+var NETWORK_MISMATCH_REFUSAL = "Refusing to pay: this Primer payment names a card network that is not your card's. Nothing was sent.";
+var FILL_REFUSAL = "Could not fill the card fields for Primer. Nothing was sent.";
+var BODY_LIMIT = 16384;
+var RESPONSE_LIMIT = 32768;
+var ROOT_KEYS = ["paymentInstrument", "userDescription", "tokenType", "paymentFlow"];
+var INSTRUMENT_KEYS = ["number", "cvv", "expirationMonth", "expirationYear", "cardholderName", "preferredNetwork"];
+var REQUIRED_INSTRUMENT_KEYS = ["number", "cvv", "expirationMonth", "expirationYear"];
+var record2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var owns3 = (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) => /(?:[0-9][ _.:-]*){12,}/.test(value);
+var plain = (value, max) => text(value, max) && !panLike(value);
+var MONTH = /^(?:0[1-9]|1[0-2])$/;
+var YEAR = /^20[0-9]{2}$/;
+var NETWORK = /^[A-Z][A-Z_]{1,31}$/;
+function isPrimerTokenizeUrl(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 && !parsed.search && !parsed.hash && PRIMER_PCI_HOSTS.includes(parsed.hostname) && parsed.pathname === PRIMER_TOKENIZE_PATH;
+}
+function judgeBody(body) {
+    if (typeof body !== "string" || body === "" || body.length > BODY_LIMIT)
+        return null;
+    let value;
+    try {
+        value = JSON.parse(body);
+    }
+    catch {
+        return null;
+    }
+    if (!record2(value) || !roundTrips(value, body))
+        return null;
+    if (!Object.keys(value).every((key) => ROOT_KEYS.includes(key)) || !owns3(value, "paymentInstrument"))
+        return null;
+    const instrument = value.paymentInstrument;
+    if (!record2(instrument) || !Object.keys(instrument).every((key) => INSTRUMENT_KEYS.includes(key)) || !REQUIRED_INSTRUMENT_KEYS.every((key) => owns3(instrument, key)))
+        return null;
+    if (!digits(instrument.number, 12, 19) || !digits(instrument.cvv, 3, 4) || !exact(MONTH, instrument.expirationMonth) || !exact(YEAR, instrument.expirationYear))
+        return null;
+    if (owns3(instrument, "cardholderName") && instrument.cardholderName !== null && !plain(instrument.cardholderName, 256) || owns3(instrument, "preferredNetwork") && instrument.preferredNetwork !== null && !exact(NETWORK, instrument.preferredNetwork) || owns3(value, "userDescription") && value.userDescription !== null && !plain(value.userDescription, 256) || owns3(value, "tokenType") && value.tokenType !== "MULTI_USE" || owns3(value, "paymentFlow") && value.paymentFlow !== "VAULT")
+        return null;
+    return { value, keepOnFile: owns3(value, "tokenType") || owns3(value, "paymentFlow") };
+}
+function primerBodyRefusal(body) {
+    const judged = judgeBody(body);
+    if (!judged)
+        return "unsupported";
+    return judged.keepOnFile ? "keep_on_file" : null;
+}
+function isPrimerNewCardBody(body) {
+    return primerBodyRefusal(body) === null;
+}
+function primerKeepOnFileRequested(body) {
+    const judged = judgeBody(body);
+    return judged ? judged.keepOnFile : null;
+}
+var CARD_GATE = /* @__PURE__ */ Object.freeze({ psp: "primer", encoding: "json", jsonCardFields: [["paymentInstrument", "number"]] });
+var CONTENT_TYPE = /^application\/json(?:;\s*charset=utf-8)?$/i;
+var LEGACY_SDK_VERSION = /^v2\.[0-9]{1,3}\.[0-9]{1,3}$/;
+var CLIENT_TOKEN = /^[A-Za-z0-9._~+/=-]{16,4096}$/;
+var REQUEST_ID = /^[A-Za-z0-9-]{1,64}$/;
+var API_VERSION = /^2\.[0-9]{1,2}$/;
+function readHeaders(headers) {
+    if (!record2(headers))
+        return null;
+    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 null;
+        folded.set(lower, value);
+    }
+    return folded;
+}
+function headersRefusal(headers) {
+    const folded = readHeaders(headers);
+    if (!folded)
+        return "unsupported";
+    const version = folded.get("primer-sdk-version");
+    if (typeof version !== "string")
+        return "unsupported";
+    if (!exact(LEGACY_SDK_VERSION, version))
+        return "unsupported_sdk";
+    if (!exact(CONTENT_TYPE, folded.get("content-type")) || !exact(CLIENT_TOKEN, folded.get("primer-client-token")) || folded.has("primer-sdk-client") && folded.get("primer-sdk-client") !== "WEB" || folded.has("x-api-version") && !exact(API_VERSION, folded.get("x-api-version")) || folded.has("primer-sdk-checkout-session-id") && !exact(REQUEST_ID, folded.get("primer-sdk-checkout-session-id")) || folded.has("x-request-id") && !exact(REQUEST_ID, folded.get("x-request-id")))
+        return "unsupported";
+    return null;
+}
+function classifyPrimerRequest(url, method, body, headers) {
+    if (method !== "POST" || !onTokenizePath(url))
+        return null;
+    if (typeof body !== "string")
+        return "unsupported";
+    if (!carriesCardFields(CARD_GATE, body))
+        return null;
+    if (!isPrimerTokenizeUrl(url))
+        return "unsupported";
+    return headersRefusal(headers) ?? primerBodyRefusal(body) ?? "card";
+}
+function onTokenizePath(url) {
+    if (typeof url !== "string")
+        return false;
+    try {
+        const parsed = new URL(url);
+        return PRIMER_PCI_HOSTS.includes(parsed.hostname.replace(/\.$/, "")) && parsed.pathname.toLowerCase() === PRIMER_TOKENIZE_PATH;
+    }
+    catch {
+        return false;
+    }
+}
+function primerTokenizeRefusal(request) {
+    if (!record2(request) || request.method !== "POST" || !isPrimerTokenizeUrl(request.url))
+        return "unsupported";
+    return headersRefusal(request.headers) ?? primerBodyRefusal(request.body);
+}
+function isPrimerTokenizeRequest(request) {
+    return primerTokenizeRefusal(request) === null;
+}
+function primerRefusalMessage(reason) {
+    if (reason === "keep_on_file")
+        return KEEP_ON_FILE_REFUSAL;
+    if (reason === "unsupported_sdk")
+        return UNSUPPORTED_SDK_REFUSAL;
+    if (reason === "network_mismatch")
+        return NETWORK_MISMATCH_REFUSAL;
+    return UNSUPPORTED_REFUSAL;
+}
+function primerCardNetwork(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 "VISA";
+    if (two >= 51 && two <= 55 || four >= 2221 && four <= 2720)
+        return "MASTERCARD";
+    if (two === 34 || two === 37)
+        return "AMEX";
+    return null;
+}
+function primerNetworkRefusal(body, card) {
+    const judged = judgeBody(body);
+    if (!judged)
+        return "unsupported";
+    const preferred = judged.value.paymentInstrument.preferredNetwork;
+    if (preferred === void 0 || preferred === null)
+        return null;
+    const network = primerCardNetwork(card && card.number);
+    return network !== null && network === preferred ? null : "network_mismatch";
+}
+function injectPrimerCard(body, card) {
+    const judged = judgeBody(body);
+    if (!judged)
+        throw new Error(UNSUPPORTED_REFUSAL);
+    if (judged.keepOnFile)
+        throw new Error(KEEP_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) || !digits(card.cvc, 3, 4)) {
+        throw new Error(FILL_REFUSAL);
+    }
+    if (primerNetworkRefusal(body, card) !== null)
+        throw new Error(NETWORK_MISMATCH_REFUSAL);
+    const instrument = judged.value.paymentInstrument;
+    instrument.number = card.number;
+    instrument.cvv = card.cvc;
+    instrument.expirationMonth = String(month).padStart(2, "0");
+    instrument.expirationYear = String(year < 100 ? 2e3 + year : year);
+    const where = ["paymentInstrument.number", "paymentInstrument.cvv", "paymentInstrument.expirationMonth", "paymentInstrument.expirationYear"];
+    if (typeof instrument.cardholderName === "string" && typeof card.name === "string" && card.name.trim() !== "" && plain(card.name, 256)) {
+        instrument.cardholderName = card.name;
+        where.push("paymentInstrument.cardholderName");
+    }
+    return { body: JSON.stringify(judged.value), where };
+}
+var TOKEN = /^[A-Za-z0-9_-]{8,256}$/;
+var ERROR_ID = /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/;
+var CODE = /^[A-Z][A-Z0-9_]{0,63}$/;
+var NETWORK_NAME = /^[A-Za-z][A-Za-z0-9 _-]{0,31}$/;
+var RESPONSE_MONTH = /^(?:0?[1-9]|1[0-2])$/;
+var RESPONSE_YEAR = /^(?:[0-9]{2}|20[0-9]{2})$/;
+var PROTOCOL = /^[0-9]{1,2}(?:\.[0-9]{1,2}){0,2}$/;
+var BIN_KEYS = [
+    "network",
+    "issuerCountryCode",
+    "issuerName",
+    "issuerCurrencyCode",
+    "regionalRestriction",
+    "accountNumberType",
+    "accountFundingType",
+    "prepaidReloadableIndicator",
+    "productUsageType",
+    "productCode",
+    "productName"
+];
+function readAnswer(body) {
+    if (typeof body !== "string" || body === "" || body.length > RESPONSE_LIMIT)
+        return null;
+    try {
+        const value = JSON.parse(body);
+        return record2(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+var tokenValue = (value) => exact(TOKEN, value) && !panLike(value);
+var optional = (value, key, check) => !owns3(value, key) || value[key] === null || check(value[key]);
+function cardDetails(data) {
+    if (!record2(data) || !exact(/^[0-9]{4}$/, data.last4Digits))
+        return null;
+    if (!optional(data, "first6Digits", (v) => exact(/^[0-9]{6}$/, v)) || !optional(data, "expirationMonth", (v) => exact(RESPONSE_MONTH, v)) || !optional(data, "expirationYear", (v) => exact(RESPONSE_YEAR, v)) || !optional(data, "cardholderName", (v) => plain(v, 256)) || !optional(data, "network", (v) => exact(NETWORK_NAME, v)) || !optional(data, "isNetworkTokenized", (v) => typeof v === "boolean") || !optional(data, "binData", record2))
+        return null;
+    const safe = { last4Digits: data.last4Digits };
+    for (const key of ["first6Digits", "expirationMonth", "expirationYear", "cardholderName", "network", "isNetworkTokenized"]) {
+        if (owns3(data, key) && data[key] !== null)
+            safe[key] = data[key];
+    }
+    if (record2(data.binData)) {
+        const bin = {};
+        for (const key of BIN_KEYS) {
+            if (!owns3(data.binData, key) || data.binData[key] === null)
+                continue;
+            if (!plain(data.binData[key], 128))
+                return null;
+            bin[key] = data.binData[key];
+        }
+        safe.binData = bin;
+    }
+    return safe;
+}
+function threeDsSummary(value) {
+    if (value === void 0 || value === null)
+        return null;
+    if (!record2(value) || !exact(CODE, value.responseCode) || !optional(value, "reasonCode", (v) => exact(CODE, v)) || !optional(value, "reasonText", (v) => plain(v, 256)) || !optional(value, "protocolVersion", (v) => v === "" || exact(PROTOCOL, v)) || !optional(value, "challengeIssued", (v) => typeof v === "boolean"))
+        return void 0;
+    const safe = { responseCode: value.responseCode };
+    for (const key of ["reasonCode", "reasonText", "protocolVersion", "challengeIssued"]) {
+        if (owns3(value, key) && value[key] !== null)
+            safe[key] = value[key];
+    }
+    return safe;
+}
+function rebuildToken(value) {
+    if (!tokenValue(value.token) || !optional(value, "analyticsId", tokenValue) || value.tokenType !== "SINGLE_USE" || value.paymentInstrumentType !== "PAYMENT_CARD" || value.vaultData !== void 0 && value.vaultData !== null)
+        return null;
+    const details = cardDetails(value.paymentInstrumentData);
+    const threeDs = threeDsSummary(value.threeDSecureAuthentication);
+    if (!details || threeDs === void 0)
+        return null;
+    const safe = { token: value.token };
+    if (owns3(value, "analyticsId") && value.analyticsId !== null)
+        safe.analyticsId = value.analyticsId;
+    safe.tokenType = "SINGLE_USE";
+    safe.paymentInstrumentType = "PAYMENT_CARD";
+    safe.paymentInstrumentData = details;
+    safe.threeDSecureAuthentication = threeDs;
+    safe.vaultData = null;
+    return safe;
+}
+function primerErrorId(body) {
+    const value = readAnswer(body);
+    const id = value && record2(value.error) ? value.error.errorId : null;
+    return exact(ERROR_ID, id) && !panLike(id) ? id : null;
+}
+function matchesCard(details, card) {
+    const number = card && typeof card.number === "string" ? card.number : "";
+    if (details.last4Digits !== number.slice(-4))
+        return false;
+    if (details.first6Digits !== void 0 && details.first6Digits !== number.slice(0, 6))
+        return false;
+    if (details.expirationMonth !== void 0 && Number(details.expirationMonth) !== Number(card.month))
+        return false;
+    return details.expirationYear === void 0 || Number(details.expirationYear) % 100 === Number(card.year) % 100;
+}
+function primerResponseOutcome(status, body, card) {
+    if (status >= 400 && status < 500)
+        return { outcome: "refused", code: primerErrorId(body) ?? `http_${status}` };
+    if (status !== 200 && status !== 201)
+        return { outcome: "unknown", reason: "primer_status_unconfirmed" };
+    const value = readAnswer(body);
+    if (!value)
+        return { outcome: "unknown", reason: "primer_unreadable" };
+    if (value.tokenType === "MULTI_USE" || value.vaultData !== void 0 && value.vaultData !== null) {
+        const minted = typeof value.token === "string" && value.token !== "";
+        return { outcome: "unknown", reason: minted ? "primer_card_kept" : "primer_unexpected_response" };
+    }
+    const safe = rebuildToken(value);
+    if (!safe)
+        return { outcome: "unknown", reason: "primer_unexpected_response" };
+    if (card && !matchesCard(safe.paymentInstrumentData, card))
+        return { outcome: "unknown", reason: "primer_token_mismatch" };
+    return { outcome: "approved" };
+}
+function sanitizePrimerResponse(body) {
+    if (primerResponseOutcome(200, body).outcome !== "approved")
+        throw new Error("Invalid Primer tokenization response.");
+    return JSON.stringify(rebuildToken(readAnswer(body)));
+}
+function primerFacts(status, body) {
+    const verdict = primerResponseOutcome(status, body);
+    return { outcome: verdict.outcome, refusalCode: verdict.outcome === "refused" ? verdict.code : null };
+}
+export { PRIMER_PCI_HOSTS, PRIMER_PROVABLE_NETWORKS, PRIMER_REFUSAL_REASONS, PRIMER_TOKENIZE_PATH, classifyPrimerRequest, injectPrimerCard, isPrimerNewCardBody, isPrimerTokenizeRequest, isPrimerTokenizeUrl, primerBodyRefusal, primerCardNetwork, primerErrorId, primerFacts, primerKeepOnFileRequested, primerNetworkRefusal, primerRefusalMessage, primerResponseOutcome, primerTokenizeRefusal, sanitizePrimerResponse };