fix: remove clutter when tree shaking browser dist

src/jwe/flattened/decrypt.ts

@@ -1,7 +1,6 @@
 import { decode as base64url } from '../../runtime/base64url.js'
 import decrypt from '../../runtime/decrypt.js'
 import { inflate } from '../../runtime/zlib.js'
-import random from '../../runtime/random.js'
 
 import { JOSEAlgNotAllowed, JOSENotSupported, JWEInvalid } from '../../util/errors.js'
 import isDisjoint from '../../lib/is_disjoint.js'
@@ -17,15 +16,10 @@ import type {
   ResolvedKey,
 } from '../../types.d'
 import { encoder, decoder, concat } from '../../lib/buffer_utils.js'
-import cekFactory from '../../lib/cek.js'
+import generateCek from '../../lib/cek.js'
 import validateCrit from '../../lib/validate_crit.js'
 import validateAlgorithms from '../../lib/validate_algorithms.js'
 
-const generateCek = cekFactory(random)
-const checkExtensions = validateCrit.bind(undefined, JWEInvalid, new Map())
-const checkAlgOption = validateAlgorithms.bind(undefined, 'keyManagementAlgorithms')
-const checkEncOption = validateAlgorithms.bind(undefined, 'contentEncryptionAlgorithms')
-
 /**
  * Interface for Flattened JWE Decryption dynamic key resolution.
  * No token components have been verified at the time of this function call.
@@ -159,7 +153,7 @@ async function flattenedDecrypt(
     ...jwe.unprotected,
   }
 
-  checkExtensions(options?.crit, parsedProt, joseHeader)
+  validateCrit(JWEInvalid, new Map(), options?.crit, parsedProt, joseHeader)
 
   if (joseHeader.zip !== undefined) {
     if (!parsedProt || !parsedProt.zip) {
@@ -183,8 +177,11 @@ async function flattenedDecrypt(
     throw new JWEInvalid('missing JWE Encryption Algorithm (enc) in JWE Header')
   }
 
-  const keyManagementAlgorithms = options && checkAlgOption(options.keyManagementAlgorithms)
-  const contentEncryptionAlgorithms = options && checkEncOption(options.contentEncryptionAlgorithms)
+  const keyManagementAlgorithms =
+    options && validateAlgorithms('keyManagementAlgorithms', options.keyManagementAlgorithms)
+  const contentEncryptionAlgorithms =
+    options &&
+    validateAlgorithms('contentEncryptionAlgorithms', options.contentEncryptionAlgorithms)
 
   if (keyManagementAlgorithms && !keyManagementAlgorithms.has(alg)) {
     throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter not allowed')

src/jwe/flattened/encrypt.ts

@@ -1,5 +1,4 @@
 import { encode as base64url } from '../../runtime/base64url.js'
-import random from '../../runtime/random.js'
 import encrypt from '../../runtime/encrypt.js'
 import { deflate } from '../../runtime/zlib.js'
 
@@ -10,16 +9,13 @@ import type {
   JWEKeyManagementHeaderParameters,
   EncryptOptions,
 } from '../../types.d'
-import ivFactory from '../../lib/iv.js'
+import generateIv from '../../lib/iv.js'
 import encryptKeyManagement from '../../lib/encrypt_key_management.js'
 import { JOSENotSupported, JWEInvalid } from '../../util/errors.js'
 import isDisjoint from '../../lib/is_disjoint.js'
 import { encoder, decoder, concat } from '../../lib/buffer_utils.js'
 import validateCrit from '../../lib/validate_crit.js'
 
-const generateIv = ivFactory(random)
-const checkExtensions = validateCrit.bind(undefined, JWEInvalid, new Map())
-
 /**
  * The FlattenedEncrypt class is a utility for creating Flattened JWE
  * objects.
@@ -202,7 +198,7 @@ class FlattenedEncrypt {
       ...this._sharedUnprotectedHeader,
     }
 
-    checkExtensions(options?.crit, this._protectedHeader, joseHeader)
+    validateCrit(JWEInvalid, new Map(), options?.crit, this._protectedHeader, joseHeader)
 
     if (joseHeader.zip !== undefined) {
       if (!this._protectedHeader || !this._protectedHeader.zip) {

src/jws/flattened/sign.ts

@@ -8,8 +8,6 @@ import type { KeyLike, FlattenedJWS, JWSHeaderParameters, SignOptions } from '..
 import checkKeyType from '../../lib/check_key_type.js'
 import validateCrit from '../../lib/validate_crit.js'
 
-const checkExtensions = validateCrit.bind(undefined, JWSInvalid, new Map([['b64', true]]))
-
 /**
  * The FlattenedSign class is a utility for creating Flattened JWS objects.
  *
@@ -105,7 +103,13 @@ class FlattenedSign {
       ...this._unprotectedHeader,
     }
 
-    const extensions = checkExtensions(options?.crit, this._protectedHeader, joseHeader)
+    const extensions = validateCrit(
+      JWSInvalid,
+      new Map([['b64', true]]),
+      options?.crit,
+      this._protectedHeader,
+      joseHeader,
+    )
 
     let b64: boolean = true
     if (extensions.has('b64')) {

src/jws/flattened/verify.ts

@@ -19,9 +19,6 @@ import type {
   ResolvedKey,
 } from '../../types.d'
 
-const checkExtensions = validateCrit.bind(undefined, JWSInvalid, new Map([['b64', true]]))
-const checkAlgOption = validateAlgorithms.bind(undefined, 'algorithms')
-
 /**
  * Interface for Flattened JWS Verification dynamic key resolution.
  * No token components have been verified at the time of this function call.
@@ -133,7 +130,13 @@ async function flattenedVerify(
     ...jws.header,
   }
 
-  const extensions = checkExtensions(options?.crit, parsedProt, joseHeader)
+  const extensions = validateCrit(
+    JWSInvalid,
+    new Map([['b64', true]]),
+    options?.crit,
+    parsedProt,
+    joseHeader,
+  )
 
   let b64: boolean = true
   if (extensions.has('b64')) {
@@ -151,7 +154,7 @@ async function flattenedVerify(
     throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid')
   }
 
-  const algorithms = options && checkAlgOption(options.algorithms)
+  const algorithms = options && validateAlgorithms('algorithms', options.algorithms)
 
   if (algorithms && !algorithms.has(alg)) {
     throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter not allowed')

src/lib/cek.ts

@@ -1,4 +1,5 @@
 import { JOSENotSupported } from '../util/errors.js'
+import random from '../runtime/random.js'
 
 const bitLengths = new Map<string, number>([
   ['A128CBC-HS256', 256],
@@ -9,16 +10,14 @@ const bitLengths = new Map<string, number>([
   ['A256GCM', 256],
 ])
 
-const factory =
-  (random: (array: Uint8Array) => Uint8Array) =>
-  (alg: string): Uint8Array => {
-    const bitLength = bitLengths.get(alg)
-    if (!bitLength) {
-      throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`)
-    }
-
-    return random(new Uint8Array(bitLength >> 3))
+const generateCek = (alg: string): Uint8Array => {
+  const bitLength = bitLengths.get(alg)
+  if (!bitLength) {
+    throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`)
   }
 
-export default factory
+  return random(new Uint8Array(bitLength >> 3))
+}
+
+export default generateCek
 export { bitLengths }

src/lib/encrypt_key_management.ts

@@ -1,4 +1,3 @@
-import random from '../runtime/random.js'
 import { wrap as aesKw } from '../runtime/aeskw.js'
 import * as ECDH from '../runtime/ecdhes.js'
 import { encrypt as pbes2Kw } from '../runtime/pbes2kw.js'
@@ -7,13 +6,11 @@ import { wrap as aesGcmKw } from '../runtime/aesgcmkw.js'
 import { encode as base64url } from '../runtime/base64url.js'
 
 import type { KeyLike, JWEKeyManagementHeaderParameters, JWEHeaderParameters } from '../types.d'
-import cekFactory, { bitLengths as cekLengths } from '../lib/cek.js'
+import generateCek, { bitLengths as cekLengths } from '../lib/cek.js'
 import { JOSENotSupported } from '../util/errors.js'
 import { exportJWK } from '../key/export.js'
 import checkKeyType from './check_key_type.js'
 
-const generateCek = cekFactory(random)
-
 async function encryptKeyManagement(
   alg: string,
   enc: string,

src/lib/iv.ts

@@ -1,4 +1,5 @@
 import { JOSENotSupported } from '../util/errors.js'
+import random from '../runtime/random.js'
 
 const bitLengths = new Map<string, number>([
   ['A128CBC-HS256', 128],
@@ -12,16 +13,14 @@ const bitLengths = new Map<string, number>([
   ['A256GCMKW', 96],
 ])
 
-const factory =
-  (random: (array: Uint8Array) => Uint8Array) =>
-  (alg: string): Uint8Array => {
-    const bitLength = bitLengths.get(alg)
-    if (!bitLength) {
-      throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`)
-    }
-
-    return random(new Uint8Array(bitLength >> 3))
+const generateIv = (alg: string): Uint8Array => {
+  const bitLength = bitLengths.get(alg)
+  if (!bitLength) {
+    throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`)
   }
 
-export default factory
+  return random(new Uint8Array(bitLength >> 3))
+}
+
+export default generateIv
 export { bitLengths }

src/runtime/browser/aesgcmkw.ts

@@ -1,12 +1,9 @@
 import type { AesGcmKwUnwrapFunction, AesGcmKwWrapFunction } from '../interfaces.d'
 import encrypt from './encrypt.js'
 import decrypt from './decrypt.js'
-import ivFactory from '../../lib/iv.js'
-import random from './random.js'
+import generateIv from '../../lib/iv.js'
 import { encode as base64url } from './base64url.js'
 
-const generateIv = ivFactory(random)
-
 export const wrap: AesGcmKwWrapFunction = async (
   alg: string,
   key: unknown,

src/runtime/browser/random.ts

@@ -1,5 +1,3 @@
 import crypto from './webcrypto.js'
 
-const random = crypto.getRandomValues.bind(crypto)
-
-export default random
+export default crypto.getRandomValues.bind(crypto)

src/runtime/node/aesgcmkw.ts

@@ -1,12 +1,9 @@
 import type { AesGcmKwWrapFunction, AesGcmKwUnwrapFunction } from '../interfaces.d'
 import encrypt from './encrypt.js'
 import decrypt from './decrypt.js'
-import ivFactory from '../../lib/iv.js'
-import random from './random.js'
+import generateIv from '../../lib/iv.js'
 import { encode as base64url } from './base64url.js'
 
-const generateIv = ivFactory(random)
-
 export const wrap: AesGcmKwWrapFunction = async (
   alg: string,
   key: unknown,

test/unit/cek.test.mjs

@@ -1,10 +1,10 @@
 import test from 'ava';
 
 const root = !('WEBCRYPTO' in process.env) ? '#dist' : '#dist/webcrypto';
-Promise.all([import(`${root}/lib/cek`), import(`${root}/util/random`)]).then(
-  ([{ default: cek }, { default: random }]) => {
+Promise.all([import(`${root}/lib/cek`)]).then(
+  ([{ default: cek }]) => {
     test('lib/cek.ts', (t) => {
-      t.throws(() => cek(random)('foo'), {
+      t.throws(() => cek('foo'), {
         code: 'ERR_JOSE_NOT_SUPPORTED',
         message: 'Unsupported JWE Algorithm: foo',
       });

test/unit/iv.test.mjs

@@ -1,10 +1,10 @@
 import test from 'ava';
 
 const root = !('WEBCRYPTO' in process.env) ? '#dist' : '#dist/webcrypto';
-Promise.all([import(`${root}/lib/iv`), import(`${root}/util/random`)]).then(
-  ([{ default: iv }, { default: random }]) => {
+Promise.all([import(`${root}/lib/iv`)]).then(
+  ([{ default: iv }]) => {
     test('lib/iv.ts', (t) => {
-      t.throws(() => iv(random)('foo'), {
+      t.throws(() => iv('foo'), {
         code: 'ERR_JOSE_NOT_SUPPORTED',
         message: 'Unsupported JWE Algorithm: foo',
       });