webcrypto-core - npm Package Compare versions

Comparing version 1.0.7 to 1.0.8

build/webcrypto-core.es.js

@@ -5,2 +5,3 @@ /**
 
+import { __awaiter } from 'tslib';
 import { Convert } from 'pvtsutils';
@@ -118,5 +119,7 @@
 class ProviderCrypto {
-    async digest(algorithm, data) {
-        this.checkDigest.apply(this, arguments);
-        return this.onDigest.apply(this, arguments);
+    digest(algorithm, data) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkDigest.apply(this, arguments);
+            return this.onDigest.apply(this, arguments);
+        });
     }
@@ -126,8 +129,12 @@ checkDigest(algorithm, data) {
     }
-    async onDigest(algorithm, data) {
-        throw new UnsupportedOperationError("digest");
+    onDigest(algorithm, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("digest");
+        });
     }
-    async generateKey(algorithm, extractable, keyUsages) {
-        this.checkGenerateKey.apply(this, arguments);
-        return this.onGenerateKey.apply(this, arguments);
+    generateKey(algorithm, extractable, keyUsages) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkGenerateKey.apply(this, arguments);
+            return this.onGenerateKey.apply(this, arguments);
+        });
     }
@@ -151,8 +158,12 @@ checkGenerateKey(algorithm, extractable, keyUsages) {
     }
-    async onGenerateKey(algorithm, extractable, keyUsages) {
-        throw new UnsupportedOperationError("generateKey");
+    onGenerateKey(algorithm, extractable, keyUsages) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("generateKey");
+        });
     }
-    async sign(algorithm, key, data) {
-        this.checkSign.apply(this, arguments);
-        return this.onSign.apply(this, arguments);
+    sign(algorithm, key, data) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkSign.apply(this, arguments);
+            return this.onSign.apply(this, arguments);
+        });
     }
@@ -164,8 +175,12 @@ checkSign(algorithm, key, data) {
     }
-    async onSign(algorithm, key, data) {
-        throw new UnsupportedOperationError("sign");
+    onSign(algorithm, key, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("sign");
+        });
     }
-    async verify(algorithm, key, signature, data) {
-        this.checkVerify.apply(this, arguments);
-        return this.onVerify.apply(this, arguments);
+    verify(algorithm, key, signature, data) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkVerify.apply(this, arguments);
+            return this.onVerify.apply(this, arguments);
+        });
     }
@@ -177,8 +192,12 @@ checkVerify(algorithm, key, signature, data) {
     }
-    async onVerify(algorithm, key, signature, data) {
-        throw new UnsupportedOperationError("verify");
+    onVerify(algorithm, key, signature, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("verify");
+        });
     }
-    async encrypt(algorithm, key, data, options) {
-        this.checkEncrypt.apply(this, arguments);
-        return this.onEncrypt.apply(this, arguments);
+    encrypt(algorithm, key, data, options) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkEncrypt.apply(this, arguments);
+            return this.onEncrypt.apply(this, arguments);
+        });
     }
@@ -190,8 +209,12 @@ checkEncrypt(algorithm, key, data, options = {}) {
     }
-    async onEncrypt(algorithm, key, data) {
-        throw new UnsupportedOperationError("encrypt");
+    onEncrypt(algorithm, key, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("encrypt");
+        });
     }
-    async decrypt(algorithm, key, data, options) {
-        this.checkDecrypt.apply(this, arguments);
-        return this.onDecrypt.apply(this, arguments);
+    decrypt(algorithm, key, data, options) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkDecrypt.apply(this, arguments);
+            return this.onDecrypt.apply(this, arguments);
+        });
     }
@@ -203,8 +226,12 @@ checkDecrypt(algorithm, key, data, options = {}) {
     }
-    async onDecrypt(algorithm, key, data) {
-        throw new UnsupportedOperationError("decrypt");
+    onDecrypt(algorithm, key, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("decrypt");
+        });
     }
-    async deriveBits(algorithm, baseKey, length, options) {
-        this.checkDeriveBits.apply(this, arguments);
-        return this.onDeriveBits.apply(this, arguments);
+    deriveBits(algorithm, baseKey, length, options) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkDeriveBits.apply(this, arguments);
+            return this.onDeriveBits.apply(this, arguments);
+        });
     }
@@ -219,8 +246,12 @@ checkDeriveBits(algorithm, baseKey, length, options = {}) {
     }
-    async onDeriveBits(algorithm, baseKey, length) {
-        throw new UnsupportedOperationError("deriveBits");
+    onDeriveBits(algorithm, baseKey, length) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("deriveBits");
+        });
     }
-    async exportKey(format, key) {
-        this.checkExportKey.apply(this, arguments);
-        return this.onExportKey.apply(this, arguments);
+    exportKey(format, key) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkExportKey.apply(this, arguments);
+            return this.onExportKey.apply(this, arguments);
+        });
     }
@@ -234,8 +265,12 @@ checkExportKey(format, key) {
     }
-    async onExportKey(format, key) {
-        throw new UnsupportedOperationError("exportKey");
+    onExportKey(format, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("exportKey");
+        });
     }
-    async importKey(format, keyData, algorithm, extractable, keyUsages) {
-        this.checkImportKey.apply(this, arguments);
-        return this.onImportKey.apply(this, arguments);
+    importKey(format, keyData, algorithm, extractable, keyUsages) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkImportKey.apply(this, arguments);
+            return this.onImportKey.apply(this, arguments);
+        });
     }
@@ -251,4 +286,6 @@ checkImportKey(format, keyData, algorithm, extractable, keyUsages) {
     }
-    async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
-        throw new UnsupportedOperationError("importKey");
+    onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("importKey");
+        });
     }
@@ -697,2 +734,29 @@ checkAlgorithmName(algorithm) {
 
+class HkdfProvider extends ProviderCrypto {
+    constructor() {
+        super(...arguments);
+        this.name = "HKDF";
+        this.hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
+        this.usages = ["deriveKey", "deriveBits"];
+    }
+    checkAlgorithmParams(algorithm) {
+        this.checkRequiredProperty(algorithm, "hash");
+        this.checkHashAlgorithm(algorithm.hash, this.hashAlgorithms);
+        this.checkRequiredProperty(algorithm, "salt");
+        if (!BufferSourceConverter.isBufferSource(algorithm.salt)) {
+            throw new TypeError("salt: Is not of type '(ArrayBuffer or ArrayBufferView)'");
+        }
+        this.checkRequiredProperty(algorithm, "info");
+        if (!BufferSourceConverter.isBufferSource(algorithm.info)) {
+            throw new TypeError("salt: Is not of type '(ArrayBuffer or ArrayBufferView)'");
+        }
+    }
+    checkImportKey(format, keyData, algorithm, extractable, keyUsages) {
+        super.checkImportKey(format, keyData, algorithm, extractable, keyUsages);
+        if (extractable) {
+            throw new SyntaxError("extractable: Must be False");
+        }
+    }
+}
+
 class Crypto {
@@ -743,122 +807,146 @@ }
     }
-    async digest(algorithm, data) {
-        this.checkRequiredArguments(arguments, 2, "digest");
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(data);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.digest(preparedAlgorithm, preparedData);
-        return result;
+    digest(algorithm, data) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 2, "digest");
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const preparedData = BufferSourceConverter.toArrayBuffer(data);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            const result = yield provider.digest(preparedAlgorithm, preparedData);
+            return result;
+        });
     }
-    async generateKey(algorithm, extractable, keyUsages) {
-        this.checkRequiredArguments(arguments, 3, "generateKey");
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.generateKey({ ...preparedAlgorithm, name: provider.name }, extractable, keyUsages);
-        return result;
+    generateKey(algorithm, extractable, keyUsages) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 3, "generateKey");
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            const result = yield provider.generateKey(Object.assign({}, preparedAlgorithm, { name: provider.name }), extractable, keyUsages);
+            return result;
+        });
     }
-    async sign(algorithm, key, data) {
-        this.checkRequiredArguments(arguments, 3, "sign");
-        this.checkCryptoKey(key);
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(data);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.sign({ ...preparedAlgorithm, name: provider.name }, key, preparedData);
-        return result;
+    sign(algorithm, key, data) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 3, "sign");
+            this.checkCryptoKey(key);
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const preparedData = BufferSourceConverter.toArrayBuffer(data);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            const result = yield provider.sign(Object.assign({}, preparedAlgorithm, { name: provider.name }), key, preparedData);
+            return result;
+        });
     }
-    async verify(algorithm, key, signature, data) {
-        this.checkRequiredArguments(arguments, 4, "verify");
-        this.checkCryptoKey(key);
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(data);
-        const preparedSignature = BufferSourceConverter.toArrayBuffer(signature);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.verify({ ...preparedAlgorithm, name: provider.name }, key, preparedSignature, preparedData);
-        return result;
+    verify(algorithm, key, signature, data) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 4, "verify");
+            this.checkCryptoKey(key);
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const preparedData = BufferSourceConverter.toArrayBuffer(data);
+            const preparedSignature = BufferSourceConverter.toArrayBuffer(signature);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            const result = yield provider.verify(Object.assign({}, preparedAlgorithm, { name: provider.name }), key, preparedSignature, preparedData);
+            return result;
+        });
     }
-    async encrypt(algorithm, key, data) {
-        this.checkRequiredArguments(arguments, 3, "encrypt");
-        this.checkCryptoKey(key);
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(data);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.encrypt({ ...preparedAlgorithm, name: provider.name }, key, preparedData, { keyUsage: true });
-        return result;
+    encrypt(algorithm, key, data) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 3, "encrypt");
+            this.checkCryptoKey(key);
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const preparedData = BufferSourceConverter.toArrayBuffer(data);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            const result = yield provider.encrypt(Object.assign({}, preparedAlgorithm, { name: provider.name }), key, preparedData, { keyUsage: true });
+            return result;
+        });
     }
-    async decrypt(algorithm, key, data) {
-        this.checkRequiredArguments(arguments, 3, "decrypt");
-        this.checkCryptoKey(key);
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(data);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.decrypt({ ...preparedAlgorithm, name: provider.name }, key, preparedData, { keyUsage: true });
-        return result;
+    decrypt(algorithm, key, data) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 3, "decrypt");
+            this.checkCryptoKey(key);
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const preparedData = BufferSourceConverter.toArrayBuffer(data);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            const result = yield provider.decrypt(Object.assign({}, preparedAlgorithm, { name: provider.name }), key, preparedData, { keyUsage: true });
+            return result;
+        });
     }
-    async deriveBits(algorithm, baseKey, length) {
-        this.checkRequiredArguments(arguments, 3, "deriveBits");
-        this.checkCryptoKey(baseKey);
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.deriveBits({ ...preparedAlgorithm, name: provider.name }, baseKey, length, { keyUsage: true });
-        return result;
+    deriveBits(algorithm, baseKey, length) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 3, "deriveBits");
+            this.checkCryptoKey(baseKey);
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            const result = yield provider.deriveBits(Object.assign({}, preparedAlgorithm, { name: provider.name }), baseKey, length, { keyUsage: true });
+            return result;
+        });
     }
-    async deriveKey(algorithm, baseKey, derivedKeyType, extractable, keyUsages) {
-        this.checkRequiredArguments(arguments, 5, "deriveKey");
-        const preparedDerivedKeyType = this.prepareAlgorithm(derivedKeyType);
-        const importProvider = this.getProvider(preparedDerivedKeyType.name);
-        importProvider.checkDerivedKeyParams(preparedDerivedKeyType);
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        provider.checkCryptoKey(baseKey, "deriveKey");
-        const derivedBits = await provider.deriveBits({ ...preparedAlgorithm, name: provider.name }, baseKey, derivedKeyType.length, { keyUsage: false });
-        return this.importKey("raw", derivedBits, derivedKeyType, extractable, keyUsages);
+    deriveKey(algorithm, baseKey, derivedKeyType, extractable, keyUsages) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 5, "deriveKey");
+            const preparedDerivedKeyType = this.prepareAlgorithm(derivedKeyType);
+            const importProvider = this.getProvider(preparedDerivedKeyType.name);
+            importProvider.checkDerivedKeyParams(preparedDerivedKeyType);
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            provider.checkCryptoKey(baseKey, "deriveKey");
+            const derivedBits = yield provider.deriveBits(Object.assign({}, preparedAlgorithm, { name: provider.name }), baseKey, derivedKeyType.length, { keyUsage: false });
+            return this.importKey("raw", derivedBits, derivedKeyType, extractable, keyUsages);
+        });
     }
-    async exportKey(format, key) {
-        this.checkRequiredArguments(arguments, 2, "exportKey");
-        this.checkCryptoKey(key);
-        const provider = this.getProvider(key.algorithm.name);
-        const result = await provider.exportKey(format, key);
-        return result;
+    exportKey(format, key) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 2, "exportKey");
+            this.checkCryptoKey(key);
+            const provider = this.getProvider(key.algorithm.name);
+            const result = yield provider.exportKey(format, key);
+            return result;
+        });
     }
-    async importKey(format, keyData, algorithm, extractable, keyUsages) {
-        this.checkRequiredArguments(arguments, 5, "importKey");
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        if (["pkcs8", "spki", "raw"].indexOf(format) !== -1) {
-            const preparedData = BufferSourceConverter.toArrayBuffer(keyData);
-            return provider.importKey(format, preparedData, { ...preparedAlgorithm, name: provider.name }, extractable, keyUsages);
-        }
-        else {
-            if (!keyData.kty) {
-                throw new TypeError("keyData: Is not JSON");
+    importKey(format, keyData, algorithm, extractable, keyUsages) {
+        return __awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 5, "importKey");
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            if (["pkcs8", "spki", "raw"].indexOf(format) !== -1) {
+                const preparedData = BufferSourceConverter.toArrayBuffer(keyData);
+                return provider.importKey(format, preparedData, Object.assign({}, preparedAlgorithm, { name: provider.name }), extractable, keyUsages);
             }
-        }
-        return provider.importKey(format, keyData, { ...preparedAlgorithm, name: provider.name }, extractable, keyUsages);
+            else {
+                if (!keyData.kty) {
+                    throw new TypeError("keyData: Is not JSON");
+                }
+            }
+            return provider.importKey(format, keyData, Object.assign({}, preparedAlgorithm, { name: provider.name }), extractable, keyUsages);
+        });
     }
-    async wrapKey(format, key, wrappingKey, wrapAlgorithm) {
-        let keyData = await this.exportKey(format, key);
-        if (format === "jwk") {
-            const json = JSON.stringify(keyData);
-            keyData = Convert.FromUtf8String(json);
-        }
-        const preparedAlgorithm = this.prepareAlgorithm(wrapAlgorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(keyData);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        return provider.encrypt({ ...preparedAlgorithm, name: provider.name }, wrappingKey, preparedData, { keyUsage: false });
+    wrapKey(format, key, wrappingKey, wrapAlgorithm) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let keyData = yield this.exportKey(format, key);
+            if (format === "jwk") {
+                const json = JSON.stringify(keyData);
+                keyData = Convert.FromUtf8String(json);
+            }
+            const preparedAlgorithm = this.prepareAlgorithm(wrapAlgorithm);
+            const preparedData = BufferSourceConverter.toArrayBuffer(keyData);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            return provider.encrypt(Object.assign({}, preparedAlgorithm, { name: provider.name }), wrappingKey, preparedData, { keyUsage: false });
+        });
     }
-    async unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages) {
-        const preparedAlgorithm = this.prepareAlgorithm(unwrapAlgorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(wrappedKey);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        let keyData = await provider.decrypt({ ...preparedAlgorithm, name: provider.name }, unwrappingKey, preparedData, { keyUsage: false });
-        if (format === "jwk") {
-            try {
-                keyData = JSON.parse(Convert.ToUtf8String(keyData));
+    unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const preparedAlgorithm = this.prepareAlgorithm(unwrapAlgorithm);
+            const preparedData = BufferSourceConverter.toArrayBuffer(wrappedKey);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            let keyData = yield provider.decrypt(Object.assign({}, preparedAlgorithm, { name: provider.name }), unwrappingKey, preparedData, { keyUsage: false });
+            if (format === "jwk") {
+                try {
+                    keyData = JSON.parse(Convert.ToUtf8String(keyData));
+                }
+                catch (e) {
+                    const error = new TypeError("wrappedKey: Is not a JSON");
+                    error.internal = e;
+                    throw error;
+                }
             }
-            catch (e) {
-                const error = new TypeError("wrappedKey: Is not a JSON");
-                error.internal = e;
-                throw error;
-            }
-        }
-        return this.importKey(format, keyData, unwrappedKeyAlgorithm, extractable, keyUsages);
+            return this.importKey(format, keyData, unwrappedKeyAlgorithm, extractable, keyUsages);
+        });
     }
@@ -877,7 +965,7 @@ checkRequiredArguments(args, size, methodName) {
         if (SubtleCrypto.isHashedAlgorithm(algorithm)) {
-            const preparedAlgorithm = { ...algorithm };
+            const preparedAlgorithm = Object.assign({}, algorithm);
             preparedAlgorithm.hash = this.prepareAlgorithm(algorithm.hash);
             return preparedAlgorithm;
         }
-        return { ...algorithm };
+        return Object.assign({}, algorithm);
     }
@@ -898,2 +986,2 @@ getProvider(name) {
 
-export { AlgorithmError, CryptoError, UnsupportedOperationError, OperationError, RequiredPropertyError, AesProvider, AesCbcProvider, AesCmacProvider, AesCtrProvider, AesEcbProvider, AesGcmProvider, AesKwProvider, DesProvider, RsaProvider, RsaSsaProvider, RsaPssProvider, RsaOaepProvider, EllipticProvider, EcdsaProvider, EcdhProvider, HmacProvider, Pbkdf2Provider, Crypto, ProviderCrypto, ProviderStorage, SubtleCrypto, CryptoKey, PemConverter, BufferSourceConverter, isJWK };
+export { AlgorithmError, CryptoError, UnsupportedOperationError, OperationError, RequiredPropertyError, AesProvider, AesCbcProvider, AesCmacProvider, AesCtrProvider, AesEcbProvider, AesGcmProvider, AesKwProvider, DesProvider, RsaProvider, RsaSsaProvider, RsaPssProvider, RsaOaepProvider, EllipticProvider, EcdsaProvider, EcdhProvider, HmacProvider, Pbkdf2Provider, HkdfProvider, Crypto, ProviderCrypto, ProviderStorage, SubtleCrypto, CryptoKey, PemConverter, BufferSourceConverter, isJWK };

build/webcrypto-core.js

@@ -9,2 +9,3 @@ /**
 
+var tslib_1 = require('tslib');
 var pvtsutils = require('pvtsutils');
@@ -122,5 +123,7 @@
 class ProviderCrypto {
-    async digest(algorithm, data) {
-        this.checkDigest.apply(this, arguments);
-        return this.onDigest.apply(this, arguments);
+    digest(algorithm, data) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkDigest.apply(this, arguments);
+            return this.onDigest.apply(this, arguments);
+        });
     }
@@ -130,8 +133,12 @@ checkDigest(algorithm, data) {
     }
-    async onDigest(algorithm, data) {
-        throw new UnsupportedOperationError("digest");
+    onDigest(algorithm, data) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("digest");
+        });
     }
-    async generateKey(algorithm, extractable, keyUsages) {
-        this.checkGenerateKey.apply(this, arguments);
-        return this.onGenerateKey.apply(this, arguments);
+    generateKey(algorithm, extractable, keyUsages) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkGenerateKey.apply(this, arguments);
+            return this.onGenerateKey.apply(this, arguments);
+        });
     }
@@ -155,8 +162,12 @@ checkGenerateKey(algorithm, extractable, keyUsages) {
     }
-    async onGenerateKey(algorithm, extractable, keyUsages) {
-        throw new UnsupportedOperationError("generateKey");
+    onGenerateKey(algorithm, extractable, keyUsages) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("generateKey");
+        });
     }
-    async sign(algorithm, key, data) {
-        this.checkSign.apply(this, arguments);
-        return this.onSign.apply(this, arguments);
+    sign(algorithm, key, data) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkSign.apply(this, arguments);
+            return this.onSign.apply(this, arguments);
+        });
     }
@@ -168,8 +179,12 @@ checkSign(algorithm, key, data) {
     }
-    async onSign(algorithm, key, data) {
-        throw new UnsupportedOperationError("sign");
+    onSign(algorithm, key, data) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("sign");
+        });
     }
-    async verify(algorithm, key, signature, data) {
-        this.checkVerify.apply(this, arguments);
-        return this.onVerify.apply(this, arguments);
+    verify(algorithm, key, signature, data) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkVerify.apply(this, arguments);
+            return this.onVerify.apply(this, arguments);
+        });
     }
@@ -181,8 +196,12 @@ checkVerify(algorithm, key, signature, data) {
     }
-    async onVerify(algorithm, key, signature, data) {
-        throw new UnsupportedOperationError("verify");
+    onVerify(algorithm, key, signature, data) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("verify");
+        });
     }
-    async encrypt(algorithm, key, data, options) {
-        this.checkEncrypt.apply(this, arguments);
-        return this.onEncrypt.apply(this, arguments);
+    encrypt(algorithm, key, data, options) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkEncrypt.apply(this, arguments);
+            return this.onEncrypt.apply(this, arguments);
+        });
     }
@@ -194,8 +213,12 @@ checkEncrypt(algorithm, key, data, options = {}) {
     }
-    async onEncrypt(algorithm, key, data) {
-        throw new UnsupportedOperationError("encrypt");
+    onEncrypt(algorithm, key, data) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("encrypt");
+        });
     }
-    async decrypt(algorithm, key, data, options) {
-        this.checkDecrypt.apply(this, arguments);
-        return this.onDecrypt.apply(this, arguments);
+    decrypt(algorithm, key, data, options) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkDecrypt.apply(this, arguments);
+            return this.onDecrypt.apply(this, arguments);
+        });
     }
@@ -207,8 +230,12 @@ checkDecrypt(algorithm, key, data, options = {}) {
     }
-    async onDecrypt(algorithm, key, data) {
-        throw new UnsupportedOperationError("decrypt");
+    onDecrypt(algorithm, key, data) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("decrypt");
+        });
     }
-    async deriveBits(algorithm, baseKey, length, options) {
-        this.checkDeriveBits.apply(this, arguments);
-        return this.onDeriveBits.apply(this, arguments);
+    deriveBits(algorithm, baseKey, length, options) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkDeriveBits.apply(this, arguments);
+            return this.onDeriveBits.apply(this, arguments);
+        });
     }
@@ -223,8 +250,12 @@ checkDeriveBits(algorithm, baseKey, length, options = {}) {
     }
-    async onDeriveBits(algorithm, baseKey, length) {
-        throw new UnsupportedOperationError("deriveBits");
+    onDeriveBits(algorithm, baseKey, length) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("deriveBits");
+        });
     }
-    async exportKey(format, key) {
-        this.checkExportKey.apply(this, arguments);
-        return this.onExportKey.apply(this, arguments);
+    exportKey(format, key) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkExportKey.apply(this, arguments);
+            return this.onExportKey.apply(this, arguments);
+        });
     }
@@ -238,8 +269,12 @@ checkExportKey(format, key) {
     }
-    async onExportKey(format, key) {
-        throw new UnsupportedOperationError("exportKey");
+    onExportKey(format, key) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("exportKey");
+        });
     }
-    async importKey(format, keyData, algorithm, extractable, keyUsages) {
-        this.checkImportKey.apply(this, arguments);
-        return this.onImportKey.apply(this, arguments);
+    importKey(format, keyData, algorithm, extractable, keyUsages) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkImportKey.apply(this, arguments);
+            return this.onImportKey.apply(this, arguments);
+        });
     }
@@ -255,4 +290,6 @@ checkImportKey(format, keyData, algorithm, extractable, keyUsages) {
     }
-    async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
-        throw new UnsupportedOperationError("importKey");
+    onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            throw new UnsupportedOperationError("importKey");
+        });
     }
@@ -701,2 +738,29 @@ checkAlgorithmName(algorithm) {
 
+class HkdfProvider extends ProviderCrypto {
+    constructor() {
+        super(...arguments);
+        this.name = "HKDF";
+        this.hashAlgorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
+        this.usages = ["deriveKey", "deriveBits"];
+    }
+    checkAlgorithmParams(algorithm) {
+        this.checkRequiredProperty(algorithm, "hash");
+        this.checkHashAlgorithm(algorithm.hash, this.hashAlgorithms);
+        this.checkRequiredProperty(algorithm, "salt");
+        if (!BufferSourceConverter.isBufferSource(algorithm.salt)) {
+            throw new TypeError("salt: Is not of type '(ArrayBuffer or ArrayBufferView)'");
+        }
+        this.checkRequiredProperty(algorithm, "info");
+        if (!BufferSourceConverter.isBufferSource(algorithm.info)) {
+            throw new TypeError("salt: Is not of type '(ArrayBuffer or ArrayBufferView)'");
+        }
+    }
+    checkImportKey(format, keyData, algorithm, extractable, keyUsages) {
+        super.checkImportKey(format, keyData, algorithm, extractable, keyUsages);
+        if (extractable) {
+            throw new SyntaxError("extractable: Must be False");
+        }
+    }
+}
+
 class Crypto {
@@ -747,122 +811,146 @@ }
     }
-    async digest(algorithm, data) {
-        this.checkRequiredArguments(arguments, 2, "digest");
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(data);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.digest(preparedAlgorithm, preparedData);
-        return result;
+    digest(algorithm, data) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 2, "digest");
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const preparedData = BufferSourceConverter.toArrayBuffer(data);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            const result = yield provider.digest(preparedAlgorithm, preparedData);
+            return result;
+        });
     }
-    async generateKey(algorithm, extractable, keyUsages) {
-        this.checkRequiredArguments(arguments, 3, "generateKey");
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.generateKey({ ...preparedAlgorithm, name: provider.name }, extractable, keyUsages);
-        return result;
+    generateKey(algorithm, extractable, keyUsages) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 3, "generateKey");
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            const result = yield provider.generateKey(Object.assign({}, preparedAlgorithm, { name: provider.name }), extractable, keyUsages);
+            return result;
+        });
     }
-    async sign(algorithm, key, data) {
-        this.checkRequiredArguments(arguments, 3, "sign");
-        this.checkCryptoKey(key);
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(data);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.sign({ ...preparedAlgorithm, name: provider.name }, key, preparedData);
-        return result;
+    sign(algorithm, key, data) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 3, "sign");
+            this.checkCryptoKey(key);
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const preparedData = BufferSourceConverter.toArrayBuffer(data);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            const result = yield provider.sign(Object.assign({}, preparedAlgorithm, { name: provider.name }), key, preparedData);
+            return result;
+        });
     }
-    async verify(algorithm, key, signature, data) {
-        this.checkRequiredArguments(arguments, 4, "verify");
-        this.checkCryptoKey(key);
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(data);
-        const preparedSignature = BufferSourceConverter.toArrayBuffer(signature);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.verify({ ...preparedAlgorithm, name: provider.name }, key, preparedSignature, preparedData);
-        return result;
+    verify(algorithm, key, signature, data) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 4, "verify");
+            this.checkCryptoKey(key);
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const preparedData = BufferSourceConverter.toArrayBuffer(data);
+            const preparedSignature = BufferSourceConverter.toArrayBuffer(signature);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            const result = yield provider.verify(Object.assign({}, preparedAlgorithm, { name: provider.name }), key, preparedSignature, preparedData);
+            return result;
+        });
     }
-    async encrypt(algorithm, key, data) {
-        this.checkRequiredArguments(arguments, 3, "encrypt");
-        this.checkCryptoKey(key);
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(data);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.encrypt({ ...preparedAlgorithm, name: provider.name }, key, preparedData, { keyUsage: true });
-        return result;
+    encrypt(algorithm, key, data) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 3, "encrypt");
+            this.checkCryptoKey(key);
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const preparedData = BufferSourceConverter.toArrayBuffer(data);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            const result = yield provider.encrypt(Object.assign({}, preparedAlgorithm, { name: provider.name }), key, preparedData, { keyUsage: true });
+            return result;
+        });
     }
-    async decrypt(algorithm, key, data) {
-        this.checkRequiredArguments(arguments, 3, "decrypt");
-        this.checkCryptoKey(key);
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(data);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.decrypt({ ...preparedAlgorithm, name: provider.name }, key, preparedData, { keyUsage: true });
-        return result;
+    decrypt(algorithm, key, data) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 3, "decrypt");
+            this.checkCryptoKey(key);
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const preparedData = BufferSourceConverter.toArrayBuffer(data);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            const result = yield provider.decrypt(Object.assign({}, preparedAlgorithm, { name: provider.name }), key, preparedData, { keyUsage: true });
+            return result;
+        });
     }
-    async deriveBits(algorithm, baseKey, length) {
-        this.checkRequiredArguments(arguments, 3, "deriveBits");
-        this.checkCryptoKey(baseKey);
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        const result = await provider.deriveBits({ ...preparedAlgorithm, name: provider.name }, baseKey, length, { keyUsage: true });
-        return result;
+    deriveBits(algorithm, baseKey, length) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 3, "deriveBits");
+            this.checkCryptoKey(baseKey);
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            const result = yield provider.deriveBits(Object.assign({}, preparedAlgorithm, { name: provider.name }), baseKey, length, { keyUsage: true });
+            return result;
+        });
     }
-    async deriveKey(algorithm, baseKey, derivedKeyType, extractable, keyUsages) {
-        this.checkRequiredArguments(arguments, 5, "deriveKey");
-        const preparedDerivedKeyType = this.prepareAlgorithm(derivedKeyType);
-        const importProvider = this.getProvider(preparedDerivedKeyType.name);
-        importProvider.checkDerivedKeyParams(preparedDerivedKeyType);
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        provider.checkCryptoKey(baseKey, "deriveKey");
-        const derivedBits = await provider.deriveBits({ ...preparedAlgorithm, name: provider.name }, baseKey, derivedKeyType.length, { keyUsage: false });
-        return this.importKey("raw", derivedBits, derivedKeyType, extractable, keyUsages);
+    deriveKey(algorithm, baseKey, derivedKeyType, extractable, keyUsages) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 5, "deriveKey");
+            const preparedDerivedKeyType = this.prepareAlgorithm(derivedKeyType);
+            const importProvider = this.getProvider(preparedDerivedKeyType.name);
+            importProvider.checkDerivedKeyParams(preparedDerivedKeyType);
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            provider.checkCryptoKey(baseKey, "deriveKey");
+            const derivedBits = yield provider.deriveBits(Object.assign({}, preparedAlgorithm, { name: provider.name }), baseKey, derivedKeyType.length, { keyUsage: false });
+            return this.importKey("raw", derivedBits, derivedKeyType, extractable, keyUsages);
+        });
     }
-    async exportKey(format, key) {
-        this.checkRequiredArguments(arguments, 2, "exportKey");
-        this.checkCryptoKey(key);
-        const provider = this.getProvider(key.algorithm.name);
-        const result = await provider.exportKey(format, key);
-        return result;
+    exportKey(format, key) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 2, "exportKey");
+            this.checkCryptoKey(key);
+            const provider = this.getProvider(key.algorithm.name);
+            const result = yield provider.exportKey(format, key);
+            return result;
+        });
     }
-    async importKey(format, keyData, algorithm, extractable, keyUsages) {
-        this.checkRequiredArguments(arguments, 5, "importKey");
-        const preparedAlgorithm = this.prepareAlgorithm(algorithm);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        if (["pkcs8", "spki", "raw"].indexOf(format) !== -1) {
-            const preparedData = BufferSourceConverter.toArrayBuffer(keyData);
-            return provider.importKey(format, preparedData, { ...preparedAlgorithm, name: provider.name }, extractable, keyUsages);
-        }
-        else {
-            if (!keyData.kty) {
-                throw new TypeError("keyData: Is not JSON");
+    importKey(format, keyData, algorithm, extractable, keyUsages) {
+        return tslib_1.__awaiter(this, arguments, void 0, function* () {
+            this.checkRequiredArguments(arguments, 5, "importKey");
+            const preparedAlgorithm = this.prepareAlgorithm(algorithm);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            if (["pkcs8", "spki", "raw"].indexOf(format) !== -1) {
+                const preparedData = BufferSourceConverter.toArrayBuffer(keyData);
+                return provider.importKey(format, preparedData, Object.assign({}, preparedAlgorithm, { name: provider.name }), extractable, keyUsages);
             }
-        }
-        return provider.importKey(format, keyData, { ...preparedAlgorithm, name: provider.name }, extractable, keyUsages);
+            else {
+                if (!keyData.kty) {
+                    throw new TypeError("keyData: Is not JSON");
+                }
+            }
+            return provider.importKey(format, keyData, Object.assign({}, preparedAlgorithm, { name: provider.name }), extractable, keyUsages);
+        });
     }
-    async wrapKey(format, key, wrappingKey, wrapAlgorithm) {
-        let keyData = await this.exportKey(format, key);
-        if (format === "jwk") {
-            const json = JSON.stringify(keyData);
-            keyData = pvtsutils.Convert.FromUtf8String(json);
-        }
-        const preparedAlgorithm = this.prepareAlgorithm(wrapAlgorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(keyData);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        return provider.encrypt({ ...preparedAlgorithm, name: provider.name }, wrappingKey, preparedData, { keyUsage: false });
+    wrapKey(format, key, wrappingKey, wrapAlgorithm) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let keyData = yield this.exportKey(format, key);
+            if (format === "jwk") {
+                const json = JSON.stringify(keyData);
+                keyData = pvtsutils.Convert.FromUtf8String(json);
+            }
+            const preparedAlgorithm = this.prepareAlgorithm(wrapAlgorithm);
+            const preparedData = BufferSourceConverter.toArrayBuffer(keyData);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            return provider.encrypt(Object.assign({}, preparedAlgorithm, { name: provider.name }), wrappingKey, preparedData, { keyUsage: false });
+        });
     }
-    async unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages) {
-        const preparedAlgorithm = this.prepareAlgorithm(unwrapAlgorithm);
-        const preparedData = BufferSourceConverter.toArrayBuffer(wrappedKey);
-        const provider = this.getProvider(preparedAlgorithm.name);
-        let keyData = await provider.decrypt({ ...preparedAlgorithm, name: provider.name }, unwrappingKey, preparedData, { keyUsage: false });
-        if (format === "jwk") {
-            try {
-                keyData = JSON.parse(pvtsutils.Convert.ToUtf8String(keyData));
+    unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const preparedAlgorithm = this.prepareAlgorithm(unwrapAlgorithm);
+            const preparedData = BufferSourceConverter.toArrayBuffer(wrappedKey);
+            const provider = this.getProvider(preparedAlgorithm.name);
+            let keyData = yield provider.decrypt(Object.assign({}, preparedAlgorithm, { name: provider.name }), unwrappingKey, preparedData, { keyUsage: false });
+            if (format === "jwk") {
+                try {
+                    keyData = JSON.parse(pvtsutils.Convert.ToUtf8String(keyData));
+                }
+                catch (e) {
+                    const error = new TypeError("wrappedKey: Is not a JSON");
+                    error.internal = e;
+                    throw error;
+                }
             }
-            catch (e) {
-                const error = new TypeError("wrappedKey: Is not a JSON");
-                error.internal = e;
-                throw error;
-            }
-        }
-        return this.importKey(format, keyData, unwrappedKeyAlgorithm, extractable, keyUsages);
+            return this.importKey(format, keyData, unwrappedKeyAlgorithm, extractable, keyUsages);
+        });
     }
@@ -881,7 +969,7 @@ checkRequiredArguments(args, size, methodName) {
         if (SubtleCrypto.isHashedAlgorithm(algorithm)) {
-            const preparedAlgorithm = { ...algorithm };
+            const preparedAlgorithm = Object.assign({}, algorithm);
             preparedAlgorithm.hash = this.prepareAlgorithm(algorithm.hash);
             return preparedAlgorithm;
         }
-        return { ...algorithm };
+        return Object.assign({}, algorithm);
     }
@@ -924,2 +1012,3 @@ getProvider(name) {
 exports.Pbkdf2Provider = Pbkdf2Provider;
+exports.HkdfProvider = HkdfProvider;
 exports.Crypto = Crypto;
@@ -926,0 +1015,0 @@ exports.ProviderCrypto = ProviderCrypto;

package.json

 {
   "name": "webcrypto-core",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Common layer to be used by crypto libraries based on WebCrypto API for input validation.",
   "main": "build/webcrypto-core.js",
   "module": "build/webcrypto-core.es.js",
-  "types": "types/index.d.ts",
+  "types": "build/webcrypto-core.d.ts",
   "scripts": {
@@ -47,3 +47,3 @@ "prepare": "npm run build",
     "rollup": "^1.1.2",
-    "rollup-plugin-typescript": "^1.0.0",
+    "rollup-plugin-dts": "^0.13.0",
     "ts-node": "^8.0.1",
@@ -50,0 +50,0 @@ "typescript": "^3.2.4"

types/hmac/index.d.ts

@@ -11,3 +11,3 @@ import { ProviderCrypto } from "../provider";
      */
-    getDefaultLength(algName: string): 256 | 160 | 384 | 512;
+    getDefaultLength(algName: string): 160 | 256 | 384 | 512;
     checkGenerateKeyParams(algorithm: HmacKeyGenParams): void;
@@ -14,0 +14,0 @@ checkImportParams(algorithm: HmacImportParams): void;

types/index.d.ts

@@ -8,2 +8,3 @@ export * from "./errors";
 export * from "./pbkdf";
+export * from "./hkdf";
 export * from "./crypto";
@@ -10,0 +11,0 @@ export * from "./provider";

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

126058

increased by33.7%

Number of package files

46

increased by6.98%

Lines of code

2835

increased by27.36%

No dependency changes