@paykka/card-checkout-ui 0.13.8 → 0.13.13

package/dist/es/core.js

@@ -1,3 +1,9 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 var n, l$3, u$3, t$2, i$2, o$2, r$1, f$3, e$3, c$2, s$3, a$2, h$2 = {}, v$2 = [], p$3 = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i, y$2 = Array.isArray;
 function d$3(n2, l2) {
   for (var u2 in l2)
@@ -2992,10 +2998,10 @@ function isPdfViewerEnabled() {
 }
 function getArchitecture() {
   var f2 = new Float32Array(1);
-  var u8 = new Uint8Array(f2.buffer);
+  var u82 = new Uint8Array(f2.buffer);
   f2[0] = Infinity;
   f2[0] = f2[0] - f2[0];
-  return u8[3];
+  return u82[3];
 }
 function getApplePayState() {
   var ApplePaySession = window.ApplePaySession;
@@ -4442,6 +4448,579 @@ function useSignal(n2) {
     return d$1(n2);
   }, []);
 }
+/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
+function isBytes(a2) {
+  return a2 instanceof Uint8Array || ArrayBuffer.isView(a2) && a2.constructor.name === "Uint8Array";
+}
+function anumber(n2) {
+  if (!Number.isSafeInteger(n2) || n2 < 0)
+    throw new Error("positive integer expected, got " + n2);
+}
+function abytes(value, length, title = "") {
+  const bytes = isBytes(value);
+  const len = value == null ? void 0 : value.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out, void 0, "output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function u8(arr) {
+  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i2 = 0; i2 < arrays.length; i2++) {
+    arrays[i2].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+function concatBytes(...arrays) {
+  let sum = 0;
+  for (let i2 = 0; i2 < arrays.length; i2++) {
+    const a2 = arrays[i2];
+    abytes(a2);
+    sum += a2.length;
+  }
+  const res = new Uint8Array(sum);
+  for (let i2 = 0, pad = 0; i2 < arrays.length; i2++) {
+    const a2 = arrays[i2];
+    res.set(a2, pad);
+    pad += a2.length;
+  }
+  return res;
+}
+function equalBytes(a2, b2) {
+  if (a2.length !== b2.length)
+    return false;
+  let diff = 0;
+  for (let i2 = 0; i2 < a2.length; i2++)
+    diff |= a2[i2] ^ b2[i2];
+  return diff === 0;
+}
+const wrapCipher = /* @__NO_SIDE_EFFECTS__ */ (params, constructor) => {
+  function wrappedCipher(key, ...args) {
+    abytes(key, void 0, "key");
+    if (!isLE)
+      throw new Error("Non little-endian hardware is not yet supported");
+    if (params.nonceLength !== void 0) {
+      const nonce = args[0];
+      abytes(nonce, params.varSizeNonce ? void 0 : params.nonceLength, "nonce");
+    }
+    const tagl = params.tagLength;
+    if (tagl && args[1] !== void 0)
+      abytes(args[1], void 0, "AAD");
+    const cipher = constructor(key, ...args);
+    const checkOutput = (fnLength, output) => {
+      if (output !== void 0) {
+        if (fnLength !== 2)
+          throw new Error("cipher output not supported");
+        abytes(output, void 0, "output");
+      }
+    };
+    let called = false;
+    const wrCipher = {
+      encrypt(data, output) {
+        if (called)
+          throw new Error("cannot encrypt() twice with same key + nonce");
+        called = true;
+        abytes(data);
+        checkOutput(cipher.encrypt.length, output);
+        return cipher.encrypt(data, output);
+      },
+      decrypt(data, output) {
+        abytes(data);
+        if (tagl && data.length < tagl)
+          throw new Error('"ciphertext" expected length bigger than tagLength=' + tagl);
+        checkOutput(cipher.decrypt.length, output);
+        return cipher.decrypt(data, output);
+      }
+    };
+    return wrCipher;
+  }
+  Object.assign(wrappedCipher, params);
+  return wrappedCipher;
+};
+function getOutput(expectedLength, out, onlyAligned = true) {
+  if (out === void 0)
+    return new Uint8Array(expectedLength);
+  if (out.length !== expectedLength)
+    throw new Error('"output" expected Uint8Array of length ' + expectedLength + ", got: " + out.length);
+  if (onlyAligned && !isAligned32(out))
+    throw new Error("invalid output, must be aligned");
+  return out;
+}
+function u64Lengths(dataLength, aadLength, isLE2) {
+  const num = new Uint8Array(16);
+  const view = createView(num);
+  view.setBigUint64(0, BigInt(aadLength), isLE2);
+  view.setBigUint64(8, BigInt(dataLength), isLE2);
+  return num;
+}
+function isAligned32(bytes) {
+  return bytes.byteOffset % 4 === 0;
+}
+function copyBytes(bytes) {
+  return Uint8Array.from(bytes);
+}
+function randomBytes(bytesLength = 32) {
+  const cr = typeof globalThis === "object" ? globalThis.crypto : null;
+  if (typeof (cr == null ? void 0 : cr.getRandomValues) !== "function")
+    throw new Error("crypto.getRandomValues must be defined");
+  return cr.getRandomValues(new Uint8Array(bytesLength));
+}
+function managedNonce(fn, randomBytes_ = randomBytes) {
+  const { nonceLength } = fn;
+  anumber(nonceLength);
+  const addNonce = (nonce, ciphertext) => {
+    const out = concatBytes(nonce, ciphertext);
+    ciphertext.fill(0);
+    return out;
+  };
+  return (key, ...args) => ({
+    encrypt(plaintext) {
+      abytes(plaintext);
+      const nonce = randomBytes_(nonceLength);
+      const encrypted = fn(key, nonce, ...args).encrypt(plaintext);
+      if (encrypted instanceof Promise)
+        return encrypted.then((ct) => addNonce(nonce, ct));
+      return addNonce(nonce, encrypted);
+    },
+    decrypt(ciphertext) {
+      abytes(ciphertext);
+      const nonce = ciphertext.subarray(0, nonceLength);
+      const decrypted = ciphertext.subarray(nonceLength);
+      return fn(key, nonce, ...args).decrypt(decrypted);
+    }
+  });
+}
+const BLOCK_SIZE$1 = 16;
+const ZEROS16 = /* @__PURE__ */ new Uint8Array(16);
+const ZEROS32 = u32(ZEROS16);
+const POLY$1 = 225;
+const mul2$1 = (s0, s1, s2, s3) => {
+  const hiBit = s3 & 1;
+  return {
+    s3: s2 << 31 | s3 >>> 1,
+    s2: s1 << 31 | s2 >>> 1,
+    s1: s0 << 31 | s1 >>> 1,
+    s0: s0 >>> 1 ^ POLY$1 << 24 & -(hiBit & 1)
+    // reduce % poly
+  };
+};
+const swapLE = (n2) => (n2 >>> 0 & 255) << 24 | (n2 >>> 8 & 255) << 16 | (n2 >>> 16 & 255) << 8 | n2 >>> 24 & 255 | 0;
+function _toGHASHKey(k2) {
+  k2.reverse();
+  const hiBit = k2[15] & 1;
+  let carry = 0;
+  for (let i2 = 0; i2 < k2.length; i2++) {
+    const t2 = k2[i2];
+    k2[i2] = t2 >>> 1 | carry;
+    carry = (t2 & 1) << 7;
+  }
+  k2[0] ^= -hiBit & 225;
+  return k2;
+}
+const estimateWindow = (bytes) => {
+  if (bytes > 64 * 1024)
+    return 8;
+  if (bytes > 1024)
+    return 4;
+  return 2;
+};
+class GHASH {
+  // We select bits per window adaptively based on expectedLength
+  constructor(key, expectedLength) {
+    __publicField(this, "blockLen", BLOCK_SIZE$1);
+    __publicField(this, "outputLen", BLOCK_SIZE$1);
+    __publicField(this, "s0", 0);
+    __publicField(this, "s1", 0);
+    __publicField(this, "s2", 0);
+    __publicField(this, "s3", 0);
+    __publicField(this, "finished", false);
+    __publicField(this, "t");
+    __publicField(this, "W");
+    __publicField(this, "windowSize");
+    abytes(key, 16, "key");
+    key = copyBytes(key);
+    const kView = createView(key);
+    let k0 = kView.getUint32(0, false);
+    let k1 = kView.getUint32(4, false);
+    let k2 = kView.getUint32(8, false);
+    let k3 = kView.getUint32(12, false);
+    const doubles = [];
+    for (let i2 = 0; i2 < 128; i2++) {
+      doubles.push({ s0: swapLE(k0), s1: swapLE(k1), s2: swapLE(k2), s3: swapLE(k3) });
+      ({ s0: k0, s1: k1, s2: k2, s3: k3 } = mul2$1(k0, k1, k2, k3));
+    }
+    const W2 = estimateWindow(expectedLength || 1024);
+    if (![1, 2, 4, 8].includes(W2))
+      throw new Error("ghash: invalid window size, expected 2, 4 or 8");
+    this.W = W2;
+    const bits = 128;
+    const windows = bits / W2;
+    const windowSize = this.windowSize = 2 ** W2;
+    const items = [];
+    for (let w2 = 0; w2 < windows; w2++) {
+      for (let byte2 = 0; byte2 < windowSize; byte2++) {
+        let s0 = 0, s1 = 0, s2 = 0, s3 = 0;
+        for (let j2 = 0; j2 < W2; j2++) {
+          const bit = byte2 >>> W2 - j2 - 1 & 1;
+          if (!bit)
+            continue;
+          const { s0: d0, s1: d1, s2: d2, s3: d3 } = doubles[W2 * w2 + j2];
+          s0 ^= d0, s1 ^= d1, s2 ^= d2, s3 ^= d3;
+        }
+        items.push({ s0, s1, s2, s3 });
+      }
+    }
+    this.t = items;
+  }
+  _updateBlock(s0, s1, s2, s3) {
+    s0 ^= this.s0, s1 ^= this.s1, s2 ^= this.s2, s3 ^= this.s3;
+    const { W: W2, t: t2, windowSize } = this;
+    let o0 = 0, o1 = 0, o2 = 0, o3 = 0;
+    const mask = (1 << W2) - 1;
+    let w2 = 0;
+    for (const num of [s0, s1, s2, s3]) {
+      for (let bytePos = 0; bytePos < 4; bytePos++) {
+        const byte2 = num >>> 8 * bytePos & 255;
+        for (let bitPos = 8 / W2 - 1; bitPos >= 0; bitPos--) {
+          const bit = byte2 >>> W2 * bitPos & mask;
+          const { s0: e0, s1: e1, s2: e2, s3: e3 } = t2[w2 * windowSize + bit];
+          o0 ^= e0, o1 ^= e1, o2 ^= e2, o3 ^= e3;
+          w2 += 1;
+        }
+      }
+    }
+    this.s0 = o0;
+    this.s1 = o1;
+    this.s2 = o2;
+    this.s3 = o3;
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    data = copyBytes(data);
+    const b32 = u32(data);
+    const blocks = Math.floor(data.length / BLOCK_SIZE$1);
+    const left = data.length % BLOCK_SIZE$1;
+    for (let i2 = 0; i2 < blocks; i2++) {
+      this._updateBlock(b32[i2 * 4 + 0], b32[i2 * 4 + 1], b32[i2 * 4 + 2], b32[i2 * 4 + 3]);
+    }
+    if (left) {
+      ZEROS16.set(data.subarray(blocks * BLOCK_SIZE$1));
+      this._updateBlock(ZEROS32[0], ZEROS32[1], ZEROS32[2], ZEROS32[3]);
+      clean(ZEROS32);
+    }
+    return this;
+  }
+  destroy() {
+    const { t: t2 } = this;
+    for (const elm of t2) {
+      elm.s0 = 0, elm.s1 = 0, elm.s2 = 0, elm.s3 = 0;
+    }
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { s0, s1, s2, s3 } = this;
+    const o32 = u32(out);
+    o32[0] = s0;
+    o32[1] = s1;
+    o32[2] = s2;
+    o32[3] = s3;
+    return out;
+  }
+  digest() {
+    const res = new Uint8Array(BLOCK_SIZE$1);
+    this.digestInto(res);
+    this.destroy();
+    return res;
+  }
+}
+class Polyval extends GHASH {
+  constructor(key, expectedLength) {
+    abytes(key);
+    const ghKey = _toGHASHKey(copyBytes(key));
+    super(ghKey, expectedLength);
+    clean(ghKey);
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    data = copyBytes(data);
+    const b32 = u32(data);
+    const left = data.length % BLOCK_SIZE$1;
+    const blocks = Math.floor(data.length / BLOCK_SIZE$1);
+    for (let i2 = 0; i2 < blocks; i2++) {
+      this._updateBlock(swapLE(b32[i2 * 4 + 3]), swapLE(b32[i2 * 4 + 2]), swapLE(b32[i2 * 4 + 1]), swapLE(b32[i2 * 4 + 0]));
+    }
+    if (left) {
+      ZEROS16.set(data.subarray(blocks * BLOCK_SIZE$1));
+      this._updateBlock(swapLE(ZEROS32[3]), swapLE(ZEROS32[2]), swapLE(ZEROS32[1]), swapLE(ZEROS32[0]));
+      clean(ZEROS32);
+    }
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { s0, s1, s2, s3 } = this;
+    const o32 = u32(out);
+    o32[0] = s0;
+    o32[1] = s1;
+    o32[2] = s2;
+    o32[3] = s3;
+    return out.reverse();
+  }
+}
+function wrapConstructorWithKey(hashCons) {
+  const hashC = (msg, key) => hashCons(key, msg.length).update(msg).digest();
+  const tmp = hashCons(new Uint8Array(16), 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (key, expectedLength) => hashCons(key, expectedLength);
+  return hashC;
+}
+const ghash = wrapConstructorWithKey((key, expectedLength) => new GHASH(key, expectedLength));
+wrapConstructorWithKey((key, expectedLength) => new Polyval(key, expectedLength));
+const BLOCK_SIZE = 16;
+const BLOCK_SIZE32 = 4;
+const EMPTY_BLOCK = /* @__PURE__ */ new Uint8Array(BLOCK_SIZE);
+const POLY = 283;
+function validateKeyLength(key) {
+  if (![16, 24, 32].includes(key.length))
+    throw new Error('"aes key" expected Uint8Array of length 16/24/32, got length=' + key.length);
+}
+function mul2(n2) {
+  return n2 << 1 ^ POLY & -(n2 >> 7);
+}
+function mul(a2, b2) {
+  let res = 0;
+  for (; b2 > 0; b2 >>= 1) {
+    res ^= a2 & -(b2 & 1);
+    a2 = mul2(a2);
+  }
+  return res;
+}
+const sbox = /* @__PURE__ */ (() => {
+  const t2 = new Uint8Array(256);
+  for (let i2 = 0, x2 = 1; i2 < 256; i2++, x2 ^= mul2(x2))
+    t2[i2] = x2;
+  const box = new Uint8Array(256);
+  box[0] = 99;
+  for (let i2 = 0; i2 < 255; i2++) {
+    let x2 = t2[255 - i2];
+    x2 |= x2 << 8;
+    box[t2[i2]] = (x2 ^ x2 >> 4 ^ x2 >> 5 ^ x2 >> 6 ^ x2 >> 7 ^ 99) & 255;
+  }
+  clean(t2);
+  return box;
+})();
+const rotr32_8 = (n2) => n2 << 24 | n2 >>> 8;
+const rotl32_8 = (n2) => n2 << 8 | n2 >>> 24;
+function genTtable(sbox2, fn) {
+  if (sbox2.length !== 256)
+    throw new Error("Wrong sbox length");
+  const T0 = new Uint32Array(256).map((_2, j2) => fn(sbox2[j2]));
+  const T1 = T0.map(rotl32_8);
+  const T2 = T1.map(rotl32_8);
+  const T3 = T2.map(rotl32_8);
+  const T01 = new Uint32Array(256 * 256);
+  const T23 = new Uint32Array(256 * 256);
+  const sbox22 = new Uint16Array(256 * 256);
+  for (let i2 = 0; i2 < 256; i2++) {
+    for (let j2 = 0; j2 < 256; j2++) {
+      const idx = i2 * 256 + j2;
+      T01[idx] = T0[i2] ^ T1[j2];
+      T23[idx] = T2[i2] ^ T3[j2];
+      sbox22[idx] = sbox2[i2] << 8 | sbox2[j2];
+    }
+  }
+  return { sbox: sbox2, sbox2: sbox22, T0, T1, T2, T3, T01, T23 };
+}
+const tableEncoding = /* @__PURE__ */ genTtable(sbox, (s2) => mul(s2, 3) << 24 | s2 << 16 | s2 << 8 | mul(s2, 2));
+const xPowers = /* @__PURE__ */ (() => {
+  const p2 = new Uint8Array(16);
+  for (let i2 = 0, x2 = 1; i2 < 16; i2++, x2 = mul2(x2))
+    p2[i2] = x2;
+  return p2;
+})();
+function expandKeyLE(key) {
+  abytes(key);
+  const len = key.length;
+  validateKeyLength(key);
+  const { sbox2 } = tableEncoding;
+  const toClean = [];
+  if (!isAligned32(key))
+    toClean.push(key = copyBytes(key));
+  const k32 = u32(key);
+  const Nk = k32.length;
+  const subByte = (n2) => applySbox(sbox2, n2, n2, n2, n2);
+  const xk = new Uint32Array(len + 28);
+  xk.set(k32);
+  for (let i2 = Nk; i2 < xk.length; i2++) {
+    let t2 = xk[i2 - 1];
+    if (i2 % Nk === 0)
+      t2 = subByte(rotr32_8(t2)) ^ xPowers[i2 / Nk - 1];
+    else if (Nk > 6 && i2 % Nk === 4)
+      t2 = subByte(t2);
+    xk[i2] = xk[i2 - Nk] ^ t2;
+  }
+  clean(...toClean);
+  return xk;
+}
+function apply0123(T01, T23, s0, s1, s2, s3) {
+  return T01[s0 << 8 & 65280 | s1 >>> 8 & 255] ^ T23[s2 >>> 8 & 65280 | s3 >>> 24 & 255];
+}
+function applySbox(sbox2, s0, s1, s2, s3) {
+  return sbox2[s0 & 255 | s1 & 65280] | sbox2[s2 >>> 16 & 255 | s3 >>> 16 & 65280] << 16;
+}
+function encrypt(xk, s0, s1, s2, s3) {
+  const { sbox2, T01, T23 } = tableEncoding;
+  let k2 = 0;
+  s0 ^= xk[k2++], s1 ^= xk[k2++], s2 ^= xk[k2++], s3 ^= xk[k2++];
+  const rounds = xk.length / 4 - 2;
+  for (let i2 = 0; i2 < rounds; i2++) {
+    const t02 = xk[k2++] ^ apply0123(T01, T23, s0, s1, s2, s3);
+    const t12 = xk[k2++] ^ apply0123(T01, T23, s1, s2, s3, s0);
+    const t22 = xk[k2++] ^ apply0123(T01, T23, s2, s3, s0, s1);
+    const t32 = xk[k2++] ^ apply0123(T01, T23, s3, s0, s1, s2);
+    s0 = t02, s1 = t12, s2 = t22, s3 = t32;
+  }
+  const t0 = xk[k2++] ^ applySbox(sbox2, s0, s1, s2, s3);
+  const t1 = xk[k2++] ^ applySbox(sbox2, s1, s2, s3, s0);
+  const t2 = xk[k2++] ^ applySbox(sbox2, s2, s3, s0, s1);
+  const t3 = xk[k2++] ^ applySbox(sbox2, s3, s0, s1, s2);
+  return { s0: t0, s1: t1, s2: t2, s3: t3 };
+}
+function ctr32(xk, isLE2, nonce, src, dst) {
+  abytes(nonce, BLOCK_SIZE, "nonce");
+  abytes(src);
+  dst = getOutput(src.length, dst);
+  const ctr = nonce;
+  const c32 = u32(ctr);
+  const view = createView(ctr);
+  const src32 = u32(src);
+  const dst32 = u32(dst);
+  const ctrPos = isLE2 ? 0 : 12;
+  const srcLen = src.length;
+  let ctrNum = view.getUint32(ctrPos, isLE2);
+  let { s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]);
+  for (let i2 = 0; i2 + 4 <= src32.length; i2 += 4) {
+    dst32[i2 + 0] = src32[i2 + 0] ^ s0;
+    dst32[i2 + 1] = src32[i2 + 1] ^ s1;
+    dst32[i2 + 2] = src32[i2 + 2] ^ s2;
+    dst32[i2 + 3] = src32[i2 + 3] ^ s3;
+    ctrNum = ctrNum + 1 >>> 0;
+    view.setUint32(ctrPos, ctrNum, isLE2);
+    ({ s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]));
+  }
+  const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);
+  if (start < srcLen) {
+    const b32 = new Uint32Array([s0, s1, s2, s3]);
+    const buf = u8(b32);
+    for (let i2 = start, pos = 0; i2 < srcLen; i2++, pos++)
+      dst[i2] = src[i2] ^ buf[pos];
+    clean(b32);
+  }
+  return dst;
+}
+function computeTag(fn, isLE2, key, data, AAD) {
+  const aadLength = AAD ? AAD.length : 0;
+  const h2 = fn.create(key, data.length + aadLength);
+  if (AAD)
+    h2.update(AAD);
+  const num = u64Lengths(8 * data.length, 8 * aadLength, isLE2);
+  h2.update(data);
+  h2.update(num);
+  const res = h2.digest();
+  clean(num);
+  return res;
+}
+const gcm = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16, varSizeNonce: true }, function aesgcm(key, nonce, AAD) {
+  if (nonce.length < 8)
+    throw new Error("aes/gcm: invalid nonce length");
+  const tagLength = 16;
+  function _computeTag(authKey, tagMask, data) {
+    const tag = computeTag(ghash, false, authKey, data, AAD);
+    for (let i2 = 0; i2 < tagMask.length; i2++)
+      tag[i2] ^= tagMask[i2];
+    return tag;
+  }
+  function deriveKeys() {
+    const xk = expandKeyLE(key);
+    const authKey = EMPTY_BLOCK.slice();
+    const counter = EMPTY_BLOCK.slice();
+    ctr32(xk, false, counter, counter, authKey);
+    if (nonce.length === 12) {
+      counter.set(nonce);
+    } else {
+      const nonceLen = EMPTY_BLOCK.slice();
+      const view = createView(nonceLen);
+      view.setBigUint64(8, BigInt(nonce.length * 8), false);
+      const g2 = ghash.create(authKey).update(nonce).update(nonceLen);
+      g2.digestInto(counter);
+      g2.destroy();
+    }
+    const tagMask = ctr32(xk, false, counter, EMPTY_BLOCK);
+    return { xk, authKey, counter, tagMask };
+  }
+  return {
+    encrypt(plaintext) {
+      const { xk, authKey, counter, tagMask } = deriveKeys();
+      const out = new Uint8Array(plaintext.length + tagLength);
+      const toClean = [xk, authKey, counter, tagMask];
+      if (!isAligned32(plaintext))
+        toClean.push(plaintext = copyBytes(plaintext));
+      ctr32(xk, false, counter, plaintext, out.subarray(0, plaintext.length));
+      const tag = _computeTag(authKey, tagMask, out.subarray(0, out.length - tagLength));
+      toClean.push(tag);
+      out.set(tag, plaintext.length);
+      clean(...toClean);
+      return out;
+    },
+    decrypt(ciphertext) {
+      const { xk, authKey, counter, tagMask } = deriveKeys();
+      const toClean = [xk, authKey, tagMask, counter];
+      if (!isAligned32(ciphertext))
+        toClean.push(ciphertext = copyBytes(ciphertext));
+      const data = ciphertext.subarray(0, -tagLength);
+      const passedTag = ciphertext.subarray(-tagLength);
+      const tag = _computeTag(authKey, tagMask, data);
+      toClean.push(tag);
+      if (!equalBytes(tag, passedTag))
+        throw new Error("aes/gcm: invalid ghash tag");
+      const out = ctr32(xk, false, counter, data);
+      clean(...toClean);
+      return out;
+    }
+  };
+});
 var browser = {};
 var canPromise$1 = function() {
   return typeof Promise === "function" && Promise.prototype && Promise.prototype.then;
@@ -5195,14 +5774,14 @@ galoisField.log = function log(n2) {
 galoisField.exp = function exp(n2) {
   return EXP_TABLE[n2];
 };
-galoisField.mul = function mul(x2, y2) {
+galoisField.mul = function mul3(x2, y2) {
   if (x2 === 0 || y2 === 0)
     return 0;
   return EXP_TABLE[LOG_TABLE[x2] + LOG_TABLE[y2]];
 };
 (function(exports) {
   const GF = galoisField;
-  exports.mul = function mul2(p1, p2) {
+  exports.mul = function mul4(p1, p2) {
     const coeff = new Uint8Array(p1.length + p2.length - 1);
     for (let i2 = 0; i2 < p1.length; i2++) {
       for (let j2 = 0; j2 < p2.length; j2++) {
@@ -6441,9 +7020,11 @@ export {
   browser,
   d$1 as d,
   e$1 as e,
+  gcm,
   h$1 as h,
   index,
   inputToRGB,
+  managedNonce,
   q,
   rgbToHex,
   rgbToHsv,

package/dist/es/hooks/index.js

@@ -2,5 +2,4 @@ import "../utils/card-brand/brands.js";
 import "../utils/system-info/get-browser-info.js";
 import "../core.js";
 import "../core/context.js";
-import "../api/http.js";
 import "../out/worldpay-jsc-origin.js";

package/dist/es/hooks/useI18n.js

@@ -2,7 +2,6 @@ import { x, h } from "../core.js";
 import { CoreContext } from "../core/context.js";
 import "../utils/card-brand/brands.js";
 import "../utils/system-info/get-browser-info.js";
-import "../api/http.js";
 import { I18n } from "../i18n/I18n.js";
 import "../out/worldpay-jsc-origin.js";
 function useI18n(locale) {

package/dist/es/hooks/usePayState.js

@@ -13,18 +13,25 @@ function usePayState(session, core) {
   const { i18n } = useI18n();
   y(() => {
     session.ready().then(() => {
-      var _a;
+      var _a, _b;
       setSessionReady(true);
       const locale = getRealLocale(
         customLocale || ((_a = session.checkout) == null ? void 0 : _a.locale) || getBrowserInfo().language
       );
       i18n.load(locale);
-      const fraudDetection2 = getFraudDetectionInstance(fraudDetectionEnv, void 0, {
-        onEvent: (type, data) => {
-          var _a2, _b;
-          (_b = core == null ? void 0 : (_a2 = core.config).onEvent) == null ? void 0 : _b.call(_a2, type, data);
+      const fraudDetection2 = getFraudDetectionInstance(
+        {
+          clientKey: session.paykkaDetectionKey,
+          env: fraudDetectionEnv
+        },
+        {
+          sessionMode: (_b = session.checkout) == null ? void 0 : _b.sessionMode,
+          onEvent: (type, data) => {
+            var _a2, _b2;
+            (_b2 = core == null ? void 0 : (_a2 = core.config).onEvent) == null ? void 0 : _b2.call(_a2, type, data);
+          }
         }
-      });
+      );
       setFraudDetection(fraudDetection2);
       fraudDetection2 == null ? void 0 : fraudDetection2.createFraudDetection();
     });

package/dist/es/i18n/locales/de-DE.js

@@ -89,7 +89,12 @@ const deDE = {
   "qrCode.expired": "Der QR-Code ist abgelaufen.",
   "qrCode.scanByGcash": "QR-Code mit GCash scannen",
   "qrCode.scanByZalopay": "QR-Code mit Zalopay scannen",
-  "qrCode.scanByVietqr": "QR-Code mit VietQR scannen"
+  "qrCode.scanByVietqr": "QR-Code mit VietQR scannen",
+  // cpf
+  "cpf.label": "CPF/CNPJ",
+  "cpf.incomplete": "Ihr CPF/CNPJ ist unvollständig",
+  "cpf.placeholder": "123.456.789-00",
+  "iofTip": "Dies ist ein internationaler Kauf, ohne mögliche IOF-Gebühren. Diese Gebühren werden von Ihrem Kartenaussteller erhoben und können von uns weder geschätzt noch erstattet werden. Der endgültige Betrag hängt von Ihrem Kontoauszug ab."
 };
 export {
   deDE as default