@suveren/gateway 0.7.6 → 0.8.0

package/node_modules/jose/dist/webapi/key/export.js

@@ -1,44 +1,39 @@
-import { toSPKI as exportPublic, toPKCS8 as exportPrivate } from '../lib/asn1.js';
-import { invalidKeyInput } from '../lib/invalid_key_input.js';
-import { encode as b64u } from '../util/base64url.js';
-import { isCryptoKey, isKeyObject } from '../lib/is_key_like.js';
+import { toSPKI as exportPublic, toPKCS8 as exportPrivate } from "../lib/asn1.js";
+import { invalidKeyInput } from "../lib/invalid_key_input.js";
+import { encode as b64u } from "../util/base64url.js";
+import { isCryptoKey, isKeyObject } from "../lib/is_key_like.js";
 function omitUndefinedProperties(jwk) {
-    return Object.fromEntries(Object.entries(jwk).filter(([, value]) => value !== undefined));
+  return Object.fromEntries(Object.entries(jwk).filter(([, value]) => value !== void 0));
 }
 async function keyToJWK(key) {
-    if (isKeyObject(key)) {
-        if (key.type === 'secret') {
-            key = key.export();
-        }
-        else {
-            return key.export({ format: 'jwk' });
-        }
-    }
-    if (key instanceof Uint8Array) {
-        return {
-            kty: 'oct',
-            k: b64u(key),
-        };
-    }
-    if (!isCryptoKey(key)) {
-        throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'KeyObject', 'Uint8Array'));
-    }
-    if (!key.extractable) {
-        throw new TypeError('non-extractable CryptoKey cannot be exported as a JWK');
-    }
-    const { ext, key_ops, alg, use, ...jwk } = omitUndefinedProperties(await crypto.subtle.exportKey('jwk', key));
-    if (jwk.kty === 'AKP') {
-        ;
-        jwk.alg = alg;
-    }
-    return jwk;
+  if (isKeyObject(key))
+    if (key.type === "secret")
+      key = key.export();
+    else
+      return key.export({ format: "jwk" });
+  if (key instanceof Uint8Array)
+    return {
+      kty: "oct",
+      k: b64u(key)
+    };
+  if (!isCryptoKey(key))
+    throw new TypeError(invalidKeyInput(key, "CryptoKey", "KeyObject", "Uint8Array"));
+  if (!key.extractable)
+    throw new TypeError("non-extractable CryptoKey cannot be exported as a JWK");
+  const { ext, key_ops, alg, use, ...jwk } = omitUndefinedProperties(await crypto.subtle.exportKey("jwk", key));
+  return jwk.kty === "AKP" && (jwk.alg = alg), jwk;
 }
-export function exportSPKI(key) {
-    return exportPublic(key);
+function exportSPKI(key) {
+  return exportPublic(key);
 }
-export function exportPKCS8(key) {
-    return exportPrivate(key);
+function exportPKCS8(key) {
+  return exportPrivate(key);
 }
-export function exportJWK(key) {
-    return keyToJWK(key);
+function exportJWK(key) {
+  return keyToJWK(key);
 }
+export {
+  exportJWK,
+  exportPKCS8,
+  exportSPKI
+};

package/node_modules/jose/dist/webapi/key/generate_key_pair.js

@@ -1,52 +1,44 @@
-import { JOSENotSupported } from '../util/errors.js';
-import { validateExtractableOption } from '../lib/key_options.js';
-import { keyAlgorithm, unsupportedAlg, algArgument } from '../lib/key_algorithm.js';
+import { JOSENotSupported } from "../util/errors.js";
+import { validateExtractableOption } from "../lib/key_options.js";
+import { keyAlgorithm, unsupportedAlg, algArgument } from "../lib/key_algorithm.js";
 function getModulusLengthOption(options) {
-    const modulusLength = options?.modulusLength ?? 2048;
-    if (typeof modulusLength !== 'number' ||
-        !Number.isInteger(modulusLength) ||
-        modulusLength < 2048) {
-        throw new JOSENotSupported('Invalid or unsupported modulusLength option provided, 2048 bits or larger keys must be used');
-    }
-    return modulusLength;
+  const modulusLength = options?.modulusLength ?? 2048;
+  if (typeof modulusLength != "number" || !Number.isInteger(modulusLength) || modulusLength < 2048)
+    throw new JOSENotSupported("Invalid or unsupported modulusLength option provided, 2048 bits or larger keys must be used");
+  return modulusLength;
 }
-export async function generateKeyPair(alg, options) {
-    const extractable = validateExtractableOption(options?.extractable);
-    const entry = keyAlgorithm(alg, algArgument);
-    if (entry.secret) {
-        unsupportedAlg(algArgument);
-    }
-    let algorithm;
-    if (entry.resolve) {
-        const crv = options?.crv ?? 'P-256';
-        switch (crv) {
-            case 'P-256':
-            case 'P-384':
-            case 'P-521':
-                algorithm = { name: 'ECDH', namedCurve: crv };
-                break;
-            case 'X25519':
-                algorithm = { name: 'X25519' };
-                break;
-            default:
-                throw new JOSENotSupported('Invalid or unsupported crv option provided, supported values are P-256, P-384, P-521, and X25519');
-        }
-    }
-    else {
-        if (entry.crv !== undefined && options?.crv !== undefined && options.crv !== entry.crv) {
-            throw new JOSENotSupported(`Invalid or unsupported crv option provided, the only supported value for ${alg} is ${entry.crv}`);
-        }
-        algorithm =
-            entry.kty[0] === 'RSA'
-                ? {
-                    ...entry.subtle,
-                    publicExponent: Uint8Array.of(0x01, 0x00, 0x01),
-                    modulusLength: getModulusLengthOption(options),
-                }
-                : entry.subtle;
+async function generateKeyPair(alg, options) {
+  const extractable = validateExtractableOption(options?.extractable), entry = keyAlgorithm(alg, algArgument);
+  entry.secret && unsupportedAlg(algArgument);
+  let algorithm;
+  if (entry.resolve) {
+    const crv = options?.crv ?? "P-256";
+    switch (crv) {
+      case "P-256":
+      case "P-384":
+      case "P-521":
+        algorithm = { name: "ECDH", namedCurve: crv };
+        break;
+      case "X25519":
+        algorithm = { name: "X25519" };
+        break;
+      default:
+        throw new JOSENotSupported("Invalid or unsupported crv option provided, supported values are P-256, P-384, P-521, and X25519");
     }
-    return crypto.subtle.generateKey(algorithm, extractable ?? false, [
-        ...entry.usages[1],
-        ...entry.usages[0],
-    ]);
+  } else {
+    if (entry.crv !== void 0 && options?.crv !== void 0 && options.crv !== entry.crv)
+      throw new JOSENotSupported(`Invalid or unsupported crv option provided, the only supported value for ${alg} is ${entry.crv}`);
+    algorithm = entry.kty[0] === "RSA" ? {
+      ...entry.subtle,
+      publicExponent: Uint8Array.of(1, 0, 1),
+      modulusLength: getModulusLengthOption(options)
+    } : entry.subtle;
+  }
+  return crypto.subtle.generateKey(algorithm, extractable ?? !1, [
+    ...entry.usages[1],
+    ...entry.usages[0]
+  ]);
 }
+export {
+  generateKeyPair
+};

package/node_modules/jose/dist/webapi/key/generate_secret.js

@@ -1,41 +1,36 @@
-import { unsupportedAlg, algArgument } from '../lib/key_algorithm.js';
-import { validateExtractableOption } from '../lib/key_options.js';
-export async function generateSecret(alg, options) {
-    const extractable = validateExtractableOption(options?.extractable);
-    let length;
-    let algorithm;
-    let keyUsages;
-    switch (alg) {
-        case 'HS256':
-        case 'HS384':
-        case 'HS512':
-            length = +alg.slice(-3);
-            algorithm = { name: 'HMAC', hash: `SHA-${length}`, length };
-            keyUsages = ['sign', 'verify'];
-            break;
-        case 'A128CBC-HS256':
-        case 'A192CBC-HS384':
-        case 'A256CBC-HS512':
-            return crypto.getRandomValues(new Uint8Array(+alg.slice(-3) >> 3));
-        case 'A128KW':
-        case 'A192KW':
-        case 'A256KW':
-            length = +alg.slice(1, 4);
-            algorithm = { name: 'AES-KW', length };
-            keyUsages = ['wrapKey', 'unwrapKey'];
-            break;
-        case 'A128GCMKW':
-        case 'A192GCMKW':
-        case 'A256GCMKW':
-        case 'A128GCM':
-        case 'A192GCM':
-        case 'A256GCM':
-            length = +alg.slice(1, 4);
-            algorithm = { name: 'AES-GCM', length };
-            keyUsages = ['encrypt', 'decrypt'];
-            break;
-        default:
-            unsupportedAlg(algArgument);
-    }
-    return crypto.subtle.generateKey(algorithm, extractable ?? false, keyUsages);
+import { unsupportedAlg, algArgument } from "../lib/key_algorithm.js";
+import { validateExtractableOption } from "../lib/key_options.js";
+async function generateSecret(alg, options) {
+  const extractable = validateExtractableOption(options?.extractable);
+  let length, algorithm, keyUsages;
+  switch (alg) {
+    case "HS256":
+    case "HS384":
+    case "HS512":
+      length = +alg.slice(-3), algorithm = { name: "HMAC", hash: `SHA-${length}`, length }, keyUsages = ["sign", "verify"];
+      break;
+    case "A128CBC-HS256":
+    case "A192CBC-HS384":
+    case "A256CBC-HS512":
+      return crypto.getRandomValues(new Uint8Array(+alg.slice(-3) >> 3));
+    case "A128KW":
+    case "A192KW":
+    case "A256KW":
+      length = +alg.slice(1, 4), algorithm = { name: "AES-KW", length }, keyUsages = ["wrapKey", "unwrapKey"];
+      break;
+    case "A128GCMKW":
+    case "A192GCMKW":
+    case "A256GCMKW":
+    case "A128GCM":
+    case "A192GCM":
+    case "A256GCM":
+      length = +alg.slice(1, 4), algorithm = { name: "AES-GCM", length }, keyUsages = ["encrypt", "decrypt"];
+      break;
+    default:
+      unsupportedAlg(algArgument);
+  }
+  return crypto.subtle.generateKey(algorithm, extractable ?? !1, keyUsages);
 }
+export {
+  generateSecret
+};

package/node_modules/jose/dist/webapi/key/import.js

@@ -1,61 +1,57 @@
-import { decode as decodeBase64URL } from '../util/base64url.js';
-import { fromSPKI, fromPKCS8, fromX509 } from '../lib/asn1.js';
-import { jwkToKey } from '../lib/jwk_to_key.js';
-import { keyAlgorithm } from '../lib/key_algorithm.js';
-import { JOSENotSupported } from '../util/errors.js';
-import { isObject } from '../lib/type_checks.js';
-import { validateExtractableOption } from '../lib/key_options.js';
-import { normalizeJwk } from '../lib/jwk_metadata.js';
-export async function importSPKI(spki, alg, options) {
-    if (typeof spki !== 'string' || spki.indexOf('-----BEGIN PUBLIC KEY-----') !== 0) {
-        throw new TypeError('"spki" must be SPKI formatted string');
-    }
-    return fromSPKI(spki, alg, options);
+import { decode as decodeBase64URL } from "../util/base64url.js";
+import { fromSPKI, fromPKCS8, fromX509 } from "../lib/asn1.js";
+import { jwkToKey } from "../lib/jwk_to_key.js";
+import { keyAlgorithm } from "../lib/key_algorithm.js";
+import { JOSENotSupported } from "../util/errors.js";
+import { isObject } from "../lib/type_checks.js";
+import { validateExtractableOption } from "../lib/key_options.js";
+import { normalizeJwk } from "../lib/jwk_metadata.js";
+async function importSPKI(spki, alg, options) {
+  if (typeof spki != "string" || spki.indexOf("-----BEGIN PUBLIC KEY-----") !== 0)
+    throw new TypeError('"spki" must be SPKI formatted string');
+  return fromSPKI(spki, alg, options);
 }
-export async function importX509(x509, alg, options) {
-    if (typeof x509 !== 'string' || x509.indexOf('-----BEGIN CERTIFICATE-----') !== 0) {
-        throw new TypeError('"x509" must be X.509 formatted string');
-    }
-    return fromX509(x509, alg, options);
+async function importX509(x509, alg, options) {
+  if (typeof x509 != "string" || x509.indexOf("-----BEGIN CERTIFICATE-----") !== 0)
+    throw new TypeError('"x509" must be X.509 formatted string');
+  return fromX509(x509, alg, options);
 }
-export async function importPKCS8(pkcs8, alg, options) {
-    if (typeof pkcs8 !== 'string' || pkcs8.indexOf('-----BEGIN PRIVATE KEY-----') !== 0) {
-        throw new TypeError('"pkcs8" must be PKCS#8 formatted string');
-    }
-    return fromPKCS8(pkcs8, alg, options);
+async function importPKCS8(pkcs8, alg, options) {
+  if (typeof pkcs8 != "string" || pkcs8.indexOf("-----BEGIN PRIVATE KEY-----") !== 0)
+    throw new TypeError('"pkcs8" must be PKCS#8 formatted string');
+  return fromPKCS8(pkcs8, alg, options);
 }
-export async function importJWK(jwk, alg, options) {
-    if (!isObject(jwk)) {
-        throw new TypeError('JWK must be an object');
-    }
-    const normalized = normalizeJwk(jwk);
-    const extractable = validateExtractableOption(options?.extractable);
-    const { alg: jwkAlg } = normalized;
-    alg ??= jwkAlg;
-    const ext = extractable ?? normalized.ext;
-    if (normalized.kty !== 'oct' && !alg) {
-        throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
-    }
-    switch (normalized.kty) {
-        case 'oct':
-            if (typeof normalized.k !== 'string') {
-                throw new TypeError('missing "k" (Key Value) Parameter value');
-            }
-            return decodeBase64URL(normalized.k);
-        case 'AKP': {
-            if (typeof jwkAlg !== 'string' || !jwkAlg) {
-                throw new TypeError('missing "alg" (Algorithm) Parameter value');
-            }
-            if (alg !== jwkAlg) {
-                throw new TypeError('JWK alg and alg option value mismatch');
-            }
-            return jwkToKey(keyAlgorithm(alg), { ...normalized, ext });
-        }
-        case 'RSA':
-        case 'EC':
-        case 'OKP':
-            return jwkToKey(keyAlgorithm(alg), { ...normalized, alg, ext });
-        default:
-            throw new JOSENotSupported('Unsupported "kty" (Key Type) Parameter value');
+async function importJWK(jwk, alg, options) {
+  if (!isObject(jwk))
+    throw new TypeError("JWK must be an object");
+  const normalized = normalizeJwk(jwk), extractable = validateExtractableOption(options?.extractable), { alg: jwkAlg } = normalized;
+  alg ??= jwkAlg;
+  const ext = extractable ?? normalized.ext;
+  if (normalized.kty !== "oct" && !alg)
+    throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
+  switch (normalized.kty) {
+    case "oct":
+      if (typeof normalized.k != "string")
+        throw new TypeError('missing "k" (Key Value) Parameter value');
+      return decodeBase64URL(normalized.k);
+    case "AKP": {
+      if (typeof jwkAlg != "string" || !jwkAlg)
+        throw new TypeError('missing "alg" (Algorithm) Parameter value');
+      if (alg !== jwkAlg)
+        throw new TypeError("JWK alg and alg option value mismatch");
+      return jwkToKey(keyAlgorithm(alg), { ...normalized, ext });
     }
+    case "RSA":
+    case "EC":
+    case "OKP":
+      return jwkToKey(keyAlgorithm(alg), { ...normalized, alg, ext });
+    default:
+      throw new JOSENotSupported('Unsupported "kty" (Key Type) Parameter value');
+  }
 }
+export {
+  importJWK,
+  importPKCS8,
+  importSPKI,
+  importX509
+};