@suveren/gateway 0.7.6 → 0.8.0

package/node_modules/jose/dist/webapi/jws/general/sign.js

@@ -1,76 +1,65 @@
-import { createSignature } from '../../lib/jws_sign.js';
-import { JWSInvalid } from '../../util/errors.js';
-import { assertNotSet } from '../../lib/helpers.js';
+import { createSignature } from "../../lib/jws_sign.js";
+import { JWSInvalid } from "../../util/errors.js";
+import { assertNotSet } from "../../lib/helpers.js";
 class IndividualSignature {
-    #parent;
-    state;
-    constructor(sig, key, options) {
-        this.#parent = sig;
-        this.state = [undefined, undefined, key, options?.crit];
-    }
-    setProtectedHeader(protectedHeader) {
-        assertNotSet(this.state[0], 'setProtectedHeader');
-        this.state[0] = protectedHeader;
-        return this;
-    }
-    setUnprotectedHeader(unprotectedHeader) {
-        assertNotSet(this.state[1], 'setUnprotectedHeader');
-        this.state[1] = unprotectedHeader;
-        return this;
-    }
-    addSignature(...args) {
-        return this.#parent.addSignature(...args);
-    }
-    sign(...args) {
-        return this.#parent.sign(...args);
-    }
-    done() {
-        return this.#parent;
-    }
+  #parent;
+  state;
+  constructor(sig, key, options) {
+    this.#parent = sig, this.state = [void 0, void 0, key, options?.crit];
+  }
+  setProtectedHeader(protectedHeader) {
+    return assertNotSet(this.state[0], "setProtectedHeader"), this.state[0] = protectedHeader, this;
+  }
+  setUnprotectedHeader(unprotectedHeader) {
+    return assertNotSet(this.state[1], "setUnprotectedHeader"), this.state[1] = unprotectedHeader, this;
+  }
+  addSignature(...args) {
+    return this.#parent.addSignature(...args);
+  }
+  sign(...args) {
+    return this.#parent.sign(...args);
+  }
+  done() {
+    return this.#parent;
+  }
 }
-export class GeneralSign {
-    #payload;
-    #signatures = [];
-    constructor(payload) {
-        this.#payload = payload;
-    }
-    addSignature(key, options) {
-        const signature = new IndividualSignature(this, key, options);
-        this.#signatures.push(signature);
-        return signature;
-    }
-    async sign() {
-        if (!this.#signatures.length) {
-            throw new JWSInvalid('at least one signature must be added');
-        }
-        if (!(this.#payload instanceof Uint8Array)) {
-            throw new TypeError('payload must be an instance of Uint8Array');
-        }
-        const jws = {
-            signatures: [],
-            payload: '',
-        };
-        const encoded = [];
-        let b64;
-        for (let i = 0; i < this.#signatures.length; i++) {
-            const signature = this.#signatures[i];
-            const [protectedHeader, unprotectedHeader, key, crit] = signature.state;
-            const [{ payload, ...rest }, signatureB64] = await createSignature({
-                payload: this.#payload,
-                protectedHeader,
-                unprotectedHeader,
-                crit,
-                encoded,
-            }, key);
-            if (b64 === undefined) {
-                b64 = signatureB64;
-                jws.payload = payload;
-            }
-            else if (b64 !== signatureB64) {
-                throw new JWSInvalid('inconsistent use of JWS Unencoded Payload (RFC7797)');
-            }
-            jws.signatures.push(rest);
-        }
-        return jws;
+class GeneralSign {
+  #payload;
+  #signatures = [];
+  constructor(payload) {
+    this.#payload = payload;
+  }
+  addSignature(key, options) {
+    const signature = new IndividualSignature(this, key, options);
+    return this.#signatures.push(signature), signature;
+  }
+  async sign() {
+    if (!this.#signatures.length)
+      throw new JWSInvalid("at least one signature must be added");
+    if (!(this.#payload instanceof Uint8Array))
+      throw new TypeError("payload must be an instance of Uint8Array");
+    const jws = {
+      signatures: [],
+      payload: ""
+    }, encoded = [];
+    let b64;
+    for (let i = 0; i < this.#signatures.length; i++) {
+      const signature = this.#signatures[i], [protectedHeader, unprotectedHeader, key, crit] = signature.state, [{ payload, ...rest }, signatureB64] = await createSignature({
+        payload: this.#payload,
+        protectedHeader,
+        unprotectedHeader,
+        crit,
+        encoded
+      }, key);
+      if (b64 === void 0)
+        b64 = signatureB64, jws.payload = payload;
+      else if (b64 !== signatureB64)
+        throw new JWSInvalid("inconsistent use of JWS Unencoded Payload (RFC7797)");
+      jws.signatures.push(rest);
     }
+    return jws;
+  }
 }
+export {
+  GeneralSign
+};

package/node_modules/jose/dist/webapi/jws/general/verify.js

@@ -1,74 +1,50 @@
-import { encodeJsonUnencodedPayload, parseProtectedHeader, prepareVerify, snapshotJws, verifySignature, verifyResult, } from '../../lib/jws_verify.js';
-import { JWSInvalid, JWSSignatureVerificationFailed } from '../../util/errors.js';
-import { isObject } from '../../lib/type_checks.js';
+import { encodeJsonUnencodedPayload, parseProtectedHeader, prepareVerify, snapshotJws, verifySignature, verifyResult } from "../../lib/jws_verify.js";
+import { JWSInvalid, JWSSignatureVerificationFailed } from "../../util/errors.js";
+import { isObject } from "../../lib/type_checks.js";
 function snapshotSignature(signature, payload) {
-    try {
-        const jws = snapshotJws(signature, [payload]);
-        const { protected: encodedProtected, header, signature: encodedSignature } = jws;
-        if (encodedProtected === undefined && header === undefined)
-            return undefined;
-        if (encodedProtected !== undefined && typeof encodedProtected !== 'string')
-            return undefined;
-        if (typeof encodedSignature !== 'string')
-            return undefined;
-        if (header !== undefined && !isObject(header))
-            return undefined;
-        const protectedHeader = parseProtectedHeader(encodedProtected);
-        const { b64, crit } = protectedHeader;
-        return [
-            jws,
-            protectedHeader,
-            Array.isArray(crit) && crit.includes('b64')
-                ? typeof b64 === 'boolean'
-                    ? b64
-                        ? 1
-                        : 2
-                    : 0
-                : 1,
-        ];
-    }
-    catch {
-        return undefined;
-    }
+  try {
+    const jws = snapshotJws(signature, [payload]), { protected: encodedProtected, header, signature: encodedSignature } = jws;
+    if (encodedProtected === void 0 && header === void 0 || encodedProtected !== void 0 && typeof encodedProtected != "string" || typeof encodedSignature != "string" || header !== void 0 && !isObject(header))
+      return;
+    const protectedHeader = parseProtectedHeader(encodedProtected), { b64, crit } = protectedHeader;
+    return [
+      jws,
+      protectedHeader,
+      Array.isArray(crit) && crit.includes("b64") ? typeof b64 == "boolean" ? b64 ? 1 : 2 : 0 : 1
+    ];
+  } catch {
+    return;
+  }
 }
-export async function generalVerify(jws, key, options) {
-    if (!isObject(jws)) {
-        throw new JWSInvalid('General JWS must be an object');
-    }
-    const { signatures, payload: inputPayload } = jws;
-    if (!Array.isArray(signatures)) {
-        throw new JWSInvalid('JWS Signatures missing or incorrect type');
-    }
-    const signatureEntries = Array.from(signatures);
-    if (!signatureEntries.every(isObject)) {
-        throw new JWSInvalid('JWS Signatures missing or incorrect type');
-    }
-    let shared;
+async function generalVerify(jws, key, options) {
+  if (!isObject(jws))
+    throw new JWSInvalid("General JWS must be an object");
+  const { signatures, payload: inputPayload } = jws;
+  if (!Array.isArray(signatures))
+    throw new JWSInvalid("JWS Signatures missing or incorrect type");
+  const signatureEntries = Array.from(signatures);
+  if (!signatureEntries.every(isObject))
+    throw new JWSInvalid("JWS Signatures missing or incorrect type");
+  let shared;
+  try {
+    if (inputPayload === void 0)
+      throw new Error();
+    shared = prepareVerify(options);
+  } catch {
+    throw new JWSSignatureVerificationFailed();
+  }
+  const payload = inputPayload instanceof Uint8Array ? new Uint8Array(inputPayload) : inputPayload, candidates = signatureEntries.map((signature) => snapshotSignature(signature, payload)).filter((candidate) => candidate !== void 0);
+  let modes = 0;
+  for (const [, , mode] of candidates)
+    if (modes |= mode, modes === 3)
+      throw new JWSInvalid("inconsistent use of JWS Unencoded Payload (RFC7797)");
+  for (const candidate of candidates)
     try {
-        if (inputPayload === undefined)
-            throw new Error();
-        shared = prepareVerify(options);
-    }
-    catch {
-        throw new JWSSignatureVerificationFailed();
-    }
-    const payload = inputPayload instanceof Uint8Array ? new Uint8Array(inputPayload) : inputPayload;
-    const candidates = signatureEntries
-        .map((signature) => snapshotSignature(signature, payload))
-        .filter((candidate) => candidate !== undefined);
-    let modes = 0;
-    for (const [, , mode] of candidates) {
-        modes |= mode;
-        if (modes === 3) {
-            throw new JWSInvalid('inconsistent use of JWS Unencoded Payload (RFC7797)');
-        }
+      return verifyResult(candidate[0], await verifySignature(candidate[0], shared, key, encodeJsonUnencodedPayload, candidate[1]));
+    } catch {
     }
-    for (const candidate of candidates) {
-        try {
-            return verifyResult(candidate[0], await verifySignature(candidate[0], shared, key, encodeJsonUnencodedPayload, candidate[1]));
-        }
-        catch {
-        }
-    }
-    throw new JWSSignatureVerificationFailed();
+  throw new JWSSignatureVerificationFailed();
 }
+export {
+  generalVerify
+};

package/node_modules/jose/dist/webapi/jwt/decrypt.js

@@ -1,21 +1,14 @@
-import { prepareDecrypt, decryptCompact } from '../lib/jwe_decrypt.js';
-import { validateClaimsSet } from '../lib/jwt_claims_set.js';
-import { JWTClaimValidationFailed } from '../util/errors.js';
-export async function jwtDecrypt(jwt, key, options) {
-    const decrypted = await decryptCompact(jwt, prepareDecrypt(options), key);
-    const protectedHeader = decrypted[1];
-    const payload = validateClaimsSet(protectedHeader, decrypted[0], options);
-    for (const claim of ['iss', 'sub', 'aud']) {
-        if (protectedHeader[claim] !== undefined &&
-            (claim === 'aud'
-                ? JSON.stringify(protectedHeader.aud) !== JSON.stringify(payload.aud)
-                : protectedHeader[claim] !== payload[claim])) {
-            throw new JWTClaimValidationFailed(`replicated "${claim}" claim header parameter mismatch`, payload, claim, 'mismatch');
-        }
-    }
-    const result = { payload, protectedHeader };
-    if (typeof key === 'function') {
-        return { ...result, key: decrypted[2] };
-    }
-    return result;
+import { prepareDecrypt, decryptCompact } from "../lib/jwe_decrypt.js";
+import { validateClaimsSet } from "../lib/jwt_claims_set.js";
+import { JWTClaimValidationFailed } from "../util/errors.js";
+async function jwtDecrypt(jwt, key, options) {
+  const decrypted = await decryptCompact(jwt, prepareDecrypt(options), key), protectedHeader = decrypted[1], payload = validateClaimsSet(protectedHeader, decrypted[0], options);
+  for (const claim of ["iss", "sub", "aud"])
+    if (protectedHeader[claim] !== void 0 && (claim === "aud" ? JSON.stringify(protectedHeader.aud) !== JSON.stringify(payload.aud) : protectedHeader[claim] !== payload[claim]))
+      throw new JWTClaimValidationFailed(`replicated "${claim}" claim header parameter mismatch`, payload, claim, "mismatch");
+  const result = { payload, protectedHeader };
+  return typeof key == "function" ? { ...result, key: decrypted[2] } : result;
 }
+export {
+  jwtDecrypt
+};

package/node_modules/jose/dist/webapi/jwt/encrypt.js

@@ -1,72 +1,59 @@
-import { createJWE } from '../lib/jwe_encrypt.js';
-import { JWTClaimsBuilder, jwtClaim, jwtData } from '../lib/jwt_claims_set.js';
-import { assertNotSet } from '../lib/helpers.js';
+import { createJWE } from "../lib/jwe_encrypt.js";
+import { JWTClaimsBuilder, jwtClaim, jwtData } from "../lib/jwt_claims_set.js";
+import { assertNotSet } from "../lib/helpers.js";
 const EncryptJWT_base = JWTClaimsBuilder;
-export class EncryptJWT extends EncryptJWT_base {
-    #cek;
-    #iv;
-    #keyManagementParameters;
-    #protectedHeader;
-    #replicateIssuerAsHeader;
-    #replicateSubjectAsHeader;
-    #replicateAudienceAsHeader;
-    setProtectedHeader(protectedHeader) {
-        assertNotSet(this.#protectedHeader, 'setProtectedHeader');
-        this.#protectedHeader = protectedHeader;
-        return this;
-    }
-    setKeyManagementParameters(parameters) {
-        assertNotSet(this.#keyManagementParameters, 'setKeyManagementParameters');
-        this.#keyManagementParameters = parameters;
-        return this;
-    }
-    setContentEncryptionKey(cek) {
-        assertNotSet(this.#cek, 'setContentEncryptionKey');
-        this.#cek = cek;
-        return this;
-    }
-    setInitializationVector(iv) {
-        assertNotSet(this.#iv, 'setInitializationVector');
-        this.#iv = iv;
-        return this;
-    }
-    replicateIssuerAsHeader() {
-        this.#replicateIssuerAsHeader = true;
-        return this;
-    }
-    replicateSubjectAsHeader() {
-        this.#replicateSubjectAsHeader = true;
-        return this;
-    }
-    replicateAudienceAsHeader() {
-        this.#replicateAudienceAsHeader = true;
-        return this;
-    }
-    async encrypt(key, options) {
-        const plaintext = jwtData(this);
-        if (this.#protectedHeader &&
-            (this.#replicateIssuerAsHeader ||
-                this.#replicateSubjectAsHeader ||
-                this.#replicateAudienceAsHeader)) {
-            this.#protectedHeader = {
-                ...this.#protectedHeader,
-                iss: this.#replicateIssuerAsHeader ? jwtClaim(this, 'iss') : undefined,
-                sub: this.#replicateSubjectAsHeader ? jwtClaim(this, 'sub') : undefined,
-                aud: this.#replicateAudienceAsHeader ? jwtClaim(this, 'aud') : undefined,
-            };
-        }
-        const jwe = await createJWE([
-            plaintext,
-            this.#protectedHeader,
-            undefined,
-            undefined,
-            undefined,
-            this.#cek,
-            this.#iv,
-            this.#keyManagementParameters,
-            undefined,
-            false,
-        ], key, options);
-        return [jwe.protected, jwe.encrypted_key, jwe.iv, jwe.ciphertext, jwe.tag].join('.');
-    }
+class EncryptJWT extends EncryptJWT_base {
+  #cek;
+  #iv;
+  #keyManagementParameters;
+  #protectedHeader;
+  #replicateIssuerAsHeader;
+  #replicateSubjectAsHeader;
+  #replicateAudienceAsHeader;
+  setProtectedHeader(protectedHeader) {
+    return assertNotSet(this.#protectedHeader, "setProtectedHeader"), this.#protectedHeader = protectedHeader, this;
+  }
+  setKeyManagementParameters(parameters) {
+    return assertNotSet(this.#keyManagementParameters, "setKeyManagementParameters"), this.#keyManagementParameters = parameters, this;
+  }
+  setContentEncryptionKey(cek) {
+    return assertNotSet(this.#cek, "setContentEncryptionKey"), this.#cek = cek, this;
+  }
+  setInitializationVector(iv) {
+    return assertNotSet(this.#iv, "setInitializationVector"), this.#iv = iv, this;
+  }
+  replicateIssuerAsHeader() {
+    return this.#replicateIssuerAsHeader = !0, this;
+  }
+  replicateSubjectAsHeader() {
+    return this.#replicateSubjectAsHeader = !0, this;
+  }
+  replicateAudienceAsHeader() {
+    return this.#replicateAudienceAsHeader = !0, this;
+  }
+  async encrypt(key, options) {
+    const plaintext = jwtData(this);
+    this.#protectedHeader && (this.#replicateIssuerAsHeader || this.#replicateSubjectAsHeader || this.#replicateAudienceAsHeader) && (this.#protectedHeader = {
+      ...this.#protectedHeader,
+      iss: this.#replicateIssuerAsHeader ? jwtClaim(this, "iss") : void 0,
+      sub: this.#replicateSubjectAsHeader ? jwtClaim(this, "sub") : void 0,
+      aud: this.#replicateAudienceAsHeader ? jwtClaim(this, "aud") : void 0
+    });
+    const jwe = await createJWE([
+      plaintext,
+      this.#protectedHeader,
+      void 0,
+      void 0,
+      void 0,
+      this.#cek,
+      this.#iv,
+      this.#keyManagementParameters,
+      void 0,
+      !1
+    ], key, options);
+    return [jwe.protected, jwe.encrypted_key, jwe.iv, jwe.ciphertext, jwe.tag].join(".");
+  }
 }
+export {
+  EncryptJWT
+};

package/node_modules/jose/dist/webapi/jwt/sign.js

@@ -1,18 +1,19 @@
-import { createCompactSignature } from '../lib/jws_sign.js';
-import { JWTInvalid } from '../util/errors.js';
-import { JWTClaimsBuilder, jwtData } from '../lib/jwt_claims_set.js';
-import { assertNotSet } from '../lib/helpers.js';
+import { createCompactSignature } from "../lib/jws_sign.js";
+import { JWTInvalid } from "../util/errors.js";
+import { JWTClaimsBuilder, jwtData } from "../lib/jwt_claims_set.js";
+import { assertNotSet } from "../lib/helpers.js";
 const SignJWT_base = JWTClaimsBuilder;
-export class SignJWT extends SignJWT_base {
-    #protectedHeader;
-    setProtectedHeader(protectedHeader) {
-        assertNotSet(this.#protectedHeader, 'setProtectedHeader');
-        this.#protectedHeader = protectedHeader;
-        return this;
-    }
-    async sign(key, options) {
-        return createCompactSignature(jwtData(this), this.#protectedHeader, options?.crit, key, () => {
-            throw new JWTInvalid('JWTs MUST NOT use unencoded payload');
-        });
-    }
+class SignJWT extends SignJWT_base {
+  #protectedHeader;
+  setProtectedHeader(protectedHeader) {
+    return assertNotSet(this.#protectedHeader, "setProtectedHeader"), this.#protectedHeader = protectedHeader, this;
+  }
+  async sign(key, options) {
+    return createCompactSignature(jwtData(this), this.#protectedHeader, options?.crit, key, () => {
+      throw new JWTInvalid("JWTs MUST NOT use unencoded payload");
+    });
+  }
 }
+export {
+  SignJWT
+};

package/node_modules/jose/dist/webapi/jwt/unsecured.js

@@ -1,43 +1,35 @@
-import * as b64u from '../util/base64url.js';
-import { decodeBase64url, parseJoseHeader } from '../lib/helpers.js';
-import { JWSInvalid, JWTInvalid } from '../util/errors.js';
-import { validateClaimsSet, JWTClaimsBuilder, jwtData } from '../lib/jwt_claims_set.js';
-import { JWS_RECOGNIZED, validateB64, validateCrit } from '../lib/options.js';
+import * as b64u from "../util/base64url.js";
+import { decodeBase64url, parseJoseHeader } from "../lib/helpers.js";
+import { JWSInvalid, JWTInvalid } from "../util/errors.js";
+import { validateClaimsSet, JWTClaimsBuilder, jwtData } from "../lib/jwt_claims_set.js";
+import { JWS_RECOGNIZED, validateB64, validateCrit } from "../lib/options.js";
 const UnsecuredJWT_base = JWTClaimsBuilder;
-export class UnsecuredJWT extends UnsecuredJWT_base {
-    encode() {
-        const header = b64u.encode(JSON.stringify({ alg: 'none' }));
-        const payload = b64u.encode(jwtData(this));
-        return `${header}.${payload}.`;
-    }
-    static decode(jwt, options) {
-        if (typeof jwt !== 'string') {
-            throw new JWTInvalid('Unsecured JWT must be a string');
-        }
-        const { 0: encodedHeader, 1: encodedPayload, 2: signature, length } = jwt.split('.');
-        if (length !== 3 || signature !== '') {
-            throw new JWTInvalid('Invalid Unsecured JWT');
-        }
-        let header;
-        let b64;
-        try {
-            header = parseJoseHeader(encodedHeader, JWSInvalid, 'JWS Protected Header is invalid');
-            const extensions = validateCrit(JWSInvalid, JWS_RECOGNIZED, undefined, header, header);
-            b64 = validateB64(header, extensions);
-        }
-        catch (cause) {
-            if (!(cause instanceof JWSInvalid)) {
-                throw cause;
-            }
-            throw new JWTInvalid('Invalid Unsecured JWT', { cause });
-        }
-        if (header.alg !== 'none') {
-            throw new JWTInvalid('Invalid Unsecured JWT');
-        }
-        if (!b64) {
-            throw new JWTInvalid('JWTs MUST NOT use unencoded payload');
-        }
-        const payload = validateClaimsSet(header, decodeBase64url(encodedPayload, 'payload', JWTInvalid), options);
-        return { payload, header };
+class UnsecuredJWT extends UnsecuredJWT_base {
+  encode() {
+    const header = b64u.encode(JSON.stringify({ alg: "none" })), payload = b64u.encode(jwtData(this));
+    return `${header}.${payload}.`;
+  }
+  static decode(jwt, options) {
+    if (typeof jwt != "string")
+      throw new JWTInvalid("Unsecured JWT must be a string");
+    const { 0: encodedHeader, 1: encodedPayload, 2: signature, length } = jwt.split(".");
+    if (length !== 3 || signature !== "")
+      throw new JWTInvalid("Invalid Unsecured JWT");
+    let header, b64;
+    try {
+      header = parseJoseHeader(encodedHeader, JWSInvalid, "JWS Protected Header is invalid");
+      const extensions = validateCrit(JWSInvalid, JWS_RECOGNIZED, void 0, header, header);
+      b64 = validateB64(header, extensions);
+    } catch (cause) {
+      throw cause instanceof JWSInvalid ? new JWTInvalid("Invalid Unsecured JWT", { cause }) : cause;
     }
+    if (header.alg !== "none")
+      throw new JWTInvalid("Invalid Unsecured JWT");
+    if (!b64)
+      throw new JWTInvalid("JWTs MUST NOT use unencoded payload");
+    return { payload: validateClaimsSet(header, decodeBase64url(encodedPayload, "payload", JWTInvalid), options), header };
+  }
 }
+export {
+  UnsecuredJWT
+};

package/node_modules/jose/dist/webapi/jwt/verify.js

@@ -1,15 +1,13 @@
-import { prepareVerify, verifyCompact } from '../lib/jws_verify.js';
-import { validateClaimsSet } from '../lib/jwt_claims_set.js';
-import { JWTInvalid } from '../util/errors.js';
-export async function jwtVerify(jwt, key, options) {
-    const verified = await verifyCompact(jwt, prepareVerify(options), key);
-    if (!verified[2]) {
-        throw new JWTInvalid('JWTs MUST NOT use unencoded payload');
-    }
-    const payload = validateClaimsSet(verified[1], verified[0], options);
-    const result = { payload, protectedHeader: verified[1] };
-    if (typeof key === 'function') {
-        return { ...result, key: verified[3] };
-    }
-    return result;
+import { prepareVerify, verifyCompact } from "../lib/jws_verify.js";
+import { validateClaimsSet } from "../lib/jwt_claims_set.js";
+import { JWTInvalid } from "../util/errors.js";
+async function jwtVerify(jwt, key, options) {
+  const verified = await verifyCompact(jwt, prepareVerify(options), key);
+  if (!verified[2])
+    throw new JWTInvalid("JWTs MUST NOT use unencoded payload");
+  const result = { payload: validateClaimsSet(verified[1], verified[0], options), protectedHeader: verified[1] };
+  return typeof key == "function" ? { ...result, key: verified[3] } : result;
 }
+export {
+  jwtVerify
+};