@agent-cards/sdk 0.20.0 → 0.22.0

package/dist/elavon-converge.generated.d.ts

@@ -0,0 +1,49 @@
+declare var CONVERGE_HOSTS: readonly string[];
+declare var CONVERGE_DEMO_HOST: string;
+declare var CONVERGE_PROCESS_PATH: string;
+declare var CONVERGE_PROCESS_URLS: readonly string[];
+declare var CONVERGE_REFUSAL_CODES: readonly string[];
+declare function parseConvergeBody(body: any): any;
+declare function convergeAmountCents(value: any): number | null;
+declare function convergeBodyVerdict(body: any): Readonly<{
+    verdict: "refuse";
+    code: any;
+}> | Readonly<{
+    verdict: "continue";
+}> | Readonly<{
+    verdict: "card";
+}>;
+declare function convergeBodyRefusal(body: any): any;
+declare function isConvergeProcessUrl(url: any): boolean;
+declare function convergeRequestRefusal(request: any): any;
+declare function convergeRefusalMessage(code: any): any;
+declare function injectConvergeHppCard(templateBody: any, card: any): {
+    body: string;
+    where: string[];
+};
+declare function convergeAnswerKind(text: any): "unknown" | "approved" | "declined" | "step" | "session_timeout";
+declare function convergeFacts(text: any, template: any): {
+    kind: string;
+    final: boolean;
+    refusalCode: any;
+    txnId: string | null;
+    approvalCode: string | null;
+    amountCents: number | null;
+    tokenIssued: boolean;
+    chargedAboveRequest: boolean;
+};
+declare function convergeResponseOutcome(status: any, text: any): {
+    outcome: string;
+    reason: string;
+    code?: undefined;
+} | {
+    outcome: string;
+    reason?: undefined;
+    code?: undefined;
+} | {
+    outcome: string;
+    code: any;
+    reason?: undefined;
+};
+declare function sanitizeConvergeResponse(text: any): string;
+export { CONVERGE_DEMO_HOST, CONVERGE_HOSTS, CONVERGE_PROCESS_PATH, CONVERGE_PROCESS_URLS, CONVERGE_REFUSAL_CODES, convergeAmountCents, convergeAnswerKind, convergeBodyRefusal, convergeBodyVerdict, convergeFacts, convergeRefusalMessage, convergeRequestRefusal, convergeResponseOutcome, injectConvergeHppCard, isConvergeProcessUrl, parseConvergeBody, sanitizeConvergeResponse };

package/dist/elavon-converge.generated.js

@@ -0,0 +1,439 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: dc4269c2533c43ddcc4f7be0f3a4645beea09bce6854c98e38701f29cf037e2b
+// src/elavon-converge.js
+var CONVERGE_HOSTS = /* @__PURE__ */ Object.freeze(["api.convergepay.com", "api.demo.convergepay.com"]);
+var CONVERGE_DEMO_HOST = "api.demo.convergepay.com";
+var CONVERGE_PROCESS_PATH = "/hosted-payments/service/payment/hpp/process";
+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 CONVERGE_REFUSAL_CODES = /* @__PURE__ */ Object.freeze([
+    "converge_body_malformed",
+    "converge_payment_type_refused",
+    "converge_debit_card_refused",
+    "converge_push_to_card_refused",
+    "converge_gift_card_refused",
+    "converge_credential_refused",
+    "converge_wallet_refused",
+    "converge_captcha_refused",
+    "converge_service_fee_refused",
+    "converge_3ds_follow_up_refused",
+    "converge_surcharge_refused",
+    "converge_amount_add_on_refused",
+    "converge_card_saving_refused",
+    "converge_recurring_refused",
+    "converge_currency_refused",
+    "converge_amount_missing",
+    "converge_context_missing",
+    "converge_card_missing",
+    "converge_card_malformed",
+    "converge_url_refused",
+    "converge_method_refused",
+    "converge_content_type_refused"
+]);
+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 text = typeof value === "number" && Number.isFinite(value) ? String(value) : value;
+    const m = typeof text === "string" ? AMOUNT.exec(text) : 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 convergeBodyRefusal(body) {
+    const verdict = convergeBodyVerdict(body);
+    return verdict.verdict === "refuse" ? verdict.code : null;
+}
+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);
+}
+function convergeRequestRefusal(request) {
+    if (!isRecord(request))
+        return "converge_body_malformed";
+    if (request.method !== "POST")
+        return "converge_method_refused";
+    if (!isConvergeProcessUrl(request.url))
+        return "converge_url_refused";
+    const headers = request.headers === void 0 ? {} : request.headers;
+    if (!isRecord(headers))
+        return "converge_content_type_refused";
+    for (const [name, value] of Object.entries(headers)) {
+        if (/^content-type$/i.test(name) && !(typeof value === "string" && /^application\/json\s*(?:;\s*charset=utf-8\s*)?$/i.test(value)))
+            return "converge_content_type_refused";
+    }
+    const verdict = convergeBodyVerdict(request.body);
+    if (verdict.verdict === "refuse")
+        return verdict.code;
+    return verdict.verdict === "card" ? null : "converge_payment_type_refused";
+}
+var EXTRA_STEP = "Refusing to pay: this payment needs an extra step the Vault can't complete here. Nothing was sent.";
+var NOT_THE_PAGE = "Refusing to pay: this is not the card request of Elavon Converge's payment page. Nothing was sent.";
+var REFUSAL_MESSAGES = /* @__PURE__ */ Object.freeze({
+    converge_body_malformed: NOT_THE_PAGE,
+    converge_payment_type_refused: "Refusing to pay: only a credit card sale on Elavon Converge's payment page is supported. Nothing was sent.",
+    converge_debit_card_refused: "Refusing to pay: a debit card payment on Elavon Converge's payment page is not supported. Nothing was sent.",
+    converge_push_to_card_refused: "Refusing to pay: this payment would send money to the card, which the Vault never does. Nothing was sent.",
+    converge_gift_card_refused: "Refusing to pay: a gift card payment on Elavon Converge's payment page is not supported. Nothing was sent.",
+    converge_credential_refused: NOT_THE_PAGE,
+    converge_wallet_refused: "Refusing to pay: this payment uses a wallet, not the card you approve here. Nothing was sent.",
+    converge_captcha_refused: "Refusing to pay: this payment page asks for a CAPTCHA, which the Vault can't complete. Nothing was sent.",
+    converge_service_fee_refused: "Refusing to pay: this merchant adds a separate service fee, which a one-time card can't pay. Nothing was sent.",
+    converge_3ds_follow_up_refused: EXTRA_STEP,
+    converge_surcharge_refused: EXTRA_STEP,
+    converge_amount_add_on_refused: "Refusing to pay: this payment adds a tip or cash back to its amount. Nothing was sent.",
+    converge_card_saving_refused: "Refusing to pay: this payment would save the card with the merchant. Nothing was sent.",
+    converge_recurring_refused: "Refusing to pay: this payment would set up recurring or installment charges. Nothing was sent.",
+    converge_currency_refused: "Refusing to pay: this payment is not in US dollars. Nothing was sent.",
+    converge_amount_missing: "Refusing to pay: this payment names no amount. Nothing was sent.",
+    converge_context_missing: "Refusing to pay: this payment carries no payment page session. Nothing was sent.",
+    converge_card_missing: NOT_THE_PAGE,
+    converge_card_malformed: NOT_THE_PAGE,
+    converge_url_refused: NOT_THE_PAGE,
+    converge_method_refused: NOT_THE_PAGE,
+    converge_content_type_refused: NOT_THE_PAGE
+});
+function convergeRefusalMessage(code) {
+    return typeof code === "string" && owns(REFUSAL_MESSAGES, code) ? REFUSAL_MESSAGES[code] : NOT_THE_PAGE;
+}
+var CONVERGE_CARD_PATHS = /* @__PURE__ */ Object.freeze(["paymentData.ssl_card_number", "paymentData.ssl_exp_date", "paymentData.ssl_cvv2cvc2"]);
+function injectConvergeHppCard(templateBody, card) {
+    const verdict = convergeBodyVerdict(templateBody);
+    if (verdict.verdict !== "card") {
+        throw new Error(convergeRefusalMessage(verdict.verdict === "refuse" ? verdict.code : "converge_payment_type_refused"));
+    }
+    const number = card ? String(card.number) : "";
+    const month = card ? String(card.month).padStart(2, "0") : "";
+    const year = card ? String(card.year) : "";
+    const cvc = card ? String(card.cvc) : "";
+    if (!CARD_NUMBER.test(number) || !/^(0[1-9]|1[0-2])$/.test(month) || !/^(?:\d{2}|\d{4})$/.test(year) || !CVC.test(cvc)) {
+        throw new Error("Could not fill the card fields for Elavon Converge. Nothing was sent.");
+    }
+    const parsed = JSON.parse(templateBody);
+    parsed.paymentData.ssl_card_number = number;
+    parsed.paymentData.ssl_exp_date = month + year.slice(-2);
+    parsed.paymentData.ssl_cvv2cvc2 = cvc;
+    return { body: JSON.stringify(parsed), where: [...CONVERGE_CARD_PATHS] };
+}
+var IDENTIFIER = /^[a-z0-9_.:-]{1,64}$/i;
+var identifier = (value) => typeof value === "string" && IDENTIFIER.exec(value)?.[0] === value ? value : null;
+function parseAnswer(text) {
+    if (typeof text !== "string" || text === "")
+        return null;
+    try {
+        const parsed = JSON.parse(text);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+var SURCHARGE_QUOTE_FIELDS = /* @__PURE__ */ Object.freeze(["ssl_credit_surcharge_amount", "ssl_total_amount"]);
+function convergeAnswerKind(text) {
+    const answer = parseAnswer(text);
+    if (answer === null)
+        return "unknown";
+    const fields = isRecord(answer.responseFields) ? answer.responseFields : null;
+    const step = !!(answer.efsToken || answer.threeDSecure || answer.dcc || fields && (fields.surchargeAllowed === "Y" || fields.ssl_result_message === "INVLD SURCHARGE") || fields && answer.approved === false && SURCHARGE_QUOTE_FIELDS.some((key) => owns(fields, key) && fields[key] !== null && fields[key] !== ""));
+    const sessionTimeout = isRecord(answer.errorModel) && answer.errorModel.errorType === "SESSION_TIMEOUT";
+    if ((step || sessionTimeout) && answer.approved === true)
+        return "unknown";
+    if (step)
+        return "step";
+    if (sessionTimeout)
+        return "session_timeout";
+    if (answer.approved === true) {
+        if (!fields || identifier(fields.ssl_txn_id) === null)
+            return "unknown";
+        if (owns(fields, "ssl_result") && String(fields.ssl_result) !== "0")
+            return "unknown";
+        return "approved";
+    }
+    if (answer.approved === false && fields && !(owns(fields, "ssl_result") && String(fields.ssl_result) === "0"))
+        return "declined";
+    return "unknown";
+}
+var KIND_REFUSAL = /* @__PURE__ */ Object.freeze({
+    declined: "converge_declined",
+    session_timeout: "converge_session_timeout",
+    step: "converge_step_unsupported"
+});
+function convergeFacts(text, template) {
+    const kind = convergeAnswerKind(text);
+    const answer = parseAnswer(text);
+    const fields = answer && isRecord(answer.responseFields) ? answer.responseFields : {};
+    const amountCents = kind === "approved" ? convergeAmountCents(fields.ssl_amount) : null;
+    const requested = template && typeof template.body === "string" ? parseConvergeBody(template.body) : null;
+    const requestAmountCents = requested && isRecord(requested.paymentData) ? convergeAmountCents(requested.paymentData.ssl_amount) : null;
+    return {
+        kind,
+        final: kind === "approved" || kind === "declined" || kind === "session_timeout",
+        refusalCode: KIND_REFUSAL[kind] ?? null,
+        txnId: kind === "approved" ? identifier(fields.ssl_txn_id) : null,
+        approvalCode: kind === "approved" ? identifier(fields.ssl_approval_code) : null,
+        amountCents,
+        tokenIssued: kind === "approved" && typeof fields.ssl_token === "string" && fields.ssl_token !== "",
+        chargedAboveRequest: amountCents !== null && requestAmountCents !== null && amountCents > requestAmountCents
+    };
+}
+function convergeResponseOutcome(status, text) {
+    if (!(status >= 200 && status < 300))
+        return { outcome: "unknown", reason: "converge_unconfirmed" };
+    const kind = convergeAnswerKind(text);
+    if (kind === "approved")
+        return { outcome: "approved" };
+    if (KIND_REFUSAL[kind])
+        return { outcome: "refused", code: KIND_REFUSAL[kind] };
+    return { outcome: "unknown", reason: "converge_unconfirmed" };
+}
+var RESPONSE_FIELDS = /* @__PURE__ */ Object.freeze([
+    "ssl_result",
+    "ssl_result_message",
+    "ssl_txn_id",
+    "ssl_approval_code",
+    "ssl_amount",
+    "ssl_txn_time",
+    "ssl_invoice_number",
+    "ssl_description",
+    "ssl_card_short_description",
+    "ssl_card_type",
+    "ssl_card_number",
+    "ssl_cvv2_response",
+    "ssl_avs_response",
+    "ssl_transaction_type",
+    "ssl_merchant_txn_id",
+    "ssl_reference_number",
+    "ssl_transaction_reference_number",
+    "ssl_salestax",
+    "ssl_customer_code"
+]);
+var MASKED_CARD = /^(?=.{12,19}$)\d{0,6}[*Xx#]+\d{0,4}$/;
+var FIELD_NAME = /^[A-Za-z0-9_.-]{1,64}$/;
+function luhn(digits) {
+    let sum = 0;
+    for (let i = 0; i < digits.length; i += 1) {
+        let d = Number(digits[digits.length - 1 - i]);
+        if (i % 2 === 1) {
+            d *= 2;
+            if (d > 9)
+                d -= 9;
+        }
+        sum += d;
+    }
+    return sum % 10 === 0;
+}
+var SEPARATORS = /[\s.\u00b7\u2010-\u2015\u2212-]+/g;
+var DIGIT_GROUPS = /\d+(?:[\s.\u00b7\u2010-\u2015\u2212-]+\d+)*/g;
+function holdsCardNumber(text) {
+    const whole = text.replace(SEPARATORS, "");
+    if (/^\d{12,19}$/.test(whole) && luhn(whole))
+        return true;
+    for (const run of text.match(DIGIT_GROUPS) ?? []) {
+        const groups = run.split(SEPARATORS);
+        for (let start = 0; start < groups.length; start += 1) {
+            if (groups[start][0] === "0")
+                continue;
+            let digits = "";
+            for (let end = start; end < groups.length && digits.length + groups[end].length <= 19; end += 1) {
+                digits += groups[end];
+                if (digits.length >= 12 && luhn(digits))
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+function safeScalar(value) {
+    if (typeof value === "boolean")
+        return true;
+    if (typeof value === "number" && !Number.isFinite(value))
+        return false;
+    if (typeof value !== "number" && (typeof value !== "string" || value.length > 1024 || /[\u0000-\u001f\u007f]/.test(value)))
+        return false;
+    return !holdsCardNumber(String(value));
+}
+function keepReturnField(name, value) {
+    if (typeof name !== "string" || !FIELD_NAME.test(name))
+        return false;
+    const lower = name.toLowerCase();
+    if (lower.startsWith("ssl_") && !RESPONSE_FIELDS.includes(lower))
+        return false;
+    if (lower === "ssl_card_number")
+        return typeof value === "string" && MASKED_CARD.test(value);
+    return safeScalar(value);
+}
+function sanitizeReturnList(list) {
+    if (Array.isArray(list)) {
+        return list.filter((entry) => isRecord(entry) && keepReturnField(entry.name, entry.value)).slice(0, 128).map((entry) => ({ name: entry.name, value: entry.value }));
+    }
+    if (isRecord(list)) {
+        const out = {};
+        for (const [name, value] of Object.entries(list).slice(0, 128))
+            if (keepReturnField(name, value))
+                out[name] = value;
+        return out;
+    }
+    return void 0;
+}
+function sanitizeConvergeResponse(text) {
+    if (convergeAnswerKind(text) !== "approved")
+        throw new Error("Refusing to store an Elavon Converge answer that is not an approval.");
+    const answer = parseAnswer(text);
+    const out = { approved: true };
+    for (const key of ["amount", "currency", "paymentType", "transactionType"]) {
+        if (owns(answer, key) && (typeof answer[key] === "string" || typeof answer[key] === "number") && safeScalar(answer[key]) && String(answer[key]).length <= 64)
+            out[key] = answer[key];
+    }
+    for (const key of ["debitAsCredit", "dcc", "threeDSecure"])
+        if (answer[key] === false)
+            out[key] = false;
+    const fields = {};
+    for (const name of RESPONSE_FIELDS) {
+        if (!owns(answer.responseFields, name))
+            continue;
+        const value = answer.responseFields[name];
+        if (name === "ssl_card_number" ? typeof value === "string" && MASKED_CARD.test(value) : safeScalar(value))
+            fields[name] = value;
+    }
+    out.responseFields = fields;
+    if (isRecord(answer.paymentReturnFields)) {
+        const returns = {};
+        for (const key of ["approveFields", "declineFields"]) {
+            const kept = sanitizeReturnList(answer.paymentReturnFields[key]);
+            if (kept !== void 0)
+                returns[key] = kept;
+        }
+        out.paymentReturnFields = returns;
+    }
+    if (typeof answer.context === "string" && answer.context.length <= 65536)
+        out.context = answer.context;
+    return JSON.stringify(out);
+}
+export { CONVERGE_DEMO_HOST, CONVERGE_HOSTS, CONVERGE_PROCESS_PATH, CONVERGE_PROCESS_URLS, CONVERGE_REFUSAL_CODES, convergeAmountCents, convergeAnswerKind, convergeBodyRefusal, convergeBodyVerdict, convergeFacts, convergeRefusalMessage, convergeRequestRefusal, convergeResponseOutcome, injectConvergeHppCard, isConvergeProcessUrl, parseConvergeBody, sanitizeConvergeResponse };

package/dist/elavon-converge.js

@@ -0,0 +1,84 @@
+// Elavon Converge Hosted Payment Page (psp `elavon_converge`): the page NY DMV's payment apps
+// redirect to, api.convergepay.com/hosted-payments/?ssl_txn_auth_token=<one-time token> (the
+// demo environment serves the same page on api.demo.convergepay.com). Converge's own AngularJS
+// app posts the card in one same-origin JSON XHR, POST /hosted-payments/service/payment/hpp/process,
+// with the card at paymentData.ssl_card_number, ssl_exp_date (MMYY) and ssl_cvv2cvc2, the amount
+// at paymentData.ssl_amount, and the page's rolling session in `context`. The same URL also takes
+// electronic check and financing payments with no card, wallet payments with a card number the
+// server supplied, the debit, gift card and push-to-card tabs, and the follow-ups after a 3-D
+// Secure, Pay Defense or surcharge step. This module holds what the SDK decides about that request.
+// The rules themselves are payment-core's (elavon-converge.generated.ts): the API applies the same
+// ones at create, and the cardholder's device applies them again before it writes a card.
+//
+// The processor ships dark. The API serves the elavon_converge recognizer only to a build that
+// declares the `converge_hpp_process` capability (client.ts SUPPORTED_CAPABILITIES), and only for
+// an org Agentcard enabled for Converge, so an SDK that has not synced, or that runs for any other
+// org, never recognizes a Converge host and leaves its requests alone.
+import { CONVERGE_HOSTS, convergeRequestRefusal } from './elavon-converge.generated.js';
+export const CONVERGE_PSP = 'elavon_converge';
+/** The dark-launch capability the API serves the elavon_converge recognizer behind. */
+export const CONVERGE_CAPABILITY = 'converge_hpp_process';
+/**
+ * Why the SDK refuses an Elavon Converge payment before anything is claimed, created or prompted:
+ * payment-core's own codes (CONVERGE_REFUSAL_CODES), the ones the API answers a create with and
+ * the device refuses with, so an integrator reads one code whichever of them refused.
+ *   - A shape the Vault never pays: `converge_wallet_refused`, `converge_debit_card_refused`,
+ *     `converge_push_to_card_refused`, `converge_gift_card_refused`, `converge_payment_type_refused`,
+ *     `converge_captcha_refused`, `converge_service_fee_refused`, `converge_recurring_refused`,
+ *     `converge_card_saving_refused` (ssl_get_token or ssl_add_token), `converge_amount_add_on_refused`
+ *     (a tip or cash back) and `converge_currency_refused` (anything but US dollars).
+ *   - A follow-up after a step the Vault cannot complete: `converge_3ds_follow_up_refused` (3-D
+ *     Secure or Pay Defense) and `converge_surcharge_refused`.
+ *   - A body the cardholder has nothing to approve on: `converge_amount_missing` and
+ *     `converge_context_missing`.
+ *   - Not the page's own card request, which the device could never fill: `converge_body_malformed`,
+ *     `converge_credential_refused`, `converge_card_missing`, `converge_card_malformed`,
+ *     `converge_url_refused`, `converge_method_refused` and `converge_content_type_refused`.
+ */
+export const CONVERGE_REFUSAL_REASONS = [
+    'converge_body_malformed',
+    'converge_payment_type_refused',
+    'converge_debit_card_refused',
+    'converge_push_to_card_refused',
+    'converge_gift_card_refused',
+    'converge_credential_refused',
+    'converge_wallet_refused',
+    'converge_captcha_refused',
+    'converge_service_fee_refused',
+    'converge_3ds_follow_up_refused',
+    'converge_surcharge_refused',
+    'converge_amount_add_on_refused',
+    'converge_card_saving_refused',
+    'converge_recurring_refused',
+    'converge_currency_refused',
+    'converge_amount_missing',
+    'converge_context_missing',
+    'converge_card_missing',
+    'converge_card_malformed',
+    'converge_url_refused',
+    'converge_method_refused',
+    'converge_content_type_refused',
+];
+/** True when the URL's host is one of Converge's two payment page hosts. */
+export function isConvergeHost(url) {
+    try {
+        return CONVERGE_HOSTS.includes(new URL(url).hostname);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The pause decision for a card-carrying POST the registry recognized on a Converge host. Null
+ * when it is the page's own first credit card sale, which pauses for approval; otherwise the reason
+ * it is refused. It judges the whole request (the exact process URL, the page's JSON content type,
+ * and a body exactly as the page serializes it) with payment-core's convergeRequestRefusal, the
+ * check the API runs at create and the device runs before it writes a card. A code this build does
+ * not list reads as not the page's request, so a newer core can only refuse more.
+ */
+export function convergeRefusal(request) {
+    const code = convergeRequestRefusal({ url: request.url, method: 'POST', headers: request.headers ?? {}, body: request.body ?? '' });
+    if (code === null)
+        return null;
+    return CONVERGE_REFUSAL_REASONS.includes(code) ? code : 'converge_body_malformed';
+}