From 95b9e5188a8e56e1d39705374748df6a55309457 Mon Sep 17 00:00:00 2001
From: Daniel Huigens <d.huigens@protonmail.com>
Date: Fri, 27 Apr 2018 11:32:13 +0200
Subject: [PATCH] Remove some ESLint silencers

---
 .eslintrc.js                          |  9 +--
 src/crypto/cipher/aes.js              |  8 +--
 src/crypto/cipher/cast5.js            | 96 +++++++++++++--------------
 src/crypto/cipher/des.js              | 92 ++++++++++++-------------
 src/crypto/cipher/twofish.js          |  3 +-
 src/crypto/hash/index.js              | 21 ++----
 src/crypto/index.js                   |  4 +-
 src/crypto/public_key/elliptic/key.js |  2 +
 src/key.js                            | 33 +++++----
 src/keyring/keyring.js                |  5 +-
 src/packet/all_packets.js             |  6 +-
 src/packet/index.js                   |  4 +-
 src/packet/packetlist.js              |  3 +-
 src/packet/secret_key.js              | 11 ++-
 src/packet/signature.js               | 47 ++++++-------
 src/util.js                           | 12 ++--
 src/worker/async_proxy.js             | 28 ++++----
 src/worker/worker.js                  |  4 +-
 test/crypto/cipher/des.js             |  2 +-
 19 files changed, 179 insertions(+), 211 deletions(-)

diff --git a/.eslintrc.js b/.eslintrc.js
index f142cfe0..37ab59c2 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -317,12 +317,9 @@ module.exports = {
 
     // Custom silencers:
     "camelcase": 0,
-    "no-debugger": 0,
     "require-await": 0,
     "no-multi-assign": 0,
     "no-underscore-dangle": 0,
-    "no-restricted-syntax": 0,
-    "one-var-declaration-per-line": 0,
 
     // Custom errors:
     "no-undef": 2,
@@ -330,6 +327,7 @@ module.exports = {
     "no-mixed-operators": [ 2, {"groups": [["&", "|", "^", "~", "<<", ">>", ">>>"], ["&&", "||"]]}],
     "no-use-before-define": [ 2, { "functions": false, "classes": true, "variables": false }],
     "no-unused-expressions": [ 2, { "allowShortCircuit": true } ],
+    "no-constant-condition": [ 2, { "checkLoops": false } ],
 
     // Custom warnings:
     "no-console": 0,
@@ -340,12 +338,7 @@ module.exports = {
     "valid-jsdoc": 0,
     "new-cap": [ 0, { "properties": false, "capIsNewExceptionPattern": "^type_.*" }],
     "no-lonely-if": 0,
-    "no-fallthrough": 0,
-    "no-invalid-this": 0,
     "import/extensions": 0,
-    "no-useless-escape": 0,
-    "no-array-constructor": 0,
-    "no-constant-condition": 0,
     "no-buffer-constructor": 0, // deprecated
   }
 };
diff --git a/src/crypto/cipher/aes.js b/src/crypto/cipher/aes.js
index 8749a718..1c345583 100644
--- a/src/crypto/cipher/aes.js
+++ b/src/crypto/cipher/aes.js
@@ -7,7 +7,7 @@ import { AES_ECB } from 'asmcrypto.js/src/aes/ecb/ecb';
 
 // TODO use webCrypto or nodeCrypto when possible.
 function aes(length) {
-  const c = function(key) {
+  const C = function(key) {
     const aes_ecb = new AES_ECB(key, _AES_heap_instance, _AES_asm_instance);
 
     this.encrypt = function(block) {
@@ -19,10 +19,10 @@ function aes(length) {
     };
   };
 
-  c.blockSize = c.prototype.blockSize = 16;
-  c.keySize = c.prototype.keySize = length / 8;
+  C.blockSize = C.prototype.blockSize = 16;
+  C.keySize = C.prototype.keySize = length / 8;
 
-  return c;
+  return C;
 }
 
 export default aes;
diff --git a/src/crypto/cipher/cast5.js b/src/crypto/cipher/cast5.js
index 821fb607..9b17050b 100644
--- a/src/crypto/cipher/cast5.js
+++ b/src/crypto/cipher/cast5.js
@@ -191,57 +191,57 @@ function OpenpgpSymencCast5() {
   const scheduleA = new Array(4);
 
   scheduleA[0] = new Array(4);
-  scheduleA[0][0] = new Array(4, 0, 0xd, 0xf, 0xc, 0xe, 0x8);
-  scheduleA[0][1] = new Array(5, 2, 16 + 0, 16 + 2, 16 + 1, 16 + 3, 0xa);
-  scheduleA[0][2] = new Array(6, 3, 16 + 7, 16 + 6, 16 + 5, 16 + 4, 9);
-  scheduleA[0][3] = new Array(7, 1, 16 + 0xa, 16 + 9, 16 + 0xb, 16 + 8, 0xb);
+  scheduleA[0][0] = [4, 0, 0xd, 0xf, 0xc, 0xe, 0x8];
+  scheduleA[0][1] = [5, 2, 16 + 0, 16 + 2, 16 + 1, 16 + 3, 0xa];
+  scheduleA[0][2] = [6, 3, 16 + 7, 16 + 6, 16 + 5, 16 + 4, 9];
+  scheduleA[0][3] = [7, 1, 16 + 0xa, 16 + 9, 16 + 0xb, 16 + 8, 0xb];
 
   scheduleA[1] = new Array(4);
-  scheduleA[1][0] = new Array(0, 6, 16 + 5, 16 + 7, 16 + 4, 16 + 6, 16 + 0);
-  scheduleA[1][1] = new Array(1, 4, 0, 2, 1, 3, 16 + 2);
-  scheduleA[1][2] = new Array(2, 5, 7, 6, 5, 4, 16 + 1);
-  scheduleA[1][3] = new Array(3, 7, 0xa, 9, 0xb, 8, 16 + 3);
+  scheduleA[1][0] = [0, 6, 16 + 5, 16 + 7, 16 + 4, 16 + 6, 16 + 0];
+  scheduleA[1][1] = [1, 4, 0, 2, 1, 3, 16 + 2];
+  scheduleA[1][2] = [2, 5, 7, 6, 5, 4, 16 + 1];
+  scheduleA[1][3] = [3, 7, 0xa, 9, 0xb, 8, 16 + 3];
 
   scheduleA[2] = new Array(4);
-  scheduleA[2][0] = new Array(4, 0, 0xd, 0xf, 0xc, 0xe, 8);
-  scheduleA[2][1] = new Array(5, 2, 16 + 0, 16 + 2, 16 + 1, 16 + 3, 0xa);
-  scheduleA[2][2] = new Array(6, 3, 16 + 7, 16 + 6, 16 + 5, 16 + 4, 9);
-  scheduleA[2][3] = new Array(7, 1, 16 + 0xa, 16 + 9, 16 + 0xb, 16 + 8, 0xb);
+  scheduleA[2][0] = [4, 0, 0xd, 0xf, 0xc, 0xe, 8];
+  scheduleA[2][1] = [5, 2, 16 + 0, 16 + 2, 16 + 1, 16 + 3, 0xa];
+  scheduleA[2][2] = [6, 3, 16 + 7, 16 + 6, 16 + 5, 16 + 4, 9];
+  scheduleA[2][3] = [7, 1, 16 + 0xa, 16 + 9, 16 + 0xb, 16 + 8, 0xb];
 
 
   scheduleA[3] = new Array(4);
-  scheduleA[3][0] = new Array(0, 6, 16 + 5, 16 + 7, 16 + 4, 16 + 6, 16 + 0);
-  scheduleA[3][1] = new Array(1, 4, 0, 2, 1, 3, 16 + 2);
-  scheduleA[3][2] = new Array(2, 5, 7, 6, 5, 4, 16 + 1);
-  scheduleA[3][3] = new Array(3, 7, 0xa, 9, 0xb, 8, 16 + 3);
+  scheduleA[3][0] = [0, 6, 16 + 5, 16 + 7, 16 + 4, 16 + 6, 16 + 0];
+  scheduleA[3][1] = [1, 4, 0, 2, 1, 3, 16 + 2];
+  scheduleA[3][2] = [2, 5, 7, 6, 5, 4, 16 + 1];
+  scheduleA[3][3] = [3, 7, 0xa, 9, 0xb, 8, 16 + 3];
 
   const scheduleB = new Array(4);
 
   scheduleB[0] = new Array(4);
-  scheduleB[0][0] = new Array(16 + 8, 16 + 9, 16 + 7, 16 + 6, 16 + 2);
-  scheduleB[0][1] = new Array(16 + 0xa, 16 + 0xb, 16 + 5, 16 + 4, 16 + 6);
-  scheduleB[0][2] = new Array(16 + 0xc, 16 + 0xd, 16 + 3, 16 + 2, 16 + 9);
-  scheduleB[0][3] = new Array(16 + 0xe, 16 + 0xf, 16 + 1, 16 + 0, 16 + 0xc);
+  scheduleB[0][0] = [16 + 8, 16 + 9, 16 + 7, 16 + 6, 16 + 2];
+  scheduleB[0][1] = [16 + 0xa, 16 + 0xb, 16 + 5, 16 + 4, 16 + 6];
+  scheduleB[0][2] = [16 + 0xc, 16 + 0xd, 16 + 3, 16 + 2, 16 + 9];
+  scheduleB[0][3] = [16 + 0xe, 16 + 0xf, 16 + 1, 16 + 0, 16 + 0xc];
 
   scheduleB[1] = new Array(4);
-  scheduleB[1][0] = new Array(3, 2, 0xc, 0xd, 8);
-  scheduleB[1][1] = new Array(1, 0, 0xe, 0xf, 0xd);
-  scheduleB[1][2] = new Array(7, 6, 8, 9, 3);
-  scheduleB[1][3] = new Array(5, 4, 0xa, 0xb, 7);
+  scheduleB[1][0] = [3, 2, 0xc, 0xd, 8];
+  scheduleB[1][1] = [1, 0, 0xe, 0xf, 0xd];
+  scheduleB[1][2] = [7, 6, 8, 9, 3];
+  scheduleB[1][3] = [5, 4, 0xa, 0xb, 7];
 
 
   scheduleB[2] = new Array(4);
-  scheduleB[2][0] = new Array(16 + 3, 16 + 2, 16 + 0xc, 16 + 0xd, 16 + 9);
-  scheduleB[2][1] = new Array(16 + 1, 16 + 0, 16 + 0xe, 16 + 0xf, 16 + 0xc);
-  scheduleB[2][2] = new Array(16 + 7, 16 + 6, 16 + 8, 16 + 9, 16 + 2);
-  scheduleB[2][3] = new Array(16 + 5, 16 + 4, 16 + 0xa, 16 + 0xb, 16 + 6);
+  scheduleB[2][0] = [16 + 3, 16 + 2, 16 + 0xc, 16 + 0xd, 16 + 9];
+  scheduleB[2][1] = [16 + 1, 16 + 0, 16 + 0xe, 16 + 0xf, 16 + 0xc];
+  scheduleB[2][2] = [16 + 7, 16 + 6, 16 + 8, 16 + 9, 16 + 2];
+  scheduleB[2][3] = [16 + 5, 16 + 4, 16 + 0xa, 16 + 0xb, 16 + 6];
 
 
   scheduleB[3] = new Array(4);
-  scheduleB[3][0] = new Array(8, 9, 7, 6, 3);
-  scheduleB[3][1] = new Array(0xa, 0xb, 5, 4, 7);
-  scheduleB[3][2] = new Array(0xc, 0xd, 3, 2, 8);
-  scheduleB[3][3] = new Array(0xe, 0xf, 1, 0, 0xd);
+  scheduleB[3][0] = [8, 9, 7, 6, 3];
+  scheduleB[3][1] = [0xa, 0xb, 5, 4, 7];
+  scheduleB[3][2] = [0xc, 0xd, 3, 2, 8];
+  scheduleB[3][3] = [0xe, 0xf, 1, 0, 0xd];
 
   // changed 'in' to 'inn' (in javascript 'in' is a reserved word)
   this.keySchedule = function(inn) {
@@ -314,7 +314,7 @@ function OpenpgpSymencCast5() {
   }
 
   const sBox = new Array(8);
-  sBox[0] = new Array(
+  sBox[0] = [
     0x30fb40d4, 0x9fa0ff0b, 0x6beccd2f, 0x3f258c7a, 0x1e213f2f, 0x9c004dd3, 0x6003e540, 0xcf9fc949,
     0xbfd4af27, 0x88bbbdb5, 0xe2034090, 0x98d09675, 0x6e63a0e0, 0x15c361d2, 0xc2e7661d, 0x22d4ff8e,
     0x28683b6f, 0xc07fd059, 0xff2379c8, 0x775f50e2, 0x43c340d3, 0xdf2f8656, 0x887ca41a, 0xa2d2bd2d,
@@ -347,9 +347,9 @@ function OpenpgpSymencCast5() {
     0x474d6ad7, 0x7c0c5e5c, 0xd1231959, 0x381b7298, 0xf5d2f4db, 0xab838653, 0x6e2f1e23, 0x83719c9e,
     0xbd91e046, 0x9a56456e, 0xdc39200c, 0x20c8c571, 0x962bda1c, 0xe1e696ff, 0xb141ab08, 0x7cca89b9,
     0x1a69e783, 0x02cc4843, 0xa2f7c579, 0x429ef47d, 0x427b169c, 0x5ac9f049, 0xdd8f0f00, 0x5c8165bf
-  );
+  ];
 
-  sBox[1] = new Array(
+  sBox[1] = [
     0x1f201094, 0xef0ba75b, 0x69e3cf7e, 0x393f4380, 0xfe61cf7a, 0xeec5207a, 0x55889c94, 0x72fc0651,
     0xada7ef79, 0x4e1d7235, 0xd55a63ce, 0xde0436ba, 0x99c430ef, 0x5f0c0794, 0x18dcdb7d, 0xa1d6eff3,
     0xa0b52f7b, 0x59e83605, 0xee15b094, 0xe9ffd909, 0xdc440086, 0xef944459, 0xba83ccb3, 0xe0c3cdfb,
@@ -382,9 +382,9 @@ function OpenpgpSymencCast5() {
     0xb284600c, 0xd835731d, 0xdcb1c647, 0xac4c56ea, 0x3ebd81b3, 0x230eabb0, 0x6438bc87, 0xf0b5b1fa,
     0x8f5ea2b3, 0xfc184642, 0x0a036b7a, 0x4fb089bd, 0x649da589, 0xa345415e, 0x5c038323, 0x3e5d3bb9,
     0x43d79572, 0x7e6dd07c, 0x06dfdf1e, 0x6c6cc4ef, 0x7160a539, 0x73bfbe70, 0x83877605, 0x4523ecf1
-  );
+  ];
 
-  sBox[2] = new Array(
+  sBox[2] = [
     0x8defc240, 0x25fa5d9f, 0xeb903dbf, 0xe810c907, 0x47607fff, 0x369fe44b, 0x8c1fc644, 0xaececa90,
     0xbeb1f9bf, 0xeefbcaea, 0xe8cf1950, 0x51df07ae, 0x920e8806, 0xf0ad0548, 0xe13c8d83, 0x927010d5,
     0x11107d9f, 0x07647db9, 0xb2e3e4d4, 0x3d4f285e, 0xb9afa820, 0xfade82e0, 0xa067268b, 0x8272792e,
@@ -417,9 +417,9 @@ function OpenpgpSymencCast5() {
     0x5727c148, 0x2be98a1d, 0x8ab41738, 0x20e1be24, 0xaf96da0f, 0x68458425, 0x99833be5, 0x600d457d,
     0x282f9350, 0x8334b362, 0xd91d1120, 0x2b6d8da0, 0x642b1e31, 0x9c305a00, 0x52bce688, 0x1b03588a,
     0xf7baefd5, 0x4142ed9c, 0xa4315c11, 0x83323ec5, 0xdfef4636, 0xa133c501, 0xe9d3531c, 0xee353783
-  );
+  ];
 
-  sBox[3] = new Array(
+  sBox[3] = [
     0x9db30420, 0x1fb6e9de, 0xa7be7bef, 0xd273a298, 0x4a4f7bdb, 0x64ad8c57, 0x85510443, 0xfa020ed1,
     0x7e287aff, 0xe60fb663, 0x095f35a1, 0x79ebf120, 0xfd059d43, 0x6497b7b1, 0xf3641f63, 0x241e4adf,
     0x28147f5f, 0x4fa2b8cd, 0xc9430040, 0x0cc32220, 0xfdd30b30, 0xc0a5374f, 0x1d2d00d9, 0x24147b15,
@@ -452,9 +452,9 @@ function OpenpgpSymencCast5() {
     0xb5676e69, 0x9bd3ddda, 0xdf7e052f, 0xdb25701c, 0x1b5e51ee, 0xf65324e6, 0x6afce36c, 0x0316cc04,
     0x8644213e, 0xb7dc59d0, 0x7965291f, 0xccd6fd43, 0x41823979, 0x932bcdf6, 0xb657c34d, 0x4edfd282,
     0x7ae5290c, 0x3cb9536b, 0x851e20fe, 0x9833557e, 0x13ecf0b0, 0xd3ffb372, 0x3f85c5c1, 0x0aef7ed2
-  );
+  ];
 
-  sBox[4] = new Array(
+  sBox[4] = [
     0x7ec90c04, 0x2c6e74b9, 0x9b0e66df, 0xa6337911, 0xb86a7fff, 0x1dd358f5, 0x44dd9d44, 0x1731167f,
     0x08fbf1fa, 0xe7f511cc, 0xd2051b00, 0x735aba00, 0x2ab722d8, 0x386381cb, 0xacf6243a, 0x69befd7a,
     0xe6a2e77f, 0xf0c720cd, 0xc4494816, 0xccf5c180, 0x38851640, 0x15b0a848, 0xe68b18cb, 0x4caadeff,
@@ -487,9 +487,9 @@ function OpenpgpSymencCast5() {
     0x5ce96c28, 0xe176eda3, 0x6bac307f, 0x376829d2, 0x85360fa9, 0x17e3fe2a, 0x24b79767, 0xf5a96b20,
     0xd6cd2595, 0x68ff1ebf, 0x7555442c, 0xf19f06be, 0xf9e0659a, 0xeeb9491d, 0x34010718, 0xbb30cab8,
     0xe822fe15, 0x88570983, 0x750e6249, 0xda627e55, 0x5e76ffa8, 0xb1534546, 0x6d47de08, 0xefe9e7d4
-  );
+  ];
 
-  sBox[5] = new Array(
+  sBox[5] = [
     0xf6fa8f9d, 0x2cac6ce1, 0x4ca34867, 0xe2337f7c, 0x95db08e7, 0x016843b4, 0xeced5cbc, 0x325553ac,
     0xbf9f0960, 0xdfa1e2ed, 0x83f0579d, 0x63ed86b9, 0x1ab6a6b8, 0xde5ebe39, 0xf38ff732, 0x8989b138,
     0x33f14961, 0xc01937bd, 0xf506c6da, 0xe4625e7e, 0xa308ea99, 0x4e23e33c, 0x79cbd7cc, 0x48a14367,
@@ -522,9 +522,9 @@ function OpenpgpSymencCast5() {
     0xb81a928a, 0x60ed5869, 0x97c55b96, 0xeaec991b, 0x29935913, 0x01fdb7f1, 0x088e8dfa, 0x9ab6f6f5,
     0x3b4cbf9f, 0x4a5de3ab, 0xe6051d35, 0xa0e1d855, 0xd36b4cf1, 0xf544edeb, 0xb0e93524, 0xbebb8fbd,
     0xa2d762cf, 0x49c92f54, 0x38b5f331, 0x7128a454, 0x48392905, 0xa65b1db8, 0x851c97bd, 0xd675cf2f
-  );
+  ];
 
-  sBox[6] = new Array(
+  sBox[6] = [
     0x85e04019, 0x332bf567, 0x662dbfff, 0xcfc65693, 0x2a8d7f6f, 0xab9bc912, 0xde6008a1, 0x2028da1f,
     0x0227bce7, 0x4d642916, 0x18fac300, 0x50f18b82, 0x2cb2cb11, 0xb232e75c, 0x4b3695f2, 0xb28707de,
     0xa05fbcf6, 0xcd4181e9, 0xe150210c, 0xe24ef1bd, 0xb168c381, 0xfde4e789, 0x5c79b0d8, 0x1e8bfd43,
@@ -557,9 +557,9 @@ function OpenpgpSymencCast5() {
     0x97fd61a9, 0xea7759f4, 0x2d57539d, 0x569a58cf, 0xe84e63ad, 0x462e1b78, 0x6580f87e, 0xf3817914,
     0x91da55f4, 0x40a230f3, 0xd1988f35, 0xb6e318d2, 0x3ffa50bc, 0x3d40f021, 0xc3c0bdae, 0x4958c24c,
     0x518f36b2, 0x84b1d370, 0x0fedce83, 0x878ddada, 0xf2a279c7, 0x94e01be8, 0x90716f4b, 0x954b8aa3
-  );
+  ];
 
-  sBox[7] = new Array(
+  sBox[7] = [
     0xe216300d, 0xbbddfffc, 0xa7ebdabd, 0x35648095, 0x7789f8b7, 0xe6c1121b, 0x0e241600, 0x052ce8b5,
     0x11a9cfb0, 0xe5952f11, 0xece7990a, 0x9386d174, 0x2a42931c, 0x76e38111, 0xb12def3a, 0x37ddddfc,
     0xde9adeb1, 0x0a0cc32c, 0xbe197029, 0x84a00940, 0xbb243a0f, 0xb4d137cf, 0xb44e79f0, 0x049eedfd,
@@ -592,7 +592,7 @@ function OpenpgpSymencCast5() {
     0x5938fa0f, 0x42399ef3, 0x36997b07, 0x0e84093d, 0x4aa93e61, 0x8360d87b, 0x1fa98b0c, 0x1149382c,
     0xe97625a5, 0x0614d1b7, 0x0e25244b, 0x0c768347, 0x589e8d82, 0x0d2059d1, 0xa466bb1e, 0xf8da0a82,
     0x04f19130, 0xba6e4ec0, 0x99265164, 0x1ee7230d, 0x50b2ad80, 0xeaee6801, 0x8db2a283, 0xea8bf59e
-  );
+  ];
 }
 
 function Cast5(key) {
diff --git a/src/crypto/cipher/des.js b/src/crypto/cipher/des.js
index b8598e6c..2cd394e4 100644
--- a/src/crypto/cipher/des.js
+++ b/src/crypto/cipher/des.js
@@ -23,15 +23,15 @@
 
 function des(keys, message, encrypt, mode, iv, padding) {
   //declaring this locally speeds things up a bit
-  const spfunction1 = new Array(
+  const spfunction1 = [
     0x1010400, 0, 0x10000, 0x1010404, 0x1010004, 0x10404, 0x4, 0x10000, 0x400, 0x1010400,
     0x1010404, 0x400, 0x1000404, 0x1010004, 0x1000000, 0x4, 0x404, 0x1000400, 0x1000400, 0x10400, 0x10400, 0x1010000,
     0x1010000, 0x1000404, 0x10004, 0x1000004, 0x1000004, 0x10004, 0, 0x404, 0x10404, 0x1000000, 0x10000, 0x1010404, 0x4,
     0x1010000, 0x1010400, 0x1000000, 0x1000000, 0x400, 0x1010004, 0x10000, 0x10400, 0x1000004, 0x400, 0x4, 0x1000404,
     0x10404, 0x1010404, 0x10004, 0x1010000, 0x1000404, 0x1000004, 0x404, 0x10404, 0x1010400, 0x404, 0x1000400,
     0x1000400, 0, 0x10004, 0x10400, 0, 0x1010004
-  );
-  const spfunction2 = new Array(
+  ];
+  const spfunction2 = [
     -0x7fef7fe0, -0x7fff8000, 0x8000, 0x108020, 0x100000, 0x20, -0x7fefffe0, -0x7fff7fe0,
     -0x7fffffe0, -0x7fef7fe0, -0x7fef8000, -0x80000000, -0x7fff8000, 0x100000, 0x20, -0x7fefffe0, 0x108000, 0x100020,
     -0x7fff7fe0, 0, -0x80000000, 0x8000, 0x108020, -0x7ff00000, 0x100020, -0x7fffffe0, 0, 0x108000, 0x8020, -0x7fef8000,
@@ -39,23 +39,23 @@ function des(keys, message, encrypt, mode, iv, padding) {
     -0x7fff8000, 0x20, -0x7fef7fe0, 0x108020, 0x20, 0x8000, -0x80000000, 0x8020, -0x7fef8000, 0x100000, -0x7fffffe0,
     0x100020, -0x7fff7fe0, -0x7fffffe0, 0x100020, 0x108000, 0, -0x7fff8000, 0x8020, -0x80000000, -0x7fefffe0,
     -0x7fef7fe0, 0x108000
-  );
-  const spfunction3 = new Array(
+  ];
+  const spfunction3 = [
     0x208, 0x8020200, 0, 0x8020008, 0x8000200, 0, 0x20208, 0x8000200, 0x20008, 0x8000008,
     0x8000008, 0x20000, 0x8020208, 0x20008, 0x8020000, 0x208, 0x8000000, 0x8, 0x8020200, 0x200, 0x20200, 0x8020000,
     0x8020008, 0x20208, 0x8000208, 0x20200, 0x20000, 0x8000208, 0x8, 0x8020208, 0x200, 0x8000000, 0x8020200, 0x8000000,
     0x20008, 0x208, 0x20000, 0x8020200, 0x8000200, 0, 0x200, 0x20008, 0x8020208, 0x8000200, 0x8000008, 0x200, 0,
     0x8020008, 0x8000208, 0x20000, 0x8000000, 0x8020208, 0x8, 0x20208, 0x20200, 0x8000008, 0x8020000, 0x8000208, 0x208,
     0x8020000, 0x20208, 0x8, 0x8020008, 0x20200
-  );
-  const spfunction4 = new Array(
+  ];
+  const spfunction4 = [
     0x802001, 0x2081, 0x2081, 0x80, 0x802080, 0x800081, 0x800001, 0x2001, 0, 0x802000,
     0x802000, 0x802081, 0x81, 0, 0x800080, 0x800001, 0x1, 0x2000, 0x800000, 0x802001, 0x80, 0x800000, 0x2001, 0x2080,
     0x800081, 0x1, 0x2080, 0x800080, 0x2000, 0x802080, 0x802081, 0x81, 0x800080, 0x800001, 0x802000, 0x802081, 0x81, 0,
     0, 0x802000, 0x2080, 0x800080, 0x800081, 0x1, 0x802001, 0x2081, 0x2081, 0x80, 0x802081, 0x81, 0x1, 0x2000, 0x800001,
     0x2001, 0x802080, 0x800081, 0x2001, 0x2080, 0x800000, 0x802001, 0x80, 0x800000, 0x2000, 0x802080
-  );
-  const spfunction5 = new Array(
+  ];
+  const spfunction5 = [
     0x100, 0x2080100, 0x2080000, 0x42000100, 0x80000, 0x100, 0x40000000, 0x2080000,
     0x40080100, 0x80000, 0x2000100, 0x40080100, 0x42000100, 0x42080000, 0x80100, 0x40000000, 0x2000000, 0x40080000,
     0x40080000, 0, 0x40000100, 0x42080100, 0x42080100, 0x2000100, 0x42080000, 0x40000100, 0, 0x42000000, 0x2080100,
@@ -63,31 +63,31 @@ function des(keys, message, encrypt, mode, iv, padding) {
     0x40080100, 0x2000100, 0x40000000, 0x42080000, 0x2080100, 0x40080100, 0x100, 0x2000000, 0x42080000, 0x42080100,
     0x80100, 0x42000000, 0x42080100, 0x2080000, 0, 0x40080000, 0x42000000, 0x80100, 0x2000100, 0x40000100, 0x80000, 0,
     0x40080000, 0x2080100, 0x40000100
-  );
-  const spfunction6 = new Array(
+  ];
+  const spfunction6 = [
     0x20000010, 0x20400000, 0x4000, 0x20404010, 0x20400000, 0x10, 0x20404010, 0x400000,
     0x20004000, 0x404010, 0x400000, 0x20000010, 0x400010, 0x20004000, 0x20000000, 0x4010, 0, 0x400010, 0x20004010,
     0x4000, 0x404000, 0x20004010, 0x10, 0x20400010, 0x20400010, 0, 0x404010, 0x20404000, 0x4010, 0x404000, 0x20404000,
     0x20000000, 0x20004000, 0x10, 0x20400010, 0x404000, 0x20404010, 0x400000, 0x4010, 0x20000010, 0x400000, 0x20004000,
     0x20000000, 0x4010, 0x20000010, 0x20404010, 0x404000, 0x20400000, 0x404010, 0x20404000, 0, 0x20400010, 0x10, 0x4000,
     0x20400000, 0x404010, 0x4000, 0x400010, 0x20004010, 0, 0x20404000, 0x20000000, 0x400010, 0x20004010
-  );
-  const spfunction7 = new Array(
+  ];
+  const spfunction7 = [
     0x200000, 0x4200002, 0x4000802, 0, 0x800, 0x4000802, 0x200802, 0x4200800, 0x4200802,
     0x200000, 0, 0x4000002, 0x2, 0x4000000, 0x4200002, 0x802, 0x4000800, 0x200802, 0x200002, 0x4000800, 0x4000002,
     0x4200000, 0x4200800, 0x200002, 0x4200000, 0x800, 0x802, 0x4200802, 0x200800, 0x2, 0x4000000, 0x200800, 0x4000000,
     0x200800, 0x200000, 0x4000802, 0x4000802, 0x4200002, 0x4200002, 0x2, 0x200002, 0x4000000, 0x4000800, 0x200000,
     0x4200800, 0x802, 0x200802, 0x4200800, 0x802, 0x4000002, 0x4200802, 0x4200000, 0x200800, 0, 0x2, 0x4200802, 0,
     0x200802, 0x4200000, 0x800, 0x4000002, 0x4000800, 0x800, 0x200002
-  );
-  const spfunction8 = new Array(
+  ];
+  const spfunction8 = [
     0x10001040, 0x1000, 0x40000, 0x10041040, 0x10000000, 0x10001040, 0x40, 0x10000000,
     0x40040, 0x10040000, 0x10041040, 0x41000, 0x10041000, 0x41040, 0x1000, 0x40, 0x10040000, 0x10000040, 0x10001000,
     0x1040, 0x41000, 0x40040, 0x10040040, 0x10041000, 0x1040, 0, 0, 0x10040040, 0x10000040, 0x10001000, 0x41040,
     0x40000, 0x41040, 0x40000, 0x10041000, 0x1000, 0x40, 0x10040040, 0x1000, 0x41040, 0x10001000, 0x40, 0x10000040,
     0x10040000, 0x10040040, 0x10000000, 0x40000, 0x10001040, 0, 0x10041040, 0x40040, 0x10000040, 0x10040000, 0x10001000,
     0x10001040, 0, 0x10041040, 0x41000, 0x41000, 0x1040, 0x1040, 0x40040, 0x10000000, 0x10041000
-  );
+  ];
 
   //create the 16 or 48 subkeys we will need
   let m = 0;
@@ -110,9 +110,9 @@ function des(keys, message, encrypt, mode, iv, padding) {
   //set up the loops for single and triple des
   const iterations = keys.length === 32 ? 3 : 9; //single or triple des
   if (iterations === 3) {
-    looping = encrypt ? new Array(0, 32, 2) : new Array(30, -2, -2);
+    looping = encrypt ? [0, 32, 2] : [30, -2, -2];
   } else {
-    looping = encrypt ? new Array(0, 32, 2, 62, 30, -2, 64, 96, 2) : new Array(94, 62, -2, 32, 64, 2, 30, -2, -2);
+    looping = encrypt ? [0, 32, 2, 62, 30, -2, 64, 96, 2] : [94, 62, -2, 32, 64, 2, 30, -2, -2];
   }
 
   //pad the message depending on the padding parameter
@@ -247,66 +247,66 @@ function des(keys, message, encrypt, mode, iv, padding) {
 
 function des_createKeys(key) {
   //declaring this locally speeds things up a bit
-  const pc2bytes0 = new Array(
+  const pc2bytes0 = [
     0, 0x4, 0x20000000, 0x20000004, 0x10000, 0x10004, 0x20010000, 0x20010004, 0x200, 0x204,
     0x20000200, 0x20000204, 0x10200, 0x10204, 0x20010200, 0x20010204
-  );
-  const pc2bytes1 = new Array(
+  ];
+  const pc2bytes1 = [
     0, 0x1, 0x100000, 0x100001, 0x4000000, 0x4000001, 0x4100000, 0x4100001, 0x100, 0x101, 0x100100,
     0x100101, 0x4000100, 0x4000101, 0x4100100, 0x4100101
-  );
-  const pc2bytes2 = new Array(
+  ];
+  const pc2bytes2 = [
     0, 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808, 0, 0x8, 0x800, 0x808,
     0x1000000, 0x1000008, 0x1000800, 0x1000808
-  );
-  const pc2bytes3 = new Array(
+  ];
+  const pc2bytes3 = [
     0, 0x200000, 0x8000000, 0x8200000, 0x2000, 0x202000, 0x8002000, 0x8202000, 0x20000, 0x220000,
     0x8020000, 0x8220000, 0x22000, 0x222000, 0x8022000, 0x8222000
-  );
-  const pc2bytes4 = new Array(
+  ];
+  const pc2bytes4 = [
     0, 0x40000, 0x10, 0x40010, 0, 0x40000, 0x10, 0x40010, 0x1000, 0x41000, 0x1010, 0x41010, 0x1000,
     0x41000, 0x1010, 0x41010
-  );
-  const pc2bytes5 = new Array(
+  ];
+  const pc2bytes5 = [
     0, 0x400, 0x20, 0x420, 0, 0x400, 0x20, 0x420, 0x2000000, 0x2000400, 0x2000020, 0x2000420,
     0x2000000, 0x2000400, 0x2000020, 0x2000420
-  );
-  const pc2bytes6 = new Array(
+  ];
+  const pc2bytes6 = [
     0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002, 0x10080002, 0, 0x10000000,
     0x80000, 0x10080000, 0x2, 0x10000002, 0x80002, 0x10080002
-  );
-  const pc2bytes7 = new Array(
+  ];
+  const pc2bytes7 = [
     0, 0x10000, 0x800, 0x10800, 0x20000000, 0x20010000, 0x20000800, 0x20010800, 0x20000, 0x30000,
     0x20800, 0x30800, 0x20020000, 0x20030000, 0x20020800, 0x20030800
-  );
-  const pc2bytes8 = new Array(
+  ];
+  const pc2bytes8 = [
     0, 0x40000, 0, 0x40000, 0x2, 0x40002, 0x2, 0x40002, 0x2000000, 0x2040000, 0x2000000, 0x2040000,
     0x2000002, 0x2040002, 0x2000002, 0x2040002
-  );
-  const pc2bytes9 = new Array(
+  ];
+  const pc2bytes9 = [
     0, 0x10000000, 0x8, 0x10000008, 0, 0x10000000, 0x8, 0x10000008, 0x400, 0x10000400, 0x408,
     0x10000408, 0x400, 0x10000400, 0x408, 0x10000408
-  );
-  const pc2bytes10 = new Array(
+  ];
+  const pc2bytes10 = [
     0, 0x20, 0, 0x20, 0x100000, 0x100020, 0x100000, 0x100020, 0x2000, 0x2020, 0x2000, 0x2020,
     0x102000, 0x102020, 0x102000, 0x102020
-  );
-  const pc2bytes11 = new Array(
+  ];
+  const pc2bytes11 = [
     0, 0x1000000, 0x200, 0x1000200, 0x200000, 0x1200000, 0x200200, 0x1200200, 0x4000000, 0x5000000,
     0x4000200, 0x5000200, 0x4200000, 0x5200000, 0x4200200, 0x5200200
-  );
-  const pc2bytes12 = new Array(
+  ];
+  const pc2bytes12 = [
     0, 0x1000, 0x8000000, 0x8001000, 0x80000, 0x81000, 0x8080000, 0x8081000, 0x10, 0x1010,
     0x8000010, 0x8001010, 0x80010, 0x81010, 0x8080010, 0x8081010
-  );
-  const pc2bytes13 = new Array(0, 0x4, 0x100, 0x104, 0, 0x4, 0x100, 0x104, 0x1, 0x5, 0x101, 0x105, 0x1, 0x5, 0x101, 0x105);
+  ];
+  const pc2bytes13 = [0, 0x4, 0x100, 0x104, 0, 0x4, 0x100, 0x104, 0x1, 0x5, 0x101, 0x105, 0x1, 0x5, 0x101, 0x105];
 
   //how many iterations (1 for des, 3 for triple des)
   const iterations = key.length > 8 ? 3 : 1; //changed by Paul 16/6/2007 to use Triple DES for 9+ byte keys
   //stores the return keys
   const keys = new Array(32 * iterations);
   //now define the left shifts which need to be done
-  const shifts = new Array(0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0);
+  const shifts = [0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0];
   //other variables
   let lefttemp;
   let righttemp;
diff --git a/src/crypto/cipher/twofish.js b/src/crypto/cipher/twofish.js
index 2b3d77dd..bed3fdb4 100644
--- a/src/crypto/cipher/twofish.js
+++ b/src/crypto/cipher/twofish.js
@@ -1,4 +1,5 @@
-/* eslint-disable no-mixed-operators */
+/* eslint-disable no-mixed-operators, no-fallthrough */
+
 
 /* Modified by Recurity Labs GmbH
  *
diff --git a/src/crypto/hash/index.js b/src/crypto/hash/index.js
index a8501a77..ffe66b89 100644
--- a/src/crypto/hash/index.js
+++ b/src/crypto/hash/index.js
@@ -122,25 +122,18 @@ export default {
    */
   getHashByteLength: function(algo) {
     switch (algo) {
-      case 1:
-        // - MD5 [HAC]
+      case 1: // - MD5 [HAC]
         return 16;
-      case 2:
-        // - SHA-1 [FIPS180]
-      case 3:
-        // - RIPE-MD/160 [HAC]
+      case 2: // - SHA-1 [FIPS180]
+      case 3: // - RIPE-MD/160 [HAC]
         return 20;
-      case 8:
-        // - SHA256 [FIPS180]
+      case 8: // - SHA256 [FIPS180]
         return 32;
-      case 9:
-        // - SHA384 [FIPS180]
+      case 9: // - SHA384 [FIPS180]
         return 48;
-      case 10:
-        // - SHA512 [FIPS180]
+      case 10: // - SHA512 [FIPS180]
         return 64;
-      case 11:
-        // - SHA224 [FIPS180]
+      case 11: // - SHA224 [FIPS180]
         return 28;
       default:
         throw new Error('Invalid hash algorithm.');
diff --git a/src/crypto/index.js b/src/crypto/index.js
index d70f36bb..c136af1e 100644
--- a/src/crypto/index.js
+++ b/src/crypto/index.js
@@ -52,8 +52,6 @@ const mod = {
   aes_kw: aes_kw
 };
 
-for (const i in crypto) {
-  mod[i] = crypto[i];
-}
+Object.assign(mod, crypto);
 
 export default mod;
diff --git a/src/crypto/public_key/elliptic/key.js b/src/crypto/public_key/elliptic/key.js
index f74e0a9b..6c591a30 100644
--- a/src/crypto/public_key/elliptic/key.js
+++ b/src/crypto/public_key/elliptic/key.js
@@ -229,6 +229,8 @@ async function nodeVerify(curve, hash_algo, { r, s }, message, publicKey) {
 // Originally written by Owen Smith https://github.com/omsmith
 // Adapted on Feb 2018 from https://github.com/Brightspace/node-jwk-to-pem/
 
+/* eslint-disable no-invalid-this */
+
 const asn1 = nodeCrypto ? require('asn1.js') : undefined;
 
 const ECDSASignature = nodeCrypto ?
diff --git a/src/key.js b/src/key.js
index 0d58a2a3..7654faaf 100644
--- a/src/key.js
+++ b/src/key.js
@@ -527,7 +527,6 @@ Key.prototype.getPrimaryUser = async function(date=new Date()) {
  * @param  {module:key.Key} key Source key to merge
  */
 Key.prototype.update = async function(key) {
-  const that = this;
   if (await key.verifyPrimaryKey() === enums.keyStatus.invalid) {
     return;
   }
@@ -537,8 +536,8 @@ Key.prototype.update = async function(key) {
   if (this.isPublic() && key.isPrivate()) {
     // check for equal subkey packets
     const equal = (this.subKeys.length === key.subKeys.length) &&
-          (this.subKeys.every(function(destSubKey) {
-            return key.subKeys.some(function(srcSubKey) {
+          (this.subKeys.every(destSubKey => {
+            return key.subKeys.some(srcSubKey => {
               return destSubKey.subKey.getFingerprint() === srcSubKey.subKey.getFingerprint();
             });
           }));
@@ -548,38 +547,38 @@ Key.prototype.update = async function(key) {
     this.primaryKey = key.primaryKey;
   }
   // revocation signatures
-  await mergeSignatures(key, this, 'revocationSignatures', function(srcRevSig) {
-    return isDataRevoked(that.primaryKey, that, [srcRevSig], null, key.primaryKey);
+  await mergeSignatures(key, this, 'revocationSignatures', srcRevSig => {
+    return isDataRevoked(this.primaryKey, this, [srcRevSig], null, key.primaryKey);
   });
   // direct signatures
   await mergeSignatures(key, this, 'directSignatures');
   // TODO replace when Promise.some or Promise.any are implemented
   // users
-  await Promise.all(key.users.map(async function(srcUser) {
+  await Promise.all(key.users.map(async srcUser => {
     let found = false;
-    await Promise.all(that.users.map(async function(dstUser) {
+    await Promise.all(this.users.map(async dstUser => {
       if ((srcUser.userId && (srcUser.userId.userid === dstUser.userId.userid)) ||
           (srcUser.userAttribute && (srcUser.userAttribute.equals(dstUser.userAttribute)))) {
-        await dstUser.update(srcUser, that.primaryKey);
+        await dstUser.update(srcUser, this.primaryKey);
         found = true;
       }
     }));
     if (!found) {
-      that.users.push(srcUser);
+      this.users.push(srcUser);
     }
   }));
   // TODO replace when Promise.some or Promise.any are implemented
   // subkeys
-  await Promise.all(key.subKeys.map(async function(srcSubKey) {
+  await Promise.all(key.subKeys.map(async srcSubKey => {
     let found = false;
-    await Promise.all(that.subKeys.map(async function(dstSubKey) {
+    await Promise.all(this.subKeys.map(async dstSubKey => {
       if (srcSubKey.subKey.getFingerprint() === dstSubKey.subKey.getFingerprint()) {
-        await dstSubKey.update(srcSubKey, that.primaryKey);
+        await dstSubKey.update(srcSubKey, this.primaryKey);
         found = true;
       }
     }));
     if (!found) {
-      that.subKeys.push(srcSubKey);
+      this.subKeys.push(srcSubKey);
     }
   }));
 };
@@ -1459,17 +1458,17 @@ export async function getPreferredAlgo(type, keys, date) {
     });
   }));
   let prefAlgo = { prio: 0, algo: defaultAlgo };
-  for (const algo in prioMap) {
+  Object.values(prioMap).forEach(({ prio, count, algo }) => {
     try {
       if (algo !== enums[type].plaintext &&
           algo !== enums[type].idea && // not implemented
           enums.read(enums[type], algo) && // known algorithm
-          prioMap[algo].count === keys.length && // available for all keys
-          prioMap[algo].prio > prefAlgo.prio) {
+          count === keys.length && // available for all keys
+          prio > prefAlgo.prio) {
         prefAlgo = prioMap[algo];
       }
     } catch (e) {}
-  }
+  });
   return prefAlgo.algo;
 }
 
diff --git a/src/keyring/keyring.js b/src/keyring/keyring.js
index c8759ee1..51d155a7 100644
--- a/src/keyring/keyring.js
+++ b/src/keyring/keyring.js
@@ -179,17 +179,16 @@ KeyArray.prototype.getForId = function (keyId, deep) {
  */
 KeyArray.prototype.importKey = async function (armored) {
   const imported = readArmored(armored);
-  const that = this;
   for (let i = 0; i < imported.keys.length; i++) {
     const key = imported.keys[i];
     // check if key already in key array
     const keyidHex = key.primaryKey.getKeyId().toHex();
-    const keyFound = that.getForId(keyidHex);
+    const keyFound = this.getForId(keyidHex);
     if (keyFound) {
       // eslint-disable-next-line no-await-in-loop
       await keyFound.update(key);
     } else {
-      that.push(key);
+      this.push(key);
     }
   }
   return imported.err ? imported.err : null;
diff --git a/src/packet/all_packets.js b/src/packet/all_packets.js
index ab4329eb..82e93000 100644
--- a/src/packet/all_packets.js
+++ b/src/packet/all_packets.js
@@ -98,11 +98,7 @@ export function newPacketFromTag(tag) {
 export function fromStructuredClone(packetClone) {
   const tagName = enums.read(enums.packet, packetClone.tag);
   const packet = newPacketFromTag(tagName);
-  for (const attr in packetClone) {
-    if (packetClone.hasOwnProperty(attr)) {
-      packet[attr] = packetClone[attr];
-    }
-  }
+  Object.assign(packet, packetClone);
   if (packet.postCloneTypeFix) {
     packet.postCloneTypeFix();
   }
diff --git a/src/packet/index.js b/src/packet/index.js
index a458f7fb..61361a1f 100644
--- a/src/packet/index.js
+++ b/src/packet/index.js
@@ -15,8 +15,6 @@ const mod = {
   clone
 };
 
-for (const i in packets) {
-  mod[i] = packets[i];
-}
+Object.assign(mod, packets);
 
 export default mod;
diff --git a/src/packet/packetlist.js b/src/packet/packetlist.js
index 0631cd0d..60123ffd 100644
--- a/src/packet/packetlist.js
+++ b/src/packet/packetlist.js
@@ -131,12 +131,11 @@ List.prototype.filter = function (callback) {
  */
 List.prototype.filterByTag = function (...args) {
   const filtered = new List();
-  const that = this;
 
   const handle = tag => packetType => tag === packetType;
 
   for (let i = 0; i < this.length; i++) {
-    if (args.some(handle(that[i].tag))) {
+    if (args.some(handle(this[i].tag))) {
       filtered.push(this[i]);
     }
   }
diff --git a/src/packet/secret_key.js b/src/packet/secret_key.js
index dd9eb56c..8a6fe012 100644
--- a/src/packet/secret_key.js
+++ b/src/packet/secret_key.js
@@ -329,13 +329,10 @@ SecretKey.prototype.decrypt = async function (passphrase) {
   return true;
 };
 
-SecretKey.prototype.generate = function (bits, curve) {
-  const that = this;
-  const algo = enums.write(enums.publicKey, that.algorithm);
-  return crypto.generateParams(algo, bits, curve).then(function(params) {
-    that.params = params;
-    that.isDecrypted = true;
-  });
+SecretKey.prototype.generate = async function (bits, curve) {
+  const algo = enums.write(enums.publicKey, this.algorithm);
+  this.params = await crypto.generateParams(algo, bits, curve);
+  this.isDecrypted = true;
 };
 
 /**
diff --git a/src/packet/signature.js b/src/packet/signature.js
index 355a3d29..37f1b522 100644
--- a/src/packet/signature.js
+++ b/src/packet/signature.js
@@ -103,7 +103,7 @@ Signature.prototype.read = function (bytes) {
   let i = 0;
   this.version = bytes[i++];
 
-  function subpackets(bytes) {
+  const subpackets = bytes => {
     // Two-octet scalar octet count for following subpacket data.
     const subpacket_length = util.readNumber(bytes.subarray(0, 2));
 
@@ -120,7 +120,7 @@ Signature.prototype.read = function (bytes) {
     }
 
     return i;
-  }
+  };
 
   // switch on version (3 and 4)
   switch (this.version) {
@@ -160,7 +160,7 @@ Signature.prototype.read = function (bytes) {
       this.hashAlgorithm = bytes[i++];
 
       // hashed subpackets
-      i += subpackets.call(this, bytes.subarray(i, bytes.length), true);
+      i += subpackets(bytes.subarray(i, bytes.length), true);
 
       // A V4 signature hashes the packet body
       // starting from its first field, the version number, through the end
@@ -172,7 +172,7 @@ Signature.prototype.read = function (bytes) {
       const sigDataLength = i;
 
       // unhashed subpackets
-      i += subpackets.call(this, bytes.subarray(i, bytes.length), false);
+      i += subpackets(bytes.subarray(i, bytes.length), false);
       this.unhashedSubpackets = bytes.subarray(sigDataLength, i);
 
       break;
@@ -308,19 +308,16 @@ Signature.prototype.write_all_sub_packets = function () {
     arr.push(write_sub_packet(sub.issuer, this.issuerKeyId.write()));
   }
   if (this.notation !== null) {
-    for (const name in this.notation) {
-      if (this.notation.hasOwnProperty(name)) {
-        const value = this.notation[name];
-        bytes = [new Uint8Array([0x80, 0, 0, 0])];
-        // 2 octets of name length
-        bytes.push(util.writeNumber(name.length, 2));
-        // 2 octets of value length
-        bytes.push(util.writeNumber(value.length, 2));
-        bytes.push(util.str_to_Uint8Array(name + value));
-        bytes = util.concatUint8Array(bytes);
-        arr.push(write_sub_packet(sub.notation_data, bytes));
-      }
-    }
+    Object.entries(this.notation).forEach(([name, value]) => {
+      bytes = [new Uint8Array([0x80, 0, 0, 0])];
+      // 2 octets of name length
+      bytes.push(util.writeNumber(name.length, 2));
+      // 2 octets of value length
+      bytes.push(util.writeNumber(value.length, 2));
+      bytes.push(util.str_to_Uint8Array(name + value));
+      bytes = util.concatUint8Array(bytes);
+      arr.push(write_sub_packet(sub.notation_data, bytes));
+    });
   }
   if (this.preferredHashAlgorithms !== null) {
     bytes = util.str_to_Uint8Array(util.Uint8Array_to_str(this.preferredHashAlgorithms));
@@ -405,13 +402,13 @@ function write_sub_packet(type, data) {
 Signature.prototype.read_sub_packet = function (bytes) {
   let mypos = 0;
 
-  function read_array(prop, bytes) {
+  const read_array = (prop, bytes) => {
     this[prop] = [];
 
     for (let i = 0; i < bytes.length; i++) {
       this[prop].push(bytes[i]);
     }
-  }
+  };
 
   // The leftwost bit denotes a "critical" packet, but we ignore it.
   const type = bytes[mypos++] & 0x7F;
@@ -458,7 +455,7 @@ Signature.prototype.read_sub_packet = function (bytes) {
       break;
     case 11:
       // Preferred Symmetric Algorithms
-      read_array.call(this, 'preferredSymmetricAlgorithms', bytes.subarray(mypos, bytes.length));
+      read_array('preferredSymmetricAlgorithms', bytes.subarray(mypos, bytes.length));
       break;
     case 12:
       // Revocation Key
@@ -497,15 +494,15 @@ Signature.prototype.read_sub_packet = function (bytes) {
       break;
     case 21:
       // Preferred Hash Algorithms
-      read_array.call(this, 'preferredHashAlgorithms', bytes.subarray(mypos, bytes.length));
+      read_array('preferredHashAlgorithms', bytes.subarray(mypos, bytes.length));
       break;
     case 22:
       // Preferred Compression Algorithms
-      read_array.call(this, 'preferredCompressionAlgorithms', bytes.subarray(mypos, bytes.length));
+      read_array('preferredCompressionAlgorithms', bytes.subarray(mypos, bytes.length));
       break;
     case 23:
       // Key Server Preferences
-      read_array.call(this, 'keyServerPreferences', bytes.subarray(mypos, bytes.length));
+      read_array('keyServerPreferences', bytes.subarray(mypos, bytes.length));
       break;
     case 24:
       // Preferred Key Server
@@ -521,7 +518,7 @@ Signature.prototype.read_sub_packet = function (bytes) {
       break;
     case 27:
       // Key Flags
-      read_array.call(this, 'keyFlags', bytes.subarray(mypos, bytes.length));
+      read_array('keyFlags', bytes.subarray(mypos, bytes.length));
       break;
     case 28:
       // Signer's User ID
@@ -534,7 +531,7 @@ Signature.prototype.read_sub_packet = function (bytes) {
       break;
     case 30:
       // Features
-      read_array.call(this, 'features', bytes.subarray(mypos, bytes.length));
+      read_array('features', bytes.subarray(mypos, bytes.length));
       break;
     case 31: {
       // Signature Target
diff --git a/src/util.js b/src/util.js
index 375dc887..c03c7dab 100644
--- a/src/util.js
+++ b/src/util.js
@@ -63,9 +63,9 @@ export default {
       return;
     }
     if (Object.prototype.isPrototypeOf(obj)) {
-      for (const key in obj) { // recursively search all children
-        util.collectBuffers(obj[key], collection);
-      }
+      Object.values(obj).forEach(value => { // recursively search all children
+        util.collectBuffers(value, collection);
+      });
     }
   },
 
@@ -160,8 +160,8 @@ export default {
    * @returns {Uint8Array} An array of 8-bit integers
    */
   b64_to_Uint8Array: function (base64) {
-//    atob(base64.replace(/\-/g, '+').replace(/_/g, '/'));
-    return b64.decode(base64.replace(/\-/g, '+').replace(/_/g, '/'));
+//    atob(base64.replace(/-/g, '+').replace(/_/g, '/'));
+    return b64.decode(base64.replace(/-/g, '+').replace(/_/g, '/'));
   },
 
   /**
@@ -565,7 +565,7 @@ export default {
     if (!util.isString(data)) {
       return false;
     }
-    const re = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+([a-zA-Z]{2,}|xn--[a-zA-Z\-0-9]+)))$/;
+    const re = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+([a-zA-Z]{2,}|xn--[a-zA-Z\-0-9]+)))$/;
     return re.test(data);
   },
 
diff --git a/src/worker/async_proxy.js b/src/worker/async_proxy.js
index 0619d7dc..d6f517e6 100644
--- a/src/worker/async_proxy.js
+++ b/src/worker/async_proxy.js
@@ -31,11 +31,20 @@ import util from '../util.js';
 import crypto from '../crypto';
 import packet from '../packet';
 
+
 /**
- * Message handling
+ * Initializes a new proxy and loads the web worker
+ * @param {String} path            The path to the worker or 'openpgp.worker.js' by default
+ * @param {Number} n               number of workers to initialize if path given
+ * @param {Object} config          config The worker configuration
+ * @param {Array<Object>} worker   alternative to path parameter: web worker initialized with 'openpgp.worker.js'
+ * @constructor
  */
-function handleMessage(workerId) {
-  return function(event) {
+function AsyncProxy({ path='openpgp.worker.js', n = 1, workers = [], config } = {}) {
+  /**
+   * Message handling
+   */
+  const handleMessage = workerId => event => {
     const msg = event.data;
     switch (msg.event) {
       case 'method-return':
@@ -59,17 +68,6 @@ function handleMessage(workerId) {
         throw new Error('Unknown Worker Event.');
     }
   };
-}
-
-/**
- * Initializes a new proxy and loads the web worker
- * @param {String} path            The path to the worker or 'openpgp.worker.js' by default
- * @param {Number} n               number of workers to initialize if path given
- * @param {Object} config          config The worker configuration
- * @param {Array<Object>} worker   alternative to path parameter: web worker initialized with 'openpgp.worker.js'
- * @constructor
- */
-function AsyncProxy({ path='openpgp.worker.js', n = 1, workers = [], config } = {}) {
 
   if (workers.length) {
     this.workers = workers;
@@ -84,7 +82,7 @@ function AsyncProxy({ path='openpgp.worker.js', n = 1, workers = [], config } =
   let workerId = 0;
   this.workers.forEach(worker => {
     worker.requests = 0;
-    worker.onmessage = handleMessage(workerId++).bind(this);
+    worker.onmessage = handleMessage(workerId++);
     worker.onerror = e => {
       throw new Error('Unhandled error in openpgp worker: ' + e.message + ' (' + e.filename + ':' + e.lineno + ')');
     };
diff --git a/src/worker/worker.js b/src/worker/worker.js
index b4cd9f9e..576f06c0 100644
--- a/src/worker/worker.js
+++ b/src/worker/worker.js
@@ -86,9 +86,7 @@ self.onmessage = function(event) {
  * @param  {Object} config   The openpgp configuration
  */
 function configure(config) {
-  for (var i in config) {
-    openpgp.config[i] = config[i];
-  }
+  Object.assign(openpgp.config, config);
 }
 
 /**
diff --git a/test/crypto/cipher/des.js b/test/crypto/cipher/des.js
index 9d8c0b79..63ba30f3 100644
--- a/test/crypto/cipher/des.js
+++ b/test/crypto/cipher/des.js
@@ -89,7 +89,7 @@ describe('TripleDES (EDE) cipher test with test vectors from NIST SP 800-20', fu
 
   it('DES encrypt/decrypt padding tests', function (done) {
     const key = new Uint8Array([0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF]);
-    const testvectors = new Array();
+    const testvectors = [];
     testvectors[0] = [[[0x01], [0x24, 0xC7, 0x4A, 0x9A, 0x79, 0x75, 0x4B, 0xC7]],
                     [[0x02, 0x03], [0xA7, 0x7A, 0x9A, 0x59, 0x8A, 0x86, 0x85, 0xC5]],
                     [[0x03, 0x04, 0x05], [0x01, 0xCF, 0xEB, 0x6A, 0x74, 0x60, 0xF5, 0x02]],