@agent-cards/sdk 0.21.0 → 0.23.0

package/dist/juspay.generated.js

@@ -0,0 +1,705 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: c771bc4608bb5f6fd8db2cd15a071bec7cfc12c8d753d1e38403790599ddf300
+// src/juspay.js
+var ENDPOINTS = Object.freeze({
+    production: Object.freeze({ host: "api.juspay.in", txns: "https://api.juspay.in/txns", tokenize: "https://api.juspay.in/card/tokenize" }),
+    sandbox: Object.freeze({ host: "sandbox.juspay.in", txns: "https://sandbox.juspay.in/txns", tokenize: "https://sandbox.juspay.in/card/tokenize" })
+});
+var JUSPAY_API_HOSTS = Object.freeze([ENDPOINTS.production.host, ENDPOINTS.sandbox.host]);
+var JUSPAY_SIBLING_HOSTS = Object.freeze(["api.juspay.io", "api-ns1.juspay.in"]);
+var JUSPAY_SYNTHETIC_TOKEN = /^ctkn_agentcard[0-9a-f]{32}$/;
+var REAL_TOKEN = /^ctkn_[A-Za-z0-9_-]{1,64}$/;
+var TOKEN_TEXT = /ctkn_/i;
+var TOKEN_TAIL = 8;
+var JUSPAY_APPROVED_STATUSES = Object.freeze(["PENDING_VBV", "AUTHORIZING", "NEW", "CHARGED"]);
+var JUSPAY_REFUSED_STATUSES = Object.freeze(["AUTHORIZATION_FAILED", "JUSPAY_DECLINED", "AUTHENTICATION_FAILED"]);
+var JUSPAY_TOKENIZE_NETWORK = "juspay_tokenize_network";
+var TOKENIZE_REFUSAL = /^juspay_tokenize_[A-Za-z0-9_]{1,48}$/;
+var MAX_BODY = 8192;
+var MAX_RESPONSE = 16384;
+var KEY = /^[a-z][a-z0-9_]{0,63}$/;
+var ORDER_ID = /^[A-Za-z0-9_-]{1,64}$/;
+var MERCHANT_ID = /^[A-Za-z0-9._-]{1,64}$/;
+var ROUTING_ID = /^[A-Za-z0-9._:-]{1,128}$/;
+var ERROR_CODE = /^[A-Za-z][A-Za-z0-9_]{0,39}$/;
+var STATUS = /^[A-Z][A-Z_]{0,63}$/;
+var CONTROL = /[\u0000-\u001f\u007f]/;
+var FORM_TYPE = /^application\/x-www-form-urlencoded(?:;\s*charset=utf-8)?$/i;
+var CARD_KEY = /card|cvv|cvc|cvn|secur(?:ity)?_?code|expir|exp_?(?:month|year|date)|ccnum|(?:^|[^a-z])pan(?:[^a-z]|$)/i;
+var PAY_START_V1 = /^\/pay\/start\/[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)*$/;
+var PAY_START_V2 = /^\/v2\/pay\/start\/([A-Za-z0-9._-]{1,64})\/[A-Za-z0-9_.-]{1,128}$/;
+var PAY_START_QUERY = Object.freeze({
+    cardIssuerBankName: /^(?:[A-Za-z][A-Za-z .,'()-]{0,79})?$/,
+    cardType: /^[A-Z_]{0,20}$/,
+    paymentMethod: /^[A-Z_]{0,32}$/,
+    paymentMethodType: /^[A-Z_]{0,20}$/
+});
+var TXNS_LEGACY = Object.freeze([
+    "order_id",
+    "merchant_id",
+    "payment_method_type",
+    "card_token",
+    "redirect_after_payment",
+    "format",
+    "card_security_code",
+    "save_to_locker"
+]);
+var TXNS_WEB = Object.freeze([...TXNS_LEGACY, "tokenize", "card_nickname"]);
+var TOKENIZE_WEB = Object.freeze([
+    "card_number",
+    "card_exp_year",
+    "card_exp_month",
+    "card_security_code",
+    "merchant_id",
+    "name_on_card",
+    "card_nickname"
+]);
+var TOKENIZE_LEGACY = Object.freeze(TOKENIZE_WEB.filter((key) => key !== "card_nickname"));
+var SAVED_TOKENIZE = Object.freeze(["stored_card_token", "merchant_id", "card_security_code"]);
+var TXNS_CARD_KEYS = Object.freeze([
+    "card_number",
+    "card_token",
+    "card_security_code",
+    "card_exp_month",
+    "card_exp_year",
+    "name_on_card",
+    "token"
+]);
+var CARD_FIELD_TEXT = /card_?(?:number|token|security_?code|exp)|security_?code|cvv|cvc|ctkn_/i;
+var CARD_NAME = /cvn|ccnum|expir|exp_?(?:month|year|date)|(?:^|[^a-z])pan(?:[^a-z]|$)/i;
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var owns = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var sameSet = (keys, allowed) => keys.length === allowed.length && allowed.every((key) => keys.includes(key));
+function fieldNames(text) {
+    const names = [];
+    for (const pair of text.replace(/^\?/, "").split("&")) {
+        const eq = pair.indexOf("=");
+        if (eq > 0)
+            names.push(pair.slice(0, eq));
+    }
+    for (const match of text.matchAll(/"((?:[^"\\]|\\.){1,128})"\s*:/g))
+        names.push(match[1]);
+    return names;
+}
+function namesCardField(text) {
+    return fieldNames(text).some((name) => {
+        let decoded = name;
+        try {
+            decoded = decodeURIComponent(name.replace(/\+/g, " "));
+        }
+        catch {
+        }
+        return CARD_NAME.test(name) || CARD_NAME.test(decoded);
+    });
+}
+function cardBearing(text) {
+    if (!text)
+        return false;
+    let decoded = text;
+    try {
+        decoded = decodeURIComponent(text.replace(/\+/g, " "));
+    }
+    catch {
+    }
+    return CARD_FIELD_TEXT.test(decoded) || namesCardField(text) || namesCardField(decoded);
+}
+function decode(raw) {
+    if (!/^(?:[A-Za-z0-9\-_.!~*'()+]|%[0-9A-Fa-f]{2})*$/.test(raw))
+        return null;
+    let value;
+    try {
+        value = decodeURIComponent(raw.replace(/\+/g, " "));
+    }
+    catch {
+        return null;
+    }
+    return CONTROL.test(value) ? null : value;
+}
+function parseJuspayForm(body) {
+    if (typeof body !== "string" || body.length === 0 || body.length > MAX_BODY)
+        return null;
+    const entries = [];
+    const seen = /* @__PURE__ */ new Set();
+    let start = 0;
+    for (;;) {
+        const amp = body.indexOf("&", start);
+        const end = amp === -1 ? body.length : amp;
+        const eq = body.indexOf("=", start);
+        if (eq === -1 || eq >= end || eq === start)
+            return null;
+        const key = body.slice(start, eq);
+        const value = decode(body.slice(eq + 1, end));
+        if (!KEY.test(key) || value === null || seen.has(key))
+            return null;
+        seen.add(key);
+        entries.push({ key, value, valueStart: eq + 1, valueEnd: end });
+        if (amp === -1)
+            return entries;
+        start = amp + 1;
+    }
+}
+function formMap(body) {
+    const entries = parseJuspayForm(body);
+    return entries ? new Map(entries.map((entry) => [entry.key, entry.value])) : null;
+}
+function luhn(digits) {
+    let sum = 0;
+    for (let i = 0; i < digits.length; i++) {
+        let digit = digits.charCodeAt(digits.length - 1 - i) - 48;
+        if (i % 2 === 1) {
+            digit *= 2;
+            if (digit > 9)
+                digit -= 9;
+        }
+        sum += digit;
+    }
+    return sum % 10 === 0;
+}
+function cardNumberIn(text) {
+    for (const match of String(text).matchAll(/\d(?:[ -]?\d)*/g)) {
+        const digits = match[0].replace(/[ -]/g, "");
+        if (digits.length >= 12 && digits.length <= 19 && luhn(digits))
+            return true;
+    }
+    return false;
+}
+function header(headers, name) {
+    if (headers === void 0 || headers === null)
+        return void 0;
+    if (!record(headers))
+        return null;
+    let found;
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() !== name)
+            continue;
+        if (found !== void 0 || typeof value !== "string")
+            return null;
+        found = value;
+    }
+    return found;
+}
+function juspayEnvironment(url) {
+    if (url === ENDPOINTS.production.txns)
+        return "production";
+    if (url === ENDPOINTS.sandbox.txns)
+        return "sandbox";
+    return void 0;
+}
+function isJuspaySyntheticToken(value) {
+    return typeof value === "string" && JUSPAY_SYNTHETIC_TOKEN.test(value);
+}
+function juspaySyntheticToken(bytes) {
+    if (Object.prototype.toString.call(bytes) !== "[object Uint8Array]" || bytes.length !== 16) {
+        throw new Error("A synthetic Juspay token needs 16 random bytes.");
+    }
+    return "ctkn_agentcard" + Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function juspayTokenizeAnswer(token) {
+    if (!isJuspaySyntheticToken(token))
+        throw new Error("Only a synthetic Juspay token may answer the page.");
+    return { status: 200, headers: { "content-type": "application/json" }, body: JSON.stringify({ token }) };
+}
+function juspayTxnsTemplateRefusal(url, headers, body) {
+    if (!juspayEnvironment(url))
+        return "juspay_endpoint";
+    const contentType = header(headers, "content-type");
+    if (typeof contentType !== "string" || !FORM_TYPE.test(contentType.trim()))
+        return "content_type";
+    const values = formMap(body);
+    if (!values)
+        return "unreadable_body";
+    const keys = [...values.keys()];
+    if (keys.some((key) => !TXNS_WEB.includes(key)))
+        return "unsupported_field";
+    if (!sameSet(keys, TXNS_WEB) && !sameSet(keys, TXNS_LEGACY))
+        return "missing_field";
+    if (!ORDER_ID.test(values.get("order_id")))
+        return "order_id";
+    if (!MERCHANT_ID.test(values.get("merchant_id")))
+        return "merchant_id";
+    const merchantHeader = header(headers, "x-merchantid");
+    if (merchantHeader === null || merchantHeader !== void 0 && merchantHeader !== values.get("merchant_id"))
+        return "merchant_mismatch";
+    const routing = header(headers, "x-routing-id");
+    if (routing === null || routing !== void 0 && !ROUTING_ID.test(routing))
+        return "routing_id";
+    if (values.get("payment_method_type") !== "CARD")
+        return "payment_method_type";
+    if (!isJuspaySyntheticToken(values.get("card_token")))
+        return "card_token";
+    if (values.get("format") !== "json")
+        return "format";
+    if (values.get("redirect_after_payment") !== "true")
+        return "redirect_after_payment";
+    if (values.get("save_to_locker") !== "false")
+        return "save_to_locker";
+    if (values.has("tokenize") && !["false", "null"].includes(values.get("tokenize")))
+        return "tokenize";
+    if (!/^\d{3,4}$/.test(values.get("card_security_code")))
+        return "card_security_code";
+    if (values.has("card_nickname")) {
+        const nickname = values.get("card_nickname");
+        if (nickname.length > 32 || /\d{6}/.test(nickname))
+            return "card_nickname";
+    }
+    return null;
+}
+function assertJuspayTxnsTemplate(url, headers, body) {
+    const refusal = juspayTxnsTemplateRefusal(url, headers, body);
+    if (refusal)
+        throw new Error(`Refusing to pay: this Juspay card request is not the reviewed payment (${refusal}).`);
+    const environment = juspayEnvironment(url);
+    const values = formMap(body);
+    const routing = header(headers, "x-routing-id");
+    return Object.freeze({
+        environment,
+        host: ENDPOINTS[environment].host,
+        txnsUrl: ENDPOINTS[environment].txns,
+        tokenizeUrl: ENDPOINTS[environment].tokenize,
+        orderId: values.get("order_id"),
+        merchantId: values.get("merchant_id"),
+        routingId: routing ?? null,
+        contentType: header(headers, "content-type").trim()
+    });
+}
+var decide = (decision, reason) => ({ decision, reason });
+function classifyTokenize(values, headers, host) {
+    const keys = [...values.keys()];
+    if (values.has("stored_card_token")) {
+        const saved = keys.every((key) => SAVED_TOKENIZE.includes(key)) && !cardNumberIn(values.get("stored_card_token")) && (!values.has("card_security_code") || /^\d{3,4}$/.test(values.get("card_security_code")));
+        return saved ? decide("continue", "saved_card_tokenize") : decide("abort", "card_on_saved_card_tokenize");
+    }
+    if (!sameSet(keys, TOKENIZE_WEB) && !sameSet(keys, TOKENIZE_LEGACY))
+        return decide("abort", "unsupported_tokenize");
+    const merchantId = values.get("merchant_id");
+    if (!MERCHANT_ID.test(merchantId))
+        return decide("abort", "merchant_id");
+    const merchantHeader = header(headers, "x-merchantid");
+    if (merchantHeader === null || merchantHeader !== void 0 && merchantHeader !== merchantId)
+        return decide("abort", "merchant_mismatch");
+    return { decision: "answer_tokenize", reason: "placeholder_tokenize", host, merchantId };
+}
+function issuedFor(issued, token) {
+    if (!issued || typeof issued.get !== "function")
+        return null;
+    const entry = issued.get(token);
+    return record(entry) ? entry : null;
+}
+function issuedEntries(issued) {
+    if (!issued || typeof issued.values !== "function")
+        return [];
+    try {
+        return Array.from(issued.values()).filter(record);
+    }
+    catch {
+        return [];
+    }
+}
+function payStartCarriesCard(text) {
+    if (!text)
+        return false;
+    let decoded = text;
+    try {
+        decoded = decodeURIComponent(text.replace(/\+/g, " "));
+    }
+    catch {
+    }
+    return cardBearing(text) || cardNumberIn(text) || cardNumberIn(decoded);
+}
+function payStartNamesCard(body) {
+    if (!body)
+        return false;
+    return body.split("&").some((pair) => {
+        const eq = pair.indexOf("=");
+        const name = eq === -1 ? pair : pair.slice(0, eq);
+        let decoded = name;
+        try {
+            decoded = decodeURIComponent(name.replace(/\+/g, " "));
+        }
+        catch {
+        }
+        return CARD_KEY.test(name) || CARD_KEY.test(decoded);
+    });
+}
+function classifyTxns(url, values, headers, body, host, issued) {
+    if (values.get("payment_method_type") !== "CARD") {
+        return TXNS_CARD_KEYS.some((key) => values.has(key)) || [...values.keys()].some((key) => CARD_NAME.test(key)) ? decide("abort", "card_on_non_card_payment") : decide("continue", "non_card_payment");
+    }
+    if (values.has("card_number"))
+        return decide("abort", "direct_card_payment");
+    const token = values.get("card_token");
+    if (!isJuspaySyntheticToken(token)) {
+        if (typeof token !== "string" || !token)
+            return decide("abort", "unsupported_card_payment");
+        const cvv = values.get("card_security_code");
+        const saved = !cardNumberIn(token) && (cvv === void 0 || /^\d{3,4}$/.test(cvv)) && !["card_exp_month", "card_exp_year", "name_on_card"].some((key) => values.has(key)) && ![...values].some(([key, value]) => (CARD_KEY.test(key) || CARD_NAME.test(key)) && cardNumberIn(value));
+        return saved ? decide("continue", "saved_card_payment") : decide("abort", "card_on_saved_card_payment");
+    }
+    const known = issuedFor(issued, token);
+    if (!known || known.host !== host || known.merchantId !== values.get("merchant_id"))
+        return decide("abort", "unknown_synthetic_token");
+    const refusal = juspayTxnsTemplateRefusal(url, headers, body);
+    return refusal ? decide("abort", refusal) : decide("pause", "synthetic_token_payment");
+}
+function classifyJuspayRequest(request, issued) {
+    if (!record(request) || typeof request.url !== "string")
+        return null;
+    let url;
+    try {
+        url = new URL(request.url);
+    }
+    catch {
+        return null;
+    }
+    const trailingDot = url.hostname.endsWith(".");
+    const host = url.hostname.toLowerCase().replace(/\.+$/, "");
+    const api = JUSPAY_API_HOSTS.some((candidate) => candidate === host);
+    if (!api && !JUSPAY_SIBLING_HOSTS.some((candidate) => candidate === host))
+        return null;
+    const method = typeof request.method === "string" ? request.method.toUpperCase() : "GET";
+    const body = typeof request.body === "string" ? request.body : "";
+    if (method !== "POST") {
+        if (cardBearing(url.search))
+            return decide("abort", "card_in_query");
+        return cardBearing(body) ? decide("abort", "card_on_non_post") : decide("continue", "not_a_post");
+    }
+    const headers = request.headers;
+    if (url.protocol !== "https:" || url.port || url.username || url.password)
+        return decide("abort", "noncanonical_url");
+    if (trailingDot)
+        return decide("abort", "noncanonical_host");
+    if (!api)
+        return cardBearing(url.search) || cardBearing(body) ? decide("abort", "sibling_host") : decide("continue", "sibling_without_card");
+    const bound = issuedEntries(issued).filter((entry) => entry.host === host);
+    if (bound.length && payStartLink(url, host, (merchant) => bound.some((entry) => entry.merchantId === merchant))) {
+        return payStartCarriesCard(url.search) || payStartCarriesCard(body) || payStartNamesCard(body) ? decide("abort", "card_on_pay_start") : decide("continue", "pay_start");
+    }
+    if (url.pathname === "/v2/card/fingerprint")
+        return decide("abort", "placeholder_fingerprint");
+    const exact = request.url === `https://${host}${url.pathname}`;
+    if (url.pathname === "/card/tokenize") {
+        const values = exact ? formMap(body) : null;
+        return values ? classifyTokenize(values, headers, host) : decide("abort", "unreadable_tokenize");
+    }
+    if (url.pathname === "/txns") {
+        const values = exact ? formMap(body) : null;
+        return values ? classifyTxns(url.href, values, headers, body, host, issued) : decide("abort", "unreadable_payment");
+    }
+    return cardBearing(url.search) || cardBearing(body) ? decide("abort", "card_on_unreviewed_path") : decide("continue", "not_a_card_request");
+}
+function realCard(card) {
+    const number = card && typeof card.number === "string" ? card.number.replace(/[ -]/g, "") : "";
+    const cvc = card && card.cvc !== void 0 && card.cvc !== null ? String(card.cvc) : "";
+    const month = card && card.month !== void 0 && card.month !== null ? String(card.month) : "";
+    const year = card && card.year !== void 0 && card.year !== null ? String(card.year) : "";
+    if (!/^\d{12,19}$/.test(number) || !/^\d{3,4}$/.test(cvc) || !/^\d{1,2}$/.test(month) || Number(month) < 1 || Number(month) > 12 || !/^(?:\d{2}|\d{4})$/.test(year)) {
+        throw new Error("Could not fill the card fields for Juspay. Nothing was sent.");
+    }
+    const name = card && typeof card.name === "string" ? card.name.trim() : "";
+    return {
+        number,
+        cvc,
+        month: month.padStart(2, "0"),
+        year: year.length === 2 ? "20" + year : year,
+        name: name && name.length <= 100 && !CONTROL.test(name) ? name : ""
+    };
+}
+function legHeaders(template) {
+    return {
+        "content-type": template.contentType,
+        "x-merchantid": template.merchantId,
+        ...template.routingId ? { "x-routing-id": template.routingId } : {}
+    };
+}
+function juspayTokenizeRequest(request, card) {
+    const template = assertJuspayTxnsTemplate(request && request.url, request && request.headers, request && request.body);
+    const real = realCard(card);
+    const pairs = [
+        ["card_number", real.number],
+        ["card_exp_year", real.year],
+        ["card_exp_month", real.month],
+        ["card_security_code", real.cvc],
+        ["merchant_id", template.merchantId],
+        ...real.name ? [["name_on_card", real.name]] : []
+    ];
+    return {
+        url: template.tokenizeUrl,
+        method: "POST",
+        headers: legHeaders(template),
+        body: pairs.map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join("&")
+    };
+}
+function juspayTxnsRequest(request, token, cvc) {
+    const template = assertJuspayTxnsTemplate(request && request.url, request && request.headers, request && request.body);
+    if (typeof token !== "string" || !REAL_TOKEN.test(token) || isJuspaySyntheticToken(token)) {
+        throw new Error("Refusing to pay: Juspay did not return a card token for this card.");
+    }
+    if (!/^\d{3,4}$/.test(String(cvc ?? "")))
+        throw new Error("Could not fill the card fields for Juspay. Nothing was sent.");
+    const replacements = { card_token: token, card_security_code: String(cvc) };
+    let body = request.body;
+    const entries = parseJuspayForm(body).filter((entry) => owns(replacements, entry.key)).sort((a, b) => b.valueStart - a.valueStart);
+    for (const entry of entries) {
+        body = body.slice(0, entry.valueStart) + encodeURIComponent(replacements[entry.key]) + body.slice(entry.valueEnd);
+    }
+    return { url: template.txnsUrl, method: "POST", headers: legHeaders(template), body };
+}
+function readJson(text, limit) {
+    if (typeof text !== "string" || !text || text.length > limit)
+        return null;
+    let at = 0, nodes = 0;
+    const fail = () => {
+        throw new Error("invalid_juspay_json");
+    };
+    const space = () => {
+        while (" 	\r\n".includes(text[at] ?? "\0"))
+            at++;
+    };
+    const string = () => {
+        space();
+        const start = at;
+        if (text[at++] !== '"')
+            fail();
+        while (at < text.length) {
+            const char = text[at++];
+            if (char === "\\") {
+                at++;
+                continue;
+            }
+            if (char === '"')
+                return JSON.parse(text.slice(start, at));
+        }
+        return fail();
+    };
+    const value = (depth) => {
+        if (depth > 8 || ++nodes > 512)
+            fail();
+        space();
+        const char = text[at];
+        if (char === '"')
+            return string();
+        if (char === "{") {
+            at++;
+            const result = /* @__PURE__ */ Object.create(null), seen = /* @__PURE__ */ new Set();
+            space();
+            if (text[at] === "}") {
+                at++;
+                return result;
+            }
+            for (;;) {
+                const key = string();
+                if (seen.has(key) || ["__proto__", "prototype", "constructor"].includes(key))
+                    fail();
+                seen.add(key);
+                space();
+                if (text[at++] !== ":")
+                    fail();
+                result[key] = value(depth + 1);
+                space();
+                const next = text[at++];
+                if (next === "}")
+                    return result;
+                if (next !== ",")
+                    fail();
+            }
+        }
+        if (char === "[") {
+            at++;
+            const result = [];
+            space();
+            if (text[at] === "]") {
+                at++;
+                return result;
+            }
+            for (;;) {
+                result.push(value(depth + 1));
+                space();
+                const next = text[at++];
+                if (next === "]")
+                    return result;
+                if (next !== ",")
+                    fail();
+            }
+        }
+        for (const literal of ["true", "false", "null"]) {
+            if (text.startsWith(literal, at)) {
+                at += literal.length;
+                return JSON.parse(literal);
+            }
+        }
+        const number = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/.exec(text.slice(at));
+        if (!number)
+            fail();
+        at += number[0].length;
+        return Number(number[0]);
+    };
+    try {
+        const parsed = value(0);
+        space();
+        return at === text.length && record(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function identifier(value, pattern) {
+    if (typeof value !== "string" || !pattern.test(value))
+        return null;
+    if (TOKEN_TEXT.test(value) || /\d{12}/.test(value))
+        return null;
+    return value;
+}
+function juspayResponseFacts(text) {
+    const value = readJson(text, MAX_RESPONSE);
+    if (!value)
+        return { errorCode: null, status: null };
+    const info = record(value.error_info) ? value.error_info : null;
+    const code = identifier(info && info.code, ERROR_CODE) ?? identifier(value.error_code, ERROR_CODE);
+    return { errorCode: code, status: identifier(value.status, STATUS) };
+}
+function readJuspayTokenizeReply(status, text) {
+    if (status === 200) {
+        const value = readJson(text, MAX_RESPONSE);
+        const token = value && !owns(value, "error_info") && !owns(value, "error") ? value.token : void 0;
+        return typeof token === "string" && REAL_TOKEN.test(token) && !isJuspaySyntheticToken(token) ? { ok: true, token } : { ok: false, code: "juspay_tokenize_unreadable" };
+    }
+    if (!Number.isInteger(status) || status < 100 || status > 599)
+        return { ok: false, code: JUSPAY_TOKENIZE_NETWORK };
+    const facts = status >= 400 && status < 500 ? juspayResponseFacts(text) : { errorCode: null };
+    return { ok: false, code: facts.errorCode ? `juspay_tokenize_${facts.errorCode}` : `juspay_tokenize_http_${status}` };
+}
+function isJuspayTokenizeRefusal(code) {
+    if (typeof code !== "string" || !TOKENIZE_REFUSAL.test(code))
+        return false;
+    return !TOKEN_TEXT.test(code) && !/\d{12}/.test(code);
+}
+function templateOf(template) {
+    if (!record(template))
+        return null;
+    try {
+        return assertJuspayTxnsTemplate(template.url, template.headers, template.body);
+    }
+    catch {
+        return null;
+    }
+}
+function tokenForms(token) {
+    if (token === void 0)
+        return [];
+    if (typeof token !== "string" || !REAL_TOKEN.test(token) || isJuspaySyntheticToken(token))
+        return null;
+    const tail = token.slice("ctkn_".length).toLowerCase();
+    return [token.toLowerCase(), ...tail.length >= TOKEN_TAIL ? [tail] : []];
+}
+function namesToken(text, forms) {
+    const texts = [String(text)];
+    try {
+        texts.push(decodeURIComponent(texts[0].replace(/\+/g, " ")));
+    }
+    catch {
+    }
+    return texts.some((candidate) => TOKEN_TEXT.test(candidate) || forms.some((form) => candidate.toLowerCase().includes(form)));
+}
+function reviewedPayStartQuery(search) {
+    let text;
+    try {
+        text = decodeURIComponent(search.slice(1));
+    }
+    catch {
+        return false;
+    }
+    if (!text || text.includes("%") || CONTROL.test(text))
+        return false;
+    const seen = /* @__PURE__ */ new Set();
+    for (const pair of text.split("&")) {
+        const eq = pair.indexOf("=");
+        const key = eq > 0 ? pair.slice(0, eq) : "";
+        if (!owns(PAY_START_QUERY, key) || seen.has(key) || !PAY_START_QUERY[key].test(pair.slice(eq + 1)))
+            return false;
+        seen.add(key);
+    }
+    return true;
+}
+function payStartLink(url, host, merchantOk) {
+    if (url.protocol !== "https:" || url.hostname !== host || url.port || url.username || url.password || url.hash)
+        return false;
+    const v2 = PAY_START_V2.exec(url.pathname);
+    if (v2 ? !merchantOk(v2[1]) : !PAY_START_V1.test(url.pathname))
+        return false;
+    if (url.search && !(v2 && reviewedPayStartQuery(url.search)))
+        return false;
+    return !url.pathname.split("/").some((segment) => /^\d{12,19}$/.test(segment) && luhn(segment));
+}
+function sanitizeJuspayTxnsResponse(text, template, token) {
+    const paused = templateOf(template);
+    const value = readJson(text, MAX_RESPONSE);
+    const forms = tokenForms(token);
+    const invalid = () => {
+        throw new Error("Invalid Juspay payment response.");
+    };
+    if (!paused || !value || !forms)
+        return invalid();
+    if (forms.some((form) => text.toLowerCase().includes(form)))
+        return invalid();
+    const { order_id: orderId, txn_id: txnId, status, payment } = value;
+    if (orderId !== paused.orderId || typeof txnId !== "string" || !/^[A-Za-z0-9_.:-]{1,128}$/.test(txnId) || !JUSPAY_APPROVED_STATUSES.includes(status) || !record(payment) || !record(payment.authentication))
+        return invalid();
+    if (namesToken(txnId, forms))
+        return invalid();
+    const { method, url: raw, params } = payment.authentication;
+    if (method !== "GET" && method !== "POST" || typeof raw !== "string" || raw.length > 2048 || method === "POST" && params === void 0)
+        return invalid();
+    if (namesToken(raw, forms))
+        return invalid();
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return invalid();
+    }
+    if (url.href !== raw || !payStartLink(url, paused.host, (merchant) => merchant === paused.merchantId))
+        return invalid();
+    const authentication = { method, url: `${url.origin}${url.pathname}` };
+    if (params !== void 0) {
+        if (!record(params) || Object.keys(params).length > 32)
+            return invalid();
+        const safe = {};
+        for (const [key, item] of Object.entries(params)) {
+            if (!/^[A-Za-z0-9_.-]{1,64}$/.test(key) || CARD_KEY.test(key) || typeof item !== "string" || item.length > 4096 || CONTROL.test(item) || cardNumberIn(item))
+                return invalid();
+            if (namesToken(key, forms) || namesToken(item, forms))
+                return invalid();
+            safe[key] = item;
+        }
+        authentication.params = safe;
+    }
+    return JSON.stringify({ order_id: orderId, txn_id: txnId, status, payment: { authentication } });
+}
+function juspayTxnsOutcome(status, text, template, token) {
+    if (!Number.isInteger(status))
+        return { outcome: "unknown", reason: "juspay_unconfirmed" };
+    if (status >= 500)
+        return { outcome: "unknown", reason: "server_error" };
+    if (status >= 400) {
+        const { errorCode } = juspayResponseFacts(text);
+        return errorCode ? { outcome: "refused", code: errorCode } : { outcome: "unknown", reason: "juspay_refusal_unreadable" };
+    }
+    if (status !== 200)
+        return { outcome: "unknown", reason: "juspay_unconfirmed" };
+    const value = readJson(text, MAX_RESPONSE);
+    if (!value)
+        return { outcome: "unknown", reason: "juspay_unreadable" };
+    if (JUSPAY_REFUSED_STATUSES.includes(value.status))
+        return { outcome: "refused", code: value.status };
+    if (!JUSPAY_APPROVED_STATUSES.includes(value.status))
+        return { outcome: "unknown", reason: "juspay_status_unknown" };
+    try {
+        return { outcome: "approved", body: sanitizeJuspayTxnsResponse(text, template, token) };
+    }
+    catch {
+        return { outcome: "unknown", reason: "juspay_unsafe_response" };
+    }
+}
+export { JUSPAY_API_HOSTS, JUSPAY_APPROVED_STATUSES, JUSPAY_REFUSED_STATUSES, JUSPAY_SIBLING_HOSTS, JUSPAY_SYNTHETIC_TOKEN, JUSPAY_TOKENIZE_NETWORK, assertJuspayTxnsTemplate, classifyJuspayRequest, isJuspaySyntheticToken, isJuspayTokenizeRefusal, juspayEnvironment, juspayResponseFacts, juspaySyntheticToken, juspayTokenizeAnswer, juspayTokenizeRequest, juspayTxnsOutcome, juspayTxnsRequest, juspayTxnsTemplateRefusal, parseJuspayForm, readJuspayTokenizeReply, sanitizeJuspayTxnsResponse };