@suveren/gateway 0.7.6 → 0.8.0

package/node_modules/jose/dist/webapi/lib/content_encryption.js

@@ -1,134 +1,98 @@
-import { concat, uint64be } from './buffer_utils.js';
-import { checkCryptoKey } from './crypto_key.js';
-import { invalidKeyInput } from './invalid_key_input.js';
-import { JWEDecryptionFailed, JWEInvalid } from '../util/errors.js';
-import { isCryptoKey } from './is_key_like.js';
-export const generateCek = (enc) => crypto.getRandomValues(new Uint8Array(enc.cekBits >> 3));
+import { concat, uint64be } from "./buffer_utils.js";
+import { checkCryptoKey } from "./crypto_key.js";
+import { invalidKeyInput } from "./invalid_key_input.js";
+import { JWEDecryptionFailed, JWEInvalid } from "../util/errors.js";
+import { isCryptoKey } from "./is_key_like.js";
+const generateCek = (enc) => crypto.getRandomValues(new Uint8Array(enc.cekBits >> 3));
 function checkCekLength(cek, expected) {
-    const actual = cek.byteLength << 3;
-    if (actual !== expected) {
-        throw new JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
-    }
+  const actual = cek.byteLength << 3;
+  if (actual !== expected)
+    throw new JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
 }
-export const generateIv = (enc) => crypto.getRandomValues(new Uint8Array(enc.ivBits >> 3));
-export function checkIvLength(enc, iv) {
-    if (iv.length << 3 !== enc.ivBits) {
-        throw new JWEInvalid('Invalid Initialization Vector length');
-    }
+const generateIv = (enc) => crypto.getRandomValues(new Uint8Array(enc.ivBits >> 3));
+function checkIvLength(enc, iv) {
+  if (iv.length << 3 !== enc.ivBits)
+    throw new JWEInvalid("Invalid Initialization Vector length");
 }
 async function cbcKeySetup(enc, cek, usage) {
-    if (!(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
-    }
-    const keySize = enc.cekBits >> 1;
-    const encKey = await crypto.subtle.importKey('raw', cek.subarray(keySize >> 3), 'AES-CBC', false, [usage]);
-    const macKey = await crypto.subtle.importKey('raw', cek.subarray(0, keySize >> 3), {
-        hash: `SHA-${keySize << 1}`,
-        name: 'HMAC',
-    }, false, ['sign']);
-    return [encKey, macKey, keySize];
+  if (!(cek instanceof Uint8Array))
+    throw new TypeError(invalidKeyInput(cek, "Uint8Array"));
+  const keySize = enc.cekBits >> 1, encKey = await crypto.subtle.importKey("raw", cek.subarray(keySize >> 3), "AES-CBC", !1, [usage]), macKey = await crypto.subtle.importKey("raw", cek.subarray(0, keySize >> 3), {
+    hash: `SHA-${keySize << 1}`,
+    name: "HMAC"
+  }, !1, ["sign"]);
+  return [encKey, macKey, keySize];
 }
 async function cbcHmacTag(macKey, macData, keySize) {
-    return new Uint8Array((await crypto.subtle.sign('HMAC', macKey, macData)).slice(0, keySize >> 3));
+  return new Uint8Array((await crypto.subtle.sign("HMAC", macKey, macData)).slice(0, keySize >> 3));
 }
 async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
-    const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, 'encrypt');
-    const ciphertext = new Uint8Array(await crypto.subtle.encrypt({
-        iv: iv,
-        name: 'AES-CBC',
-    }, encKey, plaintext));
-    const macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8));
-    const tag = await cbcHmacTag(macKey, macData, keySize);
-    return { ciphertext, tag, iv };
+  const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, "encrypt"), ciphertext = new Uint8Array(await crypto.subtle.encrypt({
+    iv,
+    name: "AES-CBC"
+  }, encKey, plaintext)), macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8)), tag = await cbcHmacTag(macKey, macData, keySize);
+  return { ciphertext, tag, iv };
 }
 async function timingSafeEqual(a, b) {
-    const algorithm = { name: 'HMAC', hash: 'SHA-256' };
-    const key = (await crypto.subtle.generateKey(algorithm, false, ['sign', 'verify']));
-    const aHmac = await crypto.subtle.sign(algorithm, key, a);
-    return crypto.subtle.verify(algorithm, key, aHmac, b);
+  const algorithm = { name: "HMAC", hash: "SHA-256" }, key = await crypto.subtle.generateKey(algorithm, !1, ["sign", "verify"]), aHmac = await crypto.subtle.sign(algorithm, key, a);
+  return crypto.subtle.verify(algorithm, key, aHmac, b);
 }
 async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
-    const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, 'decrypt');
-    const macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8));
-    const expectedTag = await cbcHmacTag(macKey, macData, keySize);
-    try {
-        if (await timingSafeEqual(tag, expectedTag)) {
-            return new Uint8Array(await crypto.subtle.decrypt({ iv: iv, name: 'AES-CBC' }, encKey, ciphertext));
-        }
-    }
-    catch {
-    }
-    throw new JWEDecryptionFailed();
+  const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, "decrypt"), macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8)), expectedTag = await cbcHmacTag(macKey, macData, keySize);
+  try {
+    if (await timingSafeEqual(tag, expectedTag))
+      return new Uint8Array(await crypto.subtle.decrypt({ iv, name: "AES-CBC" }, encKey, ciphertext));
+  } catch {
+  }
+  throw new JWEDecryptionFailed();
 }
 async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
-    const encKey = cek instanceof Uint8Array
-        ? await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, [
-            'encrypt',
-        ])
-        : (checkCryptoKey(cek, enc.subtle, 'encrypt'), cek);
-    const encrypted = new Uint8Array(await crypto.subtle.encrypt({
-        additionalData: aad,
-        iv: iv,
-        name: 'AES-GCM',
-        tagLength: 128,
-    }, encKey, plaintext));
-    const tag = encrypted.slice(-16);
-    const ciphertext = encrypted.slice(0, -16);
-    return { ciphertext, tag, iv };
+  const encKey = cek instanceof Uint8Array ? await crypto.subtle.importKey("raw", cek, "AES-GCM", !1, [
+    "encrypt"
+  ]) : (checkCryptoKey(cek, enc.subtle, "encrypt"), cek), encrypted = new Uint8Array(await crypto.subtle.encrypt({
+    additionalData: aad,
+    iv,
+    name: "AES-GCM",
+    tagLength: 128
+  }, encKey, plaintext)), tag = encrypted.slice(-16);
+  return { ciphertext: encrypted.slice(0, -16), tag, iv };
 }
 async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
-    const encKey = cek instanceof Uint8Array
-        ? await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, [
-            'decrypt',
-        ])
-        : (checkCryptoKey(cek, enc.subtle, 'decrypt'), cek);
-    try {
-        return new Uint8Array(await crypto.subtle.decrypt({
-            additionalData: aad,
-            iv: iv,
-            name: 'AES-GCM',
-            tagLength: 128,
-        }, encKey, concat(ciphertext, tag)));
-    }
-    catch {
-        throw new JWEDecryptionFailed();
-    }
+  const encKey = cek instanceof Uint8Array ? await crypto.subtle.importKey("raw", cek, "AES-GCM", !1, [
+    "decrypt"
+  ]) : (checkCryptoKey(cek, enc.subtle, "decrypt"), cek);
+  try {
+    return new Uint8Array(await crypto.subtle.decrypt({
+      additionalData: aad,
+      iv,
+      name: "AES-GCM",
+      tagLength: 128
+    }, encKey, concat(ciphertext, tag)));
+  } catch {
+    throw new JWEDecryptionFailed();
+  }
 }
-export async function encrypt(enc, plaintext, cek, iv, aad) {
-    if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'KeyObject', 'Uint8Array', 'JSON Web Key'));
-    }
-    if (iv) {
-        checkIvLength(enc, iv);
-    }
-    else {
-        iv = generateIv(enc);
-    }
-    if (cek instanceof Uint8Array) {
-        checkCekLength(cek, enc.cekBits);
-    }
-    return enc.cbc
-        ? cbcEncrypt(enc, plaintext, cek, iv, aad)
-        : gcmEncrypt(enc, plaintext, cek, iv, aad);
+async function encrypt(enc, plaintext, cek, iv, aad) {
+  if (!isCryptoKey(cek) && !(cek instanceof Uint8Array))
+    throw new TypeError(invalidKeyInput(cek, "CryptoKey", "KeyObject", "Uint8Array", "JSON Web Key"));
+  return iv ? checkIvLength(enc, iv) : iv = generateIv(enc), cek instanceof Uint8Array && checkCekLength(cek, enc.cekBits), enc.cbc ? cbcEncrypt(enc, plaintext, cek, iv, aad) : gcmEncrypt(enc, plaintext, cek, iv, aad);
 }
-export async function decrypt(enc, cek, ciphertext, iv, tag, aad) {
-    if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'KeyObject', 'Uint8Array', 'JSON Web Key'));
-    }
-    if (!iv) {
-        throw new JWEInvalid('JWE Initialization Vector missing');
-    }
-    if (!tag) {
-        throw new JWEInvalid('JWE Authentication Tag missing');
-    }
-    if (!enc.cbc && tag.length !== 16) {
-        throw new JWEInvalid('Invalid Authentication Tag length');
-    }
-    checkIvLength(enc, iv);
-    if (cek instanceof Uint8Array) {
-        checkCekLength(cek, enc.cekBits);
-    }
-    return enc.cbc
-        ? cbcDecrypt(enc, cek, ciphertext, iv, tag, aad)
-        : gcmDecrypt(enc, cek, ciphertext, iv, tag, aad);
+async function decrypt(enc, cek, ciphertext, iv, tag, aad) {
+  if (!isCryptoKey(cek) && !(cek instanceof Uint8Array))
+    throw new TypeError(invalidKeyInput(cek, "CryptoKey", "KeyObject", "Uint8Array", "JSON Web Key"));
+  if (!iv)
+    throw new JWEInvalid("JWE Initialization Vector missing");
+  if (!tag)
+    throw new JWEInvalid("JWE Authentication Tag missing");
+  if (!enc.cbc && tag.length !== 16)
+    throw new JWEInvalid("Invalid Authentication Tag length");
+  return checkIvLength(enc, iv), cek instanceof Uint8Array && checkCekLength(cek, enc.cekBits), enc.cbc ? cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) : gcmDecrypt(enc, cek, ciphertext, iv, tag, aad);
 }
+export {
+  checkCekLength,
+  checkIvLength,
+  decrypt,
+  encrypt,
+  generateCek,
+  generateIv
+};

package/node_modules/jose/dist/webapi/lib/crypto_key.js

@@ -1,28 +1,27 @@
-const unusable = (name, prop = 'algorithm.name') => new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
-export function checkUsage(key, usage) {
-    if (usage && !key.usages.includes(usage)) {
-        throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`);
-    }
+const unusable = (name, prop = "algorithm.name") => new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
+function checkUsage(key, usage) {
+  if (usage && !key.usages.includes(usage))
+    throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`);
 }
-export function checkModulusLength(alg, key) {
-    const { modulusLength } = key.algorithm;
-    if (typeof modulusLength !== 'number' || modulusLength < 2048) {
-        throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
-    }
+function checkModulusLength(alg, key) {
+  const { modulusLength } = key.algorithm;
+  if (typeof modulusLength != "number" || modulusLength < 2048)
+    throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
 }
-export function checkCryptoKey(key, expected, usage) {
-    const algorithm = key.algorithm;
-    if (algorithm.name !== expected.name) {
-        throw unusable(expected.name);
-    }
-    if (expected.hash && algorithm.hash?.name !== expected.hash) {
-        throw unusable(expected.hash, 'algorithm.hash');
-    }
-    if (expected.namedCurve && algorithm.namedCurve !== expected.namedCurve) {
-        throw unusable(expected.namedCurve, 'algorithm.namedCurve');
-    }
-    if (expected.length !== undefined && algorithm.length !== expected.length) {
-        throw unusable(expected.length, 'algorithm.length');
-    }
-    checkUsage(key, usage);
+function checkCryptoKey(key, expected, usage) {
+  const algorithm = key.algorithm;
+  if (algorithm.name !== expected.name)
+    throw unusable(expected.name);
+  if (expected.hash && algorithm.hash?.name !== expected.hash)
+    throw unusable(expected.hash, "algorithm.hash");
+  if (expected.namedCurve && algorithm.namedCurve !== expected.namedCurve)
+    throw unusable(expected.namedCurve, "algorithm.namedCurve");
+  if (expected.length !== void 0 && algorithm.length !== expected.length)
+    throw unusable(expected.length, "algorithm.length");
+  checkUsage(key, usage);
 }
+export {
+  checkCryptoKey,
+  checkModulusLength,
+  checkUsage
+};

package/node_modules/jose/dist/webapi/lib/deflate.js

@@ -1,52 +1,50 @@
-import { JOSENotSupported, JWEInvalid } from '../util/errors.js';
-import { concat } from './buffer_utils.js';
-export function validateZip(joseHeader, protectedHeader) {
-    if (joseHeader.zip !== undefined && joseHeader.zip !== 'DEF') {
-        throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
-    }
-    if (joseHeader.zip !== undefined && !protectedHeader?.zip) {
-        throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
-    }
+import { JOSENotSupported, JWEInvalid } from "../util/errors.js";
+import { concat } from "./buffer_utils.js";
+function validateZip(joseHeader, protectedHeader) {
+  if (joseHeader.zip !== void 0 && joseHeader.zip !== "DEF")
+    throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
+  if (joseHeader.zip !== void 0 && !protectedHeader?.zip)
+    throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
 }
 function supported(name) {
-    if (typeof globalThis[name] === 'undefined') {
-        throw new JOSENotSupported(`JWE "zip" (Compression Algorithm) Header Parameter requires the ${name} API.`);
-    }
+  if (typeof globalThis[name] > "u")
+    throw new JOSENotSupported(`JWE "zip" (Compression Algorithm) Header Parameter requires the ${name} API.`);
 }
-export async function compress(input) {
-    supported('CompressionStream');
-    const cs = new CompressionStream('deflate-raw');
-    const writer = cs.writable.getWriter();
-    writer.write(input).catch(() => { });
-    writer.close().catch(() => { });
-    const chunks = [];
-    const reader = cs.readable.getReader();
-    for (;;) {
-        const { value, done } = await reader.read();
-        if (done)
-            break;
-        chunks.push(value);
-    }
-    return concat(...chunks);
+async function compress(input) {
+  supported("CompressionStream");
+  const cs = new CompressionStream("deflate-raw"), writer = cs.writable.getWriter();
+  writer.write(input).catch(() => {
+  }), writer.close().catch(() => {
+  });
+  const chunks = [], reader = cs.readable.getReader();
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done)
+      break;
+    chunks.push(value);
+  }
+  return concat(...chunks);
 }
-export async function decompress(input, maxLength) {
-    supported('DecompressionStream');
-    const ds = new DecompressionStream('deflate-raw');
-    const writer = ds.writable.getWriter();
-    writer.write(input).catch(() => { });
-    writer.close().catch(() => { });
-    const chunks = [];
-    let length = 0;
-    const reader = ds.readable.getReader();
-    for (;;) {
-        const { value, done } = await reader.read();
-        if (done)
-            break;
-        chunks.push(value);
-        length += value.byteLength;
-        if (maxLength !== Infinity && length > maxLength) {
-            throw new JWEInvalid('Decompressed plaintext exceeded the configured limit');
-        }
-    }
-    return concat(...chunks);
+async function decompress(input, maxLength) {
+  supported("DecompressionStream");
+  const ds = new DecompressionStream("deflate-raw"), writer = ds.writable.getWriter();
+  writer.write(input).catch(() => {
+  }), writer.close().catch(() => {
+  });
+  const chunks = [];
+  let length = 0;
+  const reader = ds.readable.getReader();
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done)
+      break;
+    if (chunks.push(value), length += value.byteLength, maxLength !== 1 / 0 && length > maxLength)
+      throw new JWEInvalid("Decompressed plaintext exceeded the configured limit");
+  }
+  return concat(...chunks);
 }
+export {
+  compress,
+  decompress,
+  validateZip
+};

package/node_modules/jose/dist/webapi/lib/helpers.js

@@ -1,42 +1,45 @@
-import { decode } from '../util/base64url.js';
-import { encode, strictDecoder } from './buffer_utils.js';
-import { isObject } from './type_checks.js';
-export const unprotected = Symbol();
-export function assertNotSet(value, name) {
-    if (value !== undefined) {
-        throw new TypeError(`${name} can only be called once`);
-    }
+import { decode } from "../util/base64url.js";
+import { encode, strictDecoder } from "./buffer_utils.js";
+import { isObject } from "./type_checks.js";
+const unprotected = /* @__PURE__ */ Symbol();
+function assertNotSet(value, name) {
+  if (value !== void 0)
+    throw new TypeError(`${name} can only be called once`);
 }
-export function decodeBase64url(value, label, ErrorClass) {
-    try {
-        return decode(value);
-    }
-    catch {
-        throw new ErrorClass(`Failed to base64url decode the ${label}`);
-    }
+function decodeBase64url(value, label, ErrorClass) {
+  try {
+    return decode(value);
+  } catch {
+    throw new ErrorClass(`Failed to base64url decode the ${label}`);
+  }
 }
-export function encodeBase64url(value, label, ErrorClass) {
-    try {
-        return encode(value);
-    }
-    catch {
-        throw new ErrorClass(`The ${label} is not a valid base64url string`);
-    }
+function encodeBase64url(value, label, ErrorClass) {
+  try {
+    return encode(value);
+  } catch {
+    throw new ErrorClass(`The ${label} is not a valid base64url string`);
+  }
 }
-export async function digest(algorithm, data) {
-    const subtleDigest = `SHA-${algorithm.slice(-3)}`;
-    return new Uint8Array(await crypto.subtle.digest(subtleDigest, data));
+async function digest(algorithm, data) {
+  const subtleDigest = `SHA-${algorithm.slice(-3)}`;
+  return new Uint8Array(await crypto.subtle.digest(subtleDigest, data));
 }
-export function parseJoseHeader(b64, ErrorClass, message) {
-    let parsed;
-    try {
-        parsed = JSON.parse(strictDecoder.decode(decode(b64)));
-    }
-    catch {
-        throw new ErrorClass(message);
-    }
-    if (!isObject(parsed)) {
-        throw new ErrorClass(message);
-    }
-    return parsed;
+function parseJoseHeader(b64, ErrorClass, message) {
+  let parsed;
+  try {
+    parsed = JSON.parse(strictDecoder.decode(decode(b64)));
+  } catch {
+    throw new ErrorClass(message);
+  }
+  if (!isObject(parsed))
+    throw new ErrorClass(message);
+  return parsed;
 }
+export {
+  assertNotSet,
+  decodeBase64url,
+  digest,
+  encodeBase64url,
+  parseJoseHeader,
+  unprotected
+};

package/node_modules/jose/dist/webapi/lib/invalid_key_input.js

@@ -1,26 +1,12 @@
 function message(msg, actual, ...types) {
-    if (types.length > 2) {
-        const last = types.pop();
-        msg += `one of type ${types.join(', ')}, or ${last}.`;
-    }
-    else if (types.length === 2) {
-        msg += `one of type ${types[0]} or ${types[1]}.`;
-    }
-    else {
-        msg += `of type ${types[0]}.`;
-    }
-    if (actual == null) {
-        msg += ` Received ${actual}`;
-    }
-    else if (typeof actual === 'function' && actual.name) {
-        msg += ` Received function ${actual.name}`;
-    }
-    else if (typeof actual === 'object' && actual != null) {
-        if (actual.constructor?.name) {
-            msg += ` Received an instance of ${actual.constructor.name}`;
-        }
-    }
-    return msg;
+  if (types.length > 2) {
+    const last = types.pop();
+    msg += `one of type ${types.join(", ")}, or ${last}.`;
+  } else types.length === 2 ? msg += `one of type ${types[0]} or ${types[1]}.` : msg += `of type ${types[0]}.`;
+  return actual == null ? msg += ` Received ${actual}` : typeof actual == "function" && actual.name ? msg += ` Received function ${actual.name}` : typeof actual == "object" && actual != null && actual.constructor?.name && (msg += ` Received an instance of ${actual.constructor.name}`), msg;
 }
-export const invalidKeyInput = (actual, ...types) => message('Key must be ', actual, ...types);
-export const withAlg = (alg, actual, ...types) => message(`Key for the ${alg} algorithm must be `, actual, ...types);
+const invalidKeyInput = (actual, ...types) => message("Key must be ", actual, ...types), withAlg = (alg, actual, ...types) => message(`Key for the ${alg} algorithm must be `, actual, ...types);
+export {
+  invalidKeyInput,
+  withAlg
+};

package/node_modules/jose/dist/webapi/lib/is_key_like.js

@@ -1,17 +1,19 @@
-export function assertCryptoKey(key) {
-    if (!isCryptoKey(key)) {
-        throw new Error('CryptoKey instance expected');
-    }
+function assertCryptoKey(key) {
+  if (!isCryptoKey(key))
+    throw new Error("CryptoKey instance expected");
 }
-export const isCryptoKey = (key) => {
-    if (key?.[Symbol.toStringTag] === 'CryptoKey')
-        return true;
-    try {
-        return key instanceof CryptoKey;
-    }
-    catch {
-        return false;
-    }
+const isCryptoKey = (key) => {
+  if (key?.[Symbol.toStringTag] === "CryptoKey")
+    return !0;
+  try {
+    return key instanceof CryptoKey;
+  } catch {
+    return !1;
+  }
+}, isKeyObject = (key) => key?.[Symbol.toStringTag] === "KeyObject", isKeyLike = (key) => isCryptoKey(key) || isKeyObject(key);
+export {
+  assertCryptoKey,
+  isCryptoKey,
+  isKeyLike,
+  isKeyObject
 };
-export const isKeyObject = (key) => key?.[Symbol.toStringTag] === 'KeyObject';
-export const isKeyLike = (key) => isCryptoKey(key) || isKeyObject(key);