@agent-cards/sdk 0.20.0 → 0.22.0

package/dist/gmo.generated.js

@@ -0,0 +1,586 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: 8149714daf5515a2fd3ec90d5aa0c7eb58a66d5ce79c3e3f0ba81c29d2946dc3
+// src/sha256.js
+var K = /* @__PURE__ */ new Uint32Array([
+    1116352408,
+    1899447441,
+    3049323471,
+    3921009573,
+    961987163,
+    1508970993,
+    2453635748,
+    2870763221,
+    3624381080,
+    310598401,
+    607225278,
+    1426881987,
+    1925078388,
+    2162078206,
+    2614888103,
+    3248222580,
+    3835390401,
+    4022224774,
+    264347078,
+    604807628,
+    770255983,
+    1249150122,
+    1555081692,
+    1996064986,
+    2554220882,
+    2821834349,
+    2952996808,
+    3210313671,
+    3336571891,
+    3584528711,
+    113926993,
+    338241895,
+    666307205,
+    773529912,
+    1294757372,
+    1396182291,
+    1695183700,
+    1986661051,
+    2177026350,
+    2456956037,
+    2730485921,
+    2820302411,
+    3259730800,
+    3345764771,
+    3516065817,
+    3600352804,
+    4094571909,
+    275423344,
+    430227734,
+    506948616,
+    659060556,
+    883997877,
+    958139571,
+    1322822218,
+    1537002063,
+    1747873779,
+    1955562222,
+    2024104815,
+    2227730452,
+    2361852424,
+    2428436474,
+    2756734187,
+    3204031479,
+    3329325298
+]);
+var rotr = (x, n) => x >>> n | x << 32 - n;
+function utf8(text) {
+    const out = [];
+    for (const char of text) {
+        let cp = char.codePointAt(0);
+        if (cp >= 55296 && cp <= 57343)
+            cp = 65533;
+        if (cp < 128)
+            out.push(cp);
+        else if (cp < 2048)
+            out.push(192 | cp >> 6, 128 | cp & 63);
+        else if (cp < 65536)
+            out.push(224 | cp >> 12, 128 | cp >> 6 & 63, 128 | cp & 63);
+        else
+            out.push(240 | cp >> 18, 128 | cp >> 12 & 63, 128 | cp >> 6 & 63, 128 | cp & 63);
+    }
+    return Uint8Array.from(out);
+}
+function sha256Hex(input) {
+    const isBytes = Object.prototype.toString.call(input) === "[object Uint8Array]";
+    if (typeof input !== "string" && !isBytes)
+        throw new TypeError("sha256Hex takes a string or a Uint8Array.");
+    const bytes = typeof input === "string" ? utf8(input) : input;
+    const length = bytes.length;
+    const padded = new Uint8Array((length + 8 >> 6) + 1 << 6);
+    padded.set(bytes);
+    padded[length] = 128;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, Math.floor(length / 536870912));
+    view.setUint32(padded.length - 4, length << 3 >>> 0);
+    const H = new Uint32Array([1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]);
+    const W = new Uint32Array(64);
+    for (let offset = 0; offset < padded.length; offset += 64) {
+        for (let t = 0; t < 16; t++)
+            W[t] = view.getUint32(offset + t * 4);
+        for (let t = 16; t < 64; t++) {
+            const s0 = rotr(W[t - 15], 7) ^ rotr(W[t - 15], 18) ^ W[t - 15] >>> 3;
+            const s1 = rotr(W[t - 2], 17) ^ rotr(W[t - 2], 19) ^ W[t - 2] >>> 10;
+            W[t] = W[t - 16] + s0 + W[t - 7] + s1 >>> 0;
+        }
+        let a = H[0], b = H[1], c = H[2], d = H[3], e = H[4], f = H[5], g = H[6], h = H[7];
+        for (let t = 0; t < 64; t++) {
+            const t1 = h + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + (e & f ^ ~e & g) + K[t] + W[t] >>> 0;
+            const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = d + t1 >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = t1 + t2 >>> 0;
+        }
+        H[0] += a;
+        H[1] += b;
+        H[2] += c;
+        H[3] += d;
+        H[4] += e;
+        H[5] += f;
+        H[6] += g;
+        H[7] += h;
+    }
+    return Array.from(H, (word) => word.toString(16).padStart(8, "0")).join("");
+}
+// src/rsa-pkcs1v15.js
+var RsaPkcs1v15Error = class extends Error {
+    constructor(reason) {
+        super("RSA PKCS#1 v1.5 encryption refused.");
+        this.name = "RsaPkcs1v15Error";
+        this.code = "rsa_pkcs1v15_refused";
+        this.reason = reason;
+    }
+};
+var refuse = (reason) => new RsaPkcs1v15Error(reason);
+var BASE64 = /^[A-Za-z0-9+/]+={0,2}$/;
+var SHA256_HEX = /^[0-9a-f]{64}$/;
+var RSA_ALGORITHM = [48, 13, 6, 9, 42, 134, 72, 134, 247, 13, 1, 1, 1, 5, 0];
+var MODULUS_BYTES = [128, 256, 384, 512];
+var MIN_PADDING = 8;
+var MAX_DRAWS = 16;
+var TYPED_ARRAY = Object.getPrototypeOf(Uint8Array.prototype);
+var typedArrayName = Object.getOwnPropertyDescriptor(TYPED_ARRAY, Symbol.toStringTag).get;
+function parseRsaPublicKey(key) {
+    const spki = key && typeof key === "object" ? key.spki : void 0;
+    const pin = key && typeof key === "object" ? key.sha256 : void 0;
+    if (typeof spki !== "string" || spki.length > 1024 || spki.length % 4 !== 0 || !BASE64.test(spki))
+        throw refuse("key");
+    if (typeof pin !== "string" || !SHA256_HEX.test(pin))
+        throw refuse("key");
+    let binary;
+    try {
+        binary = atob(spki);
+    }
+    catch {
+        throw refuse("key");
+    }
+    if (btoa(binary) !== spki)
+        throw refuse("key");
+    const der = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+    if (sha256Hex(der) !== pin)
+        throw refuse("key");
+    const outer = readElement(der, 0, 48);
+    if (outer.end !== der.length || outer.start + RSA_ALGORITHM.length > der.length)
+        throw refuse("key");
+    if (!RSA_ALGORITHM.every((byte, i) => der[outer.start + i] === byte))
+        throw refuse("key");
+    const bits = readElement(der, outer.start + RSA_ALGORITHM.length, 3);
+    if (bits.end !== outer.end || bits.start === bits.end || der[bits.start] !== 0)
+        throw refuse("key");
+    const rsa = readElement(der, bits.start + 1, 48);
+    if (rsa.end !== bits.end)
+        throw refuse("key");
+    const modulus = readPositiveInteger(der, rsa.start);
+    const exponent = readPositiveInteger(der, modulus.end);
+    if (exponent.end !== rsa.end)
+        throw refuse("key");
+    const n = modulus.bytes;
+    if (!MODULUS_BYTES.includes(n.length) || !(n[0] & 128) || !(n[n.length - 1] & 1))
+        throw refuse("key");
+    const e = exponent.bytes;
+    if (e.length !== 3 || e[0] !== 1 || e[1] !== 0 || e[2] !== 1)
+        throw refuse("key");
+    return Object.freeze({ n: toBigInt(n), e: 65537n, size: n.length });
+}
+function rsaesPkcs1v15Encrypt(key, message, random) {
+    const { n, e, size } = parseRsaPublicKey(key);
+    if (typedArrayName.call(message) !== "Uint8Array")
+        throw refuse("message");
+    let bytes;
+    try {
+        bytes = new Uint8Array(message);
+    }
+    catch {
+        throw refuse("message");
+    }
+    const em = new Uint8Array(size);
+    try {
+        if (bytes.length > size - MIN_PADDING - 3)
+            throw refuse("message");
+        em[1] = 2;
+        fillNonZero(em.subarray(2, size - bytes.length - 1), random);
+        em.set(bytes, size - bytes.length);
+        return toBytes(modPow(toBigInt(em), e, n), size);
+    }
+    finally {
+        em.fill(0);
+        bytes.fill(0);
+    }
+}
+function readElement(der, at, tag) {
+    if (at + 2 > der.length || der[at] !== tag)
+        throw refuse("key");
+    let length = der[at + 1];
+    let start = at + 2;
+    if (length & 128) {
+        const count = length & 127;
+        if (count === 0 || count > 2 || start + count > der.length || der[start] === 0)
+            throw refuse("key");
+        length = count === 1 ? der[start] : der[start] * 256 + der[start + 1];
+        if (length < 128)
+            throw refuse("key");
+        start += count;
+    }
+    if (start + length > der.length)
+        throw refuse("key");
+    return { start, end: start + length };
+}
+function readPositiveInteger(der, at) {
+    const { start, end } = readElement(der, at, 2);
+    if (end === start || der[start] & 128)
+        throw refuse("key");
+    if (der[start] === 0 && (end - start === 1 || !(der[start + 1] & 128)))
+        throw refuse("key");
+    return { bytes: der.subarray(der[start] === 0 ? start + 1 : start, end), end };
+}
+function fillNonZero(target, random) {
+    if (!random || typeof random.getRandomValues !== "function")
+        throw refuse("random");
+    const draw = new Uint8Array(target.length);
+    let filled = 0;
+    try {
+        for (let round = 0; round < MAX_DRAWS && filled < target.length; round++) {
+            draw.fill(0);
+            random.getRandomValues(draw);
+            for (let i = 0; i < draw.length && filled < target.length; i++)
+                if (draw[i] !== 0)
+                    target[filled++] = draw[i];
+        }
+    }
+    catch {
+        throw refuse("random");
+    }
+    finally {
+        draw.fill(0);
+    }
+    if (filled < target.length)
+        throw refuse("random");
+}
+function toBigInt(bytes) {
+    let hex2 = "";
+    for (let i = 0; i < bytes.length; i++)
+        hex2 += (bytes[i] < 16 ? "0" : "") + bytes[i].toString(16);
+    return BigInt(`0x${hex2}`);
+}
+function toBytes(value, size) {
+    const hex2 = value.toString(16).padStart(size * 2, "0");
+    const out = new Uint8Array(size);
+    for (let i = 0; i < size; i++)
+        out[i] = parseInt(hex2.slice(2 * i, 2 * i + 2), 16);
+    return out;
+}
+function modPow(base, exponent, modulus) {
+    let result = 1n;
+    let square = base % modulus;
+    for (let rest = exponent; rest > 0n; rest >>= 1n) {
+        if (rest & 1n)
+            result = result * square % modulus;
+        square = square * square % modulus;
+    }
+    return result;
+}
+// src/gmo.js
+var GMO_PSP = "gmo_pg";
+var GMO_CLIENT_TYPE = "js-legacy";
+var GMO_CONTENT_TYPE = "application/json";
+var GMO_TOKEN_PATH = "/payment/CreateToken.json";
+var GMO_TOKEN_HOSTS = Object.freeze({ production: "token.mul-pay.jp", sandbox: "stg.token.mul-pay.jp" });
+var GMO_TOKEN_URLS = Object.freeze({
+    production: `https://${GMO_TOKEN_HOSTS.production}${GMO_TOKEN_PATH}`,
+    sandbox: `https://${GMO_TOKEN_HOSTS.sandbox}${GMO_TOKEN_PATH}`
+});
+var GMO_SHARED_KEYS = Object.freeze({
+    [GMO_TOKEN_HOSTS.production]: Object.freeze({
+        spki: "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzJ6Ps4kEHAoUxWoTQM2YzvCnJrCpYo3kUKV6G8Pbl7NU1eAkF+rGKhGQVOqULbOa7bS+67txfK+p+WhYIVpxoCzkL9rFKKSb1qeW+phosmN3sXYo0IUa658adLvvpPzpwAqqTu+WNiANZrlstuCC2/dRBwGVl9i8W1pxJZbz2j2lPD7G/jxnqWgfDw+d/EXUAKazS/G6Dk+WoZkmTqkIzsJij5QX4xqmXbdyfsj6BXfmBS1RLAsngJ8bxtshRY9uQ6faSCuTaEF5l38Qh9HhXBoFB+MsOKQ4biUwgW/WaFc5KZ75VDFadrJtUn+5XOlY+iXIQhgdp/zewoZda0rGnQIDAQAB",
+        sha256: "c12555cbac901b38910f7f5034a97e353767e1ab6d7c8362c13d0b82f618e142"
+    }),
+    [GMO_TOKEN_HOSTS.sandbox]: Object.freeze({
+        spki: "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAoRuXDRz86jW+7es/BxzFJAmSxsjt69NvjrRCBsmBZb29luUsayl0Ge0pFDXYasVcv0V53S2AZXsikg+dxl3Ykxv0578LMNrKoMvuSDAOZP44/wIaEhN7375754kdubdvK+fHDdW48Q4t2GLrkzMcWjoYgflSW4ldIA/jvnIAine2fK+3ho2WRbIOLHSSwKmAOPI6CKs5v8yN9fg9MvX8IOi2rmFxu0NnYYv32w5qW5BHVzqD1w1ZKfrQHhhFk1Ngkle66NUoyCpVYCsXCJyLwfeN6M2vOIM/ob/K89XXUuAJzSSOgLBVUlSwOoxH35nr1TaKIu5VXp9irYBfiLmJewIDAQAB",
+        sha256: "0b065ee8e674fd50f01f9906c1e2393032dfe739eebc9d7b36ba7628312a63d8"
+    })
+});
+var SHOP_ID = Object.freeze({ production: /^[0-9]{13}$/, sandbox: /^tshop[0-9]{8}$/ });
+var PASSPHRASE = "SecretPassphrase";
+var PBKDF2_ITERATIONS = 100;
+var ENVELOPE_KEYS = Object.freeze(["createCount", "encryptionParameters", "encryptedData"]);
+var PARAMETER_KEYS = Object.freeze(["type", "apiKey", "keySpec", "signature"]);
+var BODY_LIMIT = 8192;
+var BASE642 = /^[A-Za-z0-9+/]+={0,2}$/;
+var SIGNATURE = /^[0-9a-f]{40}$/;
+var KEY_SPEC_BYTES = 256;
+var GMO_REFUSAL_REASONS = Object.freeze([
+    "request",
+    "psp",
+    "url",
+    "environment_mismatch",
+    "template",
+    "card",
+    "test_card_required",
+    "crypto"
+]);
+var GmoError = class extends Error {
+    /** @param {string} reason one of GMO_REFUSAL_REASONS @param {string} message */
+    constructor(reason, message) {
+        super(`Refusing to pay: ${message}`);
+        this.name = "GmoError";
+        this.reason = reason;
+    }
+};
+var refuse2 = (reason, message) => {
+    throw new GmoError(reason, message);
+};
+var record = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+function gmoTokenEnvironment(rawUrl) {
+    if (typeof rawUrl !== "string" || rawUrl.length > 256 || rawUrl.includes("?") || rawUrl.includes("#"))
+        return null;
+    let url;
+    try {
+        url = new URL(rawUrl);
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== "https:" || url.port || url.username || url.password || url.search || url.hash)
+        return null;
+    if (url.href !== rawUrl || url.pathname !== GMO_TOKEN_PATH)
+        return null;
+    if (url.hostname === GMO_TOKEN_HOSTS.production)
+        return "production";
+    if (url.hostname === GMO_TOKEN_HOSTS.sandbox)
+        return "sandbox";
+    return null;
+}
+function isGmoTokenHost(rawUrl) {
+    if (typeof rawUrl !== "string")
+        return false;
+    let url;
+    try {
+        url = new URL(rawUrl);
+    }
+    catch {
+        return false;
+    }
+    const host = url.hostname.toLowerCase().replace(/\.$/, "");
+    return host === GMO_TOKEN_HOSTS.production || host === GMO_TOKEN_HOSTS.sandbox;
+}
+function base64Length(text) {
+    if (typeof text !== "string" || text.length === 0 || text.length % 4 !== 0 || !BASE642.test(text))
+        return -1;
+    let binary;
+    try {
+        binary = atob(text);
+    }
+    catch {
+        return -1;
+    }
+    return btoa(binary) === text ? binary.length : -1;
+}
+function parseGmoSharedPkBody(body, environment) {
+    if (typeof body !== "string" || body.length > BODY_LIMIT || !own(SHOP_ID, environment))
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return null;
+    }
+    if (!record(parsed) || !Object.keys(parsed).every((key) => ENVELOPE_KEYS.includes(key)))
+        return null;
+    const hasCount = own(parsed, "createCount");
+    if (hasCount && parsed.createCount !== null && parsed.createCount !== "1")
+        return null;
+    const parameters = parsed.encryptionParameters;
+    if (!record(parameters) || Object.keys(parameters).length !== PARAMETER_KEYS.length || !PARAMETER_KEYS.every((key) => own(parameters, key) && typeof parameters[key] === "string"))
+        return null;
+    const { type, apiKey, keySpec, signature } = parameters;
+    if (type !== "SHARED_PK" || !SHOP_ID[environment].test(apiKey))
+        return null;
+    if (base64Length(keySpec) !== KEY_SPEC_BYTES || !SIGNATURE.test(signature))
+        return null;
+    const dataLength = base64Length(parsed.encryptedData);
+    if (dataLength < 16 || dataLength % 16 !== 0)
+        return null;
+    const canonical = serializeEnvelope(hasCount ? { createCount: parsed.createCount } : {}, apiKey, keySpec, signature, parsed.encryptedData);
+    if (canonical !== body)
+        return null;
+    return hasCount ? { createCount: parsed.createCount, apiKey } : { apiKey };
+}
+function serializeEnvelope(count, apiKey, keySpec, signature, encryptedData) {
+    return JSON.stringify({ ...count, encryptionParameters: { type: "SHARED_PK", apiKey, keySpec, signature }, encryptedData });
+}
+function headerValues(headers, name) {
+    if (headers === void 0)
+        return [];
+    if (!record(headers))
+        return null;
+    const values = [];
+    for (const [key, value] of Object.entries(headers)) {
+        if (typeof value !== "string")
+            return null;
+        if (key.toLowerCase() === name)
+            values.push(value);
+    }
+    return values;
+}
+function isGmoSharedPkRequest(request) {
+    if (!record(request) || request.method !== "POST")
+        return false;
+    const environment = gmoTokenEnvironment(request.url);
+    if (!environment)
+        return false;
+    const clientType = headerValues(request.headers, "x-mp-client-type");
+    if (!clientType || clientType.length !== 1 || clientType[0] !== GMO_CLIENT_TYPE)
+        return false;
+    const contentType = headerValues(request.headers, "content-type");
+    if (!contentType || contentType.length > 1 || contentType.length === 1 && !/^application\/json(?:\s*;\s*charset=utf-8)?$/i.test(contentType[0].trim()))
+        return false;
+    return parseGmoSharedPkBody(request.body, environment) !== null;
+}
+function gmoShopId(request) {
+    if (!isGmoSharedPkRequest(request))
+        return null;
+    return parseGmoSharedPkBody(
+    /** @type {string} */
+    request?.body, 
+    /** @type {'production' | 'sandbox'} */
+    gmoTokenEnvironment(request?.url)).apiKey;
+}
+var utf82 = (text) => new TextEncoder().encode(text);
+var hex = (bytes) => Array.from(bytes, (byte) => (byte < 16 ? "0" : "") + byte.toString(16)).join("");
+function base64(bytes) {
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++)
+        binary += String.fromCharCode(bytes[i]);
+    return btoa(binary);
+}
+function holderName(name, number) {
+    if (typeof name !== "string")
+        return "";
+    const folded = name.normalize("NFKD").toUpperCase().replace(/[^A-Z0-9 ,./-]/g, "").replace(/\s+/g, " ").trim().slice(0, 50).trim();
+    return folded === number ? "" : folded;
+}
+function cardPlaintext(card) {
+    if (!record(card))
+        refuse2("card", "no card to send.");
+    const number = String(card.number ?? "").replace(/[ -]/g, "");
+    const month = String(card.month ?? "").padStart(2, "0");
+    const fullYear = String(card.year ?? "");
+    const year = fullYear.length === 4 ? fullYear.slice(2) : fullYear;
+    const hasCvc = card.cvc !== void 0 && card.cvc !== null && card.cvc !== "";
+    const cvc = hasCvc ? String(card.cvc) : null;
+    if (!/^[0-9]{10,16}$/.test(number) || !/^(?:0[1-9]|1[0-2])$/.test(month) || !/^[0-9]{2}$/.test(year) || !/^(?:[0-9]{2}|[0-9]{4})$/.test(fullYear) || cvc !== null && !/^[0-9]{3,4}$/.test(cvc)) {
+        refuse2("card", "this card cannot be sent to GMO.");
+    }
+    return JSON.stringify({
+        deviceFingerprint: "",
+        card: { cardNumber: number, cardholderName: holderName(card.name, number), expiryMonth: month, expiryYear: year, securityCode: cvc }
+    });
+}
+async function buildGmoSharedPkBody(templateBody, card, { crypto, host } = {}) {
+    const environment = host === GMO_TOKEN_HOSTS.production ? "production" : host === GMO_TOKEN_HOSTS.sandbox ? "sandbox" : null;
+    if (!environment)
+        refuse2("url", "this is not a GMO token host.");
+    const template = parseGmoSharedPkBody(templateBody, environment);
+    if (!template)
+        refuse2("template", "the paused request is not GMO's single-token card request.");
+    const subtle = crypto && crypto.subtle;
+    if (!subtle || typeof crypto.getRandomValues !== "function")
+        refuse2("crypto", "this device cannot encrypt for GMO.");
+    const plaintext = utf82(cardPlaintext(card));
+    const iv = new Uint8Array(16);
+    const salt = new Uint8Array(16);
+    let keyMessage = new Uint8Array(0);
+    try {
+        crypto.getRandomValues(iv);
+        crypto.getRandomValues(salt);
+        if (iv.every((byte) => byte === 0) || salt.every((byte) => byte === 0))
+            throw new Error("no randomness");
+        const passphrase = await subtle.importKey("raw", utf82(PASSPHRASE), "PBKDF2", false, ["deriveKey"]);
+        const aes = await subtle.deriveKey({ name: "PBKDF2", hash: "SHA-1", salt, iterations: PBKDF2_ITERATIONS }, passphrase, { name: "AES-CBC", length: 128 }, false, ["encrypt"]);
+        const encryptedData = base64(new Uint8Array(await subtle.encrypt({ name: "AES-CBC", iv }, aes, plaintext)));
+        keyMessage = utf82(JSON.stringify({ iv: hex(iv), salt: hex(salt) }));
+        const keySpec = base64(rsaesPkcs1v15Encrypt(GMO_SHARED_KEYS[host], keyMessage, crypto));
+        const signature = hex(new Uint8Array(await subtle.digest("SHA-1", utf82(`${template.apiKey}|${keySpec}|${encryptedData}`))));
+        const count = own(template, "createCount") ? { createCount: template.createCount } : {};
+        const body = serializeEnvelope(count, template.apiKey, keySpec, signature, encryptedData);
+        if (!parseGmoSharedPkBody(body, environment))
+            throw new Error("rebuilt body out of shape");
+        return body;
+    }
+    catch {
+        return refuse2("crypto", "the card could not be encrypted for GMO on this device.");
+    }
+    finally {
+        plaintext.fill(0);
+        iv.fill(0);
+        salt.fill(0);
+        keyMessage.fill(0);
+    }
+}
+var TOKEN = /^[0-9a-f]{64}$/;
+var MASKED_NUMBER = /^[0-9]{4,6}\*+[0-9]{4}$/;
+var RFC3339 = /^[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01])T(?:[01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:\.[0-9]{1,9})?(?:Z|[+-](?:[01][0-9]|2[0-3]):[0-5][0-9])$/;
+var REFUSAL_RESULTS = Object.freeze(["validation_error", "decryption_error"]);
+var LEGACY_CODE = /^[0-9]{3}$/;
+var RESPONSE_LIMIT = 4096;
+function parseResponse(text) {
+    if (typeof text !== "string" || text.length > RESPONSE_LIMIT)
+        return null;
+    try {
+        const parsed = JSON.parse(text);
+        return record(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function sanitizeGmoTokenResponse(text) {
+    const parsed = parseResponse(text);
+    if (!parsed || parsed.result !== "success")
+        return null;
+    const { maskedCardNumber, tokenExpiryDate, isSecurityCodeSet, tokenList } = parsed;
+    if (typeof maskedCardNumber !== "string" || !MASKED_NUMBER.test(maskedCardNumber) || typeof tokenExpiryDate !== "string" || !RFC3339.test(tokenExpiryDate) || typeof isSecurityCodeSet !== "boolean" || !Array.isArray(tokenList) || tokenList.length !== 1 || typeof tokenList[0] !== "string" || !TOKEN.test(tokenList[0]))
+        return null;
+    return JSON.stringify({ result: "success", maskedCardNumber, tokenExpiryDate, isSecurityCodeSet, tokenList: [tokenList[0]] });
+}
+function gmoTokenMatchesCard(sanitized, card) {
+    const parsed = parseResponse(sanitized);
+    const number = String(card?.number ?? "").replace(/[ -]/g, "");
+    if (!parsed || typeof parsed.maskedCardNumber !== "string" || !/^[0-9]{10,16}$/.test(number))
+        return false;
+    const masked = parsed.maskedCardNumber;
+    const head = masked.slice(0, masked.indexOf("*"));
+    return masked.length === number.length && number.startsWith(head) && number.endsWith(masked.slice(-4));
+}
+function gmoRefusalCode(text) {
+    const parsed = parseResponse(text);
+    if (!parsed || !REFUSAL_RESULTS.includes(parsed.result) || !Array.isArray(parsed.errorList))
+        return null;
+    const first = parsed.errorList[0];
+    const legacy = record(first) && typeof first.legacyCode === "string" && LEGACY_CODE.test(first.legacyCode) ? first.legacyCode : null;
+    return legacy ?? parsed.result;
+}
+function gmoResponseFacts(status, text) {
+    if (status === 200) {
+        const body = sanitizeGmoTokenResponse(text);
+        return body ? { outcome: "token", body } : { outcome: "unknown" };
+    }
+    if (status === 400) {
+        const code = gmoRefusalCode(text);
+        return code ? { outcome: "refused", code } : { outcome: "unknown" };
+    }
+    return { outcome: "unknown" };
+}
+export { GMO_CLIENT_TYPE, GMO_CONTENT_TYPE, GMO_PSP, GMO_REFUSAL_REASONS, GMO_SHARED_KEYS, GMO_TOKEN_HOSTS, GMO_TOKEN_PATH, GMO_TOKEN_URLS, GmoError, buildGmoSharedPkBody, gmoRefusalCode, gmoResponseFacts, gmoShopId, gmoTokenEnvironment, gmoTokenMatchesCard, isGmoSharedPkRequest, isGmoTokenHost, parseGmoSharedPkBody, sanitizeGmoTokenResponse };