@agent-cards/sdk 0.20.0 → 0.22.0

package/dist/payrails.js

@@ -0,0 +1,305 @@
+// Payrails web SDK v6 secure fields (Blacklane's consumer checkout), as the checkout SDK sees it.
+//
+// payrails.js 6.5.0 saves a card with one fetch from the merchant page: a POST to the session's
+// vaultConfiguration.links.saveInstrument.href (https://api-pub.payrails.io/public/payment/instruments;
+// test hosts api-pub.staging.payrails.io and sandbox-api-pub.staging.payrails.io). Its body carries
+// the whole card as one JWE, made in Payrails' secure frame under a per-session RSA key. That key
+// is not in the paused request: it comes in the init payload ({version, data}) the merchant's
+// backend hands the page before the card form renders. So the runtime reads the page's own XHR and
+// fetch answers for that payload and keeps, per attachment and in memory only, each session's
+// token, holderReference, providerConfigId, saveInstrument href and key. When a card save pauses,
+// exactly one captured session must match it on all four, seen at most nine minutes before. Its key
+// rides on the create (request.payrails.encryption_public_key); the cardholder's device encrypts
+// the real card under it and sends the save itself (mode device_encrypt); and the page receives
+// only Payrails' 201, rebuilt from an allow-list. The device's ciphertext never reaches this runtime.
+//
+// The registry entry ships dark (capability payrails_device_encrypt). This build declares the
+// capability and the mode on syncRegistry, and the API serves the entry only to an org Agentcard
+// enabled for Payrails. For every other org nothing here runs: no answer is read, no Payrails host
+// is intercepted, and Payrails' requests go through untouched, exactly as before.
+//
+// For an org in the dark launch, the pre-claim gate (pre-claim.ts) judges every POST to a Payrails
+// host before the terminal arbiter would pause it:
+//   - a card save payment-core's guard refuses (not the SDK's exact body, a future usage with no
+//     approval wording, or a save that keeps the card on file without the cardholder's consent)
+//     aborts as an unsupported checkout before any create or prompt, and the attachment holds: the
+//     merchant's integration decides that shape, so the page's next save would be the same;
+//   - a card save with no captured session, or whose captured key is not as long as the key the
+//     page's frame wrapped, aborts alone: the agent reloads the checkout and tries again;
+//   - a payment that carries an encrypted card inside paymentComposition (paying with the card
+//     form, or a stored card with a CVC field) aborts as an unsupported checkout, so the agent's
+//     placeholder card never reaches an authorization;
+//   - a POST with no body the gate can read (none, an empty one, or one the adapter could not
+//     read) aborts alone, on both adapters alike (pre-claim.ts says why), except on Payrails'
+//     static host, which serves files and takes no payment;
+//   - every other request continues.
+import { PAYRAILS_CAPABILITY, PAYRAILS_PSP, PAYRAILS_SAVE_HOSTS, PAYRAILS_SAVE_PATH, classifyPayrailsRequest, isPayrailsSaveUrl, payrailsAuthorizeCarriesCard, payrailsCardOnFileRefusal, payrailsResponseOutcome, payrailsSessionKeyRefusal, } from './payrails.generated.js';
+export { PAYRAILS_CAPABILITY, PAYRAILS_PSP };
+/**
+ * How the pre-claim gate reads a POST to a Payrails host: `card` for a card save on a save URL
+ * (data.encryptedData present, payment-core's pause predicate), `card_payment` for a payment that
+ * carries an encrypted card inside paymentComposition, and null for anything else, which continues.
+ */
+export function payrailsRequestKind(url, method, body) {
+    if (method.toUpperCase() !== 'POST')
+        return null;
+    if (classifyPayrailsRequest(url, 'POST', body) === 'card')
+        return 'card';
+    return payrailsAuthorizeCarriesCard(url, 'POST', body) ? 'card_payment' : null;
+}
+/** Refusals of the save's own shape: the page's next save would be the same, so the attachment holds. */
+export const PAYRAILS_HOLDING_REASONS = [
+    'unsupported_payrails_card_payment', 'payrails_request_malformed', 'payrails_not_card_save',
+    'payrails_jwe_malformed', 'payrails_future_usage_refused', 'payrails_card_on_file_consent_required',
+];
+/** What the agent reads when a save's session cannot be bound. Not shown to the cardholder. */
+export const PAYRAILS_SESSION_MESSAGE = 'Payrails session expired, reload the checkout';
+/** Captured sessions kept per attachment; the oldest is dropped first. */
+export const PAYRAILS_CAPTURE_LIMIT = 8;
+/** How long a captured session is kept at all. */
+export const PAYRAILS_CAPTURE_TTL_MS = 15 * 60_000;
+/** How old a captured session may be when its save pauses: Payrails gives a session key ten minutes. */
+export const PAYRAILS_SESSION_MAX_AGE_MS = 9 * 60_000;
+/** The largest answer body read for an init payload. */
+export const PAYRAILS_INIT_BODY_LIMIT = 256 * 1024;
+/** How long a paused save waits for answer bodies still being read before it binds. */
+export const PAYRAILS_PENDING_READ_MS = 1_000;
+/** Fetch interception patterns for every Payrails host, armed only for an org the API served Payrails to. */
+export const PAYRAILS_GUARD_PATTERNS = ['https://*.payrails.io/*'];
+const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const text = (value, max) => typeof value === 'string' && value.length > 0 && value.length <= max
+    && !/[\u0000-\u001f\u007f]/.test(value);
+/** Standard base64 of UTF-8 JSON, as Payrails writes an init payload's `data`; null when it is not. */
+function base64Json(value) {
+    if (value.length > PAYRAILS_INIT_BODY_LIMIT)
+        return null;
+    try {
+        const bytes = Uint8Array.from(atob(value), (c) => c.charCodeAt(0));
+        return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+    }
+    catch {
+        return null;
+    }
+}
+/** The binding fields of one init payload `{version, data}`, or null when `candidate` is not one. */
+function sessionOf(candidate) {
+    if (!record(candidate) || typeof candidate.version !== 'string' || typeof candidate.data !== 'string')
+        return null;
+    const data = base64Json(candidate.data);
+    if (!record(data) || !record(data.vaultConfiguration))
+        return null;
+    const vault = data.vaultConfiguration;
+    const save = record(vault.links) ? vault.links.saveInstrument : undefined;
+    const href = record(save) ? save.href : undefined;
+    if (!text(data.token, 8192) || !text(data.holderReference, 256) || !text(vault.providerConfigId, 64)
+        || !text(vault.encryptionPublicKey, 1024) || !text(href, 2048) || !isPayrailsSaveUrl(href, { exact: true }))
+        return null;
+    return { token: data.token, holderReference: data.holderReference, providerConfigId: vault.providerConfigId,
+        saveInstrumentHref: href, encryptionPublicKey: vault.encryptionPublicKey };
+}
+/**
+ * Every Payrails init payload one JSON answer body carries: the body itself, or its members one
+ * level down (an object's values or an array's items). An init payload is `{version, data}` whose
+ * `data` decodes to JSON with a token, a holderReference and a vaultConfiguration naming its
+ * providerConfigId, its encryptionPublicKey and a saveInstrument href on a Payrails save URL.
+ */
+export function payrailsInitSessions(body) {
+    if (typeof body !== 'string' || body.length === 0 || body.length > PAYRAILS_INIT_BODY_LIMIT)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return [];
+    }
+    const top = sessionOf(parsed);
+    if (top)
+        return [top];
+    const members = Array.isArray(parsed) ? parsed : record(parsed) ? Object.values(parsed) : [];
+    return members.map(sessionOf).filter((session) => session !== null);
+}
+/** Whether an answer may carry an init payload worth reading: a 2xx XHR or fetch with a JSON type. */
+export function payrailsInitCandidate(resourceType, status, contentType) {
+    return typeof resourceType === 'string' && ['xhr', 'fetch'].includes(resourceType.toLowerCase())
+        && typeof status === 'number' && status >= 200 && status < 300
+        && typeof contentType === 'string' && /json/i.test(contentType);
+}
+const sameSession = (a, b) => a.token === b.token && a.holderReference === b.holderReference
+    && a.providerConfigId === b.providerConfigId && a.saveInstrumentHref === b.saveInstrumentHref
+    && a.encryptionPublicKey === b.encryptionPublicKey;
+/** The bearer token a paused save carries in `authorization`, any case of the name; null otherwise. */
+function bearerOf(headers) {
+    const values = Object.entries(headers ?? {}).filter(([name]) => name.toLowerCase() === 'authorization').map(([, value]) => value);
+    if (values.length !== 1 || typeof values[0] !== 'string')
+        return null;
+    const match = /^Bearer ([^\s]+)$/.exec(values[0]);
+    return match ? match[1] : null;
+}
+/** The save body's holderReference and data.vaultProviderConfigId, read leniently; null when absent. */
+function saveBindingOf(body) {
+    try {
+        const parsed = JSON.parse(body);
+        const data = record(parsed) ? parsed.data : undefined;
+        if (!record(parsed) || !record(data) || typeof parsed.holderReference !== 'string' || typeof data.vaultProviderConfigId !== 'string')
+            return null;
+        return { holderReference: parsed.holderReference, providerConfigId: data.vaultProviderConfigId };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The Payrails sessions one attachment has seen, in memory only: at most PAYRAILS_CAPTURE_LIMIT,
+ * each dropped PAYRAILS_CAPTURE_TTL_MS after it was first seen. Nothing here is ever logged or
+ * reported; the key leaves it only on the create for the one save it binds to.
+ *
+ * The capture runs on the agent's side and trusts nothing it reads: a page can hand it any key.
+ * The binding catches a stale session or a runtime bug. What bounds a key an agent supplies is
+ * elsewhere: the device sends the ciphertext only to a Payrails host, the API holds the token to
+ * the Payrails workspace Agentcard reviewed for the merchant, and the page never sees the
+ * ciphertext the device made.
+ */
+export class PayrailsSessionCapture {
+    sessions = [];
+    reads = new Set();
+    /** Record the init payloads an answer body carries; how many it carried. Never throws. */
+    observe(body, now = Date.now()) {
+        let found;
+        try {
+            found = payrailsInitSessions(body);
+        }
+        catch {
+            return 0;
+        }
+        this.prune(now);
+        for (const session of found) {
+            // A session seen again keeps its first sighting: its age is the session's, not the read's.
+            if (this.sessions.some((seen) => sameSession(seen, session)))
+                continue;
+            this.sessions.push({ ...session, seenAt: now });
+            if (this.sessions.length > PAYRAILS_CAPTURE_LIMIT)
+                this.sessions.shift();
+        }
+        return found.length;
+    }
+    /** An answer body still being read: a save that pauses meanwhile waits for it, briefly. */
+    reading(read) {
+        const tracked = read.then(() => { }, () => { }).finally(() => { this.reads.delete(tracked); });
+        this.reads.add(tracked);
+    }
+    /** Whether an answer body is still being read. */
+    get pending() { return this.reads.size > 0; }
+    /** Wait for the answer bodies being read, at most `ms`. */
+    async settle(ms = PAYRAILS_PENDING_READ_MS) {
+        if (!this.reads.size)
+            return;
+        let timer;
+        try {
+            await Promise.race([Promise.allSettled([...this.reads]), new Promise((resolve) => { timer = setTimeout(resolve, ms); })]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    /**
+     * The session key for a paused card save: the key of the captured session whose token is the
+     * save's bearer token, whose saveInstrument href is the save's URL, and whose holderReference and
+     * providerConfigId are the body's, first seen at most PAYRAILS_SESSION_MAX_AGE_MS before `now`.
+     * Null when none matches, or when matching sessions disagree on the key.
+     */
+    keyFor(request, now = Date.now()) {
+        this.prune(now);
+        const token = bearerOf(request.headers);
+        const binding = typeof request.body === 'string' ? saveBindingOf(request.body) : null;
+        if (!token || !binding)
+            return null;
+        const keys = new Set(this.sessions.filter((session) => session.token === token && session.saveInstrumentHref === request.url
+            && session.holderReference === binding.holderReference && session.providerConfigId === binding.providerConfigId
+            && session.seenAt <= now && now - session.seenAt <= PAYRAILS_SESSION_MAX_AGE_MS).map((session) => session.encryptionPublicKey));
+        return keys.size === 1 ? [...keys][0] : null;
+    }
+    /** How many sessions are held; for tests. */
+    get size() { return this.sessions.length; }
+    prune(now) {
+        this.sessions = this.sessions.filter((session) => session.seenAt <= now && now - session.seenAt < PAYRAILS_CAPTURE_TTL_MS);
+    }
+}
+/**
+ * Whether the vault's current registry pauses Payrails' card save in mode device_encrypt: true only
+ * after syncRegistry() for an org the API serves the dark entry to. Everything Payrails-specific in
+ * the adapters (reading answers, intercepting Payrails hosts) runs only when this is true.
+ */
+export function recognizesPayrails(vault) {
+    if (!vault || typeof vault.isCardRequest !== 'function')
+        return false;
+    try {
+        return PAYRAILS_SAVE_HOSTS.some((host) => {
+            const url = `https://${host}${PAYRAILS_SAVE_PATH}`;
+            return vault.isCardRequest(url, 'POST')
+                && (typeof vault.checkoutModeOf !== 'function' || vault.checkoutModeOf(url, 'POST') === 'device_encrypt');
+        });
+    }
+    catch {
+        return false;
+    }
+}
+/** A Payrails host: https on the standard port, no userinfo, a hostname under payrails.io. */
+export function isPayrailsHost(rawUrl) {
+    let url;
+    try {
+        url = new URL(rawUrl);
+    }
+    catch {
+        return false;
+    }
+    return url.protocol === 'https:' && !url.port && !url.username && !url.password
+        && /(?:^|\.)payrails\.io$/.test(url.hostname.toLowerCase().replace(/\.$/, ''));
+}
+/** Payrails' static host: it serves the web SDK and the secure frame's files, and takes no payment. */
+export const PAYRAILS_STATIC_HOST = 'assets.payrails.io';
+/** A Payrails host (isPayrailsHost) that is exactly the static host. */
+export function isPayrailsStaticHost(rawUrl) {
+    return isPayrailsHost(rawUrl) && new URL(rawUrl).hostname.toLowerCase().replace(/\.$/, '') === PAYRAILS_STATIC_HOST;
+}
+/**
+ * payment-core's judgement of a card save's own shape, before any session is looked up: null when
+ * the save is the SDK's exact card save and keeps no card on file the cardholder has not consented
+ * to, else the refusal code. A guard that throws refuses.
+ */
+export function payrailsSaveRefusal(body) {
+    try {
+        return payrailsCardOnFileRefusal(body) ?? null;
+    }
+    catch {
+        return 'payrails_request_malformed';
+    }
+}
+/**
+ * The key check for a bound session: null when the captured key is an RSA-2048, 3072 or 4096 key as
+ * long as the key the page's frame wrapped for this save, else the refusal code.
+ */
+export function payrailsKeyRefusal(key, body) {
+    try {
+        return payrailsSessionKeyRefusal(key, body) ?? null;
+    }
+    catch {
+        return 'payrails_key_invalid';
+    }
+}
+/**
+ * The only answer the page may receive for an approved Payrails save: Payrails' 201 for a card
+ * instrument, rebuilt from payment-core's allow-list (the BIN cut to six digits), under a JSON
+ * content type. Null for anything else.
+ */
+export function payrailsSaveAnswer(status, body) {
+    try {
+        const verdict = payrailsResponseOutcome(status, body);
+        const answer = verdict.outcome === 'approved' ? verdict.body : undefined;
+        return typeof answer === 'string' ? { status: 201, headers: { 'content-type': 'application/json' }, body: answer } : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/pelecard.d.ts

@@ -0,0 +1,32 @@
+export declare const PELECARD_PSP = "pelecard";
+/** The dark-launch capability the API serves the pelecard recognizer behind. */
+export declare const PELECARD_CAPABILITY = "pelecard_transaction";
+/**
+ * Why the SDK refuses a Pelecard card submission before anything is claimed, created or prompted.
+ * The codes are the API's own for the same requests, so an integrator reads one code whether the
+ * browser or the API refused:
+ *   - `invalid_pelecard_request`: not the page's own one-time card submission. That covers a saved
+ *     token, a card track, a phone authorization, a wallet, Bit or bank field beside a card,
+ *     installments, a buyer-typed total, a key the page never builds, the exact URL spelled any
+ *     other way, or headers the page does not send. The cardholder's device could never fill it.
+ *   - `pelecard_keep_on_file_unsupported`: a sound submission that asks Pelecard to keep the card
+ *     on file (AskForTokenChecked true, or any CreateToken), so the merchant could charge it later
+ *     without another approval. Only the cardholder can agree to that, and no approval asks them yet.
+ */
+export type PelecardRefusalReason = 'invalid_pelecard_request' | 'pelecard_keep_on_file_unsupported';
+/** True when the URL's host is one of Pelecard's two payment page hosts. */
+export declare function isPelecardHost(url: string): boolean;
+/**
+ * The pause decision for a card-carrying POST the registry recognized on a Pelecard host. Null
+ * when it is the page's own one-time new-card submission, which pauses for approval; otherwise
+ * the reason it is refused. It judges the whole request (the exact URL, the page's JSON content
+ * type with Payment.js's own `charse0t` spelling, jQuery's X-Requested-With, and a body of the
+ * page's own keys) with payment-core's pelecardTransactionRefusal, the check the API runs at
+ * create and the device runs before it writes a card. It never passes keep-on-file consent:
+ * that waits for an approval that asks the cardholder.
+ */
+export declare function pelecardRefusal(request: {
+    url: string;
+    headers: Record<string, string>;
+    body: string | null;
+}): PelecardRefusalReason | null;

package/dist/pelecard.generated.d.ts

@@ -0,0 +1,32 @@
+declare var PELECARD_TRANSACTION_HOSTS: readonly string[];
+declare var PELECARD_TRANSACTION_PATH: string;
+declare var PELECARD_REFUSAL_REASONS: readonly string[];
+declare function isPelecardTransactionUrl(url: any, method?: string): boolean;
+declare function pelecardBodyRefusal(body: any): "unsupported" | "keep_on_file" | null;
+declare function isPelecardNewCardBody(body: any): boolean;
+declare function pelecardKeepOnFileRequested(body: any): boolean | null;
+declare function classifyPelecardRequest(url: any, method: any, body: any): "card" | "unsupported" | "keep_on_file" | null;
+declare function pelecardTransactionRefusal(request: any): "unsupported" | "keep_on_file" | null;
+declare function isPelecardTransactionRequest(request: any): boolean;
+declare function pelecardRefusalMessage(reason: any): string;
+declare function injectPelecardCard(body: any, card: any): {
+    body: string;
+    where: string[];
+};
+declare function pelecardResponseOutcome(status: any, body: any): {
+    outcome: string;
+    code: any;
+    reason?: undefined;
+} | {
+    outcome: string;
+    reason: string;
+    code?: undefined;
+} | {
+    outcome: string;
+};
+declare function sanitizePelecardResponse(body: any): string;
+declare function pelecardFacts(status: any, body: any): {
+    outcome: string;
+    refusalCode: any;
+};
+export { PELECARD_REFUSAL_REASONS, PELECARD_TRANSACTION_HOSTS, PELECARD_TRANSACTION_PATH, classifyPelecardRequest, injectPelecardCard, isPelecardNewCardBody, isPelecardTransactionRequest, isPelecardTransactionUrl, pelecardBodyRefusal, pelecardFacts, pelecardKeepOnFileRequested, pelecardRefusalMessage, pelecardResponseOutcome, pelecardTransactionRefusal, sanitizePelecardResponse };

package/dist/pelecard.generated.js

@@ -0,0 +1,283 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: 7b1296f83822ae81c64835c270ff9048fddb6efe0d7cdbe37ba42b8a81ac03d0
+// src/json-path.js
+function roundTrips(parsed, body) {
+    try {
+        return JSON.stringify(parsed) === body;
+    }
+    catch {
+        return false;
+    }
+}
+// src/pelecard.js
+var PELECARD_TRANSACTION_HOSTS = /* @__PURE__ */ Object.freeze(["gateway21.pelecard.biz", "gateway20.pelecard.biz"]);
+var PELECARD_TRANSACTION_PATH = "/PaymentGW/Transaction";
+var PELECARD_REFUSAL_REASONS = /* @__PURE__ */ Object.freeze(["unsupported", "keep_on_file"]);
+var UNSUPPORTED_REFUSAL = "Refusing to pay: unsupported Pelecard card payment request.";
+var KEEP_ON_FILE_REFUSAL = "Refusing to pay: this Pelecard payment would keep the card on file without your consent. Nothing was sent.";
+var TEST_CARD_REFUSAL = "Refusing to pay: a Pelecard checkout takes only a documented test card, because the merchant can have Pelecard keep the card without asking you. Nothing was sent.";
+var BODY_LIMIT = 32768;
+var RESPONSE_LIMIT = 32768;
+var MODEL_KEYS = [
+    "TransactionId",
+    "CreditCardNumber",
+    "CreditCardHolder",
+    "IdNumber",
+    "CreditCardDate",
+    "CvvNumber",
+    "FreeTotal",
+    "NumOfPayments",
+    "FirstPayment",
+    "EachPayment",
+    "Email",
+    "Phone",
+    "Address",
+    "City",
+    "Country",
+    "AddressIndex",
+    "Track2",
+    "Token",
+    "AgentCallTrxId",
+    "Platform",
+    "WalletType",
+    "Captcha",
+    "BankNumber",
+    "BranchNumber",
+    "AccountNumber"
+];
+var OPTIONAL_KEYS = ["IsIframe", "AskForTokenChecked", "BusinessNumber", "Remarks", "ReCaptchaToken", "CreateToken"];
+var NON_CARD_KEYS = ["Track2", "Token", "AgentCallTrxId", "WalletType", "BankNumber", "BranchNumber", "AccountNumber", "Platform"];
+var EMPTY_TERMS_KEYS = ["FreeTotal", "FirstPayment", "EachPayment"];
+var TEXT_KEYS = ["CreditCardHolder", "IdNumber", "Email", "Phone", "Address", "City", "Country", "AddressIndex", "BusinessNumber", "Remarks"];
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var owns = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var exact = (pattern, value) => typeof value === "string" && pattern.exec(value)?.[0] === value;
+var text = (value, max) => typeof value === "string" && value.length <= max && !/[\u0000-\u001f\u007f]/.test(value);
+var digits = (value, min, max) => typeof value === "string" && value.length >= min && value.length <= max && !/[^0-9]/.test(value);
+var GUID = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+var MMYY = /^(?:0[1-9]|1[0-2])[0-9]{2}$/;
+var TYPED_PAN = /^[0-9](?:[0-9 -]{0,30}[0-9])?$/;
+var typedPan = (value) => exact(TYPED_PAN, value) && digits(value.replace(/[ -]/g, ""), 12, 19);
+var asksForToken = (value) => value === true || value === 1 || typeof value === "string" && /^(?:true|1)$/i.test(value.trim());
+function isPelecardTransactionUrl(url, method = "POST") {
+    if (method !== "POST" || typeof url !== "string" || url.length > 256 || url.includes("?") || url.includes("#"))
+        return false;
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    return parsed.href === url && parsed.protocol === "https:" && !parsed.port && !parsed.username && !parsed.password && !parsed.search && !parsed.hash && PELECARD_TRANSACTION_HOSTS.includes(parsed.hostname) && parsed.pathname === PELECARD_TRANSACTION_PATH;
+}
+function judgeBody(body) {
+    if (typeof body !== "string" || body === "" || body.length > BODY_LIMIT)
+        return null;
+    let value;
+    try {
+        value = JSON.parse(body);
+    }
+    catch {
+        return null;
+    }
+    if (!record(value) || !roundTrips(value, body))
+        return null;
+    if (!Object.keys(value).every((key) => MODEL_KEYS.includes(key) || OPTIONAL_KEYS.includes(key)) || !MODEL_KEYS.every((key) => owns(value, key)))
+        return null;
+    if (!exact(GUID, value.TransactionId) || !typedPan(value.CreditCardNumber) || !exact(MMYY, value.CreditCardDate) || value.CvvNumber !== "" && !digits(value.CvvNumber, 3, 4))
+        return null;
+    if (value.NumOfPayments !== "1" || !EMPTY_TERMS_KEYS.every((key) => value[key] === "") || !NON_CARD_KEYS.every((key) => value[key] === ""))
+        return null;
+    if (!TEXT_KEYS.every((key) => !owns(value, key) || text(value[key], key === "Remarks" ? 1024 : 256)) || !exact(/^[A-Za-z0-9]{0,16}$/, value.Captcha) || owns(value, "ReCaptchaToken") && !exact(/^[A-Za-z0-9_-]{1,4096}$/, value.ReCaptchaToken) || owns(value, "IsIframe") && typeof value.IsIframe !== "boolean" || owns(value, "AskForTokenChecked") && typeof value.AskForTokenChecked !== "boolean" || owns(value, "CreateToken") && !asksForToken(value.CreateToken))
+        return null;
+    return { value, keepOnFile: value.AskForTokenChecked === true || owns(value, "CreateToken") };
+}
+function pelecardBodyRefusal(body) {
+    const judged = judgeBody(body);
+    if (!judged)
+        return "unsupported";
+    return judged.keepOnFile ? "keep_on_file" : null;
+}
+function isPelecardNewCardBody(body) {
+    return pelecardBodyRefusal(body) === null;
+}
+function pelecardKeepOnFileRequested(body) {
+    const judged = judgeBody(body);
+    return judged ? judged.keepOnFile : null;
+}
+function carriesCard(body) {
+    if (typeof body !== "string" || body === "")
+        return false;
+    let value;
+    try {
+        value = JSON.parse(body);
+    }
+    catch {
+        return false;
+    }
+    if (!record(value) || !owns(value, "CreditCardNumber"))
+        return false;
+    const number = value.CreditCardNumber;
+    return typeof number === "string" && number !== "" || typeof number === "number";
+}
+function classifyPelecardRequest(url, method, body) {
+    if (!isPelecardTransactionUrl(url, method) || !carriesCard(body))
+        return null;
+    return pelecardBodyRefusal(body) ?? "card";
+}
+var CONTENT_TYPE = /^application\/json(?:;\s*(?:charset|charse0t)=utf-8)?$/i;
+function pelecardTransactionRefusal(request) {
+    if (!record(request) || request.method !== "POST" || !isPelecardTransactionUrl(request.url) || !record(request.headers))
+        return "unsupported";
+    const headers = /* @__PURE__ */ new Map();
+    for (const [name, value] of Object.entries(request.headers)) {
+        const lower = name.toLowerCase();
+        if (headers.has(lower) || typeof value !== "string")
+            return "unsupported";
+        headers.set(lower, value);
+    }
+    if (!exact(CONTENT_TYPE, headers.get("content-type")) || headers.has("x-requested-with") && headers.get("x-requested-with") !== "XMLHttpRequest")
+        return "unsupported";
+    return pelecardBodyRefusal(request.body);
+}
+function isPelecardTransactionRequest(request) {
+    return pelecardTransactionRefusal(request) === null;
+}
+function pelecardRefusalMessage(reason) {
+    if (reason === "test_card_required")
+        return TEST_CARD_REFUSAL;
+    return reason === "keep_on_file" ? KEEP_ON_FILE_REFUSAL : UNSUPPORTED_REFUSAL;
+}
+function injectPelecardCard(body, card) {
+    const judged = judgeBody(body);
+    if (!judged)
+        throw new Error(UNSUPPORTED_REFUSAL);
+    if (judged.keepOnFile)
+        throw new Error(KEEP_ON_FILE_REFUSAL);
+    const value = judged.value;
+    const withCvv = value.CvvNumber !== "";
+    const month = card && (Number.isInteger(card.month) || digits(card.month, 1, 2)) ? Number(card.month) : NaN;
+    const year = card && (Number.isInteger(card.year) || digits(card.year, 2, 4)) ? Number(card.year) : NaN;
+    if (!card || !digits(card.number, 12, 19) || !(month >= 1 && month <= 12) || !(year >= 0 && year <= 99 || year >= 2e3 && year <= 2099) || withCvv && !digits(card.cvc, 3, 4)) {
+        throw new Error("Could not fill the card fields for Pelecard. Nothing was sent.");
+    }
+    value.CreditCardNumber = card.number;
+    value.CreditCardDate = String(month).padStart(2, "0") + String(year % 100).padStart(2, "0");
+    const where = ["CreditCardNumber", "CreditCardDate"];
+    if (withCvv) {
+        value.CvvNumber = card.cvc;
+        where.push("CvvNumber");
+    }
+    if (value.CreditCardHolder !== "" && typeof card.name === "string" && card.name.trim() !== "" && text(card.name, 256)) {
+        value.CreditCardHolder = card.name;
+        where.push("CreditCardHolder");
+    }
+    return { body: JSON.stringify(value), where };
+}
+var REDIRECT_KEYS = [
+    "LandingURL",
+    "Target",
+    "StatusCode",
+    "StatusDescription",
+    "ApprovalNo",
+    "Token",
+    "ConfirmationKey",
+    "UserKey",
+    "UseEndOfProcess",
+    "FeedbackDataTransferMethod"
+];
+var panLike = (value) => /(?:[0-9][ _.:-]*){12,}/.test(value);
+var markupSafe = (value, max) => text(value, max) && !/["'<>`\\]/.test(value);
+var merchantValue = (value, max) => markupSafe(value, max) && !/[&=#?]/.test(value) && !panLike(value);
+var absent = (value) => value === void 0 || value === null || value === "";
+function readAnswer(body) {
+    if (typeof body !== "string" || body === "" || body.length > RESPONSE_LIMIT)
+        return null;
+    try {
+        const value = JSON.parse(body);
+        return record(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function landingUrl(value) {
+    if (!markupSafe(value, 2048) || panLike(value))
+        return null;
+    try {
+        const url = new URL(value);
+        return url.protocol === "https:" && !url.username && !url.password && url.href === value ? url : null;
+    }
+    catch {
+        return null;
+    }
+}
+function pelecardResponseOutcome(status, body) {
+    if (Number.isInteger(status) && status >= 400 && status < 500)
+        return clientErrorOutcome(status, body);
+    if (status !== 200)
+        return { outcome: "unknown", reason: "pelecard_status_unconfirmed" };
+    const value = readAnswer(body);
+    if (!value)
+        return { outcome: "unknown", reason: "pelecard_unreadable" };
+    const code = value.StatusCode;
+    if (!exact(/^[0-9]{3}$/, code))
+        return { outcome: "unknown", reason: "pelecard_unexpected_response" };
+    if (code !== "000") {
+        return absent(value.ApprovalNo) ? { outcome: "refused", code } : { outcome: "unknown", reason: "pelecard_unconfirmed" };
+    }
+    if (!REDIRECT_KEYS.every((key) => typeof value[key] === "string") || owns(value, "ParamX") && value.ParamX !== null && typeof value.ParamX !== "string") {
+        return { outcome: "unknown", reason: "pelecard_unexpected_response" };
+    }
+    if (value.DisplayIshurPopUp === true || !absent(value.UrlOpenFinance))
+        return { outcome: "unknown", reason: "pelecard_unconfirmed" };
+    const landing = landingUrl(value.LandingURL);
+    if (!landing)
+        return { outcome: "unknown", reason: "pelecard_unconfirmed" };
+    if (/(?:^|\.)pelecard\.biz$/.test(landing.hostname) && /threeds/i.test(landing.pathname)) {
+        return { outcome: "unknown", reason: "pelecard_three_ds_unconfirmed" };
+    }
+    return { outcome: "approved" };
+}
+function clientErrorOutcome(status, body) {
+    const value = readAnswer(body);
+    if (!value || !owns(value, "StatusCode") && !owns(value, "ApprovalNo"))
+        return { outcome: "refused", code: `http_${status}` };
+    const code = value.StatusCode;
+    return exact(/^[0-9]{3}$/, code) && code !== "000" && absent(value.ApprovalNo) ? { outcome: "refused", code } : { outcome: "unknown", reason: "pelecard_unconfirmed" };
+}
+function sanitizePelecardResponse(body) {
+    const fail = () => {
+        throw new Error("Invalid Pelecard payment response.");
+    };
+    if (pelecardResponseOutcome(200, body).outcome !== "approved")
+        return fail();
+    const value = readAnswer(body);
+    if (!exact(/^_?[A-Za-z]{0,16}$/, value.Target) || !exact(/^[A-Za-z0-9]{0,10}$/, value.ApprovalNo) || !(value.ConfirmationKey === "" || exact(/^[0-9a-fA-F]{32}$/, value.ConfirmationKey)) || !merchantValue(value.UserKey, 128) || !exact(/^(?:true|false|)$/i, value.UseEndOfProcess) || !exact(/^(?:get|post|)$/i, value.FeedbackDataTransferMethod) || typeof value.ParamX === "string" && !merchantValue(value.ParamX, 256))
+        return fail();
+    const safe = {
+        LandingURL: value.LandingURL,
+        Target: value.Target,
+        StatusCode: "000",
+        StatusDescription: markupSafe(value.StatusDescription, 256) && !panLike(value.StatusDescription) ? value.StatusDescription : "",
+        ApprovalNo: value.ApprovalNo,
+        Token: "",
+        ConfirmationKey: value.ConfirmationKey
+    };
+    if (owns(value, "ParamX"))
+        safe.ParamX = value.ParamX;
+    safe.UserKey = value.UserKey;
+    safe.UseEndOfProcess = value.UseEndOfProcess;
+    safe.FeedbackDataTransferMethod = value.FeedbackDataTransferMethod;
+    return JSON.stringify(safe);
+}
+function pelecardFacts(status, body) {
+    const verdict = pelecardResponseOutcome(status, body);
+    return {
+        outcome: verdict.outcome,
+        refusalCode: verdict.outcome === "refused" && /^[0-9]{3}$/.test(verdict.code) ? verdict.code : null
+    };
+}
+export { PELECARD_REFUSAL_REASONS, PELECARD_TRANSACTION_HOSTS, PELECARD_TRANSACTION_PATH, classifyPelecardRequest, injectPelecardCard, isPelecardNewCardBody, isPelecardTransactionRequest, isPelecardTransactionUrl, pelecardBodyRefusal, pelecardFacts, pelecardKeepOnFileRequested, pelecardRefusalMessage, pelecardResponseOutcome, pelecardTransactionRefusal, sanitizePelecardResponse };