jose 3.16.0 → 3.19.0

package/README.md

@@ -23,40 +23,6 @@ implementation is correct.
 
 If you or your business use `jose`, please consider becoming a [sponsor][support-sponsor] so I can continue maintaining it and adding new features carefree.
 
-## Install
-
-```console
-npm install jose
-```
-
-<details>
-<summary><em>Looking for a Browser only distribution?</em> (Click to expand)</summary>
-
-```console
-npm install jose-browser-runtime
-```
-</details>
-
-<details>
-<summary><em>Looking for a Deno distribution?</em> (Click to expand)</summary>
-
-see [deno.land/x/jose][]
-</details>
-
-<details>
-<summary><em>Looking for a Node.js only distribution?</em> (Click to expand)</summary>
-
-ESM module (import):
-```console
-npm install jose-node-esm-runtime
-```
-
-CJS module (require):
-```console
-npm install jose-node-cjs-runtime
-```
-</details>
-
 ## Documentation
 
 - JSON Web Tokens (JWT)
@@ -65,6 +31,11 @@ npm install jose-node-cjs-runtime
   - Encrypted JSON Web Tokens
     - [Encryption](docs/classes/jwt_encrypt.EncryptJWT.md#readme)
     - [Decryption & Claims Set Validation](docs/functions/jwt_decrypt.jwtDecrypt.md#readme)
+- Key Import
+  - [JWK Import](docs/functions/key_import.importJWK.md#readme)
+  - [Public Key Import (SPKI)](docs/functions/key_import.importSPKI.md#readme)
+  - [Public Key Import (X.509 Certificate)](docs/functions/key_import.importX509.md#readme)
+  - [Private Key Import (PKCS #8)](docs/functions/key_import.importPKCS8.md#readme)
 - JSON Web Encryption (JWE)
   - Encryption - [Compact](docs/classes/jwe_compact_encrypt.CompactEncrypt.md#readme), [Flattened](docs/classes/jwe_flattened_encrypt.FlattenedEncrypt.md#readme)
   - Decryption - [Compact](docs/functions/jwe_compact_decrypt.compactDecrypt.md#readme), [Flattened](docs/functions/jwe_flattened_decrypt.flattenedDecrypt.md#readme), [General](docs/functions/jwe_general_decrypt.generalDecrypt.md#readme)
@@ -72,96 +43,29 @@ npm install jose-node-cjs-runtime
   - Signing - [Compact](docs/classes/jws_compact_sign.CompactSign.md#readme), [Flattened](docs/classes/jws_flattened_sign.FlattenedSign.md#readme), [General](docs/classes/jws_general_sign.GeneralSign.md#readme)
   - Verification - [Compact](docs/functions/jws_compact_verify.compactVerify.md#readme), [Flattened](docs/functions/jws_flattened_verify.flattenedVerify.md#readme), [General](docs/functions/jws_general_verify.generalVerify.md#readme)
 - JSON Web Key (JWK)
-  - [Parsing (JWK to KeyLike)](docs/functions/jwk_parse.parseJwk.md#readme)
-  - [Conversion (KeyLike to JWK)](docs/functions/jwk_from_key_like.fromKeyLike.md#readme)
   - [Thumbprints](docs/functions/jwk_thumbprint.calculateThumbprint.md#readme)
   - [EmbeddedJWK](docs/functions/jwk_embedded.EmbeddedJWK.md#readme)
 - JSON Web Key Set (JWKS)
   - [Verify using a remote JWKSet](docs/functions/jwks_remote.createRemoteJWKSet.md#readme)
-- Key Pair or Secret Generation (Generate KeyLike)
+- Key Pair or Secret Generation
   - [Asymmetric Key Pair Generation](docs/functions/util_generate_key_pair.generateKeyPair.md#readme)
   - [Symmetric Secret Generation](docs/functions/util_generate_secret.generateSecret.md#readme)
+- Key Export
+  - [JWK Export](docs/functions/key_export.exportJWK.md#readme)
+  - [Private Key Export](docs/functions/key_export.exportPKCS8.md#readme)
+  - [Public Key Export](docs/functions/key_export.exportSPKI.md#readme)
 - Utilities
   - [Decoding Token's Protected Header](docs/functions/util_decode_protected_header.decodeProtectedHeader.md#readme)
 - [Unsecured JWT](docs/classes/jwt_unsecured.UnsecuredJWT.md#readme)
 - [JOSE Errors](docs/modules/util_errors.md#readme)
 
-## JOSE Support Matrix
-
-| JWK Key Types | Supported | `kty` value | |
-| -- | -- | -- | -- |
-| RSA | ✓ | RSA | |
-| Elliptic Curve | ✓ | EC | supported curves: P-256, secp256k1, P-384, P-521 |
-| Octet Key Pair | ✓ | OKP | supported subtypes: Ed25519, Ed448, X25519, X448 |
-| Octet sequence | ✓ | oct | |
-
-| Serialization | JWS Sign | JWS Verify | JWE Encrypt | JWE Decrypt |
-| -- | -- | -- | -- | -- |
-| Compact | ✓ | ✓ | ✓ | ✓ |
-| General JSON | ✓ | ✓ | ✕ | ✓ |
-| Flattened JSON | ✓ | ✓ | ✓ | ✓ |
-
-| JWT Sign | JWT Verify | JWT Encrypt | JWT Decrypt |
-| -- | -- | -- | -- |
-| ✓ | ✓ | ✓ | ✓ |
-
-| JWS Algorithms | Supported | |
-| -- | -- | -- |
-| RSASSA-PKCS1-v1_5 | ✓ | RS256, RS384, RS512 |
-| RSASSA-PSS | ✓ | PS256, PS384, PS512 |
-| ECDSA | ✓ | ES256, ES256K, ES384, ES512 |
-| Edwards-curve DSA | ✓ | EdDSA |
-| HMAC with SHA-2 | ✓ | HS256, HS384, HS512 |
-| Unsecured JWS | ✓ | none |
-
-| JWE Key Management Algorithms | Supported | |
-| -- | -- | -- |
-| AES | ✓ | A128KW, A192KW, A256KW |
-| AES GCM | ✓ | A128GCMKW, A192GCMKW, A256GCMKW |
-| Direct Key Agreement | ✓ | dir |
-| RSAES OAEP | ✓ | RSA-OAEP, RSA-OAEP-256, RSA-OAEP-384, RSA-OAEP-512 |
-| RSAES-PKCS1-v1_5 | ✓ | RSA1_5 |
-| PBES2 | ✓ | PBES2-HS256+A128KW, PBES2-HS384+A192KW, PBES2-HS512+A256KW |
-| ECDH-ES | ✓ | ECDH-ES, ECDH-ES+A128KW, ECDH-ES+A192KW, ECDH-ES+A256KW |
-
-| JWE Content Encryption Algorithms | Supported | |
-| -- | -- | -- |
-| AES GCM | ✓ | A128GCM, A192GCM, A256GCM |
-| AES CBC w/ HMAC | ✓ |  A128CBC-HS256, A192CBC-HS384, A256CBC-HS512 |
-
-Legend:
-- **✓** Implemented
-- **✕** Not Considered
-
-## Runtime Support Matrix
-
-| Platform | supported versions | caveats |
-| -- | -- | -- |
-| Node.js | LTS ^12.19.0 &vert;&vert; ^14.15.0 | |
-| Electron | ^12.0.0 | see <sup>[1]</sup> |
-| Cloudflare Workers | ✓ | see <sup>[2], [4]</sup> |
-| Deno | experimental | see Deno's [Web Cryptography API roadmap](https://github.com/denoland/deno/issues/11690) |
-| React Native | ✕ | has no available and usable crypto runtime |
-| IE | ✕ | implements old version of the Web Cryptography API specification |
-| Browsers | see [caniuse.com][caniuse] | |
-| --- | | |
-| Edge | 79+ | see <sup>[2], [4]</sup> |
-| Firefox | 57+ | see <sup>[2]</sup> |
-| Chrome | 63+ | see <sup>[2], [4]</sup> |
-| Safari | 11+ | see <sup>[2], [3]</sup> |
-| Opera | 50+ | see <sup>[2], [4]</sup> |
-| iOS Safari | 12+ | see <sup>[2], [3]</sup> |
-
-<sup>1</sup> Due to its use of BoringSSL the following is not supported in Electron
-  - A128KW, A192KW, A256KW, and all composite algorithms utilizing those
-  - secp256k1 EC curve
-  - Ed448, X25519, and X448 OKP Sub Types  
-
-<sup>2</sup> RSA1_5, OKP JWK Key Type, and secp256k1 EC curve is not supported in [Web Cryptography API][webcrypto].   
-
-<sup>3</sup> P-521 EC curve is not supported in Safari  
-
-<sup>4</sup> 192 bit AES keys are not supported in Chromium  
+## Supported Runtimes, Environments, Platforms
+
+- [Browser Support][]
+- [Cloudflare Workers Support][]
+- [Deno Support][]
+- [Electron Support][]
+- [Node.js Support][]
 
 ## FAQ
 
@@ -240,5 +144,9 @@ install size should not be a cause for concern.
 [conditional-exports]: https://nodejs.org/api/packages.html#packages_conditional_exports
 [webcrypto]: https://www.w3.org/TR/WebCryptoAPI/
 [nodewebcrypto]: https://nodejs.org/docs/latest-v15.x/api/webcrypto.html
-[caniuse]: https://caniuse.com/mdn-javascript_operators_await,async-functions,mdn-javascript_statements_for_await_of,cryptography,textencoder
 [deno.land/x/jose]: https://deno.land/x/jose
+[Browser Support]: https://github.com/panva/jose/issues/263
+[Cloudflare Workers Support]: https://github.com/panva/jose/issues/265
+[Deno Support]: https://github.com/panva/jose/issues/266
+[Electron Support]: https://github.com/panva/jose/issues/264
+[Node.js Support]: https://github.com/panva/jose/issues/262

package/dist/browser/jwe/compact/decrypt.js

@@ -19,7 +19,11 @@ async function compactDecrypt(jwe, key, options) {
         tag: (tag || undefined),
         encrypted_key: encryptedKey || undefined,
     }, key, options);
-    return { plaintext: decrypted.plaintext, protectedHeader: decrypted.protectedHeader };
+    const result = { plaintext: decrypted.plaintext, protectedHeader: decrypted.protectedHeader };
+    if (typeof key === 'function') {
+        return { ...result, key: decrypted.key };
+    }
+    return result;
 }
 export { compactDecrypt };
 export default compactDecrypt;

package/dist/browser/jwe/flattened/decrypt.js

@@ -1,13 +1,13 @@
-import { JOSEAlgNotAllowed, JOSENotSupported, JWEInvalid } from '../../util/errors.js';
-import isDisjoint from '../../lib/is_disjoint.js';
-import isObject from '../../lib/is_object.js';
 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';
+import isObject from '../../lib/is_object.js';
 import decryptKeyManagement from '../../lib/decrypt_key_management.js';
 import { encoder, decoder, concat } from '../../lib/buffer_utils.js';
 import cekFactory from '../../lib/cek.js';
-import random from '../../runtime/random.js';
 import validateCrit from '../../lib/validate_crit.js';
 import validateAlgorithms from '../../lib/validate_algorithms.js';
 const generateCek = cekFactory(random);
@@ -70,7 +70,7 @@ async function flattenedDecrypt(jwe, key, options) {
             throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header MUST be integrity protected');
         }
         if (joseHeader.zip !== 'DEF') {
-            throw new JOSENotSupported('unsupported JWE "zip" (Compression Algorithm) Header Parameter value');
+            throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value');
         }
     }
     const { alg, enc } = joseHeader;
@@ -92,8 +92,10 @@ async function flattenedDecrypt(jwe, key, options) {
     if (jwe.encrypted_key !== undefined) {
         encryptedKey = base64url(jwe.encrypted_key);
     }
+    let resolvedKey = false;
     if (typeof key === 'function') {
         key = await key(parsedProt, jwe);
+        resolvedKey = true;
     }
     let cek;
     try {
@@ -132,6 +134,9 @@ async function flattenedDecrypt(jwe, key, options) {
     if (jwe.header !== undefined) {
         result.unprotectedHeader = jwe.header;
     }
+    if (resolvedKey) {
+        return { ...result, key };
+    }
     return result;
 }
 export { flattenedDecrypt };

package/dist/browser/jwe/flattened/encrypt.js

@@ -1,8 +1,8 @@
-import ivFactory from '../../lib/iv.js';
 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';
+import ivFactory 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';
@@ -12,6 +12,9 @@ const generateIv = ivFactory(random);
 const checkExtensions = validateCrit.bind(undefined, JWEInvalid, new Map());
 class FlattenedEncrypt {
     constructor(plaintext) {
+        if (!(plaintext instanceof Uint8Array)) {
+            throw new TypeError('plaintext must be an instance of Uint8Array');
+        }
         this._plaintext = plaintext;
     }
     setKeyManagementParameters(parameters) {
@@ -78,7 +81,7 @@ class FlattenedEncrypt {
                 throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header MUST be integrity protected');
             }
             if (joseHeader.zip !== 'DEF') {
-                throw new JOSENotSupported('unsupported JWE "zip" (Compression Algorithm) Header Parameter value');
+                throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value');
             }
         }
         const { alg, enc } = joseHeader;

package/dist/browser/jwk/embedded.js

@@ -1,4 +1,4 @@
-import parseJwk from './parse.js';
+import { importJWK } from '../key/import.js';
 import isObject from '../lib/is_object.js';
 import { JWSInvalid } from '../util/errors.js';
 async function EmbeddedJWK(protectedHeader, token) {
@@ -9,7 +9,7 @@ async function EmbeddedJWK(protectedHeader, token) {
     if (!isObject(joseHeader.jwk)) {
         throw new JWSInvalid('"jwk" (JSON Web Key) Header Parameter must be a JSON object');
     }
-    const key = await parseJwk(joseHeader.jwk, joseHeader.alg, true);
+    const key = (await importJWK({ ...joseHeader.jwk, ext: true }, joseHeader.alg, true));
     if (key.type !== 'public') {
         throw new JWSInvalid('"jwk" (JSON Web Key) Header Parameter must be a public key');
     }

package/dist/browser/jwk/from_key_like.js

@@ -1,6 +1,6 @@
-import asJWK from '../runtime/key_to_jwk.js';
+import { exportJWK } from '../key/export.js';
 async function fromKeyLike(key) {
-    return asJWK(key);
+    return exportJWK(key);
 }
 export { fromKeyLike };
 export default fromKeyLike;

package/dist/browser/jwk/parse.js

@@ -1,35 +1,6 @@
-import { decode as base64url } from '../runtime/base64url.js';
-import asKeyObject from '../runtime/jwk_to_key.js';
-import { JOSENotSupported } from '../util/errors.js';
-import isObject from '../lib/is_object.js';
+import { importJWK } from '../key/import.js';
 async function parseJwk(jwk, alg, octAsKeyObject) {
-    if (!isObject(jwk)) {
-        throw new TypeError('JWK must be an object');
-    }
-    alg || (alg = jwk.alg);
-    if (typeof alg !== 'string' || !alg) {
-        throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
-    }
-    switch (jwk.kty) {
-        case 'oct':
-            if (typeof jwk.k !== 'string' || !jwk.k) {
-                throw new TypeError('missing "k" (Key Value) Parameter value');
-            }
-            octAsKeyObject !== null && octAsKeyObject !== void 0 ? octAsKeyObject : (octAsKeyObject = jwk.ext !== true);
-            if (octAsKeyObject) {
-                return asKeyObject({ ...jwk, alg, ext: false });
-            }
-            return base64url(jwk.k);
-        case 'RSA':
-            if (jwk.oth !== undefined) {
-                throw new JOSENotSupported('RSA JWK "oth" (Other Primes Info) Parameter value is not supported');
-            }
-        case 'EC':
-        case 'OKP':
-            return asKeyObject({ ...jwk, alg });
-        default:
-            throw new JOSENotSupported('unsupported "kty" (Key Type) Parameter value');
-    }
+    return importJWK(jwk, alg, octAsKeyObject);
 }
 export { parseJwk };
 export default parseJwk;

package/dist/browser/jwk/thumbprint.js

@@ -1,6 +1,6 @@
-import { JOSENotSupported, JWKInvalid } from '../util/errors.js';
 import digest from '../runtime/digest.js';
 import { encode as base64url } from '../runtime/base64url.js';
+import { JOSENotSupported, JWKInvalid } from '../util/errors.js';
 import { encoder } from '../lib/buffer_utils.js';
 import isObject from '../lib/is_object.js';
 const check = (value, description) => {

package/dist/browser/jwks/remote.js

@@ -1,6 +1,6 @@
+import fetchJwks from '../runtime/fetch_jwks.js';
 import parseJWK from '../jwk/parse.js';
 import { JWKSInvalid, JOSENotSupported, JWKSNoMatchingKey, JWKSMultipleMatchingKeys, } from '../util/errors.js';
-import fetchJwks from '../runtime/fetch_jwks.js';
 import isObject from '../lib/is_object.js';
 function getKtyFromAlg(alg) {
     switch (alg.substr(0, 2)) {
@@ -93,7 +93,7 @@ class RemoteJWKSet {
         }
         const cached = this._cached.get(jwk);
         if (cached[protectedHeader.alg] === undefined) {
-            const keyObject = await parseJWK({ ...jwk, alg: protectedHeader.alg });
+            const keyObject = (await parseJWK({ ...jwk, alg: protectedHeader.alg, ext: true }));
             if (keyObject.type !== 'public') {
                 throw new JWKSInvalid('JSON Web Key Set members must be public keys');
             }

package/dist/browser/jws/compact/verify.js

@@ -17,7 +17,11 @@ async function compactVerify(jws, key, options) {
         protected: protectedHeader || undefined,
         signature: (signature || undefined),
     }, key, options);
-    return { payload: verified.payload, protectedHeader: verified.protectedHeader };
+    const result = { payload: verified.payload, protectedHeader: verified.protectedHeader };
+    if (typeof key === 'function') {
+        return { ...result, key: verified.key };
+    }
+    return result;
 }
 export { compactVerify };
 export default compactVerify;

package/dist/browser/jws/flattened/sign.js

@@ -1,13 +1,16 @@
+import { encode as base64url } from '../../runtime/base64url.js';
+import sign from '../../runtime/sign.js';
 import isDisjoint from '../../lib/is_disjoint.js';
 import { JWSInvalid } from '../../util/errors.js';
 import { encoder, decoder, concat } from '../../lib/buffer_utils.js';
-import { encode as base64url } from '../../runtime/base64url.js';
-import sign from '../../runtime/sign.js';
 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]]));
 class FlattenedSign {
     constructor(payload) {
+        if (!(payload instanceof Uint8Array)) {
+            throw new TypeError('payload must be an instance of Uint8Array');
+        }
         this._payload = payload;
     }
     setProtectedHeader(protectedHeader) {

package/dist/browser/jws/flattened/verify.js

@@ -1,10 +1,10 @@
+import { decode as base64url } from '../../runtime/base64url.js';
+import verify from '../../runtime/verify.js';
 import { JOSEAlgNotAllowed, JWSInvalid, JWSSignatureVerificationFailed } from '../../util/errors.js';
 import { concat, encoder, decoder } from '../../lib/buffer_utils.js';
 import isDisjoint from '../../lib/is_disjoint.js';
 import isObject from '../../lib/is_object.js';
 import checkKeyType from '../../lib/check_key_type.js';
-import { decode as base64url } from '../../runtime/base64url.js';
-import verify from '../../runtime/verify.js';
 import validateCrit from '../../lib/validate_crit.js';
 import validateAlgorithms from '../../lib/validate_algorithms.js';
 const checkExtensions = validateCrit.bind(undefined, JWSInvalid, new Map([['b64', true]]));
@@ -70,8 +70,10 @@ async function flattenedVerify(jws, key, options) {
     else if (typeof jws.payload !== 'string' && !(jws.payload instanceof Uint8Array)) {
         throw new JWSInvalid('JWS Payload must be a string or an Uint8Array instance');
     }
+    let resolvedKey = false;
     if (typeof key === 'function') {
         key = await key(parsedProt, jws);
+        resolvedKey = true;
     }
     checkKeyType(alg, key, 'verify');
     const data = concat(encoder.encode((_a = jws.protected) !== null && _a !== void 0 ? _a : ''), encoder.encode('.'), typeof jws.payload === 'string' ? encoder.encode(jws.payload) : jws.payload);
@@ -97,6 +99,9 @@ async function flattenedVerify(jws, key, options) {
     if (jws.header !== undefined) {
         result.unprotectedHeader = jws.header;
     }
+    if (resolvedKey) {
+        return { ...result, key };
+    }
     return result;
 }
 export { flattenedVerify };

package/dist/browser/jwt/decrypt.js

@@ -15,7 +15,11 @@ async function jwtDecrypt(jwt, key, options) {
         JSON.stringify(protectedHeader.aud) !== JSON.stringify(payload.aud)) {
         throw new JWTClaimValidationFailed('replicated "aud" claim header parameter mismatch', 'aud', 'mismatch');
     }
-    return { payload, protectedHeader };
+    const result = { payload, protectedHeader };
+    if (typeof key === 'function') {
+        return { ...result, key: decrypted.key };
+    }
+    return result;
 }
 export { jwtDecrypt };
 export default jwtDecrypt;

package/dist/browser/jwt/unsecured.js

@@ -1,5 +1,5 @@
-import { decoder } from '../lib/buffer_utils.js';
 import * as base64url from '../runtime/base64url.js';
+import { decoder } from '../lib/buffer_utils.js';
 import { JWTInvalid } from '../util/errors.js';
 import jwtPayload from '../lib/jwt_claims_set.js';
 import ProduceJWT from '../lib/jwt_producer.js';

package/dist/browser/jwt/verify.js

@@ -8,7 +8,11 @@ async function jwtVerify(jwt, key, options) {
         throw new JWTInvalid('JWTs MUST NOT use unencoded payload');
     }
     const payload = jwtPayload(verified.protectedHeader, verified.payload, options);
-    return { payload, protectedHeader: verified.protectedHeader };
+    const result = { payload, protectedHeader: verified.protectedHeader };
+    if (typeof key === 'function') {
+        return { ...result, key: verified.key };
+    }
+    return result;
 }
 export { jwtVerify };
 export default jwtVerify;

package/dist/browser/key/export.js

@@ -0,0 +1,12 @@
+import { toSPKI as exportPublic } from '../runtime/asn1.js';
+import { toPKCS8 as exportPrivate } from '../runtime/asn1.js';
+import keyToJWK from '../runtime/key_to_jwk.js';
+export async function exportSPKI(key) {
+    return exportPublic(key);
+}
+export async function exportPKCS8(key) {
+    return exportPrivate(key);
+}
+export async function exportJWK(key) {
+    return keyToJWK(key);
+}

package/dist/browser/key/import.js

@@ -0,0 +1,119 @@
+import { decode as decodeBase64URL, encodeBase64, decodeBase64 } from '../runtime/base64url.js';
+import { fromSPKI as importPublic } from '../runtime/asn1.js';
+import { fromPKCS8 as importPrivate } from '../runtime/asn1.js';
+import asKeyObject from '../runtime/jwk_to_key.js';
+import { JOSENotSupported } from '../util/errors.js';
+import formatPEM from '../lib/format_pem.js';
+import isObject from '../lib/is_object.js';
+function getElement(seq) {
+    let result = [];
+    let next = 0;
+    while (next < seq.length) {
+        let nextPart = parseElement(seq.subarray(next));
+        result.push(nextPart);
+        next += nextPart.byteLength;
+    }
+    return result;
+}
+function parseElement(bytes) {
+    let position = 0;
+    let tag = bytes[0] & 0x1f;
+    position++;
+    if (tag === 0x1f) {
+        tag = 0;
+        while (bytes[position] >= 0x80) {
+            tag = tag * 128 + bytes[position] - 0x80;
+            position++;
+        }
+        tag = tag * 128 + bytes[position] - 0x80;
+        position++;
+    }
+    let length = 0;
+    if (bytes[position] < 0x80) {
+        length = bytes[position];
+        position++;
+    }
+    else {
+        let numberOfDigits = bytes[position] & 0x7f;
+        position++;
+        length = 0;
+        for (let i = 0; i < numberOfDigits; i++) {
+            length = length * 256 + bytes[position];
+            position++;
+        }
+    }
+    if (length === 0x80) {
+        length = 0;
+        while (bytes[position + length] !== 0 || bytes[position + length + 1] !== 0) {
+            length++;
+        }
+        const byteLength = position + length + 2;
+        return {
+            byteLength,
+            contents: bytes.subarray(position, position + length),
+            raw: bytes.subarray(0, byteLength),
+        };
+    }
+    const byteLength = position + length;
+    return {
+        byteLength,
+        contents: bytes.subarray(position, byteLength),
+        raw: bytes.subarray(0, byteLength),
+    };
+}
+function spkiFromX509(buf) {
+    return encodeBase64(getElement(getElement(parseElement(buf).contents)[0].contents)[6].raw);
+}
+function getSPKI(x509) {
+    const pem = x509.replace(/(?:-----(?:BEGIN|END) CERTIFICATE-----|\s)/g, '');
+    const raw = decodeBase64(pem);
+    return formatPEM(spkiFromX509(raw), 'PUBLIC KEY');
+}
+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 importPublic(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');
+    }
+    const spki = getSPKI(x509);
+    return importPublic(spki, 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 PCKS8 formatted string');
+    }
+    return importPrivate(pkcs8, alg, options);
+}
+export async function importJWK(jwk, alg, octAsKeyObject) {
+    if (!isObject(jwk)) {
+        throw new TypeError('JWK must be an object');
+    }
+    alg || (alg = jwk.alg);
+    if (typeof alg !== 'string' || !alg) {
+        throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
+    }
+    switch (jwk.kty) {
+        case 'oct':
+            if (typeof jwk.k !== 'string' || !jwk.k) {
+                throw new TypeError('missing "k" (Key Value) Parameter value');
+            }
+            octAsKeyObject !== null && octAsKeyObject !== void 0 ? octAsKeyObject : (octAsKeyObject = jwk.ext !== true);
+            if (octAsKeyObject) {
+                return asKeyObject({ ...jwk, alg, ext: false });
+            }
+            return decodeBase64URL(jwk.k);
+        case 'RSA':
+            if (jwk.oth !== undefined) {
+                throw new JOSENotSupported('RSA JWK "oth" (Other Primes Info) Parameter value is not supported');
+            }
+        case 'EC':
+        case 'OKP':
+            return asKeyObject({ ...jwk, alg });
+        default:
+            throw new JOSENotSupported('Unsupported "kty" (Key Type) Parameter value');
+    }
+}

package/dist/browser/lib/decrypt_key_management.js

@@ -1,12 +1,12 @@
-import { JOSENotSupported, JWEInvalid } from '../util/errors.js';
 import { unwrap as aesKw } from '../runtime/aeskw.js';
 import * as ECDH from '../runtime/ecdhes.js';
 import { decrypt as pbes2Kw } from '../runtime/pbes2kw.js';
 import { decrypt as rsaEs } from '../runtime/rsaes.js';
 import { unwrap as aesGcmKw } from '../runtime/aesgcmkw.js';
 import { decode as base64url } from '../runtime/base64url.js';
+import { JOSENotSupported, JWEInvalid } from '../util/errors.js';
 import { bitLengths as cekLengths } from '../lib/cek.js';
-import { parseJwk } from '../jwk/parse.js';
+import { importJWK } from '../key/import.js';
 import checkKeyType from './check_key_type.js';
 function assertEnryptedKey(encryptedKey) {
     if (!encryptedKey) {
@@ -38,7 +38,7 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) {
             if (!ECDH.ecdhAllowed(key)) {
                 throw new JOSENotSupported('ECDH-ES with the provided key is not allowed or not supported by your javascript runtime');
             }
-            const epk = await parseJwk(joseHeader.epk, alg);
+            const epk = await importJWK(joseHeader.epk, alg);
             let partyUInfo;
             let partyVInfo;
             if (joseHeader.apu !== undefined)
@@ -88,7 +88,7 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) {
             return aesGcmKw(alg, key, encryptedKey, iv, tag);
         }
         default: {
-            throw new JOSENotSupported('unsupported or invalid "alg" (JWE Algorithm) header value');
+            throw new JOSENotSupported('Invalid or unsupported "alg" (JWE Algorithm) header value');
         }
     }
 }

package/dist/browser/lib/encrypt_key_management.js

@@ -1,5 +1,3 @@
-import cekFactory, { bitLengths as cekLengths } from '../lib/cek.js';
-import { JOSENotSupported } from '../util/errors.js';
 import random from '../runtime/random.js';
 import { wrap as aesKw } from '../runtime/aeskw.js';
 import * as ECDH from '../runtime/ecdhes.js';
@@ -7,6 +5,8 @@ import { encrypt as pbes2Kw } from '../runtime/pbes2kw.js';
 import { encrypt as rsaEs } from '../runtime/rsaes.js';
 import { wrap as aesGcmKw } from '../runtime/aesgcmkw.js';
 import { encode as base64url } from '../runtime/base64url.js';
+import cekFactory, { bitLengths as cekLengths } from '../lib/cek.js';
+import { JOSENotSupported } from '../util/errors.js';
 import { fromKeyLike } from '../jwk/from_key_like.js';
 import checkKeyType from './check_key_type.js';
 const generateCek = cekFactory(random);
@@ -79,7 +79,7 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
             break;
         }
         default: {
-            throw new JOSENotSupported('unsupported or invalid "alg" (JWE Algorithm) header value');
+            throw new JOSENotSupported('Invalid or unsupported "alg" (JWE Algorithm) header value');
         }
     }
     return { cek, encryptedKey, parameters };

package/dist/browser/lib/format_pem.js

@@ -0,0 +1,4 @@
+export default (b64, descriptor) => {
+    const newlined = (b64.match(/.{1,64}/g) || []).join('\n');
+    return `-----BEGIN ${descriptor}-----\n${newlined}\n-----END ${descriptor}-----`;
+};