@psnext/slingcli 3.0.20260827-1 → 3.3.20260911-1

package/node_modules/jose/dist/webapi/jwe/general/decrypt.js

@@ -1,51 +1,40 @@
-import { prepareDecrypt, shareJWE, decryptRecipient, decryptResult, checkRecipient, snapshotSharedJWE, snapshotRecipientJWE, } from '../../lib/jwe_decrypt.js';
-import { JWEDecryptionFailed, JWEInvalid } from '../../util/errors.js';
-import { isObject } from '../../lib/type_checks.js';
-export async function generalDecrypt(jwe, key, options) {
-    if (!isObject(jwe)) {
-        throw new JWEInvalid('General JWE must be an object');
-    }
-    const inputRecipients = jwe.recipients;
-    if (!Array.isArray(inputRecipients)) {
-        throw new JWEInvalid('JWE Recipients missing or incorrect type');
-    }
-    const recipients = Array.from(inputRecipients);
-    if (!recipients.every(isObject)) {
-        throw new JWEInvalid('JWE Recipients missing or incorrect type');
-    }
-    if (!recipients.length) {
-        throw new JWEInvalid('JWE Recipients has no members');
-    }
-    let shared;
-    let sharedJwe;
-    let token;
-    try {
-        shared = prepareDecrypt(options);
-        sharedJwe = snapshotSharedJWE(jwe);
-        token = shareJWE(sharedJwe);
-    }
-    catch {
-        throw new JWEDecryptionFailed();
-    }
-    const recipientSnapshots = recipients.map((recipient) => snapshotRecipientJWE(recipient));
-    if (recipients.length > 1) {
-        for (const [, headerAlg] of recipientSnapshots) {
-            const alg = token[0]?.alg ?? headerAlg ?? sharedJwe.unprotected?.alg;
-            if (alg === 'dir' || alg === 'ECDH-ES') {
-                throw new JWEInvalid(`"${alg}" alg may only have a single recipient`);
-            }
-        }
-    }
-    for (const [recipient] of recipientSnapshots) {
-        if (!recipient)
-            continue;
-        try {
-            const flattened = { ...sharedJwe, ...recipient };
-            checkRecipient(flattened);
-            return decryptResult(flattened, await decryptRecipient(flattened, token, shared, key));
-        }
-        catch {
-        }
-    }
+import { prepareDecrypt, shareJWE, decryptJWE, checkRecipient, snapshotSharedJWE, snapshotRecipientJWE } from "../../lib/jwe_decrypt.js";
+import { JWEDecryptionFailed, JWEInvalid } from "../../util/errors.js";
+import { isObject } from "../../lib/validate.js";
+import { JWE, isJWECEKTransport } from "../../lib/jwe_algorithms.js";
+async function generalDecrypt(jwe, key, options) {
+  if (!isObject(jwe))
+    throw new JWEInvalid("General JWE must be an object");
+  const inputRecipients = jwe.recipients;
+  if (!Array.isArray(inputRecipients))
+    throw new JWEInvalid("JWE Recipients missing or incorrect type");
+  const recipients = Array.from(inputRecipients);
+  if (!recipients.every(isObject))
+    throw new JWEInvalid("JWE Recipients missing or incorrect type");
+  if (!recipients.length)
+    throw new JWEInvalid("JWE Recipients has no members");
+  let shared, sharedJwe, token;
+  try {
+    shared = prepareDecrypt(options), sharedJwe = snapshotSharedJWE(jwe), token = shareJWE(sharedJwe);
+  } catch {
     throw new JWEDecryptionFailed();
+  }
+  const recipientSnapshots = recipients.map((recipient) => snapshotRecipientJWE(recipient));
+  if (recipients.length > 1)
+    for (const [, headerAlg] of recipientSnapshots) {
+      const alg = token[0]?.alg ?? headerAlg ?? sharedJwe.unprotected?.alg, algEntry = typeof alg == "string" ? JWE[alg] : void 0;
+      if (algEntry && !isJWECEKTransport(algEntry))
+        throw new JWEInvalid(`"${alg}" alg may only have a single recipient`);
+    }
+  for (const [recipient] of recipientSnapshots)
+    if (recipient)
+      try {
+        const flattened = { ...sharedJwe, ...recipient };
+        return checkRecipient(flattened), await decryptJWE(flattened, shared, key, token);
+      } catch {
+      }
+  throw new JWEDecryptionFailed();
 }
+export {
+  generalDecrypt
+};

package/node_modules/jose/dist/webapi/jwe/general/encrypt.js

@@ -1,177 +1,105 @@
-import { assertNotSet } from '../../lib/helpers.js';
-import { JWEInvalid } from '../../util/errors.js';
-import { generateCek } from '../../lib/content_encryption.js';
-import { encryptKeyManagement } from '../../lib/key_management.js';
-import { encode as b64u } from '../../util/base64url.js';
-import { checkDisjoint, checkEncryptHeaders, createJWE, encryptJWE } from '../../lib/jwe_encrypt.js';
-import { prepareKey } from '../../lib/key.js';
-import { jweAlgorithm } from '../../lib/jwe_algorithms.js';
-import { assertUint8Array } from '../../lib/type_checks.js';
+import { assertNotSet, assertUint8Array } from "../../lib/validate.js";
+import { JWEInvalid } from "../../util/errors.js";
+import { generateCek } from "../../lib/content_encryption.js";
+import { encode as b64u } from "../../util/base64url.js";
+import { checkDisjoint, checkEncryptHeaders, encryptJWE } from "../../lib/jwe_encrypt.js";
+import { encryptKeyManagement } from "../../lib/key_management.js";
+import { isJWECEKTransport, jweAlgorithm } from "../../lib/jwe_algorithms.js";
 class IndividualRecipient {
-    #parent;
-    state;
-    constructor(enc, key, crit) {
-        this.#parent = enc;
-        this.state = [undefined, undefined, key, crit];
-    }
-    setUnprotectedHeader(unprotectedHeader) {
-        assertNotSet(this.state[0], 'setUnprotectedHeader');
-        this.state[0] = unprotectedHeader;
-        return this;
-    }
-    setKeyManagementParameters(parameters) {
-        assertNotSet(this.state[1], 'setKeyManagementParameters');
-        this.state[1] = parameters;
-        return this;
-    }
-    addRecipient(...args) {
-        return this.#parent.addRecipient(...args);
-    }
-    encrypt(...args) {
-        return this.#parent.encrypt(...args);
-    }
-    done() {
-        return this.#parent;
-    }
+  #parent;
+  state;
+  constructor(enc, key, crit) {
+    this.#parent = enc, this.state = [void 0, void 0, key, crit];
+  }
+  setUnprotectedHeader(unprotectedHeader) {
+    return assertNotSet(this.state[0], "setUnprotectedHeader"), this.state[0] = unprotectedHeader, this;
+  }
+  setKeyManagementParameters(parameters) {
+    return assertNotSet(this.state[1], "setKeyManagementParameters"), this.state[1] = parameters, this;
+  }
+  addRecipient(...args) {
+    return this.#parent.addRecipient(...args);
+  }
+  encrypt(...args) {
+    return this.#parent.encrypt(...args);
+  }
+  done() {
+    return this.#parent;
+  }
 }
-function copyOptionalMembers(flattened, jwe, recipient) {
-    const { aad, protected: protectedHeader, unprotected, header } = flattened;
-    if (aad)
-        jwe.aad = aad;
-    if (protectedHeader)
-        jwe.protected = protectedHeader;
-    if (unprotected)
-        jwe.unprotected = unprotected;
-    if (header)
-        recipient.header = header;
-}
-export class GeneralEncrypt {
-    #plaintext;
-    #recipients = [];
-    #protectedHeader;
-    #unprotectedHeader;
-    #aad;
-    constructor(plaintext) {
-        this.#plaintext = plaintext;
-    }
-    addRecipient(key, options) {
-        const recipient = new IndividualRecipient(this, key, options?.crit);
-        this.#recipients.push(recipient);
-        return recipient;
-    }
-    setProtectedHeader(protectedHeader) {
-        assertNotSet(this.#protectedHeader, 'setProtectedHeader');
-        this.#protectedHeader = protectedHeader;
-        return this;
-    }
-    setSharedUnprotectedHeader(sharedUnprotectedHeader) {
-        assertNotSet(this.#unprotectedHeader, 'setSharedUnprotectedHeader');
-        this.#unprotectedHeader = sharedUnprotectedHeader;
-        return this;
-    }
-    setAdditionalAuthenticatedData(aad) {
-        this.#aad = aad;
-        return this;
+class GeneralEncrypt {
+  #plaintext;
+  #recipients = [];
+  #protectedHeader;
+  #unprotectedHeader;
+  #aad;
+  constructor(plaintext) {
+    this.#plaintext = plaintext;
+  }
+  addRecipient(key, options) {
+    const recipient = new IndividualRecipient(this, key, options?.crit);
+    return this.#recipients.push(recipient), recipient;
+  }
+  setProtectedHeader(protectedHeader) {
+    return assertNotSet(this.#protectedHeader, "setProtectedHeader"), this.#protectedHeader = protectedHeader, this;
+  }
+  setSharedUnprotectedHeader(sharedUnprotectedHeader) {
+    return assertNotSet(this.#unprotectedHeader, "setSharedUnprotectedHeader"), this.#unprotectedHeader = sharedUnprotectedHeader, this;
+  }
+  setAdditionalAuthenticatedData(aad) {
+    return this.#aad = aad, this;
+  }
+  async encrypt() {
+    if (!this.#recipients.length)
+      throw new JWEInvalid("at least one recipient must be added");
+    assertUint8Array(this.#plaintext, "plaintext");
+    const multiple = this.#recipients.length > 1;
+    let enc, protectedHeader = this.#protectedHeader, sharedUnprotectedHeader = this.#unprotectedHeader;
+    const recipients = [];
+    for (const recipient of this.#recipients) {
+      const [unprotectedHeader, keyManagementParameters, key, crit] = recipient.state, input = [
+        this.#plaintext,
+        protectedHeader,
+        unprotectedHeader,
+        sharedUnprotectedHeader,
+        this.#aad,
+        void 0,
+        void 0,
+        keyManagementParameters,
+        crit,
+        multiple
+      ], headers = checkEncryptHeaders(input, void 0, recipients.length > 0);
+      recipients.length || (protectedHeader = input[1], sharedUnprotectedHeader = input[3]), recipients.push([input, headers, key]);
+      const [{ alg, enc: recipientEnc }, , algEntry] = headers;
+      if (multiple && algEntry && !isJWECEKTransport(algEntry))
+        throw new JWEInvalid(`"${alg}" alg may only have a single recipient`);
+      if (!enc)
+        enc = recipientEnc;
+      else if (enc !== recipientEnc)
+        throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter must be the same for all recipients');
     }
-    async encrypt() {
-        if (!this.#recipients.length) {
-            throw new JWEInvalid('at least one recipient must be added');
-        }
-        assertUint8Array(this.#plaintext, 'plaintext');
-        if (this.#recipients.length === 1) {
-            const [unprotectedHeader, keyManagementParameters, key, crit] = this.#recipients[0].state;
-            const flattened = await createJWE([
-                this.#plaintext,
-                this.#protectedHeader,
-                unprotectedHeader,
-                this.#unprotectedHeader,
-                this.#aad,
-                undefined,
-                undefined,
-                keyManagementParameters,
-                crit,
-                false,
-            ], key);
-            const jwe = {
-                ciphertext: flattened.ciphertext,
-                iv: flattened.iv,
-                recipients: [{}],
-                tag: flattened.tag,
-            };
-            if (flattened.encrypted_key)
-                jwe.recipients[0].encrypted_key = flattened.encrypted_key;
-            copyOptionalMembers(flattened, jwe, jwe.recipients[0]);
-            return jwe;
-        }
-        let enc;
-        let protectedHeader = this.#protectedHeader;
-        let sharedUnprotectedHeader = this.#unprotectedHeader;
-        const inputs = [];
-        const checked = [];
-        for (let i = 0; i < this.#recipients.length; i++) {
-            const recipient = this.#recipients[i];
-            const [unprotectedHeader, keyManagementParameters, , crit] = recipient.state;
-            const input = [
-                this.#plaintext,
-                protectedHeader,
-                unprotectedHeader,
-                sharedUnprotectedHeader,
-                this.#aad,
-                undefined,
-                undefined,
-                keyManagementParameters,
-                crit,
-                true,
-            ];
-            const headers = checkEncryptHeaders(input);
-            inputs.push(input);
-            checked.push(headers);
-            if (i === 0) {
-                protectedHeader = input[1];
-                sharedUnprotectedHeader = input[3];
-            }
-            if (headers[1] === 'dir' || headers[1] === 'ECDH-ES') {
-                throw new JWEInvalid(`"${headers[1]}" alg may only have a single recipient`);
-            }
-            if (!enc) {
-                enc = headers[2];
-            }
-            else if (enc !== headers[2]) {
-                throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter must be the same for all recipients');
-            }
-        }
-        const cek = generateCek(checked[0][3]);
-        const jwe = {
-            ciphertext: '',
-            recipients: [],
-        };
-        for (let i = 0; i < this.#recipients.length; i++) {
-            const recipient = this.#recipients[i];
-            const [, keyManagementParameters, key] = recipient.state;
-            const target = {};
-            jwe.recipients.push(target);
-            if (i === 0) {
-                inputs[0][5] = cek;
-                const flattened = await encryptJWE(inputs[0], checked[0], key);
-                jwe.ciphertext = flattened.ciphertext;
-                jwe.iv = flattened.iv;
-                jwe.tag = flattened.tag;
-                target.encrypted_key = flattened.encrypted_key;
-                copyOptionalMembers(flattened, jwe, target);
-                continue;
-            }
-            const [, alg, , encEntry] = checked[i];
-            const unprotectedHeader = inputs[i][2];
-            const k = await prepareKey(jweAlgorithm(alg), key, 'encrypt');
-            const [, encryptedKey, parameters] = await encryptKeyManagement(alg, encEntry, k, cek, keyManagementParameters);
-            target.encrypted_key = b64u(encryptedKey);
-            if (unprotectedHeader || parameters) {
-                const header = { ...unprotectedHeader, ...parameters };
-                if (parameters)
-                    checkDisjoint(inputs[i][1], header, inputs[i][3]);
-                target.header = header;
-            }
-        }
-        return jwe;
+    for (const [, headers] of recipients)
+      headers[2] ??= jweAlgorithm(headers[0].alg);
+    const [firstInput, firstHeaders, firstKey] = recipients[0], cek = multiple ? generateCek(firstHeaders[1]) : void 0;
+    firstInput[5] = cek;
+    const { encrypted_key, header, ...shared } = await encryptJWE(firstInput, firstHeaders, firstKey), jwe = {
+      ...shared,
+      recipients: [{}]
+    };
+    encrypted_key && (jwe.recipients[0].encrypted_key = encrypted_key), header && (jwe.recipients[0].header = header);
+    for (let i = 1; i < recipients.length; i++) {
+      const [input, [joseHeader, encEntry, algEntry], key] = recipients[i], unprotectedHeader = input[2], [, encryptedKey, parameters] = await encryptKeyManagement(algEntry, encEntry, key, joseHeader, cek, input[7]), target = {
+        encrypted_key: b64u(encryptedKey)
+      };
+      if (unprotectedHeader || parameters) {
+        const header2 = { ...unprotectedHeader, ...parameters };
+        parameters && checkDisjoint(input[1], header2, input[3]), target.header = header2;
+      }
+      jwe.recipients.push(target);
     }
+    return jwe;
+  }
 }
+export {
+  GeneralEncrypt
+};

package/node_modules/jose/dist/webapi/jwk/embedded.js

@@ -1,33 +1,30 @@
-import { jwkToKey } from '../lib/jwk_to_key.js';
-import { jwsAlgorithm } from '../lib/jws_algorithms.js';
-import { isObject } from '../lib/type_checks.js';
-import { JWSInvalid } from '../util/errors.js';
-import { normalizeJwk } from '../lib/jwk_metadata.js';
-export async function EmbeddedJWK(protectedHeader, token) {
-    const joseHeader = {
-        ...protectedHeader,
-        ...token?.header,
-    };
-    if (!isObject(joseHeader.jwk)) {
-        throw new JWSInvalid('"jwk" (JSON Web Key) Header Parameter must be a JSON object');
-    }
-    let jwk;
-    try {
-        jwk = normalizeJwk(joseHeader.jwk);
-    }
-    catch (cause) {
-        throw new JWSInvalid('Invalid Embedded JWK', { cause });
-    }
-    const entry = jwsAlgorithm(joseHeader.alg);
-    if (jwk.use !== undefined && jwk.use !== 'sig') {
-        throw new JWSInvalid('Invalid Embedded JWK, its "use" must be "sig" when present');
-    }
-    if (jwk.alg !== undefined && jwk.alg !== entry.alg) {
-        throw new JWSInvalid(`Invalid Embedded JWK, its "alg" must be "${entry.alg}" when present`);
-    }
-    const key = await jwkToKey(entry, { ...jwk, ext: true });
-    if (key.type !== 'public') {
-        throw new JWSInvalid('"jwk" (JSON Web Key) Header Parameter must be a public key');
-    }
-    return key;
+import { jwkToKey, normalizeJwk } from "../lib/key.js";
+import { jwsAlgorithm } from "../lib/jws_algorithms.js";
+import { isObject } from "../lib/validate.js";
+import { JWSInvalid } from "../util/errors.js";
+async function EmbeddedJWK(protectedHeader, token) {
+  const joseHeader = {
+    ...protectedHeader,
+    ...token?.header
+  };
+  if (!isObject(joseHeader.jwk))
+    throw new JWSInvalid('"jwk" (JSON Web Key) Header Parameter must be a JSON object');
+  let jwk;
+  try {
+    jwk = normalizeJwk(joseHeader.jwk);
+  } catch (cause) {
+    throw new JWSInvalid("Invalid Embedded JWK", { cause });
+  }
+  const entry = jwsAlgorithm(joseHeader.alg);
+  if (jwk.use !== void 0 && jwk.use !== "sig")
+    throw new JWSInvalid('Invalid Embedded JWK, its "use" must be "sig" when present');
+  if (jwk.alg !== void 0 && jwk.alg !== entry.alg)
+    throw new JWSInvalid(`Invalid Embedded JWK, its "alg" must be "${entry.alg}" when present`);
+  const key = await jwkToKey(entry, jwk, !0);
+  if (key.type !== "public")
+    throw new JWSInvalid('"jwk" (JSON Web Key) Header Parameter must be a public key');
+  return key;
 }
+export {
+  EmbeddedJWK
+};

package/node_modules/jose/dist/webapi/jwk/thumbprint.js

@@ -1,74 +1,55 @@
-import { digest } from '../lib/helpers.js';
-import { encode as b64u } from '../util/base64url.js';
-import { JOSENotSupported, JWKInvalid } from '../util/errors.js';
-import { encode } from '../lib/buffer_utils.js';
-import { isKeyLike } from '../lib/is_key_like.js';
-import { isObject } from '../lib/type_checks.js';
-import { exportJWK } from '../key/export.js';
-import { invalidKeyInput } from '../lib/invalid_key_input.js';
-import { snapshotJwk } from '../lib/jwk_metadata.js';
+import { digest, encode } from "../lib/buffer_utils.js";
+import { encode as b64u } from "../util/base64url.js";
+import { JOSENotSupported, JWKInvalid } from "../util/errors.js";
+import { isKeyLike, invalidKeyInput, snapshotJwk } from "../lib/key.js";
+import { isObject } from "../lib/validate.js";
+import { exportJWK } from "../key/export.js";
 const check = (value, description) => {
-    if (typeof value !== 'string' || !value) {
-        throw new JWKInvalid(`${description} missing or invalid`);
-    }
+  if (typeof value != "string" || !value)
+    throw new JWKInvalid(`${description} missing or invalid`);
 };
-export async function calculateJwkThumbprint(key, digestAlgorithm) {
-    let jwk;
-    if (isObject(key)) {
-        jwk = snapshotJwk(key);
-        if (typeof jwk.kty !== 'string') {
-            throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'KeyObject', 'JSON Web Key'));
-        }
-    }
-    else if (isKeyLike(key)) {
-        jwk = snapshotJwk(await exportJWK(key));
-    }
-    else {
-        throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'KeyObject', 'JSON Web Key'));
-    }
-    digestAlgorithm ??= 'sha256';
-    if (digestAlgorithm !== 'sha256' &&
-        digestAlgorithm !== 'sha384' &&
-        digestAlgorithm !== 'sha512') {
-        throw new TypeError('digestAlgorithm must one of "sha256", "sha384", or "sha512"');
-    }
-    let components;
-    switch (jwk.kty) {
-        case 'AKP':
-            check(jwk.alg, '"alg" (Algorithm) Parameter');
-            check(jwk.pub, '"pub" (Public key) Parameter');
-            components = { alg: jwk.alg, kty: jwk.kty, pub: jwk.pub };
-            break;
-        case 'EC':
-            check(jwk.crv, '"crv" (Curve) Parameter');
-            check(jwk.x, '"x" (X Coordinate) Parameter');
-            check(jwk.y, '"y" (Y Coordinate) Parameter');
-            components = { crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y };
-            break;
-        case 'OKP':
-            check(jwk.crv, '"crv" (Subtype of Key Pair) Parameter');
-            check(jwk.x, '"x" (Public Key) Parameter');
-            components = { crv: jwk.crv, kty: jwk.kty, x: jwk.x };
-            break;
-        case 'RSA':
-            check(jwk.e, '"e" (Exponent) Parameter');
-            check(jwk.n, '"n" (Modulus) Parameter');
-            components = { e: jwk.e, kty: jwk.kty, n: jwk.n };
-            break;
-        case 'oct':
-            if (typeof jwk.k !== 'string') {
-                throw new JWKInvalid('"k" (Key Value) Parameter missing or invalid');
-            }
-            components = { k: jwk.k, kty: jwk.kty };
-            break;
-        default:
-            throw new JOSENotSupported('"kty" (Key Type) Parameter missing or unsupported');
-    }
-    const data = encode(JSON.stringify(components));
-    return b64u(await digest(digestAlgorithm, data));
+async function calculateJwkThumbprint(key, digestAlgorithm) {
+  let jwk;
+  if (isObject(key)) {
+    if (jwk = snapshotJwk(key), typeof jwk.kty != "string")
+      throw new TypeError(invalidKeyInput(key, "CryptoKey", "KeyObject", "JSON Web Key"));
+  } else if (isKeyLike(key))
+    jwk = snapshotJwk(await exportJWK(key));
+  else
+    throw new TypeError(invalidKeyInput(key, "CryptoKey", "KeyObject", "JSON Web Key"));
+  if (digestAlgorithm ??= "sha256", digestAlgorithm !== "sha256" && digestAlgorithm !== "sha384" && digestAlgorithm !== "sha512")
+    throw new TypeError('digestAlgorithm must one of "sha256", "sha384", or "sha512"');
+  let components;
+  switch (jwk.kty) {
+    case "AKP":
+      check(jwk.alg, '"alg" (Algorithm) Parameter'), check(jwk.pub, '"pub" (Public key) Parameter'), components = { alg: jwk.alg, kty: jwk.kty, pub: jwk.pub };
+      break;
+    case "EC":
+      check(jwk.crv, '"crv" (Curve) Parameter'), check(jwk.x, '"x" (X Coordinate) Parameter'), check(jwk.y, '"y" (Y Coordinate) Parameter'), components = { crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y };
+      break;
+    case "OKP":
+      check(jwk.crv, '"crv" (Subtype of Key Pair) Parameter'), check(jwk.x, '"x" (Public Key) Parameter'), components = { crv: jwk.crv, kty: jwk.kty, x: jwk.x };
+      break;
+    case "RSA":
+      check(jwk.e, '"e" (Exponent) Parameter'), check(jwk.n, '"n" (Modulus) Parameter'), components = { e: jwk.e, kty: jwk.kty, n: jwk.n };
+      break;
+    case "oct":
+      if (typeof jwk.k != "string")
+        throw new JWKInvalid('"k" (Key Value) Parameter missing or invalid');
+      components = { k: jwk.k, kty: jwk.kty };
+      break;
+    default:
+      throw new JOSENotSupported('"kty" (Key Type) Parameter missing or unsupported');
+  }
+  const data = encode(JSON.stringify(components));
+  return b64u(await digest(digestAlgorithm, data));
 }
-export async function calculateJwkThumbprintUri(key, digestAlgorithm) {
-    digestAlgorithm ??= 'sha256';
-    const thumbprint = await calculateJwkThumbprint(key, digestAlgorithm);
-    return `urn:ietf:params:oauth:jwk-thumbprint:sha-${digestAlgorithm.slice(-3)}:${thumbprint}`;
+async function calculateJwkThumbprintUri(key, digestAlgorithm) {
+  digestAlgorithm ??= "sha256";
+  const thumbprint = await calculateJwkThumbprint(key, digestAlgorithm);
+  return `urn:ietf:params:oauth:jwk-thumbprint:sha-${digestAlgorithm.slice(-3)}:${thumbprint}`;
 }
+export {
+  calculateJwkThumbprint,
+  calculateJwkThumbprintUri
+};