@nivinjoseph/n-sec 5.0.5 → 6.0.1

package/test/json-web-token.test.ts

@@ -1,18 +1,18 @@
-import * as Assert from "assert";
-import { JsonWebToken } from "./../src/api-security/json-web-token";
-import { Claim } from "../src/api-security/claim";
-import { SymmetricEncryption } from "../src/index";
-import { InvalidTokenException } from "../src/api-security/invalid-token-exception";
-import { ExpiredTokenException } from "../src/api-security/expired-token-exception";
-// import { AsymmetricEncryption } from "../src/index";
+import { describe, test } from "node:test";
+import assert from "node:assert";
+import { JsonWebToken } from "./../src/api-security/json-web-token.js";
+import { Claim } from "../src/api-security/claim.js";
+import { SymmetricEncryption } from "../src/index.js";
+import { InvalidTokenException } from "../src/api-security/invalid-token-exception.js";
+import { ExpiredTokenException } from "../src/api-security/expired-token-exception.js";
 
 
-suite("Json Web Token ", () =>
+await describe("Json Web Token ", async () =>
 {
-    suite("Hmac", () =>
+    await describe("Hmac", async () =>
     {
-    
-        test("should successfully create a token using hmac with one claim", async () =>
+
+        await test("should successfully create a token using hmac with one claim", async () =>
         {
             const claim = new Claim("this_claim", "ThisValue");
             const key = await SymmetricEncryption.generateKey();
@@ -20,14 +20,14 @@ suite("Json Web Token ", () =>
             const token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim]).generateToken();
             const jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            Assert.ok(jwt !== null || jwt !== undefined);
-            Assert.strictEqual(jwt.issuer, "issuer1");
-            Assert.strictEqual(jwt.algType, 1);
-            Assert.strictEqual(jwt.expiry, time + 10000000);
-            Assert.deepStrictEqual(jwt.claims, [claim]);
+            assert.ok(jwt !== null || jwt !== undefined);
+            assert.strictEqual(jwt.issuer, "issuer1");
+            assert.strictEqual(jwt.algType, 1);
+            assert.strictEqual(jwt.expiry, time + 10000000);
+            assert.deepStrictEqual(jwt.claims, [claim]);
         });
 
-        test("should successfully create a token using hmac with 2 claims", async () =>
+        await test("should successfully create a token using hmac with 2 claims", async () =>
         {
             const claim1 = new Claim("this_claim", "ThisValue");
             const claim2 = new Claim("that_claim", "ThatValue");
@@ -36,14 +36,14 @@ suite("Json Web Token ", () =>
             const token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
             const jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            Assert.ok(jwt !== null || jwt !== undefined);
-            Assert.strictEqual(jwt.issuer, "issuer1");
-            Assert.strictEqual(jwt.algType, 1);
-            Assert.strictEqual(jwt.expiry, time + 10000000);
-            Assert.deepStrictEqual(jwt.claims, [claim1, claim2]);
+            assert.ok(jwt !== null || jwt !== undefined);
+            assert.strictEqual(jwt.issuer, "issuer1");
+            assert.strictEqual(jwt.algType, 1);
+            assert.strictEqual(jwt.expiry, time + 10000000);
+            assert.deepStrictEqual(jwt.claims, [claim1, claim2]);
         });
 
-        test("should successfully create a token using hmac with 2 claims", async () =>
+        await test("should successfully create a token using hmac with 2 claims", async () =>
         {
             const claim1 = new Claim("this_claim", "ThisValue");
             const claim2 = new Claim("that_claim", "ThatValue");
@@ -52,14 +52,14 @@ suite("Json Web Token ", () =>
             const token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
             const jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            Assert.ok(jwt !== null || jwt !== undefined);
-            Assert.strictEqual(jwt.issuer, "issuer1");
-            Assert.strictEqual(jwt.algType, 1);
-            Assert.strictEqual(jwt.expiry, time + 10000000);
-            Assert.deepStrictEqual(jwt.claims, [claim1, claim2]);
+            assert.ok(jwt !== null || jwt !== undefined);
+            assert.strictEqual(jwt.issuer, "issuer1");
+            assert.strictEqual(jwt.algType, 1);
+            assert.strictEqual(jwt.expiry, time + 10000000);
+            assert.deepStrictEqual(jwt.claims, [claim1, claim2]);
         });
 
-        test("should throw an exception when getting JWT with a different issuer that what was user to generate token", async () =>
+        await test("should throw an exception when getting JWT with a different issuer that what was user to generate token", async () =>
         {
             const claim1 = new Claim("this_claim", "ThisValue");
             const claim2 = new Claim("that_claim", "ThatValue");
@@ -72,14 +72,14 @@ suite("Json Web Token ", () =>
             }
             catch (exp)
             {
-                Assert.ok(exp instanceof InvalidTokenException);
-                Assert.equal(exp.message, `Token '${token}' is invalid because iss was expected to be 'notTheIssuer' but instead was 'issuer1'.`);
+                assert.ok(exp instanceof InvalidTokenException);
+                assert.equal(exp.message, `Token '${token}' is invalid because iss was expected to be 'notTheIssuer' but instead was 'issuer1'.`);
                 return;
             }
-            Assert.ok(false);
+            assert.ok(false);
         });
-        
-        test("should throw an exception when getting JWT when the token is expired", async () =>
+
+        await test("should throw an exception when getting JWT when the token is expired", async () =>
         {
             const claim1 = new Claim("this_claim", "ThisValue");
             const claim2 = new Claim("that_claim", "ThatValue");
@@ -92,15 +92,15 @@ suite("Json Web Token ", () =>
             }
             catch (exp)
             {
-                Assert.ok(exp instanceof ExpiredTokenException);
-                Assert.equal(exp.message, `Token '${token}' is expired.`);
+                assert.ok(exp instanceof ExpiredTokenException);
+                assert.equal(exp.message, `Token '${token}' is expired.`);
                 return;
             }
-            Assert.ok(false);
+            assert.ok(false);
         });
-        
+
         // TODO: right now we only support one alg type. When we support others, we should uncomment this test
-        // test("should throw an exception when getting JWT algorithm given is different than what was used for the token generation", async () =>
+        // await test("should throw an exception when getting JWT algorithm given is different than what was used for the token generation", async () =>
         // {
         //     let claim1 = new Claim("this_claim", "ThisValue");
         //     let claim2 = new Claim("that_claim", "ThatValue");
@@ -114,14 +114,14 @@ suite("Json Web Token ", () =>
         //     catch (exp)
         //     {
         //         console.log(exp);
-        //         Assert.ok(exp instanceof InvalidTokenException);
-        //         Assert.equal(exp.message, `Token '${token}' is invalid because alg was expected to be '${2}' but instead was '${1}'.`);
+        //         assert.ok(exp instanceof InvalidTokenException);
+        //         assert.equal(exp.message, `Token '${token}' is invalid because alg was expected to be '${2}' but instead was '${1}'.`);
         //         return;
         //     }
-        //     Assert.ok(false);
+        //     assert.ok(false);
         // });
-        
-        test("should throw an exception when getting JWT key given is different than what was used for the token generation", async () =>
+
+        await test("should throw an exception when getting JWT key given is different than what was used for the token generation", async () =>
         {
             const claim1 = new Claim("this_claim", "ThisValue");
             const claim2 = new Claim("that_claim", "ThatValue");
@@ -135,14 +135,14 @@ suite("Json Web Token ", () =>
             }
             catch (exp)
             {
-                Assert.ok(exp instanceof InvalidTokenException);
-                Assert.equal(exp.message, `Token '${token}' is invalid because signature could not be verified.`);
+                assert.ok(exp instanceof InvalidTokenException);
+                assert.equal(exp.message, `Token '${token}' is invalid because signature could not be verified.`);
                 return;
             }
-            Assert.ok(false);
+            assert.ok(false);
         });
-        
-        test("should throw an exception when getting JWT when the token is tampered with", async () =>
+
+        await test("should throw an exception when getting JWT when the token is tampered with", async () =>
         {
             const claim1 = new Claim("this_claim", "ThisValue");
             const claim2 = new Claim("that_claim", "ThatValue");
@@ -156,31 +156,31 @@ suite("Json Web Token ", () =>
             }
             catch (exp)
             {
-                Assert.ok(exp instanceof InvalidTokenException);
-                Assert.equal(exp.message, `Token '${token}' is invalid because signature could not be verified.`);
+                assert.ok(exp instanceof InvalidTokenException);
+                assert.equal(exp.message, `Token '${token}' is invalid because signature could not be verified.`);
                 return;
             }
-            Assert.ok(false);
+            assert.ok(false);
         });
-    }); 
-    
-    // suite("digital Signature", () =>
+    });
+
+    // await describe("digital Signature", () =>
     // {
-    //     test("should successfully create a token using keyPair using digital Signature with one claim and get jwt using keyPair", async () =>
+    //     await test("should successfully create a token using keyPair using digital Signature with one claim and get jwt using keyPair", async () =>
     //     {
     //         let keyPair = await AsymmetricEncryption.generateKeyPair();
     //         let claim = new Claim("this_claim", "ThisValue");
     //         let time = Date.now();
     //         let token = await JsonWebToken.fromClaims("issuer1", 2, keyPair, time + 10000000, [claim]).generateToken();
     //         let jwt = await JsonWebToken.fromToken("issuer1", 2, keyPair, token);
-    //         Assert.ok(jwt !== null || jwt !== undefined);
-    //         Assert.strictEqual(jwt.issuer, "issuer1");
-    //         Assert.strictEqual(jwt.algType, 2);
-    //         Assert.strictEqual(jwt.expiry, time + 10000000);
-    //         Assert.deepStrictEqual(jwt.claims, [claim]);
+    //         assert.ok(jwt !== null || jwt !== undefined);
+    //         assert.strictEqual(jwt.issuer, "issuer1");
+    //         assert.strictEqual(jwt.algType, 2);
+    //         assert.strictEqual(jwt.expiry, time + 10000000);
+    //         assert.deepStrictEqual(jwt.claims, [claim]);
     //     });
-        
-    //     test("should successfully create a token using keyPair using digital Signature with one claim and get jwt using public key", async () =>
+
+    //     await test("should successfully create a token using keyPair using digital Signature with one claim and get jwt using public key", async () =>
     //     {
     //         let keyPair = await AsymmetricEncryption.generateKeyPair();
     //         let pubKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -188,14 +188,14 @@ suite("Json Web Token ", () =>
     //         let time = Date.now();
     //         let token = await JsonWebToken.fromClaims("issuer1", 2, keyPair, time + 10000000, [claim]).generateToken();
     //         let jwt = await JsonWebToken.fromToken("issuer1", 2, pubKey, token);
-    //         Assert.ok(jwt !== null || jwt !== undefined);
-    //         Assert.strictEqual(jwt.issuer, "issuer1");
-    //         Assert.strictEqual(jwt.algType, 2);
-    //         Assert.strictEqual(jwt.expiry, time + 10000000);
-    //         Assert.deepStrictEqual(jwt.claims, [claim]);
+    //         assert.ok(jwt !== null || jwt !== undefined);
+    //         assert.strictEqual(jwt.issuer, "issuer1");
+    //         assert.strictEqual(jwt.algType, 2);
+    //         assert.strictEqual(jwt.expiry, time + 10000000);
+    //         assert.deepStrictEqual(jwt.claims, [claim]);
     //     });
-        
-    //     test("should throw an exception when getting JWT with a different issuer that what was user to generate token", async () =>
+
+    //     await test("should throw an exception when getting JWT with a different issuer that what was user to generate token", async () =>
     //     {
     //         let keyPair = await AsymmetricEncryption.generateKeyPair();
     //         let pubKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -208,14 +208,14 @@ suite("Json Web Token ", () =>
     //         }
     //         catch (exp)
     //         {
-    //             Assert.ok(exp instanceof InvalidTokenException);
-    //             Assert.equal(exp.message, `Token '${token}' is invalid because iss was expected to be 'notTheIssuer' but instead was 'issuer1'.`);
+    //             assert.ok(exp instanceof InvalidTokenException);
+    //             assert.equal(exp.message, `Token '${token}' is invalid because iss was expected to be 'notTheIssuer' but instead was 'issuer1'.`);
     //             return;
     //         }
-    //         Assert.ok(false);
+    //         assert.ok(false);
     //     });
-        
-    //     test("should throw an exception when getting JWT algorithm given is different than what was used for the token generation", async () =>
+
+    //     await test("should throw an exception when getting JWT algorithm given is different than what was used for the token generation", async () =>
     //     {
     //         let claim1 = new Claim("this_claim", "ThisValue");
     //         let claim2 = new Claim("that_claim", "ThatValue");
@@ -229,14 +229,14 @@ suite("Json Web Token ", () =>
     //         }
     //         catch (exp)
     //         {
-    //             Assert.ok(exp instanceof InvalidTokenException);
-    //             Assert.equal(exp.message, `Token '${token}' is invalid because alg was expected to be '${1}' but instead was '${2}'.`);
+    //             assert.ok(exp instanceof InvalidTokenException);
+    //             assert.equal(exp.message, `Token '${token}' is invalid because alg was expected to be '${1}' but instead was '${2}'.`);
     //             return;
     //         }
-    //         Assert.ok(false);
+    //         assert.ok(false);
     //     });
-        
-    //     test("should throw an exception when getting JWT algorithm given is different than what was used for the token generation", async () =>
+
+    //     await test("should throw an exception when getting JWT algorithm given is different than what was used for the token generation", async () =>
     //     {
     //         let claim1 = new Claim("this_claim", "ThisValue");
     //         let claim2 = new Claim("that_claim", "ThatValue");
@@ -250,14 +250,14 @@ suite("Json Web Token ", () =>
     //         }
     //         catch (exp)
     //         {
-    //             Assert.ok(exp instanceof ExpiredTokenException);
-    //             Assert.equal(exp.message, `Token '${token}' is expired.`);
+    //             assert.ok(exp instanceof ExpiredTokenException);
+    //             assert.equal(exp.message, `Token '${token}' is expired.`);
     //             return;
     //         }
-    //         Assert.ok(false);
+    //         assert.ok(false);
     //     });
-        
-    //     test("should throw an exception when getting JWT key given is different than what was used for the token generation", async () =>
+
+    //     await test("should throw an exception when getting JWT key given is different than what was used for the token generation", async () =>
     //     {
     //         let claim1 = new Claim("this_claim", "ThisValue");
     //         let claim2 = new Claim("that_claim", "ThatValue");
@@ -271,15 +271,15 @@ suite("Json Web Token ", () =>
     //         }
     //         catch (exp)
     //         {
-    //             Assert.ok(exp instanceof InvalidTokenException);
-    //             Assert.equal(exp.message, `Token '${token}' is invalid because signature could not be verified.`);
+    //             assert.ok(exp instanceof InvalidTokenException);
+    //             assert.equal(exp.message, `Token '${token}' is invalid because signature could not be verified.`);
     //             return;
     //         }
-    //         Assert.ok(false);
+    //         assert.ok(false);
     //     });
-        
-        
-    //     test("should throw an exception when getting JWT when the token is tampered with", async () =>
+
+
+    //     await test("should throw an exception when getting JWT when the token is tampered with", async () =>
     //     {
     //         let claim1 = new Claim("this_claim", "ThisValue");
     //         let claim2 = new Claim("that_claim", "ThatValue");
@@ -293,12 +293,12 @@ suite("Json Web Token ", () =>
     //         }
     //         catch (exp)
     //         {
-    //             Assert.ok(exp instanceof InvalidTokenException);
-    //             Assert.equal(exp.message, `Token '${token}' is invalid because signature could not be verified.`);
+    //             assert.ok(exp instanceof InvalidTokenException);
+    //             assert.equal(exp.message, `Token '${token}' is invalid because signature could not be verified.`);
     //             return;
     //         }
-    //         Assert.ok(false);
+    //         assert.ok(false);
     //     });
     // });
-    
+
 });

package/test/other.test.ts

@@ -1,15 +1,16 @@
-import * as Assert from "assert";
+import assert from "node:assert";
+import { describe, test } from "node:test";
 
-suite("Other", () =>
+await describe("Other", async () =>
 {
-    test("encoding decoding", () =>
+    await test("encoding decoding", () =>
     {
         const text = "moonlight43iuj90/;msdnnksdkdkdk[[[][][";
         const encodedText = Buffer.from(text, "utf8").toString("base64");
-        Assert.notStrictEqual(encodedText, text);
-        
+        assert.notStrictEqual(encodedText, text);
+
         const decodedText = Buffer.from(encodedText, "base64").toString("utf8");
-        Assert.notStrictEqual(decodedText, encodedText);
-        Assert.strictEqual(decodedText, text);
+        assert.notStrictEqual(decodedText, encodedText);
+        assert.strictEqual(decodedText, text);
     });
 });

package/test/symmetric-encryption.test.ts

@@ -1,43 +1,44 @@
-import * as Assert from "assert";
-import { SymmetricEncryption } from "./../src/index";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { SymmetricEncryption } from "./../src/index.js";
 // import { CryptoException } from "./../src/crypto-exception";
 import "@nivinjoseph/n-ext";
 
 
-suite("SymmetricEncryption", () =>
+await describe("SymmetricEncryption", async () =>
 {
-    suite("generateKey", () =>
-    { 
-        test("must return string value that is not null, empty or whitespace", async () =>
+    await describe("generateKey", async () =>
+    {
+        await test("must return string value that is not null, empty or whitespace", async () =>
         {
             const key = await SymmetricEncryption.generateKey();
             console.log("key", key);
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            Assert.ok(key !== null && !key.isEmptyOrWhiteSpace());
+            assert.ok(key !== null && !key.isEmptyOrWhiteSpace());
         });
-        
-        
-        test("consecutive calls must yield unique values", async () =>
+
+
+        await test("consecutive calls must yield unique values", async () =>
         {
             const key1 = await SymmetricEncryption.generateKey();
             const key2 = await SymmetricEncryption.generateKey();
-            Assert.notStrictEqual(key1, key2);
+            assert.notStrictEqual(key1, key2);
         });
-    });    
-    
-    suite("encrypt", () =>
-    { 
-        test("must return cipher text value when called with key and plain text value", async () =>
+    });
+
+    await describe("encrypt", async () =>
+    {
+        await test("must return cipher text value when called with key and plain text value", async () =>
         {
             const key = "E25B269440F88601C453CD171D76EDDC11D8CF33230742DF8CAD5873D28F78B2";
             const value = "password";
             const encrypted = await SymmetricEncryption.encrypt(key, value);
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            Assert.ok(encrypted !== null);
-            Assert.notStrictEqual(encrypted, value);
+            assert.ok(encrypted !== null);
+            assert.notStrictEqual(encrypted, value);
         });
 
-        // test("encrypt with key as null throws CryptoException", async () =>
+        // await test("encrypt with key as null throws CryptoException", async () =>
         // {
         //     try
         //     {
@@ -52,7 +53,7 @@ suite("SymmetricEncryption", () =>
 
         // });
 
-        // test("encrypt with key as undefined throws CryptoException", async () =>
+        // await test("encrypt with key as undefined throws CryptoException", async () =>
         // {
         //     try
         //     {
@@ -65,8 +66,8 @@ suite("SymmetricEncryption", () =>
         //     }
         //     assert.ok(false);
         // }); 
-        
-        // test("encrypt", async () =>
+
+        // await test("encrypt", async () =>
         // {
         //     let key = await SymmetricEncryption.generateKey();
         //     let value = "password";
@@ -75,7 +76,7 @@ suite("SymmetricEncryption", () =>
         //     assert.notStrictEqual(value, encrypted);
         // });
 
-        // test("encrypt with key as null throws CryptoException", async () =>
+        // await test("encrypt with key as null throws CryptoException", async () =>
         // {
         //     try
         //     {
@@ -91,7 +92,7 @@ suite("SymmetricEncryption", () =>
 
         // });
 
-        // test("encrypt with value as null throws CryptoException", async () =>
+        // await test("encrypt with value as null throws CryptoException", async () =>
         // {
         //     try
         //     {
@@ -106,8 +107,8 @@ suite("SymmetricEncryption", () =>
         //     }
         //     assert.ok(false);
         // });
-        
-        // test("encrypt with value as undefined throws CryptoException", async () =>
+
+        // await test("encrypt with value as undefined throws CryptoException", async () =>
         // {
         //     try
         //     {
@@ -122,8 +123,8 @@ suite("SymmetricEncryption", () =>
         //     }
         //     assert.ok(false);
         // });
-        
-        // test("encrypt with value as empty string throws CryptoException", async () =>
+
+        // await test("encrypt with value as empty string throws CryptoException", async () =>
         // {
         //     try
         //     {
@@ -138,8 +139,8 @@ suite("SymmetricEncryption", () =>
         //     }
         //     assert.ok(false);
         // });
-        
-        // test("encrypt with key as empty string throws CryptoException", async () =>
+
+        // await test("encrypt with key as empty string throws CryptoException", async () =>
         // {
         //     try
         //     {
@@ -153,8 +154,8 @@ suite("SymmetricEncryption", () =>
         //     }
         //     assert.ok(false);
         // });
-        
-        // test("encrypt with invalid key as empty string throws CryptoException", async () =>
+
+        // await test("encrypt with invalid key as empty string throws CryptoException", async () =>
         // {
         //     try
         //     {
@@ -168,27 +169,27 @@ suite("SymmetricEncryption", () =>
         //     assert.ok(false);
         // });
     });
-    
-    suite("decrypt", () =>
+
+    await describe("decrypt", async () =>
     {
-        test("must return plain text value when called with key and cipher text value", async () =>
+        await test("must return plain text value when called with key and cipher text value", async () =>
         {
             const key = await SymmetricEncryption.generateKey();
             const value = "password";
             const encrypted = await SymmetricEncryption.encrypt(key, value);
             const decrypted = SymmetricEncryption.decrypt(key, encrypted);
-            Assert.strictEqual(decrypted, value);
+            assert.strictEqual(decrypted, value);
         });
-          
-        // test("decrypt with a valid encryption key", async () =>
+
+        // await test("decrypt with a valid encryption key", async () =>
         // {
         //     let key = await SymmetricEncryption.generateKey();
         //     let encryption = await SymmetricEncryption.encrypt(key, "password");
         //     let decryption = await SymmetricEncryption.decrypt(key, encryption);
         //     assert.strictEqual(decryption, "password");
         // });
-        
-        // test("decrypt with an invalid encryption key", async () =>
+
+        // await test("decrypt with an invalid encryption key", async () =>
         // {
         //     let key = await SymmetricEncryption.generateKey();
         //     let key2 = await SymmetricEncryption.generateKey();
@@ -196,8 +197,8 @@ suite("SymmetricEncryption", () =>
         //     let decryption = await SymmetricEncryption.decrypt(key2, encryption);
         //     assert.notStrictEqual(decryption, "password");
         // });
-        
-        // test("throws an CryptoException when key is null", async () =>
+
+        // await test("throws an CryptoException when key is null", async () =>
         // {
         //     try
         //     {
@@ -209,8 +210,8 @@ suite("SymmetricEncryption", () =>
         //         assert.strictEqual(exception.message, "Parameter count mismatch.");
         //     }
         // });
-        
-        // test("throws an CryptoException when value is null", async () =>
+
+        // await test("throws an CryptoException when value is null", async () =>
         // {
         //     try
         //     {
@@ -223,8 +224,8 @@ suite("SymmetricEncryption", () =>
         //         assert.strictEqual(exception.message, "Parameter count mismatch.");
         //     }
         // });
-        
-        // test("throws an CryptoException when value is empty string", async () =>
+
+        // await test("throws an CryptoException when value is empty string", async () =>
         // {
         //     try
         //     {
@@ -237,8 +238,8 @@ suite("SymmetricEncryption", () =>
         //         assert.strictEqual(exception.message, "Parameter count mismatch.");
         //     }
         // });
-        
-        // test("throws an CryptoException when key and value is empty string", async () =>
+
+        // await test("throws an CryptoException when key and value is empty string", async () =>
         // {
         //     try
         //     {

package/tsconfig.json

@@ -1,7 +1,10 @@
 {
     "compilerOptions": {
-        "module": "commonjs",
-        "target": "es2015",
+        "module": "NodeNext",
+        "target": "ES2017",
+        "lib": [
+            "ES2023"
+        ],
         "strict": true,
         "strictNullChecks": true,
         "strictFunctionTypes": true,
@@ -12,8 +15,6 @@
         "noFallthroughCasesInSwitch": true,
         "noEmitOnError": true,
         "sourceMap": true,
-        "experimentalDecorators": true,
-        "emitDecoratorMetadata": true,
         "removeComments": false,
         "forceConsistentCasingInFileNames": true,
         "incremental": false,
@@ -21,6 +22,8 @@
         "importHelpers": true,
         "noEmitHelpers": true,
         "noImplicitOverride": true,
-        "pretty": true
+        "pretty": true,
+        "esModuleInterop": false,
+        "allowSyntheticDefaultImports": true
     }
 }