@agent-cards/sdk 0.21.0 → 0.23.0

package/dist/verifone.generated.js

@@ -0,0 +1,1413 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: cf655438763f54e5d5bfea2555f76941ef80dbfd5aa7bc6342a2a75d1ac9cd39
+// 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/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 sameKeyIgnoringCase(key, step) {
+    return !FORBIDDEN_KEYS.has(key) && (key.toLowerCase() === step.toLowerCase() || key.toUpperCase() === step.toUpperCase());
+}
+function valuesIgnoringCase(root, path) {
+    let nodes = [root];
+    for (const step of path) {
+        const next = [];
+        for (const node of nodes) {
+            if (typeof step === "number") {
+                if (Array.isArray(node) && Number.isSafeInteger(step) && step >= 0 && step < node.length)
+                    next.push(node[step]);
+            }
+            else if (isPlainObject(node)) {
+                for (const key of Object.keys(node))
+                    if (sameKeyIgnoringCase(key, step))
+                        next.push(node[key]);
+            }
+        }
+        nodes = next;
+    }
+    return nodes;
+}
+// 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/verifone-keys.js
+var VERIFONE_KEY_PINS = /* @__PURE__ */ deepFreeze([]);
+var HEX40 = /^[0-9a-f]{40}$/;
+var HEX16 = /^[0-9a-f]{16}$/;
+var HEX64 = /^[0-9a-f]{64}$/;
+var PIN_ID = /^[a-z0-9_]{1,64}$/;
+var PIN_MEMBERS = "alias,encryptionSubkeyId,environment,id,merchant,observedAt,primaryFingerprint,publicKeyBase64,publicKeyBase64Sha256,source";
+function verifoneKeyPinShapeRefusal(entry) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+        return "verifone_key_pin_invalid";
+    if (Object.keys(entry).sort().join(",") !== PIN_MEMBERS)
+        return "verifone_key_pin_invalid";
+    if (typeof entry.id !== "string" || !PIN_ID.test(entry.id))
+        return "verifone_key_pin_invalid";
+    if (typeof entry.merchant !== "string" || entry.merchant.length === 0 || entry.merchant.length > 128)
+        return "verifone_key_pin_invalid";
+    if (entry.environment !== "production" && entry.environment !== "sandbox")
+        return "verifone_key_pin_invalid";
+    if (entry.alias !== null && (typeof entry.alias !== "string" || !/^[A-Za-z0-9._-]{1,128}$/.test(entry.alias)))
+        return "verifone_key_pin_invalid";
+    if (typeof entry.publicKeyBase64 !== "string" || !/^[A-Za-z0-9+/]+={0,2}$/.test(entry.publicKeyBase64))
+        return "verifone_key_pin_invalid";
+    if (!HEX64.test(String(entry.publicKeyBase64Sha256)) || !HEX40.test(String(entry.primaryFingerprint)) || !HEX16.test(String(entry.encryptionSubkeyId)))
+        return "verifone_key_pin_invalid";
+    if (sha256Hex(entry.publicKeyBase64) !== entry.publicKeyBase64Sha256)
+        return "verifone_key_pin_mismatch";
+    return null;
+}
+function verifoneKeyPinById(id, pins = VERIFONE_KEY_PINS) {
+    return typeof id === "string" ? pins.find((entry) => entry.id === id) ?? null : null;
+}
+// src/url-template.js
+var PLACEHOLDER_VALUE = /^[A-Za-z0-9._~@+-]{1,256}$/;
+var PLACEHOLDER_NAME = /^[A-Za-z][A-Za-z0-9_]{0,31}$/;
+var LITERAL_SEGMENT = /^[A-Za-z0-9._~@+-]{1,256}$/;
+var QUERY_KEY = /^[A-Za-z0-9._~-]{1,64}$/;
+var QUERY_LITERAL = /^[A-Za-z0-9._~,-]{0,256}$/;
+var QUERY_PREFIX = /^(?:[A-Za-z0-9._~,-]|%[0-9A-F]{2}){1,64}$/;
+var MAX_QUERIES = 8;
+var MAX_PAIRS = 16;
+var placeholderValue = (value) => PLACEHOLDER_VALUE.test(value) && value !== "." && !value.includes("..");
+function queryPlaceholder(value) {
+    const mark = value.lastIndexOf(":");
+    return mark === -1 ? null : { prefix: value.slice(0, mark), name: value.slice(mark + 1) };
+}
+function pathPlaceholders(template, pathname) {
+    if (typeof template !== "string" || typeof pathname !== "string")
+        return null;
+    if (!template.startsWith("/") || !pathname.startsWith("/"))
+        return null;
+    const want = template.split("/");
+    const got = pathname.split("/");
+    if (want.length !== got.length)
+        return null;
+    const values = {};
+    for (const [i, segment] of want.entries()) {
+        if (segment.startsWith(":")) {
+            if (!placeholderValue(got[i]))
+                return null;
+            values[segment.slice(1)] = got[i];
+        }
+        else if (segment !== got[i]) {
+            return null;
+        }
+    }
+    return values;
+}
+function queryPlaceholders(query, text) {
+    if (!query || typeof query !== "object" || Array.isArray(query))
+        return null;
+    const pairs = Object.entries(query);
+    if (pairs.length === 0)
+        return text === null ? {} : null;
+    if (typeof text !== "string")
+        return null;
+    const got = text.split("&");
+    if (got.length !== pairs.length)
+        return null;
+    const values = {};
+    for (const [i, [key, value]] of pairs.entries()) {
+        const mark = got[i].indexOf("=");
+        if (mark === -1 || got[i].slice(0, mark) !== key)
+            return null;
+        const written = got[i].slice(mark + 1);
+        if (typeof value !== "string")
+            return null;
+        const placeholder = queryPlaceholder(value);
+        if (placeholder) {
+            if (!written.startsWith(placeholder.prefix))
+                return null;
+            const rest = written.slice(placeholder.prefix.length);
+            if (!placeholderValue(rest))
+                return null;
+            values[placeholder.name] = rest;
+        }
+        else if (written !== value) {
+            return null;
+        }
+    }
+    return values;
+}
+function strictUrl(rawUrl) {
+    if (typeof rawUrl !== "string" || rawUrl.includes("#"))
+        return null;
+    let url;
+    try {
+        url = new URL(rawUrl);
+    }
+    catch {
+        return null;
+    }
+    if (url.href !== rawUrl || url.protocol !== "https:" || url.port || url.username || url.password)
+        return null;
+    return url;
+}
+function urlTemplateMatch(template, rawUrl) {
+    const url = strictUrl(rawUrl);
+    if (!url || !template || typeof template !== "object")
+        return null;
+    const fromPath = pathPlaceholders(template.path, url.pathname);
+    if (!fromPath)
+        return null;
+    const mark = rawUrl.indexOf("?");
+    const text = mark === -1 ? null : rawUrl.slice(mark + 1);
+    const queries = Array.isArray(template.queries) ? template.queries : [template.query];
+    for (const query of queries) {
+        const fromQuery = queryPlaceholders(query, text);
+        if (fromQuery)
+            return { origin: url.origin, placeholders: { ...fromPath, ...fromQuery } };
+    }
+    return null;
+}
+function templatePlaceholders(template) {
+    const names = [];
+    if (typeof template?.path === "string") {
+        for (const segment of template.path.split("/"))
+            if (segment.startsWith(":"))
+                names.push(segment.slice(1));
+    }
+    const queries = Array.isArray(template?.queries) ? template.queries : [template?.query];
+    for (const query of queries) {
+        if (query && typeof query === "object") {
+            for (const value of Object.values(query)) {
+                const placeholder = typeof value === "string" ? queryPlaceholder(value) : null;
+                if (placeholder)
+                    names.push(placeholder.name);
+            }
+        }
+    }
+    return names;
+}
+function pathTemplateRefusal(template) {
+    if (typeof template !== "string" || !template.startsWith("/") || template.length > 1024)
+        return "the path is not a template starting with /";
+    const names = [];
+    for (const segment of template.split("/").slice(1)) {
+        if (segment.startsWith(":")) {
+            if (!PLACEHOLDER_NAME.test(segment.slice(1)))
+                return `the path placeholder ${segment} is not a name`;
+            names.push(segment.slice(1));
+        }
+        else if (!LITERAL_SEGMENT.test(segment) || segment === "." || segment === "..") {
+            return `the path segment "${segment}" is not one literal segment`;
+        }
+    }
+    if (new Set(names).size !== names.length)
+        return "a path placeholder is named twice";
+    const literal = template.split("/").slice(1).map((segment) => segment.startsWith(":") ? "x" : segment).join("/");
+    return new URL(`https://template.invalid/${literal}`).pathname === `/${literal}` ? null : "the path is not written the way a URL writes it";
+}
+function queryTemplateRefusal(query) {
+    if (!query || typeof query !== "object" || Array.isArray(query))
+        return "the query is not an object of key=value pairs";
+    const pairs = Object.entries(query);
+    if (pairs.length > MAX_PAIRS)
+        return `the query has more than ${MAX_PAIRS} pairs`;
+    for (const [key, value] of pairs) {
+        if (!QUERY_KEY.test(key))
+            return `the query key "${key}" is not unreserved characters`;
+        if (typeof value !== "string")
+            return `the query value of ${key} is not text`;
+        const placeholder = queryPlaceholder(value);
+        if (placeholder ? !PLACEHOLDER_NAME.test(placeholder.name) || placeholder.prefix !== "" && !QUERY_PREFIX.test(placeholder.prefix) : !QUERY_LITERAL.test(value)) {
+            return `the query value of ${key} is neither a literal nor a :name placeholder`;
+        }
+    }
+    return null;
+}
+function urlTemplateRefusal(template) {
+    if (!template || typeof template !== "object")
+        return "the template is not an object";
+    const pathRefusal = pathTemplateRefusal(template.path);
+    if (pathRefusal)
+        return pathRefusal;
+    const hasQuery = Object.prototype.hasOwnProperty.call(template, "query");
+    const hasQueries = Object.prototype.hasOwnProperty.call(template, "queries");
+    if (hasQuery === hasQueries)
+        return "the template names exactly one of query and queries";
+    const queries = hasQueries ? template.queries : [template.query];
+    if (!Array.isArray(queries) || queries.length === 0 || queries.length > MAX_QUERIES)
+        return `queries is not a list of 1 to ${MAX_QUERIES}`;
+    const pathNames = templatePlaceholders({ path: template.path, query: {} });
+    for (const query of queries) {
+        const refusal = queryTemplateRefusal(query);
+        if (refusal)
+            return refusal;
+        const names = [...pathNames, ...templatePlaceholders({ query })];
+        if (new Set(names).size !== names.length)
+            return "a placeholder is named twice in one request shape";
+    }
+    const texts = queries.map((query) => JSON.stringify(Object.entries(query)));
+    return new Set(texts).size === texts.length ? null : "a query is listed twice";
+}
+// src/verifone-profiles.js
+var VERIFONE_MERCHANT_PROFILES = /* @__PURE__ */ deepFreeze([
+    {
+        // The Container Store (research/processors-wave2/items/verifone-ecommerce/DESIGN.md). TCS's own
+        // page config turns Verifone on for credit cards, its Synchrony private-label card and both
+        // employee variants (featureConfig verifoneCCEnabled, verifonePLCCEnabled,
+        // verifoneEmployeeCCEnabled, verifoneEmployeePLCCEnabled; live from late 2023, still on
+        // 2026-09-19). Checkout is www.containerstore.com/checkout?fulfillmentMethod=STANDARD|PICKUP,
+        // on the legacy app behind PerimeterX. Its card request has never been observed: the
+        // CheckoutV2 bundle was never archived and the page is session-gated. So no leg and no key
+        // are pinned, and every blob-bearing request to www.containerstore.com is aborted, until one
+        // person-run checkout captured as a HAR pins the endpoint, the member holding the blob, the
+        // key and its alias, and whether the blob is sent once or twice.
+        id: "containerstore_checkout",
+        merchant: "The Container Store",
+        processor: "verifone",
+        status: "observe",
+        environment: "production",
+        origins: [{ checkout: "https://www.containerstore.com", endpoint: "https://www.containerstore.com" }],
+        legs: [],
+        keyPin: null,
+        amount: null
+    }
+]);
+var PROFILE_ID = /^[a-z0-9_]{1,64}$/;
+var LEG_NAME = /^[a-z0-9_]{1,32}$/;
+var MAX_RULES = 16;
+var PROFILE_MEMBERS = "amount,environment,id,keyPin,legs,merchant,origins,processor,status";
+var LEG_MEMBERS = "field,holder,method,name,path,query,refuse,requires";
+function isHttpsOrigin(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === "https:" && url.origin === value && !url.port && !url.username && !url.password;
+    }
+    catch {
+        return false;
+    }
+}
+function ruleRefusal(rule, kind) {
+    if (!isPlainObject(rule) || !isJsonPath(rule.path) || rule.path.length === 0)
+        return `a ${kind} rule's path is not a JSON path`;
+    if (kind === "requires") {
+        const members = Object.keys(rule).sort().join(",");
+        if (members !== "equals,path")
+            return "a requires rule is not {path, equals}";
+        const value = rule.equals;
+        return typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value) ? null : "a requires rule does not compare with a string, a number or a boolean";
+    }
+    if (Object.keys(rule).sort().join(",") !== "path,when" || rule.when !== "true" && rule.when !== "present") {
+        return "a refuse rule is not {path, when: 'true' | 'present'}";
+    }
+    return null;
+}
+function legRefusal(leg) {
+    if (!isPlainObject(leg) || Object.keys(leg).sort().join(",") !== LEG_MEMBERS)
+        return "a leg is not {name, method, path, query, requires, refuse, holder, field}";
+    if (typeof leg.name !== "string" || !LEG_NAME.test(leg.name))
+        return "a leg has no name";
+    if (leg.method !== "POST")
+        return `leg ${leg.name} is not a POST`;
+    const template = urlTemplateRefusal({ path: leg.path, query: leg.query });
+    if (template)
+        return `leg ${leg.name}: ${template}`;
+    for (const [kind, list] of [["requires", leg.requires], ["refuse", leg.refuse]]) {
+        if (!Array.isArray(list) || list.length > MAX_RULES)
+            return `leg ${leg.name}: ${kind} is not a list of at most ${MAX_RULES}`;
+        for (const rule of list) {
+            const refusal = ruleRefusal(rule, kind);
+            if (refusal)
+                return `leg ${leg.name}: ${refusal}`;
+        }
+    }
+    if (!isJsonPath(leg.holder))
+        return `leg ${leg.name}: the holder is not a JSON path`;
+    if (typeof leg.field !== "string" || leg.field.length === 0 || leg.field.length > 64 || ["__proto__", "constructor", "prototype"].includes(leg.field)) {
+        return `leg ${leg.name}: the field is not a member name`;
+    }
+    return null;
+}
+function verifoneProfileRefusal(profile, pins = VERIFONE_KEY_PINS) {
+    if (!isPlainObject(profile) || Object.keys(profile).sort().join(",") !== PROFILE_MEMBERS)
+        return "the profile does not carry exactly the reviewed members";
+    if (typeof profile.id !== "string" || !PROFILE_ID.test(profile.id))
+        return "the profile id is not a name";
+    if (typeof profile.merchant !== "string" || profile.merchant.length === 0 || profile.merchant.length > 128)
+        return "the profile names no merchant";
+    if (profile.processor !== "verifone")
+        return "the profile is not a Verifone profile";
+    if (profile.status !== "observe" && profile.status !== "enabled")
+        return "the status is neither observe nor enabled";
+    if (profile.environment !== "production" && profile.environment !== "sandbox")
+        return "the environment is neither production nor sandbox";
+    if (!Array.isArray(profile.origins) || profile.origins.length === 0 || profile.origins.length > 8 || !profile.origins.every((pair) => isPlainObject(pair) && Object.keys(pair).sort().join(",") === "checkout,endpoint" && isHttpsOrigin(pair.checkout) && isHttpsOrigin(pair.endpoint)))
+        return "the origins are not exact HTTPS origin pairs";
+    if (!Array.isArray(profile.legs) || profile.legs.length > 2)
+        return "legs is not a list of at most two";
+    for (const leg of profile.legs) {
+        const refusal = legRefusal(leg);
+        if (refusal)
+            return refusal;
+    }
+    if (new Set(profile.legs.map((leg) => leg.name)).size !== profile.legs.length)
+        return "two legs share a name";
+    if (profile.amount !== null && (!isJsonPath(profile.amount) || profile.amount.length === 0))
+        return "the amount is neither null nor a JSON path";
+    if (profile.keyPin !== null) {
+        const pin = verifoneKeyPinById(profile.keyPin, pins);
+        if (!pin)
+            return "the key pin is not in the table";
+        if (pin.environment !== profile.environment)
+            return "the key pin is for another environment than the profile's";
+        if (pin.merchant !== profile.merchant)
+            return "the key pin is for another merchant than the profile's";
+    }
+    if (profile.status === "enabled") {
+        if (profile.legs.length !== 1)
+            return "an enabled profile pays exactly one leg";
+        if (profile.keyPin === null)
+            return "an enabled profile names a key pin";
+        if (profile.amount === null)
+            return "an enabled profile names where its card request carries the amount";
+    }
+    return null;
+}
+function verifoneProfilePin(profile, pins = VERIFONE_KEY_PINS) {
+    if (!isPlainObject(profile) || profile.keyPin === null)
+        return null;
+    const pin = verifoneKeyPinById(profile.keyPin, pins);
+    return pin && pin.merchant === profile.merchant && pin.environment === profile.environment ? pin : null;
+}
+function verifoneProfileById(id, profiles = VERIFONE_MERCHANT_PROFILES) {
+    const key = typeof id === "string" ? id : id?.id;
+    return typeof key === "string" ? profiles.find((profile) => profile.id === key) ?? null : null;
+}
+function trustedVerifoneProfile(idOrEntry, profiles = VERIFONE_MERCHANT_PROFILES) {
+    const profile = verifoneProfileById(idOrEntry, profiles);
+    if (!profile)
+        throw new Error("Refusing to pay: unknown Verifone merchant profile.");
+    return profile;
+}
+function isVerifoneProfileOrigin(profile, rawUrl) {
+    let url;
+    try {
+        url = new URL(rawUrl);
+    }
+    catch {
+        return false;
+    }
+    return url.protocol === "https:" && !url.username && !url.password && profile.origins.some((pair) => pair.endpoint === url.origin);
+}
+function verifoneLegFor(profile, rawUrl, method, opts) {
+    if (typeof rawUrl !== "string" || typeof method !== "string")
+        return null;
+    for (const leg of profile.legs) {
+        if (method.toUpperCase() !== leg.method)
+            continue;
+        const match = urlTemplateMatch({ path: leg.path, query: leg.query }, rawUrl);
+        if (!match)
+            continue;
+        const checkoutOrigin = opts?.checkoutOrigin;
+        if (profile.origins.some((pair) => pair.endpoint === match.origin && (checkoutOrigin === void 0 || pair.checkout === checkoutOrigin)))
+            return leg;
+    }
+    return null;
+}
+function verifoneLegBodyRefusal(profile, leg, body) {
+    let parsed;
+    try {
+        parsed = typeof body === "string" ? JSON.parse(body) : void 0;
+    }
+    catch {
+        return "the paused body is not JSON";
+    }
+    if (!isPlainObject(parsed))
+        return "the paused body is not a JSON object";
+    if (!roundTrips(parsed, body))
+        return "the paused body does not round-trip through JSON, so its rules cannot be read";
+    for (const rule of leg.requires) {
+        const at = jsonAt(parsed, rule.path);
+        if (!at.found || at.value !== rule.equals || valuesIgnoringCase(parsed, rule.path).some((value) => value !== rule.equals)) {
+            return `the paused body is not ${profile.merchant}'s card request`;
+        }
+    }
+    for (const rule of leg.refuse) {
+        const values = valuesIgnoringCase(parsed, rule.path);
+        const fires = rule.when === "true" ? values.some((value) => value !== false && value !== null) : values.length > 0;
+        if (fires)
+            return `the paused body asks ${profile.merchant} for more than this purchase`;
+    }
+    return null;
+}
+function wireProjection(profile, pins) {
+    const pin = verifoneProfilePin(profile, pins);
+    const { keyPin, ...rest } = profile;
+    return deepFreeze({ ...rest, keyPin, encryptionSubkeyId: pin ? pin.encryptionSubkeyId : null });
+}
+var VERIFONE_PROFILE_RECOGNIZERS = /* @__PURE__ */ deepFreeze(VERIFONE_MERCHANT_PROFILES.map((profile) => wireProjection(profile, VERIFONE_KEY_PINS)));
+// src/fiserv-envelope.js
+var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var BASE64_VALUE = /* @__PURE__ */ (() => {
+    const table = /* @__PURE__ */ new Map();
+    for (let i = 0; i < BASE64_ALPHABET.length; i++)
+        table.set(BASE64_ALPHABET[i], i);
+    return table;
+})();
+var FISERV_ENVELOPE_CONSTANTS = Object.freeze({ aesTagLength: 128, encryptionType: "AES-GCM", encryptionTarget: "MANUAL" });
+function encodeBase64(bytes) {
+    let out = "";
+    for (let i = 0; i < bytes.length; i += 3) {
+        const a = bytes[i], b = i + 1 < bytes.length ? bytes[i + 1] : 0, c = i + 2 < bytes.length ? bytes[i + 2] : 0;
+        const triple = a << 16 | b << 8 | c;
+        out += BASE64_ALPHABET[triple >> 18 & 63] + BASE64_ALPHABET[triple >> 12 & 63] + (i + 1 < bytes.length ? BASE64_ALPHABET[triple >> 6 & 63] : "=") + (i + 2 < bytes.length ? BASE64_ALPHABET[triple & 63] : "=");
+    }
+    return out;
+}
+function decodeBase64(text) {
+    if (typeof text !== "string" || text.length === 0 || text.length % 4 !== 0 || text.length > 65536)
+        return null;
+    const padding = text.endsWith("==") ? 2 : text.endsWith("=") ? 1 : 0;
+    const body = text.length - padding;
+    const out = new Uint8Array(text.length / 4 * 3 - padding);
+    let at = 0;
+    for (let i = 0; i < text.length; i += 4) {
+        const quad = [0, 0, 0, 0];
+        for (let j = 0; j < 4; j++) {
+            const index = i + j;
+            if (index >= body) {
+                quad[j] = 0;
+                continue;
+            }
+            const value = BASE64_VALUE.get(text[index]);
+            if (value === void 0)
+                return null;
+            quad[j] = value;
+        }
+        const triple = quad[0] << 18 | quad[1] << 12 | quad[2] << 6 | quad[3];
+        if (at < out.length)
+            out[at++] = triple >> 16 & 255;
+        if (at < out.length)
+            out[at++] = triple >> 8 & 255;
+        if (at < out.length)
+            out[at++] = triple & 255;
+    }
+    return encodeBase64(out) === text ? out : null;
+}
+// src/verifone-pgp.js
+var P256_OID = Object.freeze([42, 134, 72, 206, 61, 3, 1, 7]);
+var ALGORITHM_ECDH = 18;
+var ENCRYPTING_ALGORITHMS = Object.freeze([1, 2, 16, 18]);
+var KNOWN_SYMMETRIC = Object.freeze([2, 3, 4, 7, 8, 9, 10]);
+var AES = Object.freeze({ 7: 16, 8: 24, 9: 32 });
+var KDF_HASHES = Object.freeze({ 8: "SHA-256", 9: "SHA-384", 10: "SHA-512" });
+var DEFAULT_SESSION_CIPHER = 7;
+var MESSAGE_BEGIN = "-----BEGIN PGP MESSAGE-----";
+var MESSAGE_END = "-----END PGP MESSAGE-----";
+var KEY_BEGIN = "-----BEGIN PGP PUBLIC KEY BLOCK-----";
+var KEY_END = "-----END PGP PUBLIC KEY BLOCK-----";
+var ARMOR_HEADERS = Object.freeze(["Version: OpenPGP.js v4.10.9", "Comment: https://openpgpjs.org"]);
+var VERIFONE_BLOB_PREFIX = "LS0tLS1CRUdJTiBQR1AgTUVTU0FHRS0tLS0t";
+var PGP_MESSAGE_ARMOR = MESSAGE_BEGIN;
+var MAX_BASE64 = 16384;
+var concat = (...parts) => {
+    const out = new Uint8Array(parts.reduce((total, part) => total + part.length, 0));
+    let at = 0;
+    for (const part of parts) {
+        out.set(part, at);
+        at += part.length;
+    }
+    return out;
+};
+var u16 = (n) => Uint8Array.of(n >> 8 & 255, n & 255);
+var u32 = (n) => Uint8Array.of(n >>> 24 & 255, n >>> 16 & 255, n >>> 8 & 255, n & 255);
+var readU32 = (bytes, at) => (bytes[at] << 24 | bytes[at + 1] << 16 | bytes[at + 2] << 8 | bytes[at + 3]) >>> 0;
+var hex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+var sameBytes = (a, b) => a.length === b.length && a.every((byte, i) => byte === b[i]);
+var asciiBytes = (text) => Uint8Array.from(text, (char) => char.charCodeAt(0));
+function asciiText(bytes) {
+    let out = "";
+    for (const byte of bytes) {
+        if (byte !== 9 && byte !== 10 && byte !== 13 && (byte < 32 || byte > 126))
+            return null;
+        out += String.fromCharCode(byte);
+    }
+    return out;
+}
+function crc24(bytes) {
+    let crc = 11994318;
+    for (const byte of bytes) {
+        crc ^= byte << 16;
+        for (let i = 0; i < 8; i++) {
+            crc <<= 1;
+            if (crc & 16777216)
+                crc ^= 25578747;
+        }
+    }
+    return crc & 16777215;
+}
+function dearmor(text, begin, end) {
+    const lines = text.split(/\r?\n/);
+    while (lines.length > 0 && lines[lines.length - 1] === "")
+        lines.pop();
+    if (lines.length < 4 || lines[0] !== begin || lines[lines.length - 1] !== end)
+        return null;
+    let at = 1;
+    const headers = [];
+    while (at < lines.length - 1 && lines[at] !== "") {
+        if (!/^[A-Za-z][A-Za-z0-9-]{0,63}: [ -~]{0,256}$/.test(lines[at]))
+            return null;
+        headers.push(lines[at]);
+        at += 1;
+    }
+    if (lines[at] !== "")
+        return null;
+    const body = lines.slice(at + 1, lines.length - 1);
+    let checksum = null;
+    if (body.length > 0 && body[body.length - 1].startsWith("="))
+        checksum = body.pop().slice(1);
+    if (body.length === 0 || !body.every((line) => /^[A-Za-z0-9+/=]{1,76}$/.test(line)))
+        return null;
+    const bytes = decodeBase64(body.join(""));
+    if (!bytes)
+        return null;
+    if (checksum !== null) {
+        const expected = decodeBase64(checksum);
+        if (!expected || expected.length !== 3 || (expected[0] << 16 | expected[1] << 8 | expected[2]) !== crc24(bytes))
+            return null;
+    }
+    return { bytes, headers };
+}
+function readPackets(bytes) {
+    const out = [];
+    let at = 0;
+    while (at < bytes.length) {
+        const head = bytes[at];
+        if (!(head & 128))
+            return null;
+        let tag;
+        let length;
+        let headerLength;
+        if (head & 64) {
+            tag = head & 63;
+            const first = bytes[at + 1];
+            if (first === void 0)
+                return null;
+            if (first < 192) {
+                length = first;
+                headerLength = 2;
+            }
+            else if (first < 224) {
+                if (at + 2 >= bytes.length)
+                    return null;
+                length = (first - 192 << 8) + bytes[at + 2] + 192;
+                headerLength = 3;
+            }
+            else if (first === 255) {
+                if (at + 5 >= bytes.length)
+                    return null;
+                length = readU32(bytes, at + 2);
+                headerLength = 6;
+            }
+            else
+                return null;
+        }
+        else {
+            tag = head >> 2 & 15;
+            const size = [1, 2, 4][head & 3];
+            if (!size || at + size >= bytes.length)
+                return null;
+            length = 0;
+            for (let i = 0; i < size; i++)
+                length = length * 256 + bytes[at + 1 + i];
+            headerLength = 1 + size;
+        }
+        if (at + headerLength + length > bytes.length)
+            return null;
+        out.push({ tag, body: bytes.subarray(at + headerLength, at + headerLength + length) });
+        at += headerLength + length;
+    }
+    return out.length > 0 ? out : null;
+}
+function packetHeader(tag, length) {
+    if (length < 192)
+        return Uint8Array.of(192 | tag, length);
+    if (length < 8384)
+        return Uint8Array.of(192 | tag, (length - 192 >> 8) + 192, length - 192 & 255);
+    return concat(Uint8Array.of(192 | tag, 255), u32(length));
+}
+function verifoneBlobInfo(value) {
+    if (typeof value !== "string" || !value.startsWith(VERIFONE_BLOB_PREFIX) || value.length > MAX_BASE64)
+        return null;
+    const decoded = decodeBase64(value);
+    const text = decoded ? asciiText(decoded) : null;
+    const armor = text === null ? null : dearmor(text, MESSAGE_BEGIN, MESSAGE_END);
+    const packets = armor ? readPackets(armor.bytes) : null;
+    if (!packets || packets.length !== 2)
+        return null;
+    const [pkesk, seipd] = packets;
+    if (pkesk.tag !== 1 || seipd.tag !== 18)
+        return null;
+    const b = pkesk.body;
+    if (b.length < 12 || b[0] !== 3 || b[9] !== ALGORITHM_ECDH || (b[10] << 8 | b[11]) !== 515 || b[12] !== 4)
+        return null;
+    const wrappedAt = 12 + 65;
+    const wrappedLength = b[wrappedAt];
+    if (![32, 40, 48].includes(wrappedLength) || b.length !== wrappedAt + 1 + wrappedLength)
+        return null;
+    if (seipd.body[0] !== 1 || seipd.body.length < 1 + 18 + 2 + 22)
+        return null;
+    return Object.freeze({
+        recipientKeyId: hex(b.subarray(1, 9)),
+        wrappedKeyLength: wrappedLength,
+        armorHeaders: Object.freeze([...armor.headers])
+    });
+}
+function isVerifoneBlob(value) {
+    return verifoneBlobInfo(value) !== null;
+}
+function hashedSubpackets(body) {
+    if (body.length < 6 || body[0] !== 4)
+        return null;
+    const hashedLength = body[4] << 8 | body[5];
+    if (6 + hashedLength > body.length)
+        return null;
+    const area = body.subarray(6, 6 + hashedLength);
+    const out = [];
+    let at = 0;
+    while (at < area.length) {
+        let length = area[at];
+        let size = 1;
+        if (length >= 192 && length < 255) {
+            if (at + 1 >= area.length)
+                return null;
+            length = (length - 192 << 8) + area[at + 1] + 192;
+            size = 2;
+        }
+        else if (length === 255) {
+            if (at + 4 >= area.length)
+                return null;
+            length = readU32(area, at + 1);
+            size = 5;
+        }
+        if (length < 1 || at + size + length > area.length)
+            return null;
+        out.push({ type: area[at + size] & 127, data: area.subarray(at + size + 1, at + size + length) });
+        at += size + length;
+    }
+    return out;
+}
+function keyPacket(body) {
+    if (body.length < 6 || body[0] !== 4)
+        return null;
+    return { created: readU32(body, 1), algorithm: body[5], fields: body.subarray(6) };
+}
+function ecdhFields(fields) {
+    const oidLength = fields[0];
+    const oid = fields.subarray(1, 1 + oidLength);
+    if (oidLength !== P256_OID.length || !sameBytes(oid, P256_OID))
+        return { refusal: "verifone_key_curve_unsupported" };
+    let at = 1 + oidLength;
+    const bits = fields[at] << 8 | fields[at + 1];
+    const point = fields.subarray(at + 2, at + 2 + (bits + 7 >> 3));
+    at += 2 + point.length;
+    if (bits !== 515 || point.length !== 65 || point[0] !== 4)
+        return { refusal: "verifone_key_malformed" };
+    const kdf = fields.subarray(at, at + 1 + fields[at]);
+    if (kdf.length !== 4 || kdf[0] !== 3 || kdf[1] !== 1 || at + 4 !== fields.length)
+        return { refusal: "verifone_key_malformed" };
+    if (!KDF_HASHES[kdf[2]] || !AES[kdf[3]])
+        return { refusal: "verifone_key_kdf_unsupported" };
+    return { point: Uint8Array.from(point), kdfHash: kdf[2], kekAlgorithm: kdf[3] };
+}
+async function fingerprintOf(body, subtle) {
+    return new Uint8Array(await subtle.digest("SHA-1", concat(Uint8Array.of(153), u16(body.length), body)));
+}
+var REVOCATIONS = Object.freeze([32, 40]);
+var CERTIFICATIONS = Object.freeze([16, 17, 18, 19]);
+async function readVerifonePublicKey(publicKeyBase64, facilities) {
+    if (typeof publicKeyBase64 !== "string" || publicKeyBase64.length === 0 || publicKeyBase64.length > MAX_BASE64)
+        return { refusal: "verifone_key_malformed" };
+    const decoded = decodeBase64(publicKeyBase64);
+    const text = decoded ? asciiText(decoded) : null;
+    const armor = text === null ? null : dearmor(text, KEY_BEGIN, KEY_END);
+    const packets = armor ? readPackets(armor.bytes) : null;
+    if (!packets || packets[0].tag !== 6)
+        return { refusal: "verifone_key_malformed" };
+    const primary = keyPacket(packets[0].body);
+    if (!primary)
+        return { refusal: "verifone_key_malformed" };
+    const subkeys = [];
+    const userIds = [];
+    const certifications = [];
+    for (const packet of packets.slice(1)) {
+        if (packet.tag === 13)
+            userIds.push(packet.body);
+        else if (packet.tag === 14) {
+            const subkey = keyPacket(packet.body);
+            if (!subkey)
+                return { refusal: "verifone_key_malformed" };
+            subkeys.push({ ...subkey, body: packet.body, bindings: [] });
+        }
+        else if (packet.tag === 2) {
+            const subpackets = hashedSubpackets(packet.body);
+            if (!subpackets)
+                return { refusal: "verifone_key_malformed" };
+            const type = packet.body[1];
+            if (REVOCATIONS.includes(type))
+                return { refusal: "verifone_key_revoked" };
+            const signature = { type, subpackets };
+            if (type === 24 && subkeys.length > 0)
+                subkeys[subkeys.length - 1].bindings.push(signature);
+            else if (CERTIFICATIONS.includes(type) && subkeys.length === 0)
+                certifications.push(signature);
+        }
+        else if (packet.tag !== 12 && packet.tag !== 17)
+            return { refusal: "verifone_key_malformed" };
+    }
+    if (userIds.length !== 1 || certifications.length === 0)
+        return { refusal: "verifone_key_malformed" };
+    const flagsOf = (signatures) => signatures?.flatMap((signature) => signature.subpackets).find((sub) => sub.type === 27)?.data[0];
+    const canEncrypt = (algorithm, flags) => ENCRYPTING_ALGORITHMS.includes(algorithm) && (flags === void 0 || (flags & 12) !== 0);
+    const encrypting = [
+        ...canEncrypt(primary.algorithm, flagsOf(certifications)) ? [{ ...primary, body: packets[0].body, bindings: null }] : [],
+        ...subkeys.filter((subkey) => canEncrypt(subkey.algorithm, flagsOf(subkey.bindings)))
+    ];
+    if (encrypting.length !== 1)
+        return { refusal: encrypting.length === 0 ? "verifone_key_not_encrypting" : "verifone_key_ambiguous" };
+    const key = encrypting[0];
+    if (key.algorithm !== ALGORITHM_ECDH)
+        return { refusal: "verifone_key_algorithm_unsupported" };
+    const ecdh = ecdhFields(key.fields);
+    if (ecdh.refusal)
+        return ecdh;
+    const now = facilities?.nowSeconds;
+    if (!Number.isSafeInteger(now))
+        return { refusal: "verifone_key_malformed" };
+    const expired = (created, signatures) => signatures.some((signature) => signature.subpackets.some((sub) => sub.type === 9 && sub.data.length === 4 && readU32(sub.data, 0) !== 0 && now >= created + readU32(sub.data, 0)));
+    if (expired(primary.created, certifications))
+        return { refusal: "verifone_key_expired" };
+    if (key.bindings !== null && (key.bindings.length === 0 || expired(key.created, key.bindings))) {
+        return { refusal: key.bindings.length === 0 ? "verifone_key_malformed" : "verifone_key_expired" };
+    }
+    const preferences = certifications[0].subpackets.find((sub) => sub.type === 11)?.data;
+    const first = preferences ? Array.from(preferences).find((algorithm) => KNOWN_SYMMETRIC.includes(algorithm)) : void 0;
+    const cipher = first ?? DEFAULT_SESSION_CIPHER;
+    if (!AES[cipher])
+        return { refusal: "verifone_key_cipher_unsupported" };
+    const subtle = facilities?.subtle;
+    if (!subtle)
+        return { refusal: "verifone_key_malformed" };
+    const fingerprint = await fingerprintOf(key.body, subtle);
+    const primaryFingerprint = await fingerprintOf(packets[0].body, subtle);
+    return Object.freeze({
+        primaryFingerprint: hex(primaryFingerprint),
+        encryptionSubkeyId: hex(fingerprint.subarray(12, 20)),
+        encryptionFingerprint: fingerprint,
+        point: ecdh.point,
+        kdfHash: ecdh.kdfHash,
+        kekAlgorithm: ecdh.kekAlgorithm,
+        sessionCipher: cipher
+    });
+}
+async function aesBlock(subtle, key, block) {
+    return new Uint8Array(await subtle.encrypt({ name: "AES-CBC", iv: new Uint8Array(16) }, key, block)).subarray(0, 16);
+}
+async function openpgpCfb(subtle, rawKey, plaintext) {
+    const key = await subtle.importKey("raw", rawKey, "AES-CBC", false, ["encrypt"]);
+    const out = new Uint8Array(plaintext.length);
+    let register = new Uint8Array(16);
+    for (let at = 0; at < plaintext.length; at += 16) {
+        const mask = await aesBlock(subtle, key, register);
+        const n = Math.min(16, plaintext.length - at);
+        for (let i = 0; i < n; i++)
+            out[at + i] = plaintext[at + i] ^ mask[i];
+        if (n < 16)
+            break;
+        register = out.slice(at, at + 16);
+    }
+    return out;
+}
+function armorMessage(message) {
+    const body = encodeBase64(message).match(/.{1,60}/g).join("\r\n");
+    const crc = crc24(message);
+    const checksum = encodeBase64(Uint8Array.of(crc >> 16, crc >> 8 & 255, crc & 255));
+    const armored = `${MESSAGE_BEGIN}\r
+${ARMOR_HEADERS.join("\r\n")}\r
+\r
+${body}\r
+=${checksum}\r
+${MESSAGE_END}\r
+`;
+    return encodeBase64(asciiBytes(armored));
+}
+async function verifoneEncryptText(key, text, facilities) {
+    const crypto = facilities?.crypto;
+    const subtle = crypto?.subtle;
+    if (!subtle || typeof crypto.getRandomValues !== "function")
+        throw new Error("Refusing to encrypt: no WebCrypto.");
+    if (!key || key.refusal || !(key.point instanceof Uint8Array) || !AES[key.sessionCipher] || !AES[key.kekAlgorithm] || !KDF_HASHES[key.kdfHash]) {
+        throw new Error("Refusing to encrypt: the Verifone key is not one this codec reads.");
+    }
+    if (!Number.isSafeInteger(facilities.nowMs) || facilities.nowMs < 0)
+        throw new Error("Refusing to encrypt: no clock.");
+    const ephemeral = await subtle.generateKey({ name: "ECDH", namedCurve: "P-256" }, true, ["deriveBits"]);
+    const ephemeralPoint = new Uint8Array(await subtle.exportKey("raw", ephemeral.publicKey));
+    const recipient = await subtle.importKey("raw", key.point, { name: "ECDH", namedCurve: "P-256" }, false, []);
+    const shared = new Uint8Array(await subtle.deriveBits({ name: "ECDH", public: recipient }, ephemeral.privateKey, 256));
+    const param = concat(Uint8Array.of(P256_OID.length), Uint8Array.from(P256_OID), Uint8Array.of(ALGORITHM_ECDH, 3, 1, key.kdfHash, key.kekAlgorithm), asciiBytes("Anonymous Sender    "), key.encryptionFingerprint);
+    const derived = new Uint8Array(await subtle.digest(KDF_HASHES[key.kdfHash], concat(u32(1), shared, param)));
+    const kek = await subtle.importKey("raw", derived.subarray(0, AES[key.kekAlgorithm]), "AES-KW", false, ["wrapKey"]);
+    const sessionKey = crypto.getRandomValues(new Uint8Array(AES[key.sessionCipher]));
+    const checksum = sessionKey.reduce((sum, byte) => sum + byte & 65535, 0);
+    const framed = concat(Uint8Array.of(key.sessionCipher), sessionKey, u16(checksum));
+    const pad = 8 - framed.length % 8;
+    const padded = concat(framed, new Uint8Array(pad).fill(pad));
+    const toWrap = await subtle.importKey("raw", padded, { name: "HMAC", hash: "SHA-256", length: padded.length * 8 }, true, ["sign"]);
+    const wrapped = new Uint8Array(await subtle.wrapKey("raw", toWrap, kek, "AES-KW"));
+    const keyId = key.encryptionFingerprint.subarray(12, 20);
+    const pkesk = concat(Uint8Array.of(3), keyId, Uint8Array.of(ALGORITHM_ECDH), u16(515), ephemeralPoint, Uint8Array.of(wrapped.length), wrapped);
+    const data = new TextEncoder().encode(text);
+    const literalBody = concat(Uint8Array.of(117, 7), asciiBytes("msg.txt"), u32(Math.floor(facilities.nowMs / 1e3)), data);
+    const literal = concat(packetHeader(11, literalBody.length), literalBody);
+    const prefix = crypto.getRandomValues(new Uint8Array(16));
+    const plain = concat(prefix, prefix.subarray(14, 16), literal, Uint8Array.of(211, 20));
+    const mdc = new Uint8Array(await subtle.digest("SHA-1", plain));
+    const sealed = await openpgpCfb(subtle, sessionKey, concat(plain, mdc));
+    const seipd = concat(Uint8Array.of(1), sealed);
+    return armorMessage(concat(packetHeader(1, pkesk.length), pkesk, packetHeader(18, seipd.length), seipd));
+}
+// src/verifone-core.js
+var VERIFONE_TEST_PANS = Object.freeze([
+    "4000000000002701",
+    "5200000000002235",
+    "340000000002708",
+    "4000000000001000",
+    "5200000000001005",
+    "340000000001007",
+    "4000000000002503",
+    "5200000000002151",
+    "4000000000001091"
+]);
+var VERIFONE_CLOCK_SKEW_MS = 12e4;
+var VERIFONE_BLOB_MAX = 4096;
+var PASS = Object.freeze({ verdict: "pass" });
+var abort = (reason) => Object.freeze({ verdict: "abort", reason });
+function textCarriesBlob(text) {
+    return text.includes(VERIFONE_BLOB_PREFIX) || text.includes(PGP_MESSAGE_ARMOR);
+}
+function jsonStrings(root) {
+    const out = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const value = stack.pop();
+        if (typeof value === "string")
+            out.push(value);
+        else if (Array.isArray(value))
+            for (const item of value)
+                stack.push(item);
+        else if (value !== null && typeof value === "object") {
+            for (const [key, child] of Object.entries(value)) {
+                out.push(key);
+                stack.push(child);
+            }
+        }
+    }
+    return out;
+}
+function decodedTexts(text) {
+    let parsed;
+    if (/^\s*[[{"]/.test(text)) {
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            parsed = void 0;
+        }
+    }
+    const out = [];
+    if (parsed !== void 0)
+        out.push(...jsonStrings(parsed));
+    else if (/[%+]/.test(text)) {
+        try {
+            for (const [name, value] of new URLSearchParams(text))
+                out.push(name, value);
+        }
+        catch {
+        }
+    }
+    return out.filter((decoded) => decoded !== text);
+}
+var DECODE_DEPTH = 6;
+function carriesAt(text, depth) {
+    if (textCarriesBlob(text))
+        return true;
+    const decoded = decodedTexts(text);
+    if (decoded.length === 0)
+        return false;
+    if (depth >= DECODE_DEPTH)
+        return true;
+    return decoded.some((inner) => carriesAt(inner, depth + 1));
+}
+function carriesVerifoneBlob(body) {
+    if (typeof body !== "string" || body === "")
+        return false;
+    return carriesAt(body, 0);
+}
+function blobStrings(parsed) {
+    return jsonStrings(parsed).filter((text) => carriesAt(text, 0)).length;
+}
+var digitsOf = (value) => typeof value === "string" || typeof value === "number" ? String(value).replace(/[ -]/g, "") : "";
+function verifoneCardPlaintext(card, nowMs) {
+    const number = digitsOf(card?.number);
+    if (!/^\d{12,19}$/.test(number))
+        throw new Error("Refusing to encrypt: the card number is not 12 to 19 digits.");
+    const monthText = String(card?.month ?? "");
+    if (!/^\d{1,2}$/.test(monthText) || Number(monthText) < 1 || Number(monthText) > 12)
+        throw new Error("Refusing to encrypt: the expiry month is not 1 to 12.");
+    const yearText = String(card?.year ?? "");
+    if (!/^(?:\d{2}|\d{4})$/.test(yearText))
+        throw new Error("Refusing to encrypt: the expiry year is not two or four digits.");
+    const year = yearText.length === 2 ? 2e3 + Number(yearText) : Number(yearText);
+    const cvv = typeof card?.cvc === "string" ? card.cvc : "";
+    if (!/^\d{3,4}$/.test(cvv))
+        throw new Error("Refusing to encrypt: the security code is not three or four digits.");
+    if (!Number.isSafeInteger(nowMs) || nowMs < 0)
+        throw new Error("Refusing to encrypt: no clock.");
+    const captureTime = `${new Date(nowMs).toISOString().split(".")[0]}Z`;
+    return JSON.stringify({ cardNumber: number, expiryMonth: Number(monthText), expiryYear: year, cvv, captureTime });
+}
+function verifoneClockSkewRefusal(deviceNowMs, serverNowMs) {
+    if (!Number.isSafeInteger(deviceNowMs) || !Number.isSafeInteger(serverNowMs))
+        return "verifone_clock_unknown";
+    return Math.abs(deviceNowMs - serverNowMs) > VERIFONE_CLOCK_SKEW_MS ? "verifone_clock_skew" : null;
+}
+var KEY_REFUSALS = Object.freeze({
+    verifone_key_unpinned: "Refusing to encrypt: Agentcard has not pinned this Verifone key.",
+    verifone_key_curve_unsupported: "Refusing to encrypt: the Verifone key is not on NIST P-256.",
+    verifone_key_expired: "Refusing to encrypt: this Verifone key has expired.",
+    verifone_key_revoked: "Refusing to encrypt: this Verifone key was revoked."
+});
+var KEY_UNUSABLE = "Refusing to encrypt: the Verifone key is not one Agentcard can use.";
+function makeVerifone(tables) {
+    const profiles = tables.profiles;
+    const pins = tables.pins;
+    const trusted = (id) => trustedVerifoneProfile(id, profiles);
+    const pinOf = (profile) => verifoneProfilePin(profile, pins);
+    function amountRefusal(profile, parsed) {
+        if (profile.amount === null)
+            return null;
+        const at = jsonAt(parsed, profile.amount);
+        const amount = at.found ? at.value : void 0;
+        const value = isPlainObject(amount) ? amount.value : void 0;
+        const currency = isPlainObject(amount) ? amount.currency : void 0;
+        const valueOk = typeof value === "number" ? Number.isSafeInteger(value) && value >= 0 : typeof value === "string" && /^\d{1,15}$/.test(value);
+        const currencyOk = typeof currency === "string" && /^[A-Za-z]{3}$/.test(currency);
+        return valueOk && currencyOk ? null : `the amount where ${profile.merchant}'s card request holds it is not the {value, currency} Agentcard reviewed, so it cannot be checked`;
+    }
+    function legBlob(leg, parsed) {
+        const holder = jsonAt(parsed, leg.holder);
+        if (!holder.found || !isPlainObject(holder.value) || !Object.prototype.hasOwnProperty.call(holder.value, leg.field))
+            return null;
+        const value = holder.value[leg.field];
+        return typeof value === "string" && value.length <= VERIFONE_BLOB_MAX && verifoneBlobInfo(value) ? value : null;
+    }
+    function classifyRequest(profileId, rawUrl, method, body) {
+        const profile = trusted(profileId);
+        if (typeof rawUrl !== "string" || !isVerifoneProfileOrigin(profile, rawUrl) || !carriesVerifoneBlob(body))
+            return PASS;
+        const leg = verifoneLegFor(profile, rawUrl, method);
+        if (!leg)
+            return abort(`the paused request sends a Verifone-encrypted card to ${profile.merchant} somewhere other than a card request Agentcard reviewed`);
+        const refusal = verifoneLegBodyRefusal(profile, leg, body);
+        if (refusal)
+            return abort(refusal);
+        const parsed = JSON.parse(body);
+        const placeholder = legBlob(leg, parsed);
+        if (!placeholder)
+            return abort(`the paused body does not carry the encrypted card where ${profile.merchant}'s card request holds it`);
+        if (blobStrings(parsed) !== 1)
+            return abort("the paused body carries more than one encrypted card");
+        const pin = pinOf(profile);
+        if (!pin)
+            return abort(`Agentcard has not reviewed ${profile.merchant}'s Verifone key`);
+        if (verifoneBlobInfo(placeholder).recipientKeyId !== pin.encryptionSubkeyId) {
+            return abort(`the page encrypted the card under a Verifone key Agentcard has not reviewed for ${profile.merchant}`);
+        }
+        const amount = amountRefusal(profile, parsed);
+        return amount ? abort(amount) : Object.freeze({ verdict: "pause", leg: leg.name });
+    }
+    function legName(profileId, rawUrl, method, checkoutOrigin) {
+        const profile = trusted(profileId);
+        return verifoneLegFor(profile, rawUrl, method, { checkoutOrigin })?.name ?? null;
+    }
+    function placeholderBlob(profileId, request) {
+        const verdict = classifyRequest(profileId, request?.url, request?.method, request?.body);
+        if (verdict.verdict !== "pause")
+            return null;
+        const profile = trusted(profileId);
+        return legBlob(profile.legs.find((leg) => leg.name === verdict.leg), JSON.parse(request.body));
+    }
+    async function encryptCard(card, request, facilities) {
+        const profile = verifoneProfileById(request?.profile, profiles);
+        if (!profile)
+            throw new Error("Refusing to encrypt: unknown Verifone merchant profile.");
+        if (verifoneProfileRefusal(profile, pins) !== null)
+            throw new Error("Refusing to encrypt: the Verifone merchant profile is not a reviewed one.");
+        if (profile.status !== "enabled")
+            throw new Error(`Refusing to encrypt: Agentcard has not turned on payments to ${profile.merchant} yet.`);
+        if (!verifoneLegFor(profile, request.url, request.method))
+            throw new Error("Refusing to encrypt: unsupported Verifone card request.");
+        const pin = pinOf(profile);
+        if (!pin)
+            throw new Error(KEY_REFUSALS.verifone_key_unpinned);
+        if (verifoneKeyPinShapeRefusal(pin) !== null)
+            throw new Error(KEY_UNUSABLE);
+        if (typeof request.sandbox !== "boolean" || pin.environment === "sandbox" !== request.sandbox) {
+            throw new Error("Refusing to encrypt: this Verifone key is for another environment than this payment's.");
+        }
+        if (pin.environment === "sandbox" && !VERIFONE_TEST_PANS.includes(digitsOf(card?.number))) {
+            throw new Error("Refusing to encrypt: the Verifone sandbox key encrypts only Verifone's published test cards.");
+        }
+        const nowMs = facilities?.nowMs;
+        if (!Number.isSafeInteger(nowMs) || nowMs < 0)
+            throw new Error("Refusing to encrypt: no clock.");
+        const key = await readVerifonePublicKey(pin.publicKeyBase64, { subtle: facilities?.crypto?.subtle, nowSeconds: Math.floor(nowMs / 1e3) });
+        if (key.refusal)
+            throw new Error(KEY_REFUSALS[key.refusal] ?? KEY_UNUSABLE);
+        if (key.primaryFingerprint !== pin.primaryFingerprint || key.encryptionSubkeyId !== pin.encryptionSubkeyId) {
+            throw new Error("Refusing to encrypt: the Verifone key is not the one Agentcard pinned.");
+        }
+        return verifoneEncryptText(key, verifoneCardPlaintext(card, nowMs), facilities);
+    }
+    function substitution(profileId, blob) {
+        const profile = trusted(profileId);
+        if (typeof blob !== "string" || blob.length > VERIFONE_BLOB_MAX || !verifoneBlobInfo(blob))
+            throw new Error("Refusing the Verifone blob: it is not one verifone.js writes.");
+        return { encoding: "json", kind: "verifone", profile: profile.id, blob };
+    }
+    function substitute(request, sub) {
+        if (!isPlainObject(sub) || Object.keys(sub).sort().join(",") !== "blob,encoding,kind,profile" || sub.encoding !== "json" || sub.kind !== "verifone") {
+            throw new Error("Refusing to substitute: not a Verifone substitution.");
+        }
+        const profile = trusted(sub.profile);
+        if (profile.status !== "enabled")
+            throw new Error(`Refusing to substitute: Agentcard has not turned on payments to ${profile.merchant} yet.`);
+        const verdict = classifyRequest(profile.id, request?.url, request?.method, request?.body);
+        if (verdict.verdict !== "pause")
+            throw new Error("Refusing to substitute: the paused request is not the card request Agentcard reviewed.");
+        const info = typeof sub.blob === "string" && sub.blob.length <= VERIFONE_BLOB_MAX ? verifoneBlobInfo(sub.blob) : null;
+        const pin = pinOf(profile);
+        if (!info || !pin || info.recipientKeyId !== pin.encryptionSubkeyId)
+            throw new Error("Refusing to substitute: the blob is not under the key Agentcard pinned.");
+        const parsed = JSON.parse(request.body);
+        const leg = profile.legs.find((candidate) => candidate.name === verdict.leg);
+        const holder = jsonAt(parsed, leg.holder).value;
+        if (holder[leg.field] === sub.blob)
+            throw new Error("Refusing to substitute: the blob is the page's own.");
+        holder[leg.field] = sub.blob;
+        return JSON.stringify(parsed);
+    }
+    function approvedBlobRefusal(blob, context) {
+        if (typeof blob !== "string" || blob.length > VERIFONE_BLOB_MAX)
+            return "verifone_substitution_invalid";
+        const info = verifoneBlobInfo(blob);
+        if (!info)
+            return "verifone_substitution_invalid";
+        if (!isPlainObject(context) || typeof context.sandbox !== "boolean" || typeof context.placeholderSha256 !== "string" || !/^[0-9a-f]{64}$/.test(context.placeholderSha256))
+            return "verifone_approval_context_invalid";
+        const profile = verifoneProfileById(context.profile, profiles);
+        if (!profile)
+            return "verifone_profile_unknown";
+        if (!verifoneLegFor(profile, context.url, context.method))
+            return "verifone_request_invalid";
+        const pin = pinOf(profile);
+        if (!pin)
+            return "verifone_key_unpinned";
+        if (pin.environment === "sandbox" !== context.sandbox)
+            return "verifone_environment_mismatch";
+        if (info.recipientKeyId !== pin.encryptionSubkeyId)
+            return "verifone_key_mismatch";
+        if (sha256Hex(blob) === context.placeholderSha256)
+            return "verifone_blob_unchanged";
+        return null;
+    }
+    function isPreparedRequest(url, method, body, profileId) {
+        const profile = verifoneProfileById(profileId, profiles);
+        return !!profile && profile.status === "enabled" && verifoneProfileRefusal(profile, pins) === null && classifyRequest(profile.id, url, method, body).verdict === "pause";
+    }
+    function endpointFor(profileId, checkoutOrigin) {
+        const profile = trusted(profileId);
+        const pair = profile.origins.find((candidate) => candidate.checkout === checkoutOrigin);
+        if (!pair || profile.legs.length !== 1)
+            return null;
+        const leg = profile.legs[0];
+        if (leg.path.split("/").some((segment) => segment.startsWith(":")) || Object.values(leg.query).some((value) => value.startsWith(":")))
+            return null;
+        const query = Object.entries(leg.query).map(([key, value]) => `${key}=${value}`).join("&");
+        const url = `${pair.endpoint}${leg.path}${query ? `?${query}` : ""}`;
+        return urlTemplateMatch({ path: leg.path, query: leg.query }, url) ? url : null;
+    }
+    function templatedUrl(profileId, rawUrl) {
+        const profile = trusted(profileId);
+        let origin = null;
+        try {
+            origin = new URL(rawUrl).origin;
+        }
+        catch {
+            origin = null;
+        }
+        const pair = profile.origins.find((candidate) => candidate.endpoint === origin) ?? profile.origins[0];
+        const leg = typeof rawUrl === "string" && typeof origin === "string" ? verifoneLegFor(profile, rawUrl, "POST") : null;
+        return leg ? `${pair.endpoint}${leg.path}` : `${pair.endpoint}/`;
+    }
+    function urlGlobs(profileId) {
+        const profile = trusted(profileId);
+        return [...new Set(profile.origins.map((pair) => `${pair.endpoint}/*`))];
+    }
+    return Object.freeze({
+        classifyRequest,
+        legName,
+        placeholderBlob,
+        encryptCard,
+        substitution,
+        substitute,
+        approvedBlobRefusal,
+        isPreparedRequest,
+        endpointFor,
+        templatedUrl,
+        urlGlobs,
+        amountPath: (profileId) => {
+            const path = trusted(profileId).amount;
+            return path === null ? null : [...path];
+        }
+    });
+}
+// src/verifone.js
+var core = /* @__PURE__ */ makeVerifone({ profiles: VERIFONE_MERCHANT_PROFILES, pins: VERIFONE_KEY_PINS });
+var VERIFONE_SUBSTITUTION = /* @__PURE__ */ Object.freeze({ at: "merchant_profile", fields: Object.freeze(["encryptedCard"]) });
+function classifyVerifoneRequest(profileId, url, method, body) {
+    return core.classifyRequest(profileId, url, method, body);
+}
+function verifoneLegName(profileId, url, method, checkoutOrigin) {
+    return core.legName(profileId, url, method, checkoutOrigin);
+}
+function verifonePlaceholderBlob(profileId, request) {
+    return core.placeholderBlob(profileId, request);
+}
+function encryptVerifoneCard(card, request, facilities) {
+    return core.encryptCard(card, request, facilities);
+}
+function verifoneSubstitution(profileId, blob) {
+    return core.substitution(profileId, blob);
+}
+function substituteVerifoneBlob(request, sub) {
+    return core.substitute(request, sub);
+}
+function verifoneApprovedBlobRefusal(blob, context) {
+    return core.approvedBlobRefusal(blob, context);
+}
+function isPreparedVerifoneRequest(url, method, body, profileId) {
+    return core.isPreparedRequest(url, method, body, profileId);
+}
+function verifoneProfileEndpointFor(profileId, checkoutOrigin) {
+    return core.endpointFor(profileId, checkoutOrigin);
+}
+function verifoneProfileTemplatedUrl(profileId, url) {
+    return core.templatedUrl(profileId, url);
+}
+function verifoneProfileUrlGlobs(profileId) {
+    return core.urlGlobs(profileId);
+}
+function verifoneProfileAmountPath(profileId) {
+    return core.amountPath(profileId);
+}
+function verifoneProfileEnvironment(profileId) {
+    const profile = verifoneProfileById(profileId);
+    if (!profile)
+        throw new Error("Refusing to pay: unknown Verifone merchant profile.");
+    return profile.environment;
+}
+function verifoneMerchantProfile(id) {
+    const profile = verifoneProfileById(id);
+    return profile ? deepFreeze({ id: profile.id, merchant: profile.merchant, status: profile.status, environment: profile.environment }) : null;
+}
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (isPlainObject(value))
+        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+    return JSON.stringify(value) ?? "null";
+}
+function verifoneProfileRulesMatch(profileId, served) {
+    const built = VERIFONE_PROFILE_RECOGNIZERS.find((entry) => entry.id === profileId);
+    if (!built || !isPlainObject(served) || served.id !== built.id)
+        return false;
+    const { status: _built, ...mine } = built;
+    const { status: _served, ...theirs } = served;
+    try {
+        return canonical(mine) === canonical(theirs);
+    }
+    catch {
+        return false;
+    }
+}
+export { VERIFONE_BLOB_MAX, VERIFONE_BLOB_PREFIX, VERIFONE_CLOCK_SKEW_MS, VERIFONE_KEY_PINS, VERIFONE_MERCHANT_PROFILES, VERIFONE_PROFILE_RECOGNIZERS, VERIFONE_SUBSTITUTION, VERIFONE_TEST_PANS, carriesVerifoneBlob, classifyVerifoneRequest, encryptVerifoneCard, isPreparedVerifoneRequest, isVerifoneBlob, substituteVerifoneBlob, verifoneApprovedBlobRefusal, verifoneBlobInfo, verifoneCardPlaintext, verifoneClockSkewRefusal, verifoneKeyPinShapeRefusal, verifoneLegName, verifoneMerchantProfile, verifonePlaceholderBlob, verifoneProfileAmountPath, verifoneProfileEndpointFor, verifoneProfileEnvironment, verifoneProfileRefusal, verifoneProfileRulesMatch, verifoneProfileTemplatedUrl, verifoneProfileUrlGlobs, verifoneSubstitution };