jose 4.15.4 → 5.0.0

package/dist/node/esm/jwt/produce.js

@@ -1,8 +1,15 @@
 import epoch from '../lib/epoch.js';
 import isObject from '../lib/is_object.js';
 import secs from '../lib/secs.js';
+function validateInput(label, input) {
+    if (!Number.isFinite(input)) {
+        throw new TypeError(`Invalid ${label} input`);
+    }
+    return input;
+}
 export class ProduceJWT {
-    constructor(payload) {
+    _payload;
+    constructor(payload = {}) {
         if (!isObject(payload)) {
             throw new TypeError('JWT Claims Set MUST be an object');
         }
@@ -26,7 +33,10 @@ export class ProduceJWT {
     }
     setNotBefore(input) {
         if (typeof input === 'number') {
-            this._payload = { ...this._payload, nbf: input };
+            this._payload = { ...this._payload, nbf: validateInput('setNotBefore', input) };
+        }
+        else if (input instanceof Date) {
+            this._payload = { ...this._payload, nbf: validateInput('setNotBefore', epoch(input)) };
         }
         else {
             this._payload = { ...this._payload, nbf: epoch(new Date()) + secs(input) };
@@ -35,7 +45,10 @@ export class ProduceJWT {
     }
     setExpirationTime(input) {
         if (typeof input === 'number') {
-            this._payload = { ...this._payload, exp: input };
+            this._payload = { ...this._payload, exp: validateInput('setExpirationTime', input) };
+        }
+        else if (input instanceof Date) {
+            this._payload = { ...this._payload, exp: validateInput('setExpirationTime', epoch(input)) };
         }
         else {
             this._payload = { ...this._payload, exp: epoch(new Date()) + secs(input) };
@@ -46,8 +59,11 @@ export class ProduceJWT {
         if (typeof input === 'undefined') {
             this._payload = { ...this._payload, iat: epoch(new Date()) };
         }
+        else if (input instanceof Date) {
+            this._payload = { ...this._payload, iat: validateInput('setIssuedAt', epoch(input)) };
+        }
         else {
-            this._payload = { ...this._payload, iat: input };
+            this._payload = { ...this._payload, iat: validateInput('setIssuedAt', input) };
         }
         return this;
     }

package/dist/node/esm/jwt/sign.js

@@ -3,15 +3,15 @@ import { JWTInvalid } from '../util/errors.js';
 import { encoder } from '../lib/buffer_utils.js';
 import { ProduceJWT } from './produce.js';
 export class SignJWT extends ProduceJWT {
+    _protectedHeader;
     setProtectedHeader(protectedHeader) {
         this._protectedHeader = protectedHeader;
         return this;
     }
     async sign(key, options) {
-        var _a;
         const sig = new CompactSign(encoder.encode(JSON.stringify(this._payload)));
         sig.setProtectedHeader(this._protectedHeader);
-        if (Array.isArray((_a = this._protectedHeader) === null || _a === void 0 ? void 0 : _a.crit) &&
+        if (Array.isArray(this._protectedHeader?.crit) &&
             this._protectedHeader.crit.includes('b64') &&
             this._protectedHeader.b64 === false) {
             throw new JWTInvalid('JWTs MUST NOT use unencoded payload');

package/dist/node/esm/jwt/verify.js

@@ -2,9 +2,8 @@ import { compactVerify } from '../jws/compact/verify.js';
 import jwtPayload from '../lib/jwt_claims_set.js';
 import { JWTInvalid } from '../util/errors.js';
 export async function jwtVerify(jwt, key, options) {
-    var _a;
     const verified = await compactVerify(jwt, key, options);
-    if (((_a = verified.protectedHeader.crit) === null || _a === void 0 ? void 0 : _a.includes('b64')) && verified.protectedHeader.b64 === false) {
+    if (verified.protectedHeader.crit?.includes('b64') && verified.protectedHeader.b64 === false) {
         throw new JWTInvalid('JWTs MUST NOT use unencoded payload');
     }
     const payload = jwtPayload(verified.protectedHeader, verified.payload, options);

package/dist/node/esm/key/import.js

@@ -21,21 +21,16 @@ export async function importPKCS8(pkcs8, alg, options) {
     }
     return fromPKCS8(pkcs8, alg, options);
 }
-export async function importJWK(jwk, alg, octAsKeyObject) {
-    var _a;
+export async function importJWK(jwk, alg) {
     if (!isObject(jwk)) {
         throw new TypeError('JWK must be an object');
     }
-    alg || (alg = jwk.alg);
+    alg ||= jwk.alg;
     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: (_a = jwk.ext) !== null && _a !== void 0 ? _a : false });
-            }
             return decodeBase64URL(jwk.k);
         case 'RSA':
             if (jwk.oth !== undefined) {

package/dist/node/esm/lib/aesgcmkw.js

@@ -4,7 +4,7 @@ import generateIv from './iv.js';
 import { encode as base64url } from '../runtime/base64url.js';
 export async function wrap(alg, key, cek, iv) {
     const jweAlgorithm = alg.slice(0, 7);
-    iv || (iv = generateIv(jweAlgorithm));
+    iv ||= generateIv(jweAlgorithm);
     const { ciphertext: encryptedKey, tag } = await encrypt(jweAlgorithm, cek, key, iv, new Uint8Array(0));
     return { encryptedKey, iv: base64url(iv), tag: base64url(tag) };
 }

package/dist/node/esm/lib/decrypt_key_management.js

@@ -73,7 +73,7 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader, options)
                 throw new JWEInvalid('JWE Encrypted Key missing');
             if (typeof joseHeader.p2c !== 'number')
                 throw new JWEInvalid(`JOSE Header "p2c" (PBES2 Count) missing or invalid`);
-            const p2cLimit = (options === null || options === void 0 ? void 0 : options.maxPBES2Count) || 10000;
+            const p2cLimit = options?.maxPBES2Count || 10000;
             if (joseHeader.p2c > p2cLimit)
                 throw new JWEInvalid(`JOSE Header "p2c" (PBES2 Count) out is of acceptable bounds`);
             if (typeof joseHeader.p2s !== 'string')

package/dist/node/esm/lib/encrypt_key_management.js

@@ -27,7 +27,7 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
             }
             const { apu, apv } = providedParameters;
             let { epk: ephemeralKey } = providedParameters;
-            ephemeralKey || (ephemeralKey = (await ECDH.generateEpk(key)).privateKey);
+            ephemeralKey ||= (await ECDH.generateEpk(key)).privateKey;
             const { x, y, crv, kty } = await exportJWK(ephemeralKey);
             const sharedSecret = await ECDH.deriveKey(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, alg === 'ECDH-ES' ? cekLength(enc) : parseInt(alg.slice(-5, -2), 10), apu, apv);
             parameters = { epk: { x, crv, kty } };

package/dist/node/esm/runtime/aeskw.js

@@ -1,5 +1,5 @@
-import { Buffer } from 'buffer';
-import { KeyObject, createDecipheriv, createCipheriv, createSecretKey } from 'crypto';
+import { Buffer } from 'node:buffer';
+import { KeyObject, createDecipheriv, createCipheriv, createSecretKey } from 'node:crypto';
 import { JOSENotSupported } from '../util/errors.js';
 import { concat } from '../lib/buffer_utils.js';
 import { isCryptoKey } from './webcrypto.js';

package/dist/node/esm/runtime/asn1.js

@@ -1,5 +1,5 @@
-import { createPrivateKey, createPublicKey, KeyObject } from 'crypto';
-import { Buffer } from 'buffer';
+import { createPrivateKey, createPublicKey, KeyObject } from 'node:crypto';
+import { Buffer } from 'node:buffer';
 import { isCryptoKey } from './webcrypto.js';
 import isKeyObject from './is_key_object.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';

package/dist/node/esm/runtime/base64url.js

@@ -1,6 +1,5 @@
-import { Buffer } from 'buffer';
+import { Buffer } from 'node:buffer';
 import { decoder } from '../lib/buffer_utils.js';
-let encode;
 function normalize(input) {
     let encoded = input;
     if (encoded instanceof Uint8Array) {
@@ -8,13 +7,8 @@ function normalize(input) {
     }
     return encoded;
 }
-if (Buffer.isEncoding('base64url')) {
-    encode = (input) => Buffer.from(input).toString('base64url');
-}
-else {
-    encode = (input) => Buffer.from(input).toString('base64').replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
-}
-export const decodeBase64 = (input) => Buffer.from(input, 'base64');
+const encode = (input) => Buffer.from(input).toString('base64url');
+export const decodeBase64 = (input) => new Uint8Array(Buffer.from(input, 'base64'));
 export const encodeBase64 = (input) => Buffer.from(input).toString('base64');
 export { encode };
-export const decode = (input) => Buffer.from(normalize(input), 'base64');
+export const decode = (input) => new Uint8Array(Buffer.from(normalize(input), 'base64'));

package/dist/node/esm/runtime/cbc_tag.js

@@ -1,4 +1,4 @@
-import { createHmac } from 'crypto';
+import { createHmac } from 'node:crypto';
 import { concat, uint64be } from '../lib/buffer_utils.js';
 export default function cbcTag(aad, iv, ciphertext, macSize, macKey, keySize) {
     const macData = concat(aad, iv, ciphertext, uint64be(aad.length << 3));

package/dist/node/esm/runtime/check_key_length.js

@@ -0,0 +1,6 @@
+export default (key, alg) => {
+    const { modulusLength } = key.asymmetricKeyDetails;
+    if (typeof modulusLength !== 'number' || modulusLength < 2048) {
+        throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
+    }
+};

package/dist/node/esm/runtime/ciphers.js

@@ -1,6 +1,6 @@
-import { getCiphers } from 'crypto';
+import { getCiphers } from 'node:crypto';
 let ciphers;
 export default (algorithm) => {
-    ciphers || (ciphers = new Set(getCiphers()));
+    ciphers ||= new Set(getCiphers());
     return ciphers.has(algorithm);
 };

package/dist/node/esm/runtime/decrypt.js

@@ -1,4 +1,4 @@
-import { createDecipheriv, KeyObject } from 'crypto';
+import { createDecipheriv, KeyObject } from 'node:crypto';
 import checkIvLength from '../lib/check_iv_length.js';
 import checkCekLength from './check_cek_length.js';
 import { concat } from '../lib/buffer_utils.js';

package/dist/node/esm/runtime/digest.js

@@ -1,3 +1,3 @@
-import { createHash } from 'crypto';
+import { createHash } from 'node:crypto';
 const digest = (algorithm, data) => createHash(algorithm).update(data).digest();
 export default digest;

package/dist/node/esm/runtime/ecdhes.js

@@ -1,5 +1,5 @@
-import { diffieHellman, generateKeyPair as generateKeyPairCb, KeyObject } from 'crypto';
-import { promisify } from 'util';
+import { diffieHellman, generateKeyPair as generateKeyPairCb, KeyObject } from 'node:crypto';
+import { promisify } from 'node:util';
 import getNamedCurve from './get_named_curve.js';
 import { encoder, concat, uint32be, lengthAndInput, concatKdf } from '../lib/buffer_utils.js';
 import { JOSENotSupported } from '../util/errors.js';

package/dist/node/esm/runtime/encrypt.js

@@ -1,4 +1,4 @@
-import { createCipheriv, KeyObject } from 'crypto';
+import { createCipheriv, KeyObject } from 'node:crypto';
 import checkIvLength from '../lib/check_iv_length.js';
 import checkCekLength from './check_cek_length.js';
 import { concat } from '../lib/buffer_utils.js';

package/dist/node/esm/runtime/fetch_jwks.js

@@ -1,6 +1,6 @@
-import * as http from 'http';
-import * as https from 'https';
-import { once } from 'events';
+import * as http from 'node:http';
+import * as https from 'node:https';
+import { once } from 'node:events';
 import { JOSEError, JWKSTimeout } from '../util/errors.js';
 import { concat, decoder } from '../lib/buffer_utils.js';
 const fetchJwks = async (url, timeout, options) => {

package/dist/node/esm/runtime/generate.js

@@ -1,7 +1,6 @@
-import { createSecretKey, generateKeyPair as generateKeyPairCb } from 'crypto';
-import { promisify } from 'util';
+import { createSecretKey, generateKeyPair as generateKeyPairCb } from 'node:crypto';
+import { promisify } from 'node:util';
 import random from './random.js';
-import { setModulusLength } from './check_modulus_length.js';
 import { JOSENotSupported } from '../util/errors.js';
 const generate = promisify(generateKeyPairCb);
 export async function generateSecret(alg, options) {
@@ -32,7 +31,6 @@ export async function generateSecret(alg, options) {
     return createSecretKey(random(new Uint8Array(length >> 3)));
 }
 export async function generateKeyPair(alg, options) {
-    var _a, _b;
     switch (alg) {
         case 'RS256':
         case 'RS384':
@@ -45,7 +43,7 @@ export async function generateKeyPair(alg, options) {
         case 'RSA-OAEP-384':
         case 'RSA-OAEP-512':
         case 'RSA1_5': {
-            const modulusLength = (_a = options === null || options === void 0 ? void 0 : options.modulusLength) !== null && _a !== void 0 ? _a : 2048;
+            const modulusLength = options?.modulusLength ?? 2048;
             if (typeof modulusLength !== 'number' || modulusLength < 2048) {
                 throw new JOSENotSupported('Invalid or unsupported modulusLength option provided, 2048 bits or larger keys must be used');
             }
@@ -53,8 +51,6 @@ export async function generateKeyPair(alg, options) {
                 modulusLength,
                 publicExponent: 0x10001,
             });
-            setModulusLength(keypair.privateKey, modulusLength);
-            setModulusLength(keypair.publicKey, modulusLength);
             return keypair;
         }
         case 'ES256':
@@ -66,7 +62,7 @@ export async function generateKeyPair(alg, options) {
         case 'ES512':
             return generate('ec', { namedCurve: 'P-521' });
         case 'EdDSA': {
-            switch (options === null || options === void 0 ? void 0 : options.crv) {
+            switch (options?.crv) {
                 case undefined:
                 case 'Ed25519':
                     return generate('ed25519');
@@ -80,7 +76,7 @@ export async function generateKeyPair(alg, options) {
         case 'ECDH-ES+A128KW':
         case 'ECDH-ES+A192KW':
         case 'ECDH-ES+A256KW':
-            const crv = (_b = options === null || options === void 0 ? void 0 : options.crv) !== null && _b !== void 0 ? _b : 'P-256';
+            const crv = options?.crv ?? 'P-256';
             switch (crv) {
                 case undefined:
                 case 'P-256':

package/dist/node/esm/runtime/get_named_curve.js

@@ -1,14 +1,9 @@
-import { Buffer } from 'buffer';
-import { createPublicKey, KeyObject } from 'crypto';
+import { KeyObject } from 'node:crypto';
 import { JOSENotSupported } from '../util/errors.js';
 import { isCryptoKey } from './webcrypto.js';
 import isKeyObject from './is_key_object.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
 import { types } from './is_key_like.js';
-const p256 = Buffer.from([42, 134, 72, 206, 61, 3, 1, 7]);
-const p384 = Buffer.from([43, 129, 4, 0, 34]);
-const p521 = Buffer.from([43, 129, 4, 0, 35]);
-const secp256k1 = Buffer.from([43, 129, 4, 0, 10]);
 export const weakMap = new WeakMap();
 const namedCurveToJOSE = (namedCurve) => {
     switch (namedCurve) {
@@ -25,7 +20,6 @@ const namedCurveToJOSE = (namedCurve) => {
     }
 };
 const getNamedCurve = (kee, raw) => {
-    var _a;
     let key;
     if (isCryptoKey(kee)) {
         key = KeyObject.from(kee);
@@ -47,45 +41,14 @@ const getNamedCurve = (kee, raw) => {
         case 'x448':
             return `X${key.asymmetricKeyType.slice(1)}`;
         case 'ec': {
-            if (weakMap.has(key)) {
-                return weakMap.get(key);
-            }
-            let namedCurve = (_a = key.asymmetricKeyDetails) === null || _a === void 0 ? void 0 : _a.namedCurve;
-            if (!namedCurve && key.type === 'private') {
-                namedCurve = getNamedCurve(createPublicKey(key), true);
-            }
-            else if (!namedCurve) {
-                const buf = key.export({ format: 'der', type: 'spki' });
-                const i = buf[1] < 128 ? 14 : 15;
-                const len = buf[i];
-                const curveOid = buf.slice(i + 1, i + 1 + len);
-                if (curveOid.equals(p256)) {
-                    namedCurve = 'prime256v1';
-                }
-                else if (curveOid.equals(p384)) {
-                    namedCurve = 'secp384r1';
-                }
-                else if (curveOid.equals(p521)) {
-                    namedCurve = 'secp521r1';
-                }
-                else if (curveOid.equals(secp256k1)) {
-                    namedCurve = 'secp256k1';
-                }
-                else {
-                    throw new JOSENotSupported('Unsupported key curve for this operation');
-                }
-            }
-            if (raw)
+            let namedCurve = key.asymmetricKeyDetails.namedCurve;
+            if (raw) {
                 return namedCurve;
-            const curve = namedCurveToJOSE(namedCurve);
-            weakMap.set(key, curve);
-            return curve;
+            }
+            return namedCurveToJOSE(namedCurve);
         }
         default:
             throw new TypeError('Invalid asymmetric key type for this operation');
     }
 };
-export function setCurve(keyObject, curve) {
-    weakMap.set(keyObject, curve);
-}
 export default getNamedCurve;

package/dist/node/esm/runtime/get_sign_verify_key.js

@@ -1,4 +1,4 @@
-import { KeyObject, createSecretKey } from 'crypto';
+import { KeyObject, createSecretKey } from 'node:crypto';
 import { isCryptoKey } from './webcrypto.js';
 import { checkSigCryptoKey } from '../lib/crypto_key.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';

package/dist/node/esm/runtime/is_key_like.js

@@ -2,7 +2,7 @@ import webcrypto, { isCryptoKey } from './webcrypto.js';
 import isKeyObject from './is_key_object.js';
 export default (key) => isKeyObject(key) || isCryptoKey(key);
 const types = ['KeyObject'];
-if (globalThis.CryptoKey || (webcrypto === null || webcrypto === void 0 ? void 0 : webcrypto.CryptoKey)) {
+if (globalThis.CryptoKey || webcrypto?.CryptoKey) {
     types.push('CryptoKey');
 }
 export { types };

package/dist/node/esm/runtime/is_key_object.js

@@ -1,5 +1,2 @@
-import { KeyObject } from 'crypto';
-import * as util from 'util';
-export default util.types.isKeyObject
-    ? (obj) => util.types.isKeyObject(obj)
-    : (obj) => obj != null && obj instanceof KeyObject;
+import * as util from 'node:util';
+export default (obj) => util.types.isKeyObject(obj);

package/dist/node/esm/runtime/jwk_to_key.js

@@ -1,116 +1,5 @@
-import { Buffer } from 'buffer';
-import { createPrivateKey, createPublicKey, createSecretKey } from 'crypto';
-import { decode as base64url } from './base64url.js';
-import { JOSENotSupported } from '../util/errors.js';
-import { setCurve } from './get_named_curve.js';
-import { setModulusLength } from './check_modulus_length.js';
-import Asn1SequenceEncoder from './asn1_sequence_encoder.js';
-import { jwkImport } from './flags.js';
+import { createPrivateKey, createPublicKey } from 'node:crypto';
 const parse = (jwk) => {
-    if (jwkImport && jwk.kty !== 'oct') {
-        return jwk.d
-            ? createPrivateKey({ format: 'jwk', key: jwk })
-            : createPublicKey({ format: 'jwk', key: jwk });
-    }
-    switch (jwk.kty) {
-        case 'oct': {
-            return createSecretKey(base64url(jwk.k));
-        }
-        case 'RSA': {
-            const enc = new Asn1SequenceEncoder();
-            const isPrivate = jwk.d !== undefined;
-            const modulus = Buffer.from(jwk.n, 'base64');
-            const exponent = Buffer.from(jwk.e, 'base64');
-            if (isPrivate) {
-                enc.zero();
-                enc.unsignedInteger(modulus);
-                enc.unsignedInteger(exponent);
-                enc.unsignedInteger(Buffer.from(jwk.d, 'base64'));
-                enc.unsignedInteger(Buffer.from(jwk.p, 'base64'));
-                enc.unsignedInteger(Buffer.from(jwk.q, 'base64'));
-                enc.unsignedInteger(Buffer.from(jwk.dp, 'base64'));
-                enc.unsignedInteger(Buffer.from(jwk.dq, 'base64'));
-                enc.unsignedInteger(Buffer.from(jwk.qi, 'base64'));
-            }
-            else {
-                enc.unsignedInteger(modulus);
-                enc.unsignedInteger(exponent);
-            }
-            const der = enc.end();
-            const createInput = {
-                key: der,
-                format: 'der',
-                type: 'pkcs1',
-            };
-            const keyObject = isPrivate ? createPrivateKey(createInput) : createPublicKey(createInput);
-            setModulusLength(keyObject, modulus.length << 3);
-            return keyObject;
-        }
-        case 'EC': {
-            const enc = new Asn1SequenceEncoder();
-            const isPrivate = jwk.d !== undefined;
-            const pub = Buffer.concat([
-                Buffer.alloc(1, 4),
-                Buffer.from(jwk.x, 'base64'),
-                Buffer.from(jwk.y, 'base64'),
-            ]);
-            if (isPrivate) {
-                enc.zero();
-                const enc$1 = new Asn1SequenceEncoder();
-                enc$1.oidFor('ecPublicKey');
-                enc$1.oidFor(jwk.crv);
-                enc.add(enc$1.end());
-                const enc$2 = new Asn1SequenceEncoder();
-                enc$2.one();
-                enc$2.octStr(Buffer.from(jwk.d, 'base64'));
-                const enc$3 = new Asn1SequenceEncoder();
-                enc$3.bitStr(pub);
-                const f2 = enc$3.end(Buffer.from([0xa1]));
-                enc$2.add(f2);
-                const f = enc$2.end();
-                const enc$4 = new Asn1SequenceEncoder();
-                enc$4.add(f);
-                const f3 = enc$4.end(Buffer.from([0x04]));
-                enc.add(f3);
-                const der = enc.end();
-                const keyObject = createPrivateKey({ key: der, format: 'der', type: 'pkcs8' });
-                setCurve(keyObject, jwk.crv);
-                return keyObject;
-            }
-            const enc$1 = new Asn1SequenceEncoder();
-            enc$1.oidFor('ecPublicKey');
-            enc$1.oidFor(jwk.crv);
-            enc.add(enc$1.end());
-            enc.bitStr(pub);
-            const der = enc.end();
-            const keyObject = createPublicKey({ key: der, format: 'der', type: 'spki' });
-            setCurve(keyObject, jwk.crv);
-            return keyObject;
-        }
-        case 'OKP': {
-            const enc = new Asn1SequenceEncoder();
-            const isPrivate = jwk.d !== undefined;
-            if (isPrivate) {
-                enc.zero();
-                const enc$1 = new Asn1SequenceEncoder();
-                enc$1.oidFor(jwk.crv);
-                enc.add(enc$1.end());
-                const enc$2 = new Asn1SequenceEncoder();
-                enc$2.octStr(Buffer.from(jwk.d, 'base64'));
-                const f = enc$2.end(Buffer.from([0x04]));
-                enc.add(f);
-                const der = enc.end();
-                return createPrivateKey({ key: der, format: 'der', type: 'pkcs8' });
-            }
-            const enc$1 = new Asn1SequenceEncoder();
-            enc$1.oidFor(jwk.crv);
-            enc.add(enc$1.end());
-            enc.bitStr(Buffer.from(jwk.x, 'base64'));
-            const der = enc.end();
-            return createPublicKey({ key: der, format: 'der', type: 'spki' });
-        }
-        default:
-            throw new JOSENotSupported('Invalid or unsupported JWK "kty" (Key Type) Parameter value');
-    }
+    return (jwk.d ? createPrivateKey : createPublicKey)({ format: 'jwk', key: jwk });
 };
 export default parse;