@agent-cards/sdk 0.21.0 → 0.23.0

package/dist/eprotect.generated.js

@@ -0,0 +1,498 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: a9b6c689690a719af354b2f260064b8e276b8566f3b3482f4b1891f6c4db1caa
+// src/deep-freeze.js
+function deepFreeze(value) {
+    if (value && typeof value === "object" && !Object.isFrozen(value)) {
+        for (const child of Object.values(value))
+            deepFreeze(child);
+        Object.freeze(value);
+    }
+    return value;
+}
+// src/test-pans.js
+function immutableSet(values, name) {
+    const set = new Set(values);
+    for (const method of ["add", "delete", "clear"]) {
+        set[method] = () => {
+            throw new TypeError(`${name} is immutable`);
+        };
+    }
+    return Object.freeze(set);
+}
+var DOCUMENTED_TEST_PANS = /* @__PURE__ */ immutableSet([
+    "4242424242424242",
+    "4000000000000002",
+    "4000002500003155",
+    "4111111111111111"
+], "DOCUMENTED_TEST_PANS");
+// src/eprotect.js
+var EPROTECT_PATH = "/eProtect/paypage";
+var EPROTECT_HOSTS = /* @__PURE__ */ Object.freeze({
+    production: "request.eprotect.vantivcnp.com",
+    sandbox: "request.eprotect.vantivprelive.com"
+});
+var EPROTECT_SECONDARY_HOST = "secondary.eprotect.vantivcnp.com";
+var EPROTECT_KEYS = /* @__PURE__ */ Object.freeze({
+    production: /* @__PURE__ */ Object.freeze({
+        keyId: "26455500012",
+        exponent: "10001",
+        modulus: "b9c7095ff203475347a932a6e11bacbb61cfb66a877158683634e5fb1dbf9923401bd7f82c21b67ffd3c82bdc64797c5e2ba4b57c68b1aaccb7fbe847da7234a21df910dfcc0aebacbbd4d36b35c0c35f7ee27358610d2e2fb2aa87d359deda0b5f4d77e31ac5ab98741da5b6052cb657087da05ad496154b8954939ee6fd463301ff15ebca94f210f4627a255a95ca8833728c1ab80b6cc3a874e4d3dce5d40f66c043ba1b042717bb9cc5d89434fa489a51c2ba9a3843b310df58c9e8a54c36cdd5fd66e76651b6fc88850b60e0739abfcf7d0d0cb44beb7e768da3bcea7e743b8c2d57edef59643f54432ccf60c49d4f5f84410ecf9c5a7af19bc5e792801"
+    }),
+    sandbox: /* @__PURE__ */ Object.freeze({
+        keyId: "1",
+        exponent: "10001",
+        modulus: "bc637dd74ba76507dad5af1c7ad6f97dbef5298c3b9f74caea7301347db7b4a8c37f26491863100667246fd45071f3346bf62239f9b117d06fb67861b66ad0d158beeddd2f6f28be93d846f4c8f9ba1bd7e8f186f36cab0e432f22b3d732c221a9ff00a9bfacb88b24503e2695fd7237835d4936477b21289478906a49b164f52503c20eb29f11fcbda2af94deb9a0bfde5a4589276897436315c5d664d60bf10650164f509283aed39747ad5d6cb2bbe54e1b42306e5db37dfd42dcbfcc689e0ddfe3bc9cb22ae7018e5a4a1ff39813584ac7bd6d6d65ca763f0a672da454081ea20e8b1d403316d80b9353ba396bea8962b1a7d2f775c76612d857c1f7594f"
+    })
+});
+var EPROTECT_TEST_PANS = /* @__PURE__ */ immutableSet([
+    "5112010000000003",
+    "44570100000000009",
+    "6011010000000003",
+    "51234567898010003",
+    "375001000000005",
+    "4457010200000007"
+], "EPROTECT_TEST_PANS");
+var EPROTECT_REFUSAL_CODES = /* @__PURE__ */ Object.freeze(["871", "872", "873", "874", "876", "881", "882", "883"]);
+var QUERY_ORDER = [
+    "paypageId",
+    "reportGroup",
+    "id",
+    "orderId",
+    "encryptedAccount",
+    "pciNonSensitive",
+    "encryptedCvv",
+    "publicKeyId",
+    "firstEight",
+    "requestType",
+    "targetServer",
+    "jsoncallback"
+];
+var OPTIONAL = /* @__PURE__ */ new Set(["encryptedCvv", "firstEight", "requestType"]);
+var URL_LIMIT = 4096;
+var VALUE_LIMIT = 1024;
+var CALLBACK = /^[A-Za-z_][A-Za-z0-9_]{0,127}$/;
+var PAYPAGE_ID = /^[A-Za-z0-9]{1,64}$/;
+var exact = (pattern, value) => typeof value === "string" && pattern.exec(value)?.[0] === value;
+var controlFree = (value, min, max) => typeof value === "string" && value.length >= min && value.length <= max && !/[\u0000-\u001f\u007f]/.test(value);
+function canonicalComponent(value) {
+    return encodeURIComponent(value).replace(/'/g, "%27");
+}
+function decodeComponent(raw) {
+    try {
+        const value = decodeURIComponent(raw);
+        return canonicalComponent(value) === raw ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function eprotectEnvironment(hostname) {
+    const host = typeof hostname === "string" ? hostname : "";
+    if (host === EPROTECT_HOSTS.production)
+        return "production";
+    if (host === EPROTECT_HOSTS.sandbox)
+        return "sandbox";
+    return null;
+}
+function failoverEnvironment(hostname) {
+    if (hostname === EPROTECT_SECONDARY_HOST)
+        return "production";
+    if (hostname === EPROTECT_HOSTS.sandbox)
+        return "sandbox";
+    return null;
+}
+function eprotectPreparationUrl(environment) {
+    if (environment !== "production" && environment !== "sandbox")
+        throw new Error("unsupported_eprotect_environment");
+    return `https://${EPROTECT_HOSTS[environment]}${EPROTECT_PATH}`;
+}
+var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function bytesToBase64(bytes) {
+    let out = "";
+    for (let i = 0; i < bytes.length; i += 3) {
+        const n = bytes[i] << 16 | (bytes[i + 1] ?? 0) << 8 | (bytes[i + 2] ?? 0);
+        out += B64[n >> 18 & 63] + B64[n >> 12 & 63] + (i + 1 < bytes.length ? B64[n >> 6 & 63] : "=") + (i + 2 < bytes.length ? B64[n & 63] : "=");
+    }
+    return out;
+}
+function base64ToBytes(text) {
+    if (typeof text !== "string" || text.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(text))
+        return null;
+    const pad = text.endsWith("==") ? 2 : text.endsWith("=") ? 1 : 0;
+    const bytes = [];
+    for (let i = 0; i < text.length; i += 4) {
+        const n = [0, 1, 2, 3].reduce((acc, k) => acc << 6 | Math.max(0, B64.indexOf(text[i + k])), 0);
+        bytes.push(n >> 16 & 255, n >> 8 & 255, n & 255);
+    }
+    const out = bytes.slice(0, bytes.length - pad);
+    return bytesToBase64(out) === text ? out : null;
+}
+function ciphertext(value) {
+    const bytes = base64ToBytes(value);
+    return !!bytes && bytes.length >= 248 && bytes.length <= 256;
+}
+var VALUE_RULES = {
+    paypageId: (value) => exact(PAYPAGE_ID, value),
+    reportGroup: (value) => controlFree(value, 1, VALUE_LIMIT),
+    id: (value) => controlFree(value, 1, VALUE_LIMIT),
+    orderId: (value) => controlFree(value, 0, VALUE_LIMIT),
+    encryptedAccount: ciphertext,
+    // true bypasses Worldpay's Mod10 check and hides the BIN: private-label cards only.
+    pciNonSensitive: (value) => value === "false",
+    encryptedCvv: ciphertext,
+    publicKeyId: (value) => exact(/^[0-9]{1,32}$/, value),
+    firstEight: (value) => value === "true",
+    requestType: (value) => value === "eProtect",
+    targetServer: (value) => value === "primary" || value === "secondary",
+    jsoncallback: (value) => exact(CALLBACK, value)
+};
+function parseRegistration(url, host) {
+    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;
+    const environment = host === "secondary" ? failoverEnvironment(parsed.hostname) : eprotectEnvironment(parsed.hostname);
+    if (!environment || parsed.pathname !== EPROTECT_PATH || !parsed.search.startsWith("?"))
+        return null;
+    const pairs = [];
+    const values = /* @__PURE__ */ Object.create(null);
+    let last = -1;
+    for (const chunk of parsed.search.slice(1).split("&")) {
+        const separator = chunk.indexOf("=");
+        if (separator < 1)
+            return null;
+        const name = chunk.slice(0, separator), raw = chunk.slice(separator + 1);
+        const position = QUERY_ORDER.indexOf(name);
+        if (position <= last)
+            return null;
+        last = position;
+        const value = decodeComponent(raw);
+        if (value === null || !VALUE_RULES[name](value))
+            return null;
+        pairs.push({ name, raw });
+        values[name] = value;
+    }
+    if (QUERY_ORDER.some((name) => !OPTIONAL.has(name) && !(name in values)))
+        return null;
+    if (values.publicKeyId !== EPROTECT_KEYS[environment].keyId)
+        return null;
+    if (values.targetServer !== (host === "secondary" ? "secondary" : "primary"))
+        return null;
+    return { environment, origin: parsed.origin, pairs, values };
+}
+function isEprotectTokenRequest(url, method) {
+    return method === "GET" && parseRegistration(url, "primary") !== null;
+}
+function isEprotectRequest(request) {
+    return !!request && typeof request === "object" && !Array.isArray(request) && request.method === "GET" && (request.body === void 0 || request.body === null || request.body === "") && isEprotectTokenRequest(request.url, "GET");
+}
+function eprotectRequestFacts(url) {
+    const parsed = parseRegistration(url, "primary");
+    if (!parsed)
+        return null;
+    const v = parsed.values;
+    return {
+        environment: parsed.environment,
+        paypageId: v.paypageId,
+        id: v.id,
+        orderId: v.orderId,
+        reportGroup: v.reportGroup,
+        callback: v.jsoncallback,
+        cvv: "encryptedCvv" in v
+    };
+}
+function eprotectSecondaryAttempt(url) {
+    const parsed = parseRegistration(url, "secondary");
+    return parsed ? { paypageId: parsed.values.paypageId, id: parsed.values.id } : null;
+}
+var CIPHERTEXT_KEYS = /* @__PURE__ */ new Set(["encryptedAccount", "encryptedCvv"]);
+function isEprotectDeviceRequest(templateUrl, deviceUrl) {
+    const template = parseRegistration(templateUrl, "primary");
+    const device = parseRegistration(deviceUrl, "primary");
+    if (!template || !device || device.origin !== template.origin || device.pairs.length !== template.pairs.length)
+        return false;
+    return device.pairs.every((pair, i) => pair.name === template.pairs[i].name && (CIPHERTEXT_KEYS.has(pair.name) ? pair.raw !== template.pairs[i].raw : pair.raw === template.pairs[i].raw));
+}
+function isPreparedEprotectRequest(url, method, body, environment, paypageId) {
+    if (environment !== "production" && environment !== "sandbox")
+        return false;
+    if (method !== "GET" || body !== void 0 && body !== null && body !== "")
+        return false;
+    const facts = eprotectRequestFacts(url);
+    return !!facts && facts.environment === environment && facts.paypageId === paypageId;
+}
+var EPROTECT_MERCHANT_PINS = /* @__PURE__ */ deepFreeze([]);
+function eprotectMerchantPin(paypageId, merchantOrigin, pins = EPROTECT_MERCHANT_PINS) {
+    if (!exact(PAYPAGE_ID, paypageId) || typeof merchantOrigin !== "string" || !Array.isArray(pins))
+        return null;
+    return pins.find((pin) => !!pin && Array.isArray(pin.paypageIds) && Array.isArray(pin.origins) && pin.paypageIds.includes(paypageId) && pin.origins.includes(merchantOrigin)) ?? null;
+}
+function eprotectMerchantRefusal(environment, paypageId, merchantOrigin, pins = EPROTECT_MERCHANT_PINS) {
+    if (!exact(PAYPAGE_ID, paypageId))
+        return "invalid_paypage_id";
+    if (environment === "sandbox")
+        return null;
+    if (environment !== "production")
+        return "unsupported_environment";
+    return eprotectMerchantPin(paypageId, merchantOrigin, pins) ? null : "eprotect_merchant_unreviewed";
+}
+function modPow(base, exponent, modulus) {
+    let result = 1n, b = base % modulus, e = exponent;
+    while (e > 0n) {
+        if (e & 1n)
+            result = result * b % modulus;
+        b = b * b % modulus;
+        e >>= 1n;
+    }
+    return result;
+}
+function randomNonZero(count, random) {
+    const out = new Uint8Array(count);
+    let filled = 0;
+    while (filled < count) {
+        const batch = new Uint8Array(count - filled + 16);
+        random(batch);
+        for (const byte of batch)
+            if (byte !== 0 && filled < count)
+                out[filled++] = byte;
+    }
+    return out;
+}
+function defaultRandom(bytes) {
+    const source = globalThis.crypto;
+    if (!source || typeof source.getRandomValues !== "function")
+        throw new Error("Refusing to pay: no secure random source for eProtect.");
+    source.getRandomValues(bytes);
+}
+function eprotectEncrypt(text, key, random = defaultRandom) {
+    if (typeof text !== "string" || !/^[0-9]{1,19}$/.test(text))
+        throw new Error("Refusing to pay: eProtect encrypts digits only.");
+    if (!key || !/^[0-9a-f]{256,1024}$/.test(key.modulus) || !/^[0-9a-f]{1,8}$/.test(key.exponent)) {
+        throw new Error("Refusing to pay: malformed eProtect key.");
+    }
+    const n = BigInt(`0x${key.modulus}`), e = BigInt(`0x${key.exponent}`);
+    const k = Math.ceil(n.toString(16).length / 2);
+    const message = Array.from(text, (ch) => ch.charCodeAt(0));
+    const padding = randomNonZero(k - 3 - message.length, random);
+    const em = [0, 2, ...padding, 0, ...message];
+    const m = BigInt(`0x${em.map((byte) => byte.toString(16).padStart(2, "0")).join("")}`);
+    let hex = modPow(m, e, n).toString(16);
+    if (hex.length % 2)
+        hex = `0${hex}`;
+    const bytes = [];
+    for (let i = 0; i < hex.length; i += 2)
+        bytes.push(parseInt(hex.slice(i, i + 2), 16));
+    return bytesToBase64(bytes);
+}
+function luhn(number) {
+    let sum = 0;
+    for (let i = 0; i < number.length; i++) {
+        let digit = number.charCodeAt(number.length - 1 - i) - 48;
+        if (i % 2 === 1) {
+            digit *= 2;
+            if (digit > 9)
+                digit -= 9;
+        }
+        sum += digit;
+    }
+    return sum % 10 === 0;
+}
+function eprotectCardRefusal(environment, cardNumber) {
+    const pan = String(cardNumber ?? "");
+    if (environment === "sandbox")
+        return EPROTECT_TEST_PANS.has(pan) ? null : "sandbox_host_requires_documented_test_card";
+    if (environment !== "production")
+        return "unsupported_environment";
+    if (!/^[0-9]{13,19}$/.test(pan) || /^([0-9])\1+$/.test(pan) || !luhn(pan))
+        return "invalid_card_number";
+    return EPROTECT_TEST_PANS.has(pan) || DOCUMENTED_TEST_PANS.has(pan) ? "live_host_refuses_documented_test_card" : null;
+}
+function eprotectDeviceRequest(templateUrl, card, random = defaultRandom) {
+    const parsed = parseRegistration(templateUrl, "primary");
+    if (!parsed)
+        throw new Error("Refusing to pay: unsupported eProtect card request.");
+    const refusal = eprotectCardRefusal(parsed.environment, card && card.number);
+    if (refusal === "sandbox_host_requires_documented_test_card") {
+        throw new Error("Refusing to pay: a sandbox or test host accepts only the processor's documented test cards, not a real card.");
+    }
+    if (refusal)
+        throw new Error("Could not fill the card fields for Worldpay eProtect. Nothing was sent.");
+    const withCvv = "encryptedCvv" in parsed.values;
+    if (withCvv && (typeof card.cvc !== "string" || !/^[0-9]{3,4}$/.test(card.cvc))) {
+        throw new Error("Could not fill the card fields for Worldpay eProtect. Nothing was sent.");
+    }
+    const key = EPROTECT_KEYS[parsed.environment];
+    const fresh = { encryptedAccount: eprotectEncrypt(String(card.number), key, random) };
+    if (withCvv)
+        fresh.encryptedCvv = eprotectEncrypt(card.cvc, key, random);
+    const query = parsed.pairs.map(({ name, raw }) => `${name}=${name in fresh ? canonicalComponent(fresh[name]) : raw}`).join("&");
+    const url = `${parsed.origin}${EPROTECT_PATH}?${query}`;
+    if (!isEprotectDeviceRequest(templateUrl, url))
+        throw new Error("Refusing to pay: unsupported eProtect card request.");
+    return { url, method: "GET", headers: {}, body: "", where: Object.keys(fresh) };
+}
+var RESPONSE_LIMIT = 8192;
+var JSON_STRING = '"(?:[^"\\\\\\u0000-\\u001f]|\\\\(?:["\\\\/bfnrt]|u[0-9a-fA-F]{4}))*"';
+function readFlatObject(text) {
+    if (typeof text !== "string" || text.length > RESPONSE_LIMIT)
+        return null;
+    const open = /^\s*\{\s*/.exec(text);
+    if (!open)
+        return null;
+    const scalar = `${JSON_STRING}|-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?|true|false|null`;
+    const members = new RegExp(`\\s*(${JSON_STRING})\\s*:\\s*(${scalar})\\s*([,}])`, "y");
+    const out = /* @__PURE__ */ Object.create(null);
+    let at = open[0].length;
+    if (text[at] === "}")
+        return /^\s*$/.test(text.slice(at + 1)) ? out : null;
+    while (true) {
+        members.lastIndex = at;
+        const member = members.exec(text);
+        if (!member)
+            return null;
+        const key = JSON.parse(member[1]);
+        if (Object.prototype.hasOwnProperty.call(out, key) || ["__proto__", "prototype", "constructor"].includes(key))
+            return null;
+        out[key] = JSON.parse(member[2]);
+        at = members.lastIndex;
+        if (member[3] === "}")
+            return /^\s*$/.test(text.slice(at)) ? out : null;
+    }
+}
+function readJsonp(text, callback) {
+    if (typeof text !== "string" || !exact(CALLBACK, callback) || !text.startsWith(`${callback}(`))
+        return null;
+    const close = /\);?\s*$/.exec(text);
+    if (!close)
+        return null;
+    return readFlatObject(text.slice(callback.length + 1, close.index));
+}
+var KEEP = [
+    "paypageRegistrationId",
+    "bin",
+    "type",
+    "targetServer",
+    "vantivTxnId",
+    "orderId",
+    "response",
+    "responseTime",
+    "message",
+    "reportGroup",
+    "id"
+];
+var FIELD_RULES = {
+    paypageRegistrationId: (value) => exact(/^[A-Za-z0-9+/=]{8,512}$/, value),
+    bin: (value) => exact(/^[0-9]{6}$/, value),
+    type: (value) => exact(/^[A-Z]{2}$/, value),
+    targetServer: (value) => value === "primary",
+    vantivTxnId: (value) => exact(/^[A-Za-z0-9]{1,64}$/, value),
+    responseTime: (value) => exact(/^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}$/, value),
+    message: (value) => value === "Success"
+};
+var REFUSAL_FIELDS = /* @__PURE__ */ new Set(["response", "message", "responseTime", "id", "orderId", "reportGroup", "vantivTxnId", "targetServer"]);
+function sameAsTemplate(answer, facts) {
+    if (answer.id !== facts.id)
+        return false;
+    for (const key of ["orderId", "reportGroup"]) {
+        if (key in answer && answer[key] !== facts[key])
+            return false;
+    }
+    return !("targetServer" in answer) || answer.targetServer === "primary";
+}
+function eprotectOutcome(status, bodyText, templateUrl, card) {
+    const facts = eprotectRequestFacts(templateUrl);
+    if (!facts)
+        return { outcome: "unknown", reason: "eprotect_template_invalid" };
+    if (status !== 200)
+        return { outcome: "unknown", reason: "eprotect_status" };
+    const answer = readJsonp(bodyText, facts.callback);
+    if (!answer)
+        return { outcome: "unknown", reason: "eprotect_unreadable" };
+    if (Object.values(answer).some((value) => typeof value !== "string"))
+        return { outcome: "unknown", reason: "eprotect_shape" };
+    if (!sameAsTemplate(answer, facts))
+        return { outcome: "unknown", reason: "eprotect_mismatch" };
+    if (EPROTECT_REFUSAL_CODES.includes(answer.response)) {
+        return Object.keys(answer).every((key) => REFUSAL_FIELDS.has(key)) ? { outcome: "refused", code: answer.response } : { outcome: "unknown", reason: "eprotect_unconfirmed" };
+    }
+    if (answer.response !== "870" || !("paypageRegistrationId" in answer))
+        return { outcome: "unknown", reason: "eprotect_unconfirmed" };
+    for (const [key, rule] of Object.entries(FIELD_RULES)) {
+        if (key in answer && !rule(answer[key]))
+            return { outcome: "unknown", reason: "eprotect_shape" };
+    }
+    for (const [key, width] of [["firstSix", 6], ["lastFour", 4], ["firstEight", 8]]) {
+        if (key in answer && !exact(new RegExp(`^[0-9]{${width}}$`), answer[key]))
+            return { outcome: "unknown", reason: "eprotect_shape" };
+    }
+    if (card) {
+        const pan = String(card.number ?? "");
+        const mine = { firstSix: pan.slice(0, 6), lastFour: pan.slice(-4), firstEight: pan.slice(0, 8) };
+        if ("bin" in answer && answer.bin !== "000000" && answer.bin !== mine.firstSix || ["firstSix", "lastFour", "firstEight"].some((key) => key in answer && answer[key] !== mine[key])) {
+            return { outcome: "unknown", reason: "eprotect_card_mismatch" };
+        }
+    }
+    const kept = {};
+    for (const key of KEEP)
+        if (key in answer)
+            kept[key] = answer[key];
+    return { outcome: "registered", sanitizedJson: JSON.stringify(kept) };
+}
+function sanitizeEprotectRegistration(bodyText, templateUrl) {
+    const verdict = eprotectOutcome(200, bodyText, templateUrl, void 0);
+    if (verdict.outcome !== "registered")
+        throw new Error("Invalid eProtect registration response.");
+    return verdict.sanitizedJson;
+}
+function eprotectJsonp(callback, json) {
+    if (!exact(CALLBACK, callback) || !readFlatObject(json))
+        throw new Error("Refusing to answer: malformed eProtect callback.");
+    return `${callback}(${json})`;
+}
+function eprotectGiveUp(url) {
+    if (typeof url !== "string" || url.length > URL_LIMIT)
+        return null;
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return null;
+    }
+    const hosts = [EPROTECT_HOSTS.production, EPROTECT_HOSTS.sandbox, EPROTECT_SECONDARY_HOST];
+    if (parsed.protocol !== "https:" || parsed.port || parsed.username || parsed.password || !hosts.includes(parsed.hostname) || parsed.pathname !== "/eProtect/ppstats")
+        return null;
+    const seen = /* @__PURE__ */ Object.create(null);
+    for (const chunk of parsed.search.slice(1).split("&")) {
+        const separator = chunk.indexOf("=");
+        if (separator < 1)
+            return null;
+        const name = chunk.slice(0, separator);
+        if (name in seen)
+            return null;
+        const value = decodeComponent(chunk.slice(separator + 1));
+        if (value === null)
+            return null;
+        seen[name] = value;
+    }
+    const code = seen.responseCode;
+    if (code !== "900" && code !== "901" || !exact(/^[A-Za-z0-9]{1,64}$/, seen.paypageId) || !controlFree(seen.txnId, 1, VALUE_LIMIT))
+        return null;
+    return { paypageId: seen.paypageId, txnId: seen.txnId, code };
+}
+function eprotectRefusalCode(bodyText) {
+    const callback = typeof bodyText === "string" ? /^[A-Za-z_][A-Za-z0-9_]{0,127}(?=\()/.exec(bodyText)?.[0] : void 0;
+    const answer = callback ? readJsonp(bodyText, callback) : null;
+    if (!answer || !EPROTECT_REFUSAL_CODES.includes(answer.response))
+        return null;
+    return Object.entries(answer).every(([key, value]) => REFUSAL_FIELDS.has(key) && typeof value === "string") ? answer.response : null;
+}
+export { EPROTECT_HOSTS, EPROTECT_KEYS, EPROTECT_MERCHANT_PINS, EPROTECT_PATH, EPROTECT_REFUSAL_CODES, EPROTECT_SECONDARY_HOST, EPROTECT_TEST_PANS, eprotectCardRefusal, eprotectDeviceRequest, eprotectEncrypt, eprotectEnvironment, eprotectGiveUp, eprotectJsonp, eprotectMerchantPin, eprotectMerchantRefusal, eprotectOutcome, eprotectPreparationUrl, eprotectRefusalCode, eprotectRequestFacts, eprotectSecondaryAttempt, isEprotectDeviceRequest, isEprotectRequest, isEprotectTokenRequest, isPreparedEprotectRequest, sanitizeEprotectRegistration };