@agent-cards/sdk 0.20.0 → 0.22.0

package/dist/shiji-sts.generated.js

@@ -0,0 +1,913 @@
+// @ts-nocheck
+// Generated from @agent-cards/payment-core. Do not edit.
+// artifact-sha256: 364c3799a825b2f0a1058cadcf9aec6c6bf63d845616a9d451f048b8baa4f8de
+// 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 hex = "";
+    for (let i = 0; i < bytes.length; i++)
+        hex += (bytes[i] < 16 ? "0" : "") + bytes[i].toString(16);
+    return BigInt(`0x${hex}`);
+}
+function toBytes(value, size) {
+    const hex = value.toString(16).padStart(size * 2, "0");
+    const out = new Uint8Array(size);
+    for (let i = 0; i < size; i++)
+        out[i] = parseInt(hex.slice(2 * i, 2 * i + 2), 16);
+    return out;
+}
+function modPow(base, exponent, modulus) {
+    let result = 1n;
+    let square = base % modulus;
+    for (let rest = exponent; rest > 0n; rest >>= 1n) {
+        if (rest & 1n)
+            result = result * square % modulus;
+        square = square * square % modulus;
+    }
+    return result;
+}
+// src/adyen-jwe.js
+var ADYEN_JWE_HEADER = { alg: "RSA-OAEP-256", enc: "A256GCM", version: "1" };
+var BASE64URL = /^[A-Za-z0-9_-]+$/;
+function isAdyenJweCompact(s) {
+    if (typeof s !== "string" || s.length > 2048)
+        return false;
+    const parts = s.split(".");
+    if (parts.length !== 5)
+        return false;
+    const [header, encryptedKey, iv, ciphertext, tag] = parts;
+    if (!parts.every((p) => p.length > 0 && BASE64URL.test(p)))
+        return false;
+    if (encryptedKey.length !== 342 || iv.length !== 16 || tag.length !== 22)
+        return false;
+    if (ciphertext.length > 1024)
+        return false;
+    return isAdyenJweHeader(header);
+}
+function isAdyenJweHeader(segment) {
+    if (!BASE64URL.test(segment) || segment.length > 128)
+        return false;
+    let parsed;
+    try {
+        parsed = JSON.parse(new TextDecoder().decode(Uint8Array.from(atob(segment.replace(/-/g, "+").replace(/_/g, "/")), (c) => c.charCodeAt(0))));
+    }
+    catch {
+        return false;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return false;
+    const obj = parsed;
+    const keys = Object.keys(obj).sort();
+    if (keys.join(",") !== "alg,enc,version")
+        return false;
+    return obj.alg === ADYEN_JWE_HEADER.alg && obj.enc === ADYEN_JWE_HEADER.enc && obj.version === ADYEN_JWE_HEADER.version;
+}
+// src/json-path.js
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isPlainObject(v) {
+    return !!v && typeof v === "object" && !Array.isArray(v);
+}
+var MAX_PATH_STEPS = 16;
+function isJsonPath(path) {
+    return Array.isArray(path) && path.length <= MAX_PATH_STEPS && path.every((step) => typeof step === "string" ? step.length > 0 && !FORBIDDEN_KEYS.has(step) : Number.isSafeInteger(step) && step >= 0);
+}
+function jsonAt(root, path) {
+    let node = root;
+    for (const step of path) {
+        if (typeof step === "string") {
+            if (!isPlainObject(node) || FORBIDDEN_KEYS.has(step) || !Object.prototype.hasOwnProperty.call(node, step))
+                return { found: false };
+        }
+        else if (!Array.isArray(node) || !Number.isSafeInteger(step) || step < 0 || step >= node.length) {
+            return { found: false };
+        }
+        node = node[step];
+    }
+    return { found: true, value: node };
+}
+function roundTrips(parsed, body) {
+    try {
+        return JSON.stringify(parsed) === body;
+    }
+    catch {
+        return false;
+    }
+}
+function sameSteps(a, b) {
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((step, i) => step === b[i]);
+}
+function pathsOverlap(a, b) {
+    const n = Math.min(a.length, b.length);
+    for (let i = 0; i < n; i += 1)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+function describePath(path) {
+    return path.length ? path.map((step) => typeof step === "number" ? `[${step}]` : `.${step}`).join("").replace(/^\./, "") : "(root)";
+}
+// src/substitution-primitives.js
+var SubstitutionError = class extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SubstitutionError";
+    }
+};
+var SWAP_MEMBERS = /* @__PURE__ */ new Set(["path", "fields", "remove", "set"]);
+function checkedSet(set, path, names, remove) {
+    if (!Array.isArray(set))
+        throw new SubstitutionError("substitutions.set is not a list");
+    const entries = [...set].map((raw) => {
+        const entry = isPlainObject(raw) ? Object.fromEntries(Object.entries(raw)) : null;
+        if (!entry || Object.keys(entry).sort().join(",") !== "path,value")
+            throw new SubstitutionError("a set entry is not a {path, value}");
+        const at = Array.isArray(entry.path) ? [...entry.path] : entry.path;
+        if (!isJsonPath(at) || at.length === 0 || typeof at[at.length - 1] !== "string")
+            throw new SubstitutionError("refusing set path");
+        const value = entry.value;
+        if (value !== null && !["string", "boolean"].includes(typeof value) && !(typeof value === "number" && Number.isFinite(value))) {
+            throw new SubstitutionError(`the set value at ${describePath(at)} is not a string, number, boolean or null`);
+        }
+        const key = at[at.length - 1];
+        if (sameSteps(at.slice(0, -1), path) && (names.includes(key) || remove.includes(key))) {
+            throw new SubstitutionError(`the set entry at ${describePath(at)} writes over an encrypted field or a removed key`);
+        }
+        return { path: at, value };
+    });
+    for (const [i, a] of entries.entries()) {
+        for (const b of entries.slice(i + 1)) {
+            if (pathsOverlap(a.path, b.path))
+                throw new SubstitutionError(`two set entries write at ${describePath(a.path)}`);
+        }
+    }
+    return entries;
+}
+var ADYEN_JWE = /* @__PURE__ */ Object.freeze({ accepts: isAdyenJweCompact, label: "an Adyen JWE" });
+function swapMerchantHostedFields(body, spec, ciphertext = ADYEN_JWE) {
+    if (!isPlainObject(spec))
+        throw new SubstitutionError("refusing a substitution that is not an object");
+    for (const member of Object.keys(spec)) {
+        if (!SWAP_MEMBERS.has(member))
+            throw new SubstitutionError(`unexpected substitution member ${member}`);
+    }
+    const path = Array.isArray(spec.path) ? [...spec.path] : spec.path;
+    const fields = isPlainObject(spec.fields) ? Object.fromEntries(Object.entries(spec.fields)) : null;
+    const remove = Array.isArray(spec.remove) ? [...spec.remove] : spec.remove ?? [];
+    if (!isJsonPath(path))
+        throw new SubstitutionError("refusing substitution path");
+    if (!fields || Object.keys(fields).length === 0)
+        throw new SubstitutionError("substitutions carry no fields");
+    const names = Object.keys(fields);
+    const values = names.map((name) => fields[name]);
+    for (const name of names) {
+        if (FORBIDDEN_KEYS.has(name))
+            throw new SubstitutionError(`refusing substitution field ${name}`);
+        if (!ciphertext.accepts(fields[name]))
+            throw new SubstitutionError(`substitution for ${name} is not ${ciphertext.label}`);
+    }
+    if (!Array.isArray(remove))
+        throw new SubstitutionError("substitutions.remove is not a list");
+    for (const key of remove) {
+        if (typeof key !== "string" || !key || FORBIDDEN_KEYS.has(key))
+            throw new SubstitutionError(`refusing removal of ${String(key)}`);
+        if (names.includes(key))
+            throw new SubstitutionError(`substitution field ${key} is also listed for removal`);
+    }
+    if (new Set(remove).size !== remove.length)
+        throw new SubstitutionError("substitutions.remove names a key twice");
+    const set = checkedSet(spec.set ?? [], path, names, remove);
+    if (typeof body !== "string")
+        throw new SubstitutionError("the paused body is not JSON");
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        throw new SubstitutionError("the paused body is not JSON");
+    }
+    if (!isPlainObject(parsed))
+        throw new SubstitutionError("the paused body is not a JSON object");
+    const holder = jsonAt(parsed, path);
+    if (!holder.found || !isPlainObject(holder.value))
+        throw new SubstitutionError(`the paused body has no object at ${describePath(path)}`);
+    const swaps = /* @__PURE__ */ new Map();
+    for (const name of names) {
+        const dummy = Object.prototype.hasOwnProperty.call(holder.value, name) ? holder.value[name] : void 0;
+        if (typeof dummy !== "string")
+            throw new SubstitutionError(`the paused body has no string field ${name} at ${describePath(path)}`);
+        if (!ciphertext.accepts(dummy))
+            throw new SubstitutionError(`the paused field ${name} is not ${ciphertext.label}`);
+        if (swaps.has(dummy))
+            throw new SubstitutionError("two paused fields carry the same ciphertext");
+        swaps.set(dummy, fields[name]);
+    }
+    const dummies = [...swaps.keys()];
+    if (new Set(values).size !== values.length || values.some((value) => swaps.has(value))) {
+        throw new SubstitutionError("two ciphertexts in this substitution are the same");
+    }
+    const texts = [...dummies, ...values];
+    for (const a of texts)
+        for (const b of texts)
+            if (a !== b && b.includes(a))
+                throw new SubstitutionError("one ciphertext is part of another");
+    if ((remove.length > 0 || set.length > 0) && !roundTrips(parsed, body)) {
+        throw new SubstitutionError("the paused body does not round-trip through JSON, so it cannot be edited");
+    }
+    for (const entry of set) {
+        const parent = jsonAt(parsed, entry.path.slice(0, -1));
+        if (!parent.found || !isPlainObject(parent.value)) {
+            throw new SubstitutionError(`the paused body has no object at ${describePath(entry.path.slice(0, -1))} to write a value in`);
+        }
+        const key = entry.path[entry.path.length - 1];
+        const current = Object.prototype.hasOwnProperty.call(parent.value, key) ? parent.value[key] : void 0;
+        if (current !== null && typeof current === "object") {
+            throw new SubstitutionError(`refusing to write over the object at ${describePath(entry.path)}`);
+        }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const pattern = new RegExp(dummies.map((text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"), "g");
+    const swapped = body.replace(pattern, (text) => {
+        seen.add(text);
+        return swaps.get(text);
+    });
+    if (seen.size !== dummies.length)
+        throw new SubstitutionError("a paused field is not written verbatim in the body");
+    let out;
+    try {
+        out = JSON.parse(swapped);
+    }
+    catch {
+        throw new SubstitutionError("the substituted body is not JSON");
+    }
+    const written = jsonAt(out, path);
+    if (!written.found || !isPlainObject(written.value) || names.some((name) => written.value[name] !== fields[name]) || dummies.some((dummy) => swapped.includes(dummy))) {
+        throw new SubstitutionError(`the substitution did not land at ${describePath(path)}`);
+    }
+    if (remove.length === 0 && set.length === 0)
+        return swapped;
+    for (const key of remove)
+        if (Object.prototype.hasOwnProperty.call(written.value, key))
+            delete written.value[key];
+    for (const entry of set) {
+        const parent = jsonAt(out, entry.path.slice(0, -1));
+        if (!parent.found || !isPlainObject(parent.value))
+            throw new SubstitutionError(`the set entry at ${describePath(entry.path)} did not land`);
+        parent.value[entry.path[entry.path.length - 1]] = entry.value;
+    }
+    return JSON.stringify(out);
+}
+// src/shiji-sts.js
+var SHIJI_STS_PSP = "shiji_sts";
+var SHIJI_STS_HOSTS = /* @__PURE__ */ Object.freeze(["iframe.vault.eu.prod.shijipayment.com", "iframe.vault.eu.uat.shijipayment.com"]);
+var SHIJI_STS_SANDBOX_HOST = "iframe.vault.eu.uat.shijipayment.com";
+var SHIJI_STS_TOKEN_PATH = "/v1/token/getTokenId";
+var SHIJI_STS_CVV_PATH = "/v1/token/getCvvId";
+var SHIJI_STS_KEY = /* @__PURE__ */ Object.freeze({
+    spki: "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDF68IfqgqwmtmAKHNDlEyO9dYQiJHLd9ZixQ32PmzQtBH/mK+KB0q9K2kT7IjL1KdfSPSh8zXlXJOzZ8HQPewmxZgDSnKBVoeVb8HENiaMcIioddz9GJSY1z5ZvEE2DZawiSRxOiOorXQ8HjyVF+1McoWbIShrbeLcT/lC/FS5UQIDAQAB",
+    sha256: "c7846a0f1736b11b7549a364122d43b6517b87989f873ad805748b1f5a469ff7"
+});
+var SHIJI_STS_CIPHERTEXT_BYTES = 128;
+var SHIJI_STS_COMPANION_WINDOW_MS = 12e4;
+var SHIJI_STS_FIELDS = /* @__PURE__ */ Object.freeze({
+    token: Object.freeze(["pan", "expires"]),
+    cvv: Object.freeze(["cvv"])
+});
+var SHIJI_STS_KEEP_ON_FILE = "refuse";
+var SHIJI_STS_REFUSAL_REASONS = /* @__PURE__ */ Object.freeze([
+    "unsupported",
+    "foreign_key",
+    "keep_on_file",
+    "companion_unbound",
+    "companion_expired",
+    "companion_used",
+    "card"
+]);
+var MESSAGES = /* @__PURE__ */ Object.freeze({
+    unsupported: "Refusing to pay: unsupported Shiji card request. Nothing was sent.",
+    foreign_key: "Refusing to pay: this Shiji card request is encrypted under a key Agentcard has not reviewed. Nothing was sent.",
+    keep_on_file: "Refusing to pay: this hotel keeps the card on file to guarantee the stay, and Agentcard cannot ask for your consent to that yet. Nothing was sent.",
+    companion_unbound: "Refusing to pay: this Shiji security code request does not belong to a card payment you approved. Nothing was sent.",
+    companion_expired: "Refusing to pay: this Shiji security code request came too late after the card payment you approved. Nothing was sent.",
+    companion_used: "Refusing to pay: the security code for the card payment you approved was already sent. Nothing was sent.",
+    card: "Could not encrypt this card for Shiji. Nothing was sent."
+});
+var ShijiStsError = class extends Error {
+    constructor(reason) {
+        const known = Object.prototype.hasOwnProperty.call(MESSAGES, reason) ? reason : "unsupported";
+        super(MESSAGES[known]);
+        this.name = "ShijiStsError";
+        this.code = "shiji_sts_refused";
+        this.reason = known;
+    }
+};
+function shijiStsRefusalMessage(reason) {
+    return MESSAGES[Object.prototype.hasOwnProperty.call(MESSAGES, reason) ? reason : "unsupported"];
+}
+function shijiStsKeepOnFileRefusal(policy = SHIJI_STS_KEEP_ON_FILE) {
+    return policy === "ask" ? null : "keep_on_file";
+}
+function parseUrl(url) {
+    if (typeof url !== "string" || url.length > 2048)
+        return null;
+    try {
+        return new URL(url);
+    }
+    catch {
+        return null;
+    }
+}
+function shijiStsEndpoint(url, method = "POST") {
+    if (method !== "POST")
+        return null;
+    const parsed = parseUrl(url);
+    if (!parsed || parsed.protocol !== "https:" || parsed.port || parsed.username || parsed.password || parsed.search || parsed.hash || url.includes("?") || url.includes("#"))
+        return null;
+    if (!SHIJI_STS_HOSTS.includes(parsed.hostname))
+        return null;
+    if (parsed.pathname === SHIJI_STS_TOKEN_PATH)
+        return "token";
+    if (parsed.pathname === SHIJI_STS_CVV_PATH)
+        return "cvv";
+    return null;
+}
+function shijiStsEnvironment(url, method = "POST") {
+    if (!shijiStsEndpoint(url, method))
+        return null;
+    return new URL(url).hostname === SHIJI_STS_SANDBOX_HOST ? "sandbox" : "live";
+}
+function isShijiStsHost(url) {
+    if (typeof url !== "string")
+        return false;
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    const host = parsed.hostname.toLowerCase().replace(/\.$/, "");
+    return SHIJI_STS_HOSTS.includes(host);
+}
+var CIPHERTEXT_B64 = /^[A-Za-z0-9+/]{170}[AEIMQUYcgkosw048]=$/;
+var BASE642 = /^[A-Za-z0-9+/]+={0,2}$/;
+var OTHER_KEY_BYTES = [256, 384, 512];
+function isShijiStsCiphertext(value) {
+    return typeof value === "string" && CIPHERTEXT_B64.test(value);
+}
+function decodedLength(value) {
+    if (typeof value !== "string" || value.length % 4 !== 0 || !BASE642.test(value))
+        return -1;
+    const pad = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+    return value.length / 4 * 3 - pad;
+}
+function isOtherKeyCiphertext(value) {
+    return OTHER_KEY_BYTES.includes(decodedLength(value)) && btoa(atob(value)) === value;
+}
+function ciphertextInteger(value) {
+    const binary = atob(value);
+    let hex = "";
+    for (let i = 0; i < binary.length; i++)
+        hex += binary.charCodeAt(i).toString(16).padStart(2, "0");
+    return BigInt(`0x${hex}`);
+}
+function isShijiStsCiphertextUnderKey(value) {
+    if (!isShijiStsCiphertext(value))
+        return false;
+    const c = ciphertextInteger(value);
+    return c > 1n && c < parseRsaPublicKey(SHIJI_STS_KEY).n;
+}
+var BODY_LIMIT = 16384;
+var ACCESS_TOKEN = /^[\x21-\x7e]{1,4096}$/;
+var KEY_SEQUENCE = /^[\x21-\x7e]{0,256}$/;
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function readShijiStsBody(kind, body) {
+    const unsupported = Object.freeze({ ok: false, reason: "unsupported" });
+    const names = kind === "token" || kind === "cvv" ? SHIJI_STS_FIELDS[kind] : null;
+    if (!names || typeof body !== "string" || body.length > BODY_LIMIT)
+        return unsupported;
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return unsupported;
+    }
+    if (!record(parsed) || JSON.stringify(parsed) !== body)
+        return unsupported;
+    const keys = Object.keys(parsed);
+    const expected = ["accessToken", ...names];
+    const withSequence = keys.length === expected.length + 1 && keys[expected.length] === "keySequence";
+    if (!(keys.length === expected.length || withSequence) || !expected.every((key, i) => keys[i] === key))
+        return unsupported;
+    if (typeof parsed.accessToken !== "string" || !ACCESS_TOKEN.test(parsed.accessToken))
+        return unsupported;
+    if (withSequence && (typeof parsed.keySequence !== "string" || !KEY_SEQUENCE.test(parsed.keySequence)))
+        return unsupported;
+    const fields = {};
+    for (const name of names) {
+        const value = parsed[name];
+        if (isOtherKeyCiphertext(value))
+            return (
+            /** @type {ShijiStsBodyRead} */
+            Object.freeze({ ok: false, reason: "foreign_key" }));
+        if (!isShijiStsCiphertext(value))
+            return unsupported;
+        fields[name] = value;
+    }
+    if (new Set(Object.values(fields)).size !== names.length)
+        return unsupported;
+    const read = { ok: true, accessToken: parsed.accessToken, keySequence: withSequence ? parsed.keySequence : null, fields: Object.freeze(fields) };
+    return Object.freeze(read);
+}
+function shijiStsBodyRefusal(url, body) {
+    const kind = shijiStsEndpoint(url);
+    if (!kind)
+        return "unsupported";
+    const read = readShijiStsBody(kind, body);
+    return read.ok ? null : read.reason;
+}
+function classifyShijiStsRequest(url, method, body) {
+    const kind = shijiStsEndpoint(url, method);
+    if (!kind)
+        return null;
+    const read = readShijiStsBody(kind, body);
+    if (!read.ok)
+        return read.reason;
+    if (kind === "cvv")
+        return "companion";
+    return shijiStsKeepOnFileRefusal() ?? "card";
+}
+function isShijiStsCardRequest(request) {
+    return record(request) && classifyShijiStsRequest(request.url, request.method, request.body) === "card";
+}
+var digitsOf = (value) => typeof value === "string" || typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? String(value) : null;
+function shijiStsPlaintexts(card) {
+    if (!record(card))
+        throw new ShijiStsError("card");
+    const number = digitsOf(card.number)?.replace(/\s/g, "") ?? "";
+    const month = digitsOf(card.month) ?? "";
+    const year = digitsOf(card.year) ?? "";
+    const cvv = digitsOf(card.cvc) ?? "";
+    if (!/^\d{12,19}$/.test(number) || !/^\d{1,2}$/.test(month) || !/^(?:\d{2}|\d{4})$/.test(year) || !/^\d{3,4}$/.test(cvv)) {
+        throw new ShijiStsError("card");
+    }
+    if (Number(month) < 1 || Number(month) > 12)
+        throw new ShijiStsError("card");
+    return { pan: number, expires: `${month.padStart(2, "0")}/${year.slice(-2)}`, cvv };
+}
+function base64(bytes) {
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++)
+        binary += String.fromCharCode(bytes[i]);
+    return btoa(binary);
+}
+function encryptText(text, random) {
+    const message = new TextEncoder().encode(text);
+    try {
+        return base64(rsaesPkcs1v15Encrypt(SHIJI_STS_KEY, message, random));
+    }
+    finally {
+        message.fill(0);
+    }
+}
+function encryptShijiStsCard(card, facilities = {}) {
+    const refusal = shijiStsKeepOnFileRefusal();
+    if (refusal)
+        throw new ShijiStsError(refusal);
+    const random = facilities.crypto ?? globalThis.crypto;
+    const texts = shijiStsPlaintexts(card);
+    return { pan: encryptText(texts.pan, random), expires: encryptText(texts.expires, random), cvv: encryptText(texts.cvv, random) };
+}
+function shijiStsKeyUsable(authorization) {
+    if (!record(authorization) || !record(authorization.cse))
+        return false;
+    const cse = authorization.cse;
+    if (cse.psp !== SHIJI_STS_PSP || cse.scheme !== "rsa-pkcs1v15")
+        return false;
+    if (cse.public_key != null || cse.client_key != null || Object.prototype.hasOwnProperty.call(cse, "merchant_hosted"))
+        return false;
+    if (shijiStsEndpoint(authorization.url) !== "token")
+        return false;
+    const environment = shijiStsEnvironment(authorization.url);
+    if (cse.environment !== environment || authorization.sandbox !== (environment === "sandbox"))
+        return false;
+    try {
+        return parseRsaPublicKey(SHIJI_STS_KEY).size === SHIJI_STS_CIPHERTEXT_BYTES;
+    }
+    catch {
+        return false;
+    }
+}
+var SHIJI_CIPHERTEXT = /* @__PURE__ */ Object.freeze({ accepts: isShijiStsCiphertext, label: "a Shiji STS ciphertext" });
+function exactFields(kind, fields) {
+    if (!record(fields))
+        return null;
+    const names = SHIJI_STS_FIELDS[kind];
+    const keys = Object.keys(fields);
+    if (keys.length !== names.length || !names.every((name) => keys.includes(name)))
+        return null;
+    return Object.fromEntries(names.map((name) => [name, fields[name]]));
+}
+function substituteShijiSts(url, body, fields) {
+    const policy = shijiStsKeepOnFileRefusal();
+    if (policy)
+        throw new SubstitutionError(shijiStsRefusalMessage(policy));
+    const kind = shijiStsEndpoint(url);
+    if (!kind)
+        throw new SubstitutionError("the paused request is not a Shiji STS card request");
+    const paused = readShijiStsBody(kind, body);
+    if (!paused.ok)
+        throw new SubstitutionError(shijiStsRefusalMessage(paused.reason));
+    const swap = exactFields(kind, fields);
+    if (!swap)
+        throw new SubstitutionError(`the substitution must carry exactly ${SHIJI_STS_FIELDS[kind].join(" and ")}`);
+    const taken = [paused.accessToken, paused.keySequence, ...Object.values(paused.fields)];
+    for (const [name, value] of Object.entries(swap)) {
+        if (!isShijiStsCiphertextUnderKey(value))
+            throw new SubstitutionError(`substitution for ${name} is not a ciphertext under the pinned Shiji key`);
+        if (taken.includes(value))
+            throw new SubstitutionError("a ciphertext in this substitution is already in the body");
+    }
+    const values = Object.values(swap);
+    if (new Set(values).size !== values.length)
+        throw new SubstitutionError("the substitution carries one ciphertext twice");
+    const out = swapMerchantHostedFields(body, { path: [], fields: swap }, SHIJI_CIPHERTEXT);
+    const written = readShijiStsBody(kind, out);
+    if (!written.ok || written.accessToken !== paused.accessToken || written.keySequence !== paused.keySequence || Object.entries(swap).some(([name, value]) => written.fields[name] !== value)) {
+        throw new SubstitutionError("the substitution did not land at the body root");
+    }
+    return out;
+}
+function shijiStsSubstitutionsRefusal(template, substitutions) {
+    const policy = shijiStsKeepOnFileRefusal();
+    if (policy)
+        return { code: policy, message: shijiStsRefusalMessage(policy) };
+    const refuse2 = (message) => ({ code: "invalid_substitutions", message });
+    if (!record(template) || shijiStsEndpoint(template.url) !== "token")
+        return refuse2("This authorization is not a Shiji STS card request.");
+    const paused = readShijiStsBody("token", template.body);
+    if (!paused.ok)
+        return refuse2("The paused Shiji STS request is not the shape the vault fills.");
+    const names = ["pan", "expires", "cvv"];
+    const keys = record(substitutions) ? Object.keys(substitutions) : [];
+    if (keys.length !== names.length || !names.every((name) => keys.includes(name))) {
+        return refuse2("substitutions must carry exactly these fields: pan, expires, cvv.");
+    }
+    for (const name of names) {
+        if (!isShijiStsCiphertextUnderKey(substitutions[name]))
+            return refuse2(`substitutions.${name} is not a ciphertext under the pinned Shiji key.`);
+    }
+    const values = names.map((name) => substitutions[name]);
+    const taken = [paused.accessToken, paused.keySequence, ...Object.values(paused.fields)];
+    if (new Set(values).size !== values.length || values.some((value) => taken.includes(value))) {
+        return refuse2("substitutions must be three new ciphertexts, none already in the paused request.");
+    }
+    return null;
+}
+var PAGE = /^[\x21-\x7e]{1,256}$/;
+var instant = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+var REVIEWED_KEY_SEQUENCE = /^[\x21-\x7e]{1,256}$/;
+var REVIEWED_KEY_SEQUENCES_LIMIT = 16;
+function reviewedKeySequences(list) {
+    if (!Array.isArray(list) || list.length === 0 || list.length > REVIEWED_KEY_SEQUENCES_LIMIT)
+        return null;
+    if (!list.every((key) => typeof key === "string" && REVIEWED_KEY_SEQUENCE.test(key)))
+        return null;
+    return Object.freeze([...list]);
+}
+function createShijiStsCompanion(tokenRequest, { page, now, cvvKeySequences } = {}) {
+    const policy = shijiStsKeepOnFileRefusal();
+    if (policy)
+        throw new ShijiStsError(policy);
+    if (!record(tokenRequest) || shijiStsEndpoint(tokenRequest.url, tokenRequest.method) !== "token")
+        throw new ShijiStsError("unsupported");
+    const token = readShijiStsBody("token", tokenRequest.body);
+    if (!token.ok)
+        throw new ShijiStsError(token.reason);
+    if (typeof page !== "string" || !PAGE.test(page) || !instant(now))
+        throw new ShijiStsError("unsupported");
+    const reviewed = reviewedKeySequences(cvvKeySequences);
+    if (!reviewed)
+        throw new ShijiStsError("unsupported");
+    const host = new URL(tokenRequest.url).hostname;
+    const boundPage = page;
+    const boundAt = now;
+    let used = false;
+    const claim = (request, context = {}) => {
+        if (!record(request) || shijiStsEndpoint(request.url, request.method) !== "cvv")
+            return "unsupported";
+        const cvv = readShijiStsBody("cvv", request.body);
+        if (!cvv.ok)
+            return cvv.reason;
+        if (used)
+            return "companion_used";
+        if (new URL(request.url).hostname !== host || context.page !== boundPage || cvv.accessToken !== token.accessToken || cvv.keySequence === null || !reviewed.includes(cvv.keySequence))
+            return "companion_unbound";
+        if (!instant(context.now) || context.now < boundAt || context.now - boundAt > SHIJI_STS_COMPANION_WINDOW_MS)
+            return "companion_expired";
+        used = true;
+        return "swap";
+    };
+    return Object.freeze({ claim });
+}
+var RESPONSE_LIMIT = 16384;
+var RESP_CODE = /^[A-Za-z0-9]{1,8}$/;
+var SUCCESS = "00";
+function readAnswer(text) {
+    if (typeof text !== "string" || text.length > RESPONSE_LIMIT)
+        return null;
+    try {
+        const value = JSON.parse(text);
+        return record(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function shijiStsResponseFacts(status, text) {
+    const unknown = { outcome: "unknown", code: null };
+    if (!Number.isInteger(status) || status < 100 || status >= 500)
+        return unknown;
+    const answer = readAnswer(text);
+    const code = answer && typeof answer.respCode === "string" && RESP_CODE.test(answer.respCode) ? answer.respCode : null;
+    if (code && code !== SUCCESS)
+        return { outcome: "refused", code };
+    if (!code && status >= 400)
+        return { outcome: "refused", code: `http_${status}` };
+    if (code === SUCCESS && status >= 200 && status < 300) {
+        const id = typeof answer.tokenId === "string" ? answer.tokenId : answer.cvvId;
+        if (typeof id === "string" && id.length > 0)
+            return { outcome: "token", code: SUCCESS };
+    }
+    return unknown;
+}
+function sanitizeShijiStsResponse(text, status = 200) {
+    const facts = shijiStsResponseFacts(status, text);
+    if (facts.outcome === "unknown")
+        throw new ShijiStsError("unsupported");
+    return JSON.stringify(RESP_CODE.test(facts.code) ? { respCode: facts.code } : {});
+}
+export { SHIJI_STS_CIPHERTEXT_BYTES, SHIJI_STS_COMPANION_WINDOW_MS, SHIJI_STS_CVV_PATH, SHIJI_STS_FIELDS, SHIJI_STS_HOSTS, SHIJI_STS_KEEP_ON_FILE, SHIJI_STS_KEY, SHIJI_STS_PSP, SHIJI_STS_REFUSAL_REASONS, SHIJI_STS_SANDBOX_HOST, SHIJI_STS_TOKEN_PATH, ShijiStsError, classifyShijiStsRequest, createShijiStsCompanion, encryptShijiStsCard, isShijiStsCardRequest, isShijiStsCiphertext, isShijiStsCiphertextUnderKey, isShijiStsHost, readShijiStsBody, sanitizeShijiStsResponse, shijiStsBodyRefusal, shijiStsEndpoint, shijiStsEnvironment, shijiStsKeepOnFileRefusal, shijiStsKeyUsable, shijiStsPlaintexts, shijiStsRefusalMessage, shijiStsResponseFacts, shijiStsSubstitutionsRefusal, substituteShijiSts };