@agent-cards/sdk 0.23.12 → 0.23.14

package/dist/paddle-tokenex.generated.js

@@ -0,0 +1,951 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: c9116965f8802329701f18adf6519c9111857dfc4329e4f59d7666de150fb5a4
+// src/sha256.js
+var K = /* @__PURE__ */ new Uint32Array([
+    1116352408,
+    1899447441,
+    3049323471,
+    3921009573,
+    961987163,
+    1508970993,
+    2453635748,
+    2870763221,
+    3624381080,
+    310598401,
+    607225278,
+    1426881987,
+    1925078388,
+    2162078206,
+    2614888103,
+    3248222580,
+    3835390401,
+    4022224774,
+    264347078,
+    604807628,
+    770255983,
+    1249150122,
+    1555081692,
+    1996064986,
+    2554220882,
+    2821834349,
+    2952996808,
+    3210313671,
+    3336571891,
+    3584528711,
+    113926993,
+    338241895,
+    666307205,
+    773529912,
+    1294757372,
+    1396182291,
+    1695183700,
+    1986661051,
+    2177026350,
+    2456956037,
+    2730485921,
+    2820302411,
+    3259730800,
+    3345764771,
+    3516065817,
+    3600352804,
+    4094571909,
+    275423344,
+    430227734,
+    506948616,
+    659060556,
+    883997877,
+    958139571,
+    1322822218,
+    1537002063,
+    1747873779,
+    1955562222,
+    2024104815,
+    2227730452,
+    2361852424,
+    2428436474,
+    2756734187,
+    3204031479,
+    3329325298
+]);
+var rotr = (x, n) => x >>> n | x << 32 - n;
+function utf8(text) {
+    const out = [];
+    for (const char of text) {
+        let cp = char.codePointAt(0);
+        if (cp >= 55296 && cp <= 57343)
+            cp = 65533;
+        if (cp < 128)
+            out.push(cp);
+        else if (cp < 2048)
+            out.push(192 | cp >> 6, 128 | cp & 63);
+        else if (cp < 65536)
+            out.push(224 | cp >> 12, 128 | cp >> 6 & 63, 128 | cp & 63);
+        else
+            out.push(240 | cp >> 18, 128 | cp >> 12 & 63, 128 | cp >> 6 & 63, 128 | cp & 63);
+    }
+    return Uint8Array.from(out);
+}
+function sha256Hex(input) {
+    const isBytes = Object.prototype.toString.call(input) === "[object Uint8Array]";
+    if (typeof input !== "string" && !isBytes)
+        throw new TypeError("sha256Hex takes a string or a Uint8Array.");
+    const bytes = typeof input === "string" ? utf8(input) : input;
+    const length = bytes.length;
+    const padded = new Uint8Array((length + 8 >> 6) + 1 << 6);
+    padded.set(bytes);
+    padded[length] = 128;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, Math.floor(length / 536870912));
+    view.setUint32(padded.length - 4, length << 3 >>> 0);
+    const H = new Uint32Array([1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]);
+    const W = new Uint32Array(64);
+    for (let offset = 0; offset < padded.length; offset += 64) {
+        for (let t = 0; t < 16; t++)
+            W[t] = view.getUint32(offset + t * 4);
+        for (let t = 16; t < 64; t++) {
+            const s0 = rotr(W[t - 15], 7) ^ rotr(W[t - 15], 18) ^ W[t - 15] >>> 3;
+            const s1 = rotr(W[t - 2], 17) ^ rotr(W[t - 2], 19) ^ W[t - 2] >>> 10;
+            W[t] = W[t - 16] + s0 + W[t - 7] + s1 >>> 0;
+        }
+        let a = H[0], b = H[1], c = H[2], d = H[3], e = H[4], f = H[5], g = H[6], h = H[7];
+        for (let t = 0; t < 64; t++) {
+            const t1 = h + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + (e & f ^ ~e & g) + K[t] + W[t] >>> 0;
+            const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = d + t1 >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = t1 + t2 >>> 0;
+        }
+        H[0] += a;
+        H[1] += b;
+        H[2] += c;
+        H[3] += d;
+        H[4] += e;
+        H[5] += f;
+        H[6] += g;
+        H[7] += h;
+    }
+    return Array.from(H, (word) => word.toString(16).padStart(8, "0")).join("");
+}
+// src/rsa-pkcs1v15.js
+var RsaPkcs1v15Error = class extends Error {
+    constructor(reason) {
+        super("RSA PKCS#1 v1.5 encryption refused.");
+        this.name = "RsaPkcs1v15Error";
+        this.code = "rsa_pkcs1v15_refused";
+        this.reason = reason;
+    }
+};
+var refuse = (reason) => new RsaPkcs1v15Error(reason);
+var BASE64 = /^[A-Za-z0-9+/]+={0,2}$/;
+var SHA256_HEX = /^[0-9a-f]{64}$/;
+var RSA_ALGORITHM = [48, 13, 6, 9, 42, 134, 72, 134, 247, 13, 1, 1, 1, 5, 0];
+var MODULUS_BYTES = [128, 256, 384, 512];
+var MIN_PADDING = 8;
+var MAX_DRAWS = 16;
+var TYPED_ARRAY = Object.getPrototypeOf(Uint8Array.prototype);
+var typedArrayName = Object.getOwnPropertyDescriptor(TYPED_ARRAY, Symbol.toStringTag).get;
+function parseRsaPublicKey(key) {
+    const spki = key && typeof key === "object" ? key.spki : void 0;
+    const pin2 = key && typeof key === "object" ? key.sha256 : void 0;
+    if (typeof spki !== "string" || spki.length > 1024 || spki.length % 4 !== 0 || !BASE64.test(spki))
+        throw refuse("key");
+    if (typeof pin2 !== "string" || !SHA256_HEX.test(pin2))
+        throw refuse("key");
+    let binary;
+    try {
+        binary = atob(spki);
+    }
+    catch {
+        throw refuse("key");
+    }
+    if (btoa(binary) !== spki)
+        throw refuse("key");
+    const der = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+    if (sha256Hex(der) !== pin2)
+        throw refuse("key");
+    const outer = readElement(der, 0, 48);
+    if (outer.end !== der.length || outer.start + RSA_ALGORITHM.length > der.length)
+        throw refuse("key");
+    if (!RSA_ALGORITHM.every((byte, i) => der[outer.start + i] === byte))
+        throw refuse("key");
+    const bits = readElement(der, outer.start + RSA_ALGORITHM.length, 3);
+    if (bits.end !== outer.end || bits.start === bits.end || der[bits.start] !== 0)
+        throw refuse("key");
+    const rsa = readElement(der, bits.start + 1, 48);
+    if (rsa.end !== bits.end)
+        throw refuse("key");
+    const modulus = readPositiveInteger(der, rsa.start);
+    const exponent = readPositiveInteger(der, modulus.end);
+    if (exponent.end !== rsa.end)
+        throw refuse("key");
+    const n = modulus.bytes;
+    if (!MODULUS_BYTES.includes(n.length) || !(n[0] & 128) || !(n[n.length - 1] & 1))
+        throw refuse("key");
+    const e = exponent.bytes;
+    if (e.length !== 3 || e[0] !== 1 || e[1] !== 0 || e[2] !== 1)
+        throw refuse("key");
+    return Object.freeze({ n: toBigInt(n), e: 65537n, size: n.length });
+}
+function rsaesPkcs1v15Encrypt(key, message, random) {
+    const { n, e, size } = parseRsaPublicKey(key);
+    if (typedArrayName.call(message) !== "Uint8Array")
+        throw refuse("message");
+    let bytes;
+    try {
+        bytes = new Uint8Array(message);
+    }
+    catch {
+        throw refuse("message");
+    }
+    const em = new Uint8Array(size);
+    try {
+        if (bytes.length > size - MIN_PADDING - 3)
+            throw refuse("message");
+        em[1] = 2;
+        fillNonZero(em.subarray(2, size - bytes.length - 1), random);
+        em.set(bytes, size - bytes.length);
+        return toBytes(modPow(toBigInt(em), e, n), size);
+    }
+    finally {
+        em.fill(0);
+        bytes.fill(0);
+    }
+}
+function readElement(der, at, tag) {
+    if (at + 2 > der.length || der[at] !== tag)
+        throw refuse("key");
+    let length = der[at + 1];
+    let start = at + 2;
+    if (length & 128) {
+        const count = length & 127;
+        if (count === 0 || count > 2 || start + count > der.length || der[start] === 0)
+            throw refuse("key");
+        length = count === 1 ? der[start] : der[start] * 256 + der[start + 1];
+        if (length < 128)
+            throw refuse("key");
+        start += count;
+    }
+    if (start + length > der.length)
+        throw refuse("key");
+    return { start, end: start + length };
+}
+function readPositiveInteger(der, at) {
+    const { start, end } = readElement(der, at, 2);
+    if (end === start || der[start] & 128)
+        throw refuse("key");
+    if (der[start] === 0 && (end - start === 1 || !(der[start + 1] & 128)))
+        throw refuse("key");
+    return { bytes: der.subarray(der[start] === 0 ? start + 1 : start, end), end };
+}
+function fillNonZero(target, random) {
+    if (!random || typeof random.getRandomValues !== "function")
+        throw refuse("random");
+    const draw = new Uint8Array(target.length);
+    let filled = 0;
+    try {
+        for (let round = 0; round < MAX_DRAWS && filled < target.length; round++) {
+            draw.fill(0);
+            random.getRandomValues(draw);
+            for (let i = 0; i < draw.length && filled < target.length; i++)
+                if (draw[i] !== 0)
+                    target[filled++] = draw[i];
+        }
+    }
+    catch {
+        throw refuse("random");
+    }
+    finally {
+        draw.fill(0);
+    }
+    if (filled < target.length)
+        throw refuse("random");
+}
+function toBigInt(bytes) {
+    let hex = "";
+    for (let i = 0; i < bytes.length; i++)
+        hex += (bytes[i] < 16 ? "0" : "") + bytes[i].toString(16);
+    return BigInt(`0x${hex}`);
+}
+function toBytes(value, size) {
+    const hex = value.toString(16).padStart(size * 2, "0");
+    const out = new Uint8Array(size);
+    for (let i = 0; i < size; i++)
+        out[i] = parseInt(hex.slice(2 * i, 2 * i + 2), 16);
+    return out;
+}
+function modPow(base, exponent, modulus) {
+    let result = 1n;
+    let square = base % modulus;
+    for (let rest = exponent; rest > 0n; rest >>= 1n) {
+        if (rest & 1n)
+            result = result * square % modulus;
+        square = square * square % modulus;
+    }
+    return result;
+}
+// src/paddle-keys.js
+var PADDLE_TOKENEX_KEYS = /* @__PURE__ */ Object.freeze({
+    sandbox: Object.freeze({
+        spki: "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvWpIQFjQQCPpaIlJKpegirp5kLkzLB1AxHmnLk73D3TJbAGqr1QmlsWDBtMPMRpdzzUM7ZwX3kzhIuATV4Pe7RKp3nZlVmcrT0YCQXBrTwqZNh775z58GP2kZs+gVfNqBampJPzSB/hB62KkByhECn6grrRjiAVwJyZVEvs/2vrxaEpO+aE16emtX12RgI5JdzdOiNyZEQteU6zRBRJEocPWVxExaOpVVVJ5+UnW0LcalzA+lRGRTrQJ5JguAPiAOzRPTK/lYFFpCAl/F8wtoAVG1c8zO2NcQ0Pko+fmeidRFxJ/did2btV+9Mkze3mBphwFmvnxa35LF+Cs/XJHDwIDAQAB",
+        sha256: "877d29a008ed9998d6035032870c63dcc4cbf37ca22cb50b0cc9fe2250a9e3dc"
+    }),
+    production: Object.freeze({
+        spki: "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA8gGPMwBRPuVyJReZGIkWH/+Bf5pnpDN1bSR2cLYLXVT8CaSnTw74qeboSnktgYCi1D9R3Bj2fYzTIwGGZb8KinLdxwbqZmHwrE9cFhCaHbG/E0PbqQGhXP2vbniZTT4M0i0Cbi7ES3Bw5zqNbIZZnX041QEpxLvIyWPKZCX+fBogNMhWfCF779aclChjHkwZMsufThVWE9xklWGxXiytx5aL4I5JPxq0I7cAkZGGs4aF/GxWwPaq7R3wPikJQ0YHnCMfcURzl2Hnw/inqyMy+JB6djTq2/BdzMAhWTh3cDWq9Xu+gEkb/QCd0n1yYIdKuDISlk/AfHdWe34IvzhVyQIDAQAB",
+        sha256: "92529bd289bb24d52a1bdcc42edc9ac0bb1dacbb58f7568573d44771e1287762"
+    })
+});
+function paddleTokenexKey(environment) {
+    if (environment !== "sandbox" && environment !== "production")
+        return null;
+    return PADDLE_TOKENEX_KEYS[environment] ?? null;
+}
+function paddleTokenexKeyBytes(environment) {
+    const key = paddleTokenexKey(environment);
+    if (!key)
+        return null;
+    try {
+        return parseRsaPublicKey(key).size;
+    }
+    catch {
+        return null;
+    }
+}
+// src/paddle-vgs.js
+var CARD_NUMBER = /^[0-9]{12,19}$/;
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var pin = (fields) => Object.freeze({
+    ...fields,
+    origins: Object.freeze([...fields.origins]),
+    sellerClaim: fields.sellerClaim ? Object.freeze({ ...fields.sellerClaim }) : null
+});
+var PADDLE_VGS_MERCHANT_PINS = /* @__PURE__ */ Object.freeze([
+    pin({ id: "rectangle_pro", merchant: "Rectangle Pro", origins: ["https://rectangleapp.com"], sellerClaim: null })
+]);
+var PADDLE_VGS_CARD_NETWORKS = /* @__PURE__ */ Object.freeze(["visa", "mastercard", "amex"]);
+function cardNetwork(number) {
+    if (typeof number !== "string" || !CARD_NUMBER.test(number))
+        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;
+}
+var storedBrand = (brand) => typeof brand === "string" && brand !== "" ? brand.toLowerCase() : null;
+var PAY_BRANDS = /* @__PURE__ */ Object.freeze({ visa: "visa", mastercard: "master", amex: "american_express" });
+var FACT_KEYS = /* @__PURE__ */ Object.freeze(["card_first_six", "card_last_four", "expiry_month", "expiry_year", "card_brand"]);
+var FIRST_SIX = /^[0-9]{6}$/;
+var LAST_FOUR = /^[0-9]{4}$/;
+var fullYear = (year) => {
+    const value = Number(year);
+    return Number.isInteger(value) && value >= 0 && value <= 99 ? 2e3 + value : value;
+};
+var expiryMonth = (month) => Number.isInteger(month) && month >= 1 && month <= 12;
+var expiryYear = (year) => Number.isInteger(year) && year >= 2e3 && year <= 2099;
+function paddleVgsCardFacts(card) {
+    const number = card ? String(card.number) : "";
+    const network = cardNetwork(number);
+    const month = card ? Number(card.month) : NaN;
+    const year = card ? fullYear(card.year) : NaN;
+    if (network === null || !expiryMonth(month) || !expiryYear(year))
+        throw new Error("Could not read this card's details for Paddle. Nothing was sent.");
+    return Object.freeze({ card_first_six: number.slice(0, 6), card_last_four: number.slice(-4), expiry_month: month, expiry_year: year, card_brand: PAY_BRANDS[network] });
+}
+function paddleVgsCardFactsOf(value) {
+    if (!record(value))
+        return null;
+    const keys = Object.keys(value);
+    if (keys.length !== FACT_KEYS.length || !FACT_KEYS.every((key) => keys.includes(key)))
+        return null;
+    const { card_first_six: firstSix, card_last_four: lastFour, expiry_month: month, expiry_year: year, card_brand: brand } = value;
+    const network = typeof firstSix === "string" && FIRST_SIX.test(firstSix) ? cardNetwork(`${firstSix}000000`) : null;
+    if (network === null || PAY_BRANDS[network] !== brand || typeof lastFour !== "string" || !LAST_FOUR.test(lastFour) || !expiryMonth(month) || !expiryYear(year))
+        return null;
+    return Object.freeze({ card_first_six: firstSix, card_last_four: lastFour, expiry_month: month, expiry_year: year, card_brand: brand });
+}
+function paddleVgsCardFactsAgree(facts, stored) {
+    const read = paddleVgsCardFactsOf(facts);
+    if (!read)
+        return false;
+    const card = record(stored) ? stored : {};
+    const network = Object.keys(PAY_BRANDS).find((name) => PAY_BRANDS[name] === read.card_brand);
+    const brand = storedBrand(card.brand);
+    return !(typeof card.last4 === "string" && LAST_FOUR.test(card.last4) && card.last4 !== read.card_last_four) && (brand === null || brand === network) && !(Number.isInteger(card.expiryMonth) && card.expiryMonth !== read.expiry_month) && !(Number.isInteger(card.expiryYear) && card.expiryYear % 100 !== read.expiry_year % 100);
+}
+var METADATA_KEYS = /* @__PURE__ */ Object.freeze(["cardholder_name", ...FACT_KEYS]);
+// src/adyen-jwe.js
+var ADYEN_JWE_HEADER = { alg: "RSA-OAEP-256", enc: "A256GCM", version: "1" };
+var BASE64URL = /^[A-Za-z0-9_-]+$/;
+function isAdyenJweCompact(s) {
+    if (typeof s !== "string" || s.length > 2048)
+        return false;
+    const parts = s.split(".");
+    if (parts.length !== 5)
+        return false;
+    const [header, encryptedKey, iv, ciphertext, tag] = parts;
+    if (!parts.every((p) => p.length > 0 && BASE64URL.test(p)))
+        return false;
+    if (encryptedKey.length !== 342 || iv.length !== 16 || tag.length !== 22)
+        return false;
+    if (ciphertext.length > 1024)
+        return false;
+    return isAdyenJweHeader(header);
+}
+function isAdyenJweHeader(segment) {
+    if (!BASE64URL.test(segment) || segment.length > 128)
+        return false;
+    let parsed;
+    try {
+        parsed = JSON.parse(new TextDecoder().decode(Uint8Array.from(atob(segment.replace(/-/g, "+").replace(/_/g, "/")), (c) => c.charCodeAt(0))));
+    }
+    catch {
+        return false;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return false;
+    const obj = parsed;
+    const keys = Object.keys(obj).sort();
+    if (keys.join(",") !== "alg,enc,version")
+        return false;
+    return obj.alg === ADYEN_JWE_HEADER.alg && obj.enc === ADYEN_JWE_HEADER.enc && obj.version === ADYEN_JWE_HEADER.version;
+}
+// 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;
+    }
+}
+function sameSteps(a, b) {
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((step, i) => step === b[i]);
+}
+function pathsOverlap(a, b) {
+    const n = Math.min(a.length, b.length);
+    for (let i = 0; i < n; i += 1)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+function describePath(path) {
+    return path.length ? path.map((step) => typeof step === "number" ? `[${step}]` : `.${step}`).join("").replace(/^\./, "") : "(root)";
+}
+// src/substitution-primitives.js
+var SubstitutionError = class extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SubstitutionError";
+    }
+};
+var SWAP_MEMBERS = /* @__PURE__ */ new Set(["path", "fields", "remove", "set"]);
+function checkedSet(set, path, names, remove) {
+    if (!Array.isArray(set))
+        throw new SubstitutionError("substitutions.set is not a list");
+    const entries = [...set].map((raw) => {
+        const entry = isPlainObject(raw) ? Object.fromEntries(Object.entries(raw)) : null;
+        if (!entry || Object.keys(entry).sort().join(",") !== "path,value")
+            throw new SubstitutionError("a set entry is not a {path, value}");
+        const at = Array.isArray(entry.path) ? [...entry.path] : entry.path;
+        if (!isJsonPath(at) || at.length === 0 || typeof at[at.length - 1] !== "string")
+            throw new SubstitutionError("refusing set path");
+        const value = entry.value;
+        if (value !== null && !["string", "boolean"].includes(typeof value) && !(typeof value === "number" && Number.isFinite(value))) {
+            throw new SubstitutionError(`the set value at ${describePath(at)} is not a string, number, boolean or null`);
+        }
+        const key = at[at.length - 1];
+        if (sameSteps(at.slice(0, -1), path) && (names.includes(key) || remove.includes(key))) {
+            throw new SubstitutionError(`the set entry at ${describePath(at)} writes over an encrypted field or a removed key`);
+        }
+        return { path: at, value };
+    });
+    for (const [i, a] of entries.entries()) {
+        for (const b of entries.slice(i + 1)) {
+            if (pathsOverlap(a.path, b.path))
+                throw new SubstitutionError(`two set entries write at ${describePath(a.path)}`);
+        }
+    }
+    return entries;
+}
+var ADYEN_JWE = /* @__PURE__ */ Object.freeze({ accepts: isAdyenJweCompact, label: "an Adyen JWE" });
+function swapMerchantHostedFields(body, spec, ciphertext = ADYEN_JWE) {
+    if (!isPlainObject(spec))
+        throw new SubstitutionError("refusing a substitution that is not an object");
+    for (const member of Object.keys(spec)) {
+        if (!SWAP_MEMBERS.has(member))
+            throw new SubstitutionError(`unexpected substitution member ${member}`);
+    }
+    const path = Array.isArray(spec.path) ? [...spec.path] : spec.path;
+    const fields = isPlainObject(spec.fields) ? Object.fromEntries(Object.entries(spec.fields)) : null;
+    const remove = Array.isArray(spec.remove) ? [...spec.remove] : spec.remove ?? [];
+    if (!isJsonPath(path))
+        throw new SubstitutionError("refusing substitution path");
+    if (!fields || Object.keys(fields).length === 0)
+        throw new SubstitutionError("substitutions carry no fields");
+    const names = Object.keys(fields);
+    const values = names.map((name) => fields[name]);
+    for (const name of names) {
+        if (FORBIDDEN_KEYS.has(name))
+            throw new SubstitutionError(`refusing substitution field ${name}`);
+        if (!ciphertext.accepts(fields[name]))
+            throw new SubstitutionError(`substitution for ${name} is not ${ciphertext.label}`);
+    }
+    if (!Array.isArray(remove))
+        throw new SubstitutionError("substitutions.remove is not a list");
+    for (const key of remove) {
+        if (typeof key !== "string" || !key || FORBIDDEN_KEYS.has(key))
+            throw new SubstitutionError(`refusing removal of ${String(key)}`);
+        if (names.includes(key))
+            throw new SubstitutionError(`substitution field ${key} is also listed for removal`);
+    }
+    if (new Set(remove).size !== remove.length)
+        throw new SubstitutionError("substitutions.remove names a key twice");
+    const set = checkedSet(spec.set ?? [], path, names, remove);
+    if (typeof body !== "string")
+        throw new SubstitutionError("the paused body is not JSON");
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        throw new SubstitutionError("the paused body is not JSON");
+    }
+    if (!isPlainObject(parsed))
+        throw new SubstitutionError("the paused body is not a JSON object");
+    const holder = jsonAt(parsed, path);
+    if (!holder.found || !isPlainObject(holder.value))
+        throw new SubstitutionError(`the paused body has no object at ${describePath(path)}`);
+    const swaps = /* @__PURE__ */ new Map();
+    for (const name of names) {
+        const dummy = Object.prototype.hasOwnProperty.call(holder.value, name) ? holder.value[name] : void 0;
+        if (typeof dummy !== "string")
+            throw new SubstitutionError(`the paused body has no string field ${name} at ${describePath(path)}`);
+        if (!ciphertext.accepts(dummy))
+            throw new SubstitutionError(`the paused field ${name} is not ${ciphertext.label}`);
+        if (swaps.has(dummy))
+            throw new SubstitutionError("two paused fields carry the same ciphertext");
+        swaps.set(dummy, fields[name]);
+    }
+    const dummies = [...swaps.keys()];
+    if (new Set(values).size !== values.length || values.some((value) => swaps.has(value))) {
+        throw new SubstitutionError("two ciphertexts in this substitution are the same");
+    }
+    const texts = [...dummies, ...values];
+    for (const a of texts)
+        for (const b of texts)
+            if (a !== b && b.includes(a))
+                throw new SubstitutionError("one ciphertext is part of another");
+    if ((remove.length > 0 || set.length > 0) && !roundTrips(parsed, body)) {
+        throw new SubstitutionError("the paused body does not round-trip through JSON, so it cannot be edited");
+    }
+    for (const entry of set) {
+        const parent = jsonAt(parsed, entry.path.slice(0, -1));
+        if (!parent.found || !isPlainObject(parent.value)) {
+            throw new SubstitutionError(`the paused body has no object at ${describePath(entry.path.slice(0, -1))} to write a value in`);
+        }
+        const key = entry.path[entry.path.length - 1];
+        const current = Object.prototype.hasOwnProperty.call(parent.value, key) ? parent.value[key] : void 0;
+        if (current !== null && typeof current === "object") {
+            throw new SubstitutionError(`refusing to write over the object at ${describePath(entry.path)}`);
+        }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const pattern = new RegExp(dummies.map((text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"), "g");
+    const swapped = body.replace(pattern, (text) => {
+        seen.add(text);
+        return swaps.get(text);
+    });
+    if (seen.size !== dummies.length)
+        throw new SubstitutionError("a paused field is not written verbatim in the body");
+    let out;
+    try {
+        out = JSON.parse(swapped);
+    }
+    catch {
+        throw new SubstitutionError("the substituted body is not JSON");
+    }
+    const written = jsonAt(out, path);
+    if (!written.found || !isPlainObject(written.value) || names.some((name) => written.value[name] !== fields[name]) || dummies.some((dummy) => swapped.includes(dummy))) {
+        throw new SubstitutionError(`the substitution did not land at ${describePath(path)}`);
+    }
+    if (remove.length === 0 && set.length === 0)
+        return swapped;
+    for (const key of remove)
+        if (Object.prototype.hasOwnProperty.call(written.value, key))
+            delete written.value[key];
+    for (const entry of set) {
+        const parent = jsonAt(out, entry.path.slice(0, -1));
+        if (!parent.found || !isPlainObject(parent.value))
+            throw new SubstitutionError(`the set entry at ${describePath(entry.path)} did not land`);
+        parent.value[entry.path[entry.path.length - 1]] = entry.value;
+    }
+    return JSON.stringify(out);
+}
+// src/paddle-tokenex.js
+var PADDLE_TOKENEX_PSP = "paddle_tokenex";
+var PADDLE_TOKENEX_CAPABILITY = "paddle_tokenex_pay";
+var PADDLE_TOKENEX_OPERATION = "paddle_tokenex.encrypted_card";
+var PADDLE_TOKENEX_SCHEME = "rsa-pkcs1v15";
+var PADDLE_TOKENEX_FIELDS = /* @__PURE__ */ Object.freeze(["encrypted_card_number", "encrypted_cvv"]);
+var PADDLE_TOKENEX_FACT_KEYS = /* @__PURE__ */ Object.freeze(["card_first_six", "card_last_four", "expiry_month", "expiry_year", "card_brand"]);
+var PADDLE_TOKENEX_CARD_NETWORKS = PADDLE_VGS_CARD_NETWORKS;
+var PADDLE_TOKENEX_REFUSAL_CODES = /* @__PURE__ */ Object.freeze([
+    "paddle_tokenex_pay_unsupported",
+    "paddle_tokenex_card_unsupported",
+    "paddle_tokenex_card_mismatch",
+    "paddle_tokenex_key_unavailable"
+]);
+var record2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var sameKeys = (value, keys) => {
+    const own = Object.keys(value);
+    return own.length === keys.length && own.every((key, at) => key === keys[at]);
+};
+var refuse2 = (code) => Object.freeze({ verdict: "refuse", code });
+var CARD = /* @__PURE__ */ Object.freeze({ verdict: "card" });
+var CONTINUE = /* @__PURE__ */ Object.freeze({ verdict: "continue" });
+var PAY_URL = /^https:\/\/(sandbox-)?checkout-service\.paddle\.com\/(checkout|transaction-checkout)\/[A-Za-z0-9_-]{1,64}\/pay$/;
+function paddleTokenexPayTarget(url) {
+    const match = typeof url === "string" ? PAY_URL.exec(url) : null;
+    return match ? Object.freeze({ environment: match[1] ? "sandbox" : "production", line: match[2] === "checkout" ? "classic" : "billing" }) : null;
+}
+function paddleTokenexPayCarriesCard(body) {
+    if (typeof body !== "string")
+        return true;
+    try {
+        return JSON.stringify(JSON.parse(body)).includes('"tokenex_card"');
+    }
+    catch {
+        return true;
+    }
+}
+var FRAME_BRANDS = /* @__PURE__ */ Object.freeze(["visa", "master", "american_express", "discover", "diners_club", "jcb", "maestro", "dankort", "unionpay", "unknown"]);
+var NAME_LIMIT = 256;
+var CONTROL = /[\u0000-\u001f\u007f]/;
+var FIRST_SIX2 = /^[0-9]{6}$/;
+var LAST_FOUR2 = /^[0-9]{4}$/;
+var BASE642 = /^[A-Za-z0-9+/]+={0,2}$/;
+var PAN_LIKE = /(?:[0-9][ _.:-]*){12,}/;
+var cardLikeName = (name) => (name.match(/[0-9]/g) ?? []).length >= 12;
+var expiryMonth2 = (month) => Number.isInteger(month) && month >= 1 && month <= 12;
+var expiryYear2 = (year) => Number.isInteger(year) && year >= 2e3 && year <= 2099;
+var PAY_BODY_LIMIT = 16384;
+var PAY_DATA_KEYS = /* @__PURE__ */ Object.freeze(["payment_method_type", "payment_method_data"]);
+var PAY_CARD_KEYS = /* @__PURE__ */ Object.freeze(["metadata", "three_d_s", "tokenex_card"]);
+var METADATA_KEYS2 = /* @__PURE__ */ Object.freeze(["cardholder_name", ...PADDLE_TOKENEX_FACT_KEYS]);
+var CARD_KEYS = /* @__PURE__ */ Object.freeze(["encrypted_card_number", "encrypted_cvv"]);
+var BROWSER_INFO = /^[A-Za-z0-9+/]{1,4096}={0,2}$/;
+var RADAR_TOKEN = /^[\x21-\x7e]{1,512}$/;
+var COUNTRY_CODE = /^[A-Za-z]{2}$/;
+var FRONTEND_HOST = /^https:\/\/[\x21-\x7e]{1,1024}$/;
+var radarKeys = (value) => sameKeys(value, ["token", "country_code"]) || sameKeys(value, ["country_code", "token"]);
+function isBase64OfBytes(value, bytes) {
+    if (typeof value !== "string" || value.length !== Math.ceil(bytes / 3) * 4 || !BASE642.test(value))
+        return false;
+    const pad = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+    return value.length / 4 * 3 - pad === bytes && btoa(atob(value)) === value;
+}
+function ciphertextInteger(value) {
+    const binary = atob(value);
+    let hex = "";
+    for (let i = 0; i < binary.length; i++)
+        hex += binary.charCodeAt(i).toString(16).padStart(2, "0");
+    return BigInt(`0x${hex}`);
+}
+function isPaddleTokenexCiphertextUnderKey(value, environment) {
+    const key = paddleTokenexKey(environment);
+    const bytes = paddleTokenexKeyBytes(environment);
+    if (!key || !bytes || !isBase64OfBytes(value, bytes))
+        return false;
+    const n = parseRsaPublicKey(key).n;
+    const c = ciphertextInteger(value);
+    return c > 1n && c < n;
+}
+function isPaddleTokenexCiphertext(value, environment) {
+    const bytes = paddleTokenexKeyBytes(environment);
+    return bytes !== null && isBase64OfBytes(value, bytes);
+}
+function readPay(body, line, environment) {
+    if (typeof body !== "string" || body === "" || body.length > PAY_BODY_LIMIT)
+        return null;
+    let value;
+    try {
+        value = JSON.parse(body);
+        if (!record2(value) || JSON.stringify(value) !== body)
+            return null;
+    }
+    catch {
+        return null;
+    }
+    const data = value.data;
+    if (!sameKeys(value, ["data"]) || !record2(data) || !(sameKeys(data, PAY_DATA_KEYS) || sameKeys(data, [...PAY_DATA_KEYS, "checkout"])) || data.payment_method_type !== (line === "classic" ? "CARD" : "card"))
+        return null;
+    if (data.checkout !== void 0 && !(record2(data.checkout) && sameKeys(data.checkout, ["frontend_host"]) && typeof data.checkout.frontend_host === "string" && FRONTEND_HOST.test(data.checkout.frontend_host)))
+        return null;
+    const method = data.payment_method_data;
+    const card = record2(method) && sameKeys(method, ["card"]) ? method.card : null;
+    if (!record2(card) || !(sameKeys(card, PAY_CARD_KEYS) || sameKeys(card, [...PAY_CARD_KEYS, "session_tracking"])))
+        return null;
+    const metadata = card.metadata;
+    if (!record2(metadata) || !sameKeys(metadata, METADATA_KEYS2) || typeof metadata.cardholder_name !== "string" || metadata.cardholder_name.length > NAME_LIMIT || CONTROL.test(metadata.cardholder_name) || cardLikeName(metadata.cardholder_name) || typeof metadata.card_first_six !== "string" || !FIRST_SIX2.test(metadata.card_first_six) || typeof metadata.card_last_four !== "string" || !LAST_FOUR2.test(metadata.card_last_four) || !expiryMonth2(metadata.expiry_month) || !expiryYear2(metadata.expiry_year) || !FRAME_BRANDS.includes(metadata.card_brand))
+        return null;
+    const details = card.three_d_s;
+    if (!record2(details) || !sameKeys(details, ["browser_info"]) || typeof details.browser_info !== "string" || !BROWSER_INFO.test(details.browser_info))
+        return null;
+    const tokenex = card.tokenex_card;
+    if (!record2(tokenex) || !sameKeys(tokenex, CARD_KEYS))
+        return null;
+    for (const name of CARD_KEYS) {
+        const blob = tokenex[name];
+        if (environment === void 0) {
+            if (typeof blob !== "string" || !BASE642.test(blob) || blob.length < 4 || blob.length > 4096)
+                return null;
+        }
+        else if (!isPaddleTokenexCiphertext(blob, environment))
+            return null;
+    }
+    if (tokenex.encrypted_card_number === tokenex.encrypted_cvv)
+        return null;
+    if (card.session_tracking !== void 0) {
+        const tracking = card.session_tracking;
+        const radar = record2(tracking) && sameKeys(tracking, ["stripe_radar"]) ? tracking.stripe_radar : null;
+        if (!record2(radar) || !radarKeys(radar) || typeof radar.token !== "string" || !RADAR_TOKEN.test(radar.token) || typeof radar.country_code !== "string" || !COUNTRY_CODE.test(radar.country_code))
+            return null;
+    }
+    return value;
+}
+function paddleTokenexRequestRefusal(request, environment) {
+    if (!record2(request) || typeof request.method !== "string" || request.method.toUpperCase() !== "POST")
+        return "paddle_tokenex_pay_unsupported";
+    const target = paddleTokenexPayTarget(request.url);
+    if (!target || environment !== void 0 && target.environment !== environment)
+        return "paddle_tokenex_pay_unsupported";
+    return readPay(request.body, target.line, environment) === null ? "paddle_tokenex_pay_unsupported" : null;
+}
+function isPaddleTokenexCardRequest(request) {
+    return record2(request) && paddleTokenexPayCarriesCard(request.body) && paddleTokenexRequestRefusal(request) === null;
+}
+function paddleTokenexBodyVerdict(body, line) {
+    if (!paddleTokenexPayCarriesCard(body))
+        return CONTINUE;
+    for (const candidate of line === "classic" || line === "billing" ? [line] : ["classic", "billing"]) {
+        if (readPay(body, candidate) !== null)
+            return CARD;
+    }
+    return refuse2("paddle_tokenex_pay_unsupported");
+}
+var REFUSAL_MESSAGES = /* @__PURE__ */ Object.freeze({
+    paddle_tokenex_pay_unsupported: "Refusing to pay: this is not the card payment Paddle's checkout sends. Nothing was sent.",
+    paddle_tokenex_card_unsupported: "Refusing to pay: Paddle cannot charge this card network here. Nothing was sent.",
+    paddle_tokenex_card_mismatch: "Refusing to pay: this Paddle payment names a card expiry or network that is not your card's. Nothing was sent.",
+    // The cardholder cannot act on key pinning, so this message stays plain. The code and
+    // encryptPaddleTokenexCard's JSDoc carry the precise reason: no TokenEx key is pinned for this
+    // environment (paddle-keys.js).
+    paddle_tokenex_key_unavailable: "Refusing to pay: Agentcard cannot pay this checkout right now. Try again later. Nothing was sent."
+});
+function paddleTokenexRefusalMessage(code) {
+    return Object.prototype.hasOwnProperty.call(REFUSAL_MESSAGES, code) ? REFUSAL_MESSAGES[code] : REFUSAL_MESSAGES.paddle_tokenex_pay_unsupported;
+}
+function paddleTokenexStoredCardRefusal(brand) {
+    const network = typeof brand === "string" && brand !== "" ? brand.toLowerCase() : null;
+    return network === null || PADDLE_TOKENEX_CARD_NETWORKS.some((name) => name === network) ? null : "paddle_tokenex_card_unsupported";
+}
+function tokenexError(code) {
+    const error = (
+    /** @type {Error & { code: string }} */
+    new Error(paddleTokenexRefusalMessage(code)));
+    error.code = code;
+    return error;
+}
+function encryptPaddleTokenexCard(card, environment, facilities = {}) {
+    const key = paddleTokenexKey(environment);
+    if (!key)
+        throw tokenexError("paddle_tokenex_key_unavailable");
+    let facts;
+    try {
+        facts = paddleVgsCardFacts(card);
+    }
+    catch {
+        throw tokenexError("paddle_tokenex_card_unsupported");
+    }
+    const random = facilities.crypto ?? globalThis.crypto;
+    const number = String(card.number);
+    const cvc = String(card.cvc);
+    const encrypt = (text) => {
+        const message = new TextEncoder().encode(text);
+        try {
+            return base64(rsaesPkcs1v15Encrypt(key, message, random));
+        }
+        finally {
+            message.fill(0);
+        }
+    };
+    return Object.freeze({ encrypted_card_number: encrypt(number), encrypted_cvv: encrypt(cvc), ...facts });
+}
+function base64(bytes) {
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++)
+        binary += String.fromCharCode(bytes[i]);
+    return btoa(binary);
+}
+function paddleTokenexSubstitutionOf(value, environment) {
+    if (!record2(value))
+        return null;
+    const keys = Object.keys(value);
+    const all = [...PADDLE_TOKENEX_FIELDS, ...PADDLE_TOKENEX_FACT_KEYS];
+    if (keys.length !== all.length || !all.every((key) => keys.includes(key)))
+        return null;
+    for (const name of PADDLE_TOKENEX_FIELDS)
+        if (!isPaddleTokenexCiphertextUnderKey(value[name], environment))
+            return null;
+    if (value.encrypted_card_number === value.encrypted_cvv)
+        return null;
+    const facts = paddleVgsCardFactsOf({
+        card_first_six: value.card_first_six,
+        card_last_four: value.card_last_four,
+        expiry_month: value.expiry_month,
+        expiry_year: value.expiry_year,
+        card_brand: value.card_brand
+    });
+    if (!facts)
+        return null;
+    return Object.freeze({ encrypted_card_number: value.encrypted_card_number, encrypted_cvv: value.encrypted_cvv, ...facts });
+}
+var tokenexCiphertext = (environment) => Object.freeze({ accepts: (value) => isPaddleTokenexCiphertextUnderKey(value, environment), label: "a Paddle TokenEx ciphertext under the pinned key" });
+var CARD_PATH = /* @__PURE__ */ Object.freeze(["data", "payment_method_data", "card"]);
+var TOKENEX_PATH = /* @__PURE__ */ Object.freeze([...CARD_PATH, "tokenex_card"]);
+function substitutePaddleTokenex(url, body, substitution) {
+    const target = paddleTokenexPayTarget(url);
+    if (!target)
+        throw new SubstitutionError("the paused request is not a Paddle TokenEx /pay");
+    const environment = target.environment;
+    const paused = readPay(body, target.line, environment);
+    if (!paused)
+        throw new SubstitutionError("the paused Paddle /pay is not the shape the vault fills");
+    const sub = paddleTokenexSubstitutionOf(substitution, environment);
+    if (!sub)
+        throw new SubstitutionError("the substitution is not two TokenEx ciphertexts under the pinned key and five card facts");
+    const placeholder = paused.data.payment_method_data.card.tokenex_card;
+    for (const name of PADDLE_TOKENEX_FIELDS) {
+        if (sub[name] === placeholder.encrypted_card_number || sub[name] === placeholder.encrypted_cvv) {
+            throw new SubstitutionError("a ciphertext in this substitution is already in the paused /pay");
+        }
+    }
+    const out = swapMerchantHostedFields(body, {
+        path: TOKENEX_PATH,
+        fields: { encrypted_card_number: sub.encrypted_card_number, encrypted_cvv: sub.encrypted_cvv },
+        set: PADDLE_TOKENEX_FACT_KEYS.map((key) => ({ path: [...CARD_PATH, "metadata", key], value: sub[key] }))
+    }, tokenexCiphertext(environment));
+    const written = readPay(out, target.line, environment);
+    if (!written)
+        throw new SubstitutionError("the substitution did not land in the frame's /pay shape");
+    const card = written.data.payment_method_data.card;
+    if (card.tokenex_card.encrypted_card_number !== sub.encrypted_card_number || card.tokenex_card.encrypted_cvv !== sub.encrypted_cvv || PADDLE_TOKENEX_FACT_KEYS.some((key) => card.metadata[key] !== sub[key])) {
+        throw new SubstitutionError("the substitution did not write the card and its facts");
+    }
+    return out;
+}
+function paddleTokenexKeyUsable(authorization) {
+    if (!record2(authorization) || !record2(authorization.cse))
+        return false;
+    const cse = authorization.cse;
+    if (cse.psp !== PADDLE_TOKENEX_PSP || cse.scheme !== PADDLE_TOKENEX_SCHEME)
+        return false;
+    if (cse.public_key != null || cse.client_key != null || Object.prototype.hasOwnProperty.call(cse, "merchant_hosted"))
+        return false;
+    const target = paddleTokenexPayTarget(authorization.url);
+    if (!target || cse.environment !== target.environment || authorization.sandbox !== (target.environment === "sandbox"))
+        return false;
+    return paddleTokenexKeyBytes(target.environment) !== null;
+}
+function paddleTokenexSubstitutionsRefusal(template, substitution) {
+    const refuseWith = (message) => ({ code: "invalid_substitutions", message });
+    if (!record2(template))
+        return refuseWith("This authorization is not a Paddle TokenEx /pay.");
+    const target = paddleTokenexPayTarget(template.url);
+    if (!target)
+        return refuseWith("This authorization is not a Paddle TokenEx /pay.");
+    const paused = readPay(template.body, target.line, target.environment);
+    if (!paused)
+        return refuseWith("The paused Paddle /pay is not the shape the vault fills.");
+    const sub = paddleTokenexSubstitutionOf(substitution, target.environment);
+    if (!sub)
+        return refuseWith("substitutions must carry two TokenEx ciphertexts under the pinned key and five card facts.");
+    const placeholder = paused.data.payment_method_data.card.tokenex_card;
+    if (PADDLE_TOKENEX_FIELDS.some((name) => sub[name] === placeholder.encrypted_card_number || sub[name] === placeholder.encrypted_cvv)) {
+        return refuseWith("substitutions must be new ciphertexts, neither already in the paused /pay.");
+    }
+    return null;
+}
+var ANSWER_LIMIT = 65536;
+var REFUSAL_CODE = /^[A-Za-z0-9_.:-]{1,64}$/;
+var MAX_CODE_DIGITS = 11;
+function readAnswer(text) {
+    if (typeof text !== "string" || text === "" || text.length > ANSWER_LIMIT)
+        return null;
+    try {
+        const value = JSON.parse(text);
+        return record2(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+var boundedCode = (value) => typeof value === "string" && REFUSAL_CODE.test(value) && (value.match(/[0-9]/g) ?? []).length <= MAX_CODE_DIGITS && !PAN_LIKE.test(value) ? value : null;
+function paddleTokenexRefusalCode(text) {
+    const answer = readAnswer(text);
+    if (!answer)
+        return null;
+    const first = Array.isArray(answer.errors) && record2(answer.errors[0]) ? answer.errors[0] : null;
+    return boundedCode(first && first.error_code) ?? boundedCode(first && first.code) ?? boundedCode(answer.error_code) ?? boundedCode(answer.code);
+}
+function needs3ds(answer) {
+    const action = record2(answer) && record2(answer.data) ? answer.data.required_action : record2(answer) ? answer.required_action : null;
+    return record2(action) && typeof action.type === "string" && /(^|_)card$/.test(action.type);
+}
+function paddleTokenexAnswerOutcome(status, text) {
+    if (!Number.isInteger(status))
+        return { outcome: "unknown", reason: "paddle_tokenex_unconfirmed" };
+    if (status >= 500)
+        return { outcome: "unknown", reason: "server_error" };
+    if (status >= 400)
+        return { outcome: "refused", code: paddleTokenexRefusalCode(text) ?? `http_${status}` };
+    if (status !== 200 && status !== 201)
+        return { outcome: "unknown", reason: "paddle_tokenex_unconfirmed" };
+    const answer = readAnswer(text);
+    if (answer === null)
+        return { outcome: "unknown", reason: "paddle_tokenex_unconfirmed" };
+    return needs3ds(answer) ? { outcome: "challenge" } : { outcome: "approved" };
+}
+export { PADDLE_TOKENEX_CAPABILITY, PADDLE_TOKENEX_CARD_NETWORKS, PADDLE_TOKENEX_FACT_KEYS, PADDLE_TOKENEX_FIELDS, PADDLE_TOKENEX_OPERATION, PADDLE_TOKENEX_PSP, PADDLE_TOKENEX_REFUSAL_CODES, PADDLE_TOKENEX_SCHEME, encryptPaddleTokenexCard, isPaddleTokenexCardRequest, isPaddleTokenexCiphertext, isPaddleTokenexCiphertextUnderKey, paddleTokenexAnswerOutcome, paddleTokenexBodyVerdict, paddleVgsCardFactsAgree as paddleTokenexCardFactsAgree, paddleTokenexKeyUsable, paddleTokenexPayCarriesCard, paddleTokenexPayTarget, paddleTokenexRefusalCode, paddleTokenexRefusalMessage, paddleTokenexRequestRefusal, paddleTokenexStoredCardRefusal, paddleTokenexSubstitutionOf, paddleTokenexSubstitutionsRefusal, substitutePaddleTokenex };