diff --git a/index.html b/index.html
index 1acedee..5c596d4 100644
--- a/index.html
+++ b/index.html
@@ -124,7 +124,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="encrypt recommended">
                     <script>
                         //encrypt
-                        window.crypto.subtle.generateKey(AESGCM, false, ["encrypt"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESGCM, false, ["encrypt"]);
+                        })
                         .then(function(key){
                             return window.crypto.subtle.encrypt({
                                 name: "AES-GCM",
@@ -140,7 +142,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="decrypt recommended">
                     <script>
                         //decrypt
-                        window.crypto.subtle.generateKey(AESGCM, false, ["encrypt", "decrypt"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESGCM, false, ["encrypt", "decrypt"]);
+                        })
                         .then(function(key){
                             var iv = window.crypto.getRandomValues(new Uint8Array(12));
                             var addtl = window.crypto.getRandomValues(new Uint8Array(256));
@@ -172,26 +176,32 @@ <h1>Web Cryptography API Live Table</h1>
                         //generateKey
 
                         //128 bits
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "AES-GCM",
                             length: 128,
-                        }, false, ["encrypt", "decrypt"])
+                        }, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-gcm", "generateKey", "128 bits"))
                         .catch(err("aes-gcm", "generateKey", "128 bits"));
 
                         //192 bits
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "AES-GCM",
                             length: 192,
-                        }, false, ["encrypt", "decrypt"])
+                        }, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-gcm", "generateKey", "192 bits"))
                         .catch(err("aes-gcm", "generateKey", "192 bits"));
 
                         //256 bits
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "AES-GCM",
                             length: 256,
-                        }, false, ["encrypt", "decrypt"])
+                        }, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-gcm", "generateKey", "256 bits"))
                         .catch(err("aes-gcm", "generateKey", "256 bits"));
                     </script>
@@ -203,20 +213,24 @@ <h1>Web Cryptography API Live Table</h1>
                         //importKey
 
                         //jwk
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "oct",
                             k: "KfKY5nueRX7eBrOddn9IerHLv1r-T7qpggaCF3MfSR4",
                             alg: "A256GCM",
                             ext: true,
-                        }, AESGCM, false, ["encrypt", "decrypt"])
+                        }, AESGCM, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-gcm", "importKey", "jwk-key"))
                         .catch(err("aes-gcm", "importKey", "jwk-key"));
 
                         //raw
-                        window.crypto.subtle.importKey("raw", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", new Uint8Array([
                             122,94,39,230,46,23,151,80,131,230,3,101,80,234,143,9,251,
                             152,229,228,89,222,31,135,214,104,55,68,67,59,5,51
-                        ]), AESGCM, false, ["encrypt", "decrypt"])
+                        ]), AESGCM, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-gcm", "importKey", "raw-key"))
                         .catch(err("aes-gcm", "importKey", "raw-key"));
                     </script>
@@ -224,7 +238,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="exportKey recommended">
                     <script>
                         //exportKey
-                        window.crypto.subtle.generateKey(AESGCM, true, ["encrypt", "decrypt"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESGCM, true, ["encrypt", "decrypt"]);
+                        })
                         .then(function(key){
 
                             //jwk
@@ -244,7 +260,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="wrapKey recommended">
                     <script>
                         //RSASSA-PKCS1-v1_5
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSASSA-PKCS1-v1_5",
@@ -271,7 +289,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-gcm", "wrapKey", "RSASSA-PKCS1-v1_5"));
 
                         //RSA-PSS
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSA-PSS",
@@ -299,7 +319,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-gcm", "wrapKey", "RSA-PSS"));
 
                         //RSA-OAEP
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSA-OAEP",
@@ -326,7 +348,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-gcm", "wrapKey", "RSA-OAEP"));
 
                         //ECDSA
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "ECDSA",
@@ -352,7 +376,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-gcm", "wrapKey", "ECDSA"));
 
                         //ECDH
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "ECDH",
@@ -377,7 +403,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-gcm", "wrapKey", "ECDH"));
 
                         //AES-CTR
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CTR", length: 256},
@@ -394,7 +422,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-gcm", "wrapKey", "AES-CTR"));
 
                         //AES-CBC
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CBC", length: 256},
@@ -411,7 +441,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-gcm", "wrapKey", "AES-CBC"));
 
                         //AES-GCM
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-GCM", length: 256},
@@ -428,7 +460,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-gcm", "wrapKey", "AES-GCM"));
 
                         //HMAC
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "HMAC", hash: {name: "SHA-256"}},
@@ -448,7 +482,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="unwrapKey recommended">
                     <script>
                         //RSASSA-PKCS1-v1_5
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSASSA-PKCS1-v1_5",
@@ -500,7 +536,9 @@ <h1>Web Cryptography API Live Table</h1>
 
 
                         //RSA-PSS
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSA-PSS",
@@ -554,7 +592,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-gcm", "unwrapKey", "RSA-PSS"));
 
                         //RSA-OAEP
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSA-OAEP",
@@ -605,7 +645,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-gcm", "unwrapKey", "RSA-OAEP"));
 
                         //ECDSA
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "ECDSA",
@@ -653,7 +695,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-gcm", "unwrapKey", "ECDSA"));
 
                         //ECDH
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "ECDH",
@@ -701,7 +745,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-gcm", "unwrapKey", "ECDH"));
 
                         //AES-CTR
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CTR", length: 256},
@@ -726,7 +772,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-gcm", "unwrapKey", "AES-CTR"));
 
                         //AES-CBC
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CBC", length: 256},
@@ -751,7 +799,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-gcm", "unwrapKey", "AES-CBC"));
 
                         //AES-GCM
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-GCM", length: 256},
@@ -776,7 +826,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-gcm", "unwrapKey", "AES-GCM"));
 
                         //HMAC
-                        window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-GCM", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "HMAC", hash: {name: "SHA-256"}},
@@ -824,7 +876,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="sign recommended">
                     <script>
                         //sign
-                        window.crypto.subtle.generateKey(ECDSA, true, ["sign", "verify"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(ECDSA, true, ["sign", "verify"]);
+                        })
                         .then(function(key){
                             return window.crypto.subtle.sign(ECDSA, key.privateKey, TESTBYTES);
                         })
@@ -835,7 +889,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="verify recommended">
                     <script>
                         //verify
-                        window.crypto.subtle.generateKey(ECDSA, true, ["sign", "verify"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(ECDSA, true, ["sign", "verify"]);
+                        })
                         .then(function(key){
                             window.crypto.subtle.sign(ECDSA, key.privateKey, TESTBYTES)
                             .then(function(sig){
@@ -853,26 +909,32 @@ <h1>Web Cryptography API Live Table</h1>
                         //generateKey
 
                         //P-256
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "ECDSA",
                             namedCurve: "P-256",
-                        }, false, ["sign", "verify"])
+                        }, false, ["sign", "verify"]);
+                        })
                         .then(ok("ecdsa", "generateKey", "P-256"))
                         .catch(err("ecdsa", "generateKey", "P-256"));
 
                         //P-384
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "ECDSA",
                             namedCurve: "P-384",
-                        }, false, ["sign", "verify"])
+                        }, false, ["sign", "verify"]);
+                        })
                         .then(ok("ecdsa", "generateKey", "P-384"))
                         .catch(err("ecdsa", "generateKey", "P-384"));
 
                         //P-521
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "ECDSA",
                             namedCurve: "P-521",
-                        }, false, ["sign", "verify"])
+                        }, false, ["sign", "verify"]);
+                        })
                         .then(ok("ecdsa", "generateKey", "P-521"))
                         .catch(err("ecdsa", "generateKey", "P-521"));
                     </script>
@@ -884,46 +946,54 @@ <h1>Web Cryptography API Live Table</h1>
                         //importKey
 
                         //jwk
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "EC",
                             crv: "P-256",
                             x: "A5fQnBdBSgBhTjMr1Atpzvh5SKYQ4aQRJ9WTCG5U4m4",
                             y: "8YF98byzMljHX3T5ORLYTDbcwG-_eq3f23JtTE6lOe0",
                             ext: true,
-                        }, ECDSA, false, ["verify"])
+                        }, ECDSA, false, ["verify"]);
+                        })
                         .then(ok("ecdsa", "importKey", "jwk-pub"))
                         .catch(err("ecdsa", "importKey", "jwk-pub"));
 
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "EC",
                             crv: "P-256",
                             x: "A5fQnBdBSgBhTjMr1Atpzvh5SKYQ4aQRJ9WTCG5U4m4",
                             y: "8YF98byzMljHX3T5ORLYTDbcwG-_eq3f23JtTE6lOe0",
                             d: "4DvC-hxpv8myZLNeMY-8nq55MhdfA4obM1lGG3hF_yo",
                             ext: true,
-                        }, ECDSA, false, ["sign"])
+                        }, ECDSA, false, ["sign"]);
+                        })
                         .then(ok("ecdsa", "importKey", "jwk-priv"))
                         .catch(err("ecdsa", "importKey", "jwk-priv"));
 
                         //spki
-                        window.crypto.subtle.importKey("spki", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("spki", new Uint8Array([
                             48,89,48,19,6,7,42,134,72,206,61,2,1,6,8,42,134,72,206,61,3,1,7,3,66,0,4,3,151,
                             208,156,23,65,74,0,97,78,51,43,212,11,105,206,248,121,72,166,16,225,164,17,39,
                             213,147,8,110,84,226,110,241,129,125,241,188,179,50,88,199,95,116,249,57,18,216,
                             76,54,220,192,111,191,122,173,223,219,114,109,76,78,165,57,237
-                        ]), ECDSA, false, ["verify"])
+                        ]), ECDSA, false, ["verify"]);
+                        })
                         .then(ok("ecdsa", "importKey", "spki-pub"))
                         .catch(err("ecdsa", "importKey", "spki-pub"));
 
                         //pkcs8
-                        window.crypto.subtle.importKey("pkcs8", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("pkcs8", new Uint8Array([
                             48,129,135,2,1,0,48,19,6,7,42,134,72,206,61,2,1,6,8,42,134,72,206,61,3,1,7,4,109,48,
                             107,2,1,1,4,32,224,59,194,250,28,105,191,201,178,100,179,94,49,143,188,158,174,121,50,
                             23,95,3,138,27,51,89,70,27,120,69,255,42,161,68,3,66,0,4,3,151,208,156,23,65,74,0,97,
                             78,51,43,212,11,105,206,248,121,72,166,16,225,164,17,39,213,147,8,110,84,226,110,241,
                             129,125,241,188,179,50,88,199,95,116,249,57,18,216,76,54,220,192,111,191,122,173,223,
                             219,114,109,76,78,165,57,237
-                        ]), ECDSA, false, ["sign"])
+                        ]), ECDSA, false, ["sign"]);
+                        })
                         .then(ok("ecdsa", "importKey", "pkcs8-priv"))
                         .catch(err("ecdsa", "importKey", "pkcs8-priv"));
                     </script>
@@ -931,7 +1001,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="exportKey recommended">
                     <script>
                         //exportKey
-                        window.crypto.subtle.generateKey(ECDSA, true, ["sign", "verify"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(ECDSA, true, ["sign", "verify"]);
+                        })
                         .then(function(key){
 
                             //jwk
@@ -981,7 +1053,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="sign recommended">
                     <script>
                         //sign
-                        window.crypto.subtle.generateKey(HMAC, false, ["sign"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(HMAC, false, ["sign"]);
+                        })
                         .then(function(key){
                             return window.crypto.subtle.sign(HMAC, key, TESTBYTES);
                         })
@@ -992,7 +1066,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="verify recommended">
                     <script>
                         //verify
-                        window.crypto.subtle.generateKey(HMAC, false, ["sign", "verify"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(HMAC, false, ["sign", "verify"]);
+                        })
                         .then(function(key){
                             window.crypto.subtle.sign(HMAC, key, TESTBYTES)
                             .then(function(sig){
@@ -1010,34 +1086,42 @@ <h1>Web Cryptography API Live Table</h1>
                         //generateKey
 
                         //sha-1
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "HMAC",
                             hash: {name: "SHA-1"},
-                        }, false, ["sign", "verify"])
+                        }, false, ["sign", "verify"]);
+                        })
                         .then(ok("hmac", "generateKey", "SHA-1"))
                         .catch(err("hmac", "generateKey", "SHA-1"));
 
                         //sha-256
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "HMAC",
                             hash: {name: "SHA-256"},
-                        }, false, ["sign", "verify"])
+                        }, false, ["sign", "verify"]);
+                        })
                         .then(ok("hmac", "generateKey", "SHA-256"))
                         .catch(err("hmac", "generateKey", "SHA-256"));
 
                         //sha-384
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "HMAC",
                             hash: {name: "SHA-384"},
-                        }, false, ["sign", "verify"])
+                        }, false, ["sign", "verify"]);
+                        })
                         .then(ok("hmac", "generateKey", "SHA-384"))
                         .catch(err("hmac", "generateKey", "SHA-384"));
 
                         //sha-512
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "HMAC",
                             hash: {name: "SHA-512"},
-                        }, false, ["sign", "verify"])
+                        }, false, ["sign", "verify"]);
+                        })
                         .then(ok("hmac", "generateKey", "SHA-512"))
                         .catch(err("hmac", "generateKey", "SHA-512"));
                     </script>
@@ -1049,20 +1133,24 @@ <h1>Web Cryptography API Live Table</h1>
                         //importKey
 
                         //jwk
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "oct",
                             k: "KfKY5nueRX7eBrOddn9IerHLv1r-T7qpggaCF3MfSR4",
                             alg: "HS256",
                             ext: true,
-                        }, HMAC, false, ["sign", "verify"])
+                        }, HMAC, false, ["sign", "verify"]);
+                        })
                         .then(ok("hmac", "importKey", "jwk-key"))
                         .catch(err("hmac", "importKey", "jwk-key"));
 
                         //raw
-                        window.crypto.subtle.importKey("raw", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", new Uint8Array([
                             122,94,39,230,46,23,151,80,131,230,3,101,80,234,143,9,251,
                             152,229,228,89,222,31,135,214,104,55,68,67,59,5,51
-                        ]), HMAC, false, ["sign", "verify"])
+                        ]), HMAC, false, ["sign", "verify"]);
+                        })
                         .then(ok("hmac", "importKey", "raw-key"))
                         .catch(err("hmac", "importKey", "raw-key"));
                     </script>
@@ -1070,7 +1158,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="exportKey recommended">
                     <script>
                         //exportKey
-                        window.crypto.subtle.generateKey(HMAC, true, ["sign", "verify"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(HMAC, true, ["sign", "verify"]);
+                        })
                         .then(function(key){
 
                             //jwk
@@ -1106,7 +1196,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="digest recommended">
                     <script>
                         //digest
-                        window.crypto.subtle.digest({name: "SHA-256"}, TESTBYTES)
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.digest({name: "SHA-256"}, TESTBYTES);
+                        })
                         .then(ok("sha-256", "digest", "Yes"))
                         .catch(err("sha-256", "digest", "No"));
                     </script>
@@ -1135,7 +1227,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="digest recommended">
                     <script>
                         //digest
-                        window.crypto.subtle.digest({name: "SHA-384"}, TESTBYTES)
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.digest({name: "SHA-384"}, TESTBYTES);
+                        })
                         .then(ok("sha-384", "digest", "Yes"))
                         .catch(err("sha-384", "digest", "No"));
                     </script>
@@ -1164,7 +1258,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="digest recommended">
                     <script>
                         //digest
-                        window.crypto.subtle.digest({name: "SHA-512"}, TESTBYTES)
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.digest({name: "SHA-512"}, TESTBYTES);
+                        })
                         .then(ok("sha-512", "digest", "Yes"))
                         .catch(err("sha-512", "digest", "No"));
                     </script>
@@ -1203,26 +1299,32 @@ <h1>Web Cryptography API Live Table</h1>
                         //generateKey
 
                         //P-256
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "ECDH",
                             namedCurve: "P-256",
-                        }, false, ["deriveBits", "deriveKey"])
+                        }, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(ok("ecdh", "generateKey", "P-256"))
                         .catch(err("ecdh", "generateKey", "P-256"));
 
                         //P-384
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "ECDH",
                             namedCurve: "P-384",
-                        }, false, ["deriveBits", "deriveKey"])
+                        }, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(ok("ecdh", "generateKey", "P-384"))
                         .catch(err("ecdh", "generateKey", "P-384"));
 
                         //P-521
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "ECDH",
                             namedCurve: "P-521",
-                        }, false, ["deriveBits", "deriveKey"])
+                        }, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(ok("ecdh", "generateKey", "P-521"))
                         .catch(err("ecdh", "generateKey", "P-521"));
                     </script>
@@ -1230,7 +1332,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="deriveKey recommended">
                     <script>
                         //deriveKey
-                        window.crypto.subtle.generateKey(ECDH, false, ["deriveKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(ECDH, false, ["deriveKey"]);
+                        })
                         .then(function(key1){
                             window.crypto.subtle.generateKey(ECDH, false, ["deriveKey"])
                             .then(function(key2){
@@ -1252,7 +1356,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="deriveBits recommended">
                     <script>
                         //deriveBits
-                        window.crypto.subtle.generateKey(ECDH, false, ["deriveBits"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(ECDH, false, ["deriveBits"]);
+                        })
                         .then(function(key1){
                             window.crypto.subtle.generateKey(ECDH, false, ["deriveBits"])
                             .then(function(key2){
@@ -1276,50 +1382,60 @@ <h1>Web Cryptography API Live Table</h1>
                         //importKey
 
                         //jwk
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "EC",
                             crv: "P-256",
                             x: "kgR_PqO07L8sZOBbw6rvv7O_f7clqDeiE3WnMkb5EoI",
                             y: "djI-XqCqSyO9GFk_QT_stROMCAROIvU8KOORBgQUemE",
                             ext: true,
-                        }, ECDH, false, [])
+                        }, ECDH, false, []);
+                        })
                         .then(ok("ecdh", "importKey", "jwk-pub"))
                         .catch(err("ecdh", "importKey", "jwk-pub"));
 
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "EC",
                             crv: "P-256",
                             x: "kgR_PqO07L8sZOBbw6rvv7O_f7clqDeiE3WnMkb5EoI",
                             y: "djI-XqCqSyO9GFk_QT_stROMCAROIvU8KOORBgQUemE",
                             d: "5aPFSt0UFVXYGu-ZKyC9FQIUOAMmnjzdIwkxCMe3Iok",
                             ext: true,
-                        }, ECDH, false, ["deriveBits", "deriveKey"])
+                        }, ECDH, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(ok("ecdh", "importKey", "jwk-priv"))
                         .catch(err("ecdh", "importKey", "jwk-priv"));
 
                         //raw
-                        window.crypto.subtle.importKey("raw", null, ECDH, false, ["deriveBits", "deriveKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", null, ECDH, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(ok("ecdh", "importKey", "raw-pub"))
                         .catch(err("ecdh", "importKey", "raw-pub*"));
 
                         //spki
-                        window.crypto.subtle.importKey("spki", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("spki", new Uint8Array([
                             48,89,48,19,6,7,42,134,72,206,61,2,1,6,8,42,134,72,206,61,3,1,7,3,66,0,4,146,4,127,62,
                             163,180,236,191,44,100,224,91,195,170,239,191,179,191,127,183,37,168,55,162,19,117,167,
                             50,70,249,18,130,118,50,62,94,160,170,75,35,189,24,89,63,65,63,236,181,19,140,8,4,78,
                             34,245,60,40,227,145,6,4,20,122,97
-                        ]), ECDH, false, [])
+                        ]), ECDH, false, []);
+                        })
                         .then(ok("ecdh", "importKey", "spki-pub"))
                         .catch(err("ecdh", "importKey", "spki-pub"));
 
                         //pkcs8
-                        window.crypto.subtle.importKey("pkcs8", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("pkcs8", new Uint8Array([
                             48,129,135,2,1,0,48,19,6,7,42,134,72,206,61,2,1,6,8,42,134,72,206,61,3,1,7,4,109,48,107,2,
                             1,1,4,32,229,163,197,74,221,20,21,85,216,26,239,153,43,32,189,21,2,20,56,3,38,158,60,221,35,
                             9,49,8,199,183,34,137,161,68,3,66,0,4,146,4,127,62,163,180,236,191,44,100,224,91,195,170,239,
                             191,179,191,127,183,37,168,55,162,19,117,167,50,70,249,18,130,118,50,62,94,160,170,75,35,189,
                             24,89,63,65,63,236,181,19,140,8,4,78,34,245,60,40,227,145,6,4,20,122,97
-                        ]), ECDH, false, ["deriveBits", "deriveKey"])
+                        ]), ECDH, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(ok("ecdh", "importKey", "pkcs8-priv"))
                         .catch(err("ecdh", "importKey", "pkcs8-priv"));
                     </script>
@@ -1327,7 +1443,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="exportKey recommended">
                     <script>
                         //exportKey
-                        window.crypto.subtle.generateKey(ECDH, true, ["deriveBits", "deriveKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(ECDH, true, ["deriveBits", "deriveKey"]);
+                        })
                         .then(function(key){
 
                             //jwk
@@ -1393,7 +1511,9 @@ <h1>Web Cryptography API Live Table</h1>
                     <script>
                         //deriveKey
                         var password = window.crypto.getRandomValues(new Uint8Array(16));
-                        window.crypto.subtle.importKey("raw", password, {name: "PBKDF2"}, false, ["deriveBits", "deriveKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", password, {name: "PBKDF2"}, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(function(key){
 
                             //sha-1
@@ -1444,7 +1564,9 @@ <h1>Web Cryptography API Live Table</h1>
                     <script>
                         //deriveBits
                         var password = window.crypto.getRandomValues(new Uint8Array(16));
-                        window.crypto.subtle.importKey("raw", password, {name: "PBKDF2"}, false, ["deriveBits", "deriveKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", password, {name: "PBKDF2"}, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(function(key){
 
                             //sha-1
@@ -1497,7 +1619,9 @@ <h1>Web Cryptography API Live Table</h1>
 
                         //raw
                         var password = window.crypto.getRandomValues(new Uint8Array(16));
-                        window.crypto.subtle.importKey("raw", password, {name: "PBKDF2"}, false, ["deriveBits", "deriveKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", password, {name: "PBKDF2"}, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(ok("pbkdf2", "importKey", "raw"))
                         .catch(err("pbkdf2", "importKey", "raw"));
                     </script>
@@ -1532,26 +1656,32 @@ <h1>Web Cryptography API Live Table</h1>
                         //generateKey
 
                         //128 bits
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "AES-KW",
                             length: 128,
-                        }, false, ["wrapKey", "unwrapKey"])
+                        }, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(ok("aes-kw", "generateKey", "128 bits"))
                         .catch(err("aes-kw", "generateKey", "128 bits"));
 
                         //192 bits
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "AES-KW",
                             length: 192,
-                        }, false, ["wrapKey", "unwrapKey"])
+                        }, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(ok("aes-kw", "generateKey", "192 bits"))
                         .catch(err("aes-kw", "generateKey", "192 bits"));
 
                         //256 bits
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "AES-KW",
                             length: 256,
-                        }, false, ["wrapKey", "unwrapKey"])
+                        }, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(ok("aes-kw", "generateKey", "256 bits"))
                         .catch(err("aes-kw", "generateKey", "256 bits"));
                     </script>
@@ -1563,20 +1693,24 @@ <h1>Web Cryptography API Live Table</h1>
                         //importKey
 
                         //jwk
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "oct",
                             k: "KfKY5nueRX7eBrOddn9IerHLv1r-T7qpggaCF3MfSR4",
                             alg: "A256KW",
                             ext: true,
-                        }, AESKW, false, ["wrapKey", "unwrapKey"])
+                        }, AESKW, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(ok("aes-kw", "importKey", "jwk-key"))
                         .catch(err("aes-kw", "importKey", "jwk-key"));
 
                         //raw
-                        window.crypto.subtle.importKey("raw", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", new Uint8Array([
                             122,94,39,230,46,23,151,80,131,230,3,101,80,234,143,9,251,
                             152,229,228,89,222,31,135,214,104,55,68,67,59,5,51
-                        ]), AESKW, false, ["wrapKey", "unwrapKey"])
+                        ]), AESKW, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(ok("aes-kw", "importKey", "raw-key"))
                         .catch(err("aes-kw", "importKey", "raw-key"));
                     </script>
@@ -1584,7 +1718,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="exportKey recommended">
                     <script>
                         //exportKey
-                        window.crypto.subtle.generateKey(AESKW, true, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESKW, true, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(key){
 
                             //jwk
@@ -1604,7 +1740,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="wrapKey recommended">
                     <script>
                         //ECDH
-                        window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "ECDH",
@@ -1633,7 +1771,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-kw", "wrapKey", "ECDH"));
 
                         //AES-CTR
-                        window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CTR", length: 256},
@@ -1649,7 +1789,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-kw", "wrapKey", "AES-CTR"));
 
                         //AES-CBC
-                        window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CBC", length: 256},
@@ -1665,7 +1807,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-kw", "wrapKey", "AES-CBC"));
 
                         //AES-GCM
-                        window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-GCM", length: 256},
@@ -1681,7 +1825,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-kw", "wrapKey", "AES-GCM"));
 
                         //HMAC
-                        window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "HMAC", hash: {name: "SHA-256"}},
@@ -1700,7 +1846,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="unwrapKey recommended">
                     <script>
                         //ECDH
-                        window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "ECDH",
@@ -1746,7 +1894,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-kw", "unwrapKey", "ECDH"));
 
                         //AES-CTR
-                        window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CTR", length: 256},
@@ -1770,7 +1920,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-kw", "unwrapKey", "AES-CTR"));
 
                         //AES-CBC
-                        window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CBC", length: 256},
@@ -1794,7 +1946,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-kw", "unwrapKey", "AES-CBC"));
 
                         //AES-GCM
-                        window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-GCM", length: 256},
@@ -1818,7 +1972,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-kw", "unwrapKey", "AES-GCM"));
 
                         //HMAC
-                        window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-KW", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "HMAC", hash: {name: "SHA-256"}},
@@ -1866,7 +2022,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="encrypt unsafe">
                     <script>
                         //encrypt
-                        window.crypto.subtle.generateKey(RSAOAEP, false, ["encrypt", "decrypt"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(RSAOAEP, false, ["encrypt", "decrypt"]);
+                        })
                         .then(function(key){
                             return window.crypto.subtle.encrypt(RSAOAEP, key.publicKey, TESTBYTES);
                         })
@@ -1877,7 +2035,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="decrypt unsafe">
                     <script>
                         //decrypt
-                        window.crypto.subtle.generateKey(RSAOAEP, false, ["encrypt", "decrypt"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(RSAOAEP, false, ["encrypt", "decrypt"]);
+                        })
                         .then(function(key){
                             window.crypto.subtle.encrypt(RSAOAEP, key.publicKey, TESTBYTES)
                             .then(function(encrypted){
@@ -1940,17 +2100,20 @@ <h1>Web Cryptography API Live Table</h1>
                         //importKey
 
                         //jwk
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "RSA",
                             e: "AQAB",
                             n: "vGO3eU16ag9zRkJ4AK8ZUZrjbtp5xWK0LyFMNT8933evJoHeczexMUzSiXaLrEFSyQZortk81zJH3y41MBO_UFDO_X0crAquNrkjZDrf9Scc5-MdxlWU2Jl7Gc4Z18AC9aNibWVmXhgvHYkEoFdLCFG-2Sq-qIyW4KFkjan05IE",
                             alg: "RSA-OAEP-256",
                             ext: true,
-                        }, RSAOAEP, false, ["encrypt"])
+                        }, RSAOAEP, false, ["encrypt"]);
+                        })
                         .then(ok("rsa-oaep", "importKey", "jwk-pub"))
                         .catch(err("rsa-oaep", "importKey", "jwk-pub"));
 
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "RSA",
                             e: "AQAB",
                             d: "e-Nm1CB_F7j0p4Cb-T4WmFTh7RbxUthC3j8xnlXwHgWYwaPs9ZRkicgNCfmjEb-qJ-m0ho1Cz4WzlL1CtTKEdr2w0P6L_IQPvWkFYwUm0rpY9doxnOKkzq53dhP5zdc6N8aOLk4cmAcVjw4o_csc85H-0fxzQxsTP0_jhJn7SNE",
@@ -1962,12 +2125,14 @@ <h1>Web Cryptography API Live Table</h1>
                             qi: "R1aKNnhUiTjoCHfOVHZ6Qv5R7So-F5mtjDKCBvCi8190U3E25DiKRvDqHZ0bHMRbdQPLLknxHVnuETw6gddHUg",
                             alg: "RSA-OAEP-256",
                             ext: true,
-                        }, RSAOAEP, false, ["decrypt"])
+                        }, RSAOAEP, false, ["decrypt"]);
+                        })
                         .then(ok("rsa-oaep", "importKey", "jwk-priv"))
                         .catch(err("rsa-oaep", "importKey", "jwk-priv"));
 
                         //spki
-                        window.crypto.subtle.importKey("spki", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("spki", new Uint8Array([
                             48,129,159,48,13,6,9,42,134,72,134,247,13,1,1,1,5,0,3,
                             129,141,0,48,129,137,2,129,129,0,182,93,35,213,252,204,
                             20,103,91,238,105,199,53,114,24,221,114,210,137,173,88,
@@ -1978,12 +2143,14 @@ <h1>Web Cryptography API Live Table</h1>
                             110,3,70,202,148,95,45,228,94,95,148,2,162,79,146,137,29,
                             189,102,75,207,214,116,58,63,171,219,27,5,9,108,16,218,23,
                             169,43,181,119,31,172,95,205,180,18,255,203,2,3,1,0,1
-                        ]), RSAOAEP, false, ["encrypt"])
+                        ]), RSAOAEP, false, ["encrypt"]);
+                        })
                         .then(ok("rsa-oaep", "importKey", "spki-pub"))
                         .catch(err("rsa-oaep", "importKey", "spki-pub"));
 
                         //pkcs8
-                        window.crypto.subtle.importKey("pkcs8", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("pkcs8", new Uint8Array([
                             48,130,2,118,2,1,0,48,13,6,9,42,134,72,134,247,13,1,1,1,5,0,4,130,2,96,48,130,2,92,2,1,0,2,129,
                             129,0,217,78,147,218,221,152,10,66,75,127,242,108,182,142,157,44,93,58,176,193,135,103,216,179,
                             69,72,38,115,144,244,12,139,0,245,48,115,204,234,158,193,231,127,178,240,244,203,35,229,203,245,
@@ -2007,7 +2174,8 @@ <h1>Web Cryptography API Live Table</h1>
                             253,30,241,2,64,15,148,8,16,189,122,55,109,203,175,173,24,222,36,130,130,179,87,189,32,141,149,30,
                             115,211,227,79,234,78,202,253,48,173,95,167,203,20,193,160,30,146,33,109,4,221,25,212,216,183,100,
                             18,46,184,52,65,146,249,68,225,10,84,38,98,133
-                        ]), RSAOAEP, false, ["decrypt"])
+                        ]), RSAOAEP, false, ["decrypt"]);
+                        })
                         .then(ok("rsa-oaep", "importKey", "pkcs8-priv"))
                         .catch(err("rsa-oaep", "importKey", "pkcs8-priv"));
                     </script>
@@ -2015,7 +2183,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="exportKey unsafe">
                     <script>
                         //exportKey
-                        window.crypto.subtle.generateKey(RSAOAEP, true, ["encrypt", "decrypt"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(RSAOAEP, true, ["encrypt", "decrypt"]);
+                        })
                         .then(function(key){
 
                             //jwk
@@ -2044,12 +2214,14 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="wrapKey unsafe">
                     <script>
                         //ECDH
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "RSA-OAEP",
                             modulusLength: 1024,
                             publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
                             hash: {name: "SHA-256"},
-                        }, false, ["wrapKey", "unwrapKey"])
+                        }, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "ECDH",
@@ -2072,12 +2244,14 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("rsa-oaep", "wrapKey", "ECDH"));
 
                         //AES-CTR
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "RSA-OAEP",
                             modulusLength: 1024,
                             publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
                             hash: {name: "SHA-256"},
-                        }, false, ["wrapKey", "unwrapKey"])
+                        }, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CTR", length: 256},
@@ -2098,12 +2272,14 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("rsa-oaep", "wrapKey", "AES-CTR"));
 
                         //AES-CBC
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "RSA-OAEP",
                             modulusLength: 1024,
                             publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
                             hash: {name: "SHA-256"},
-                        }, false, ["wrapKey", "unwrapKey"])
+                        }, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CBC", length: 256},
@@ -2124,12 +2300,14 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("rsa-oaep", "wrapKey", "AES-CBC"));
 
                         //AES-GCM
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "RSA-OAEP",
                             modulusLength: 1024,
                             publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
                             hash: {name: "SHA-256"},
-                        }, false, ["wrapKey", "unwrapKey"])
+                        }, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-GCM", length: 256},
@@ -2150,12 +2328,14 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("rsa-oaep", "wrapKey", "AES-GCM"));
 
                         //HMAC
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "RSA-OAEP",
                             modulusLength: 1024,
                             publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
                             hash: {name: "SHA-1"}, //need shorter hash to accomidate 64 byte HMAC raw export
-                        }, false, ["wrapKey", "unwrapKey"])
+                        }, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "HMAC", hash: {name: "SHA-256"}},
@@ -2179,12 +2359,14 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="unwrapKey unsafe">
                     <script>
                         //ECDH
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "RSA-OAEP",
                             modulusLength: 1024,
                             publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
                             hash: {name: "SHA-256"},
-                        }, false, ["wrapKey", "unwrapKey"])
+                        }, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "ECDH",
@@ -2223,12 +2405,14 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("rsa-oaep", "unwrapKey", "ECDH"));
 
                         //AES-CTR
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "RSA-OAEP",
                             modulusLength: 1024,
                             publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
                             hash: {name: "SHA-256"},
-                        }, false, ["wrapKey", "unwrapKey"])
+                        }, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CTR", length: 256},
@@ -2262,12 +2446,14 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("rsa-oaep", "unwrapKey", "AES-CTR"));
 
                         //AES-CBC
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "RSA-OAEP",
                             modulusLength: 1024,
                             publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
                             hash: {name: "SHA-256"},
-                        }, false, ["wrapKey", "unwrapKey"])
+                        }, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CBC", length: 256},
@@ -2301,12 +2487,14 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("rsa-oaep", "unwrapKey", "AES-CBC"));
 
                         //AES-GCM
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "RSA-OAEP",
                             modulusLength: 1024,
                             publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
                             hash: {name: "SHA-256"},
-                        }, false, ["wrapKey", "unwrapKey"])
+                        }, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-GCM", length: 256},
@@ -2340,12 +2528,14 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("rsa-oaep", "unwrapKey", "AES-GCM"));
 
                         //HMAC
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "RSA-OAEP",
                             modulusLength: 1024,
                             publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
                             hash: {name: "SHA-1"}, //need shorter hash to accomidate 64 byte HMAC raw export
-                        }, false, ["wrapKey", "unwrapKey"])
+                        }, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "HMAC", hash: {name: "SHA-256"}},
@@ -2399,7 +2589,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="encrypt unsafe">
                     <script>
                         //encrypt
-                        window.crypto.subtle.generateKey(AESCTR, false, ["encrypt"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESCTR, false, ["encrypt"]);
+                        })
                         .then(function(key){
                             return window.crypto.subtle.encrypt({
                                 name: "AES-CTR",
@@ -2414,7 +2606,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="decrypt unsafe">
                     <script>
                         //decrypt
-                        window.crypto.subtle.generateKey(AESCTR, false, ["encrypt", "decrypt"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESCTR, false, ["encrypt", "decrypt"]);
+                        })
                         .then(function(key){
                             var counter = new Uint8Array(16);
                             var length = 128;
@@ -2444,26 +2638,32 @@ <h1>Web Cryptography API Live Table</h1>
                         //generateKey
 
                         //128 bits
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "AES-CTR",
                             length: 128,
-                        }, false, ["encrypt", "decrypt"])
+                        }, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-ctr", "generateKey", "128 bits"))
                         .catch(err("aes-ctr", "generateKey", "128 bits"));
 
                         //192 bits
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "AES-CTR",
                             length: 192,
-                        }, false, ["encrypt", "decrypt"])
+                        }, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-ctr", "generateKey", "192 bits"))
                         .catch(err("aes-ctr", "generateKey", "192 bits"));
 
                         //256 bits
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "AES-CTR",
                             length: 256,
-                        }, false, ["encrypt", "decrypt"])
+                        }, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-ctr", "generateKey", "256 bits"))
                         .catch(err("aes-ctr", "generateKey", "256 bits"));
                     </script>
@@ -2475,20 +2675,24 @@ <h1>Web Cryptography API Live Table</h1>
                         //importKey
 
                         //jwk
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "oct",
                             k: "Y0zt37HgOx-BY7SQjYVmrqhPkO44Ii2Jcb9yydUDPfE",
                             alg: "A256CTR",
                             ext: true,
-                        }, AESCTR, false, ["encrypt", "decrypt"])
+                        }, AESCTR, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-ctr", "importKey", "jwk-key"))
                         .catch(err("aes-ctr", "importKey", "jwk-key"));
 
                         //raw
-                        window.crypto.subtle.importKey("raw", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", new Uint8Array([
                             122,94,39,230,46,23,151,80,131,230,3,101,80,234,143,9,251,
                             152,229,228,89,222,31,135,214,104,55,68,67,59,5,51
-                        ]), AESCTR, false, ["encrypt", "decrypt"])
+                        ]), AESCTR, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-ctr", "importKey", "raw-key"))
                         .catch(err("aes-ctr", "importKey", "raw-key"));
                     </script>
@@ -2496,7 +2700,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="exportKey unsafe">
                     <script>
                         //exportKey
-                        window.crypto.subtle.generateKey(AESCTR, true, ["encrypt", "decrypt"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESCTR, true, ["encrypt", "decrypt"]);
+                        })
                         .then(function(key){
 
                             //jwk
@@ -2516,7 +2722,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="wrapKey unsafe">
                     <script>
                         //RSASSA-PKCS1-v1_5
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSASSA-PKCS1-v1_5",
@@ -2545,7 +2753,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-ctr", "wrapKey", "RSASSA-PKCS1-v1_5"));
 
                         //RSA-PSS
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSA-PSS",
@@ -2575,7 +2785,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-ctr", "wrapKey", "RSA-PSS"));
 
                         //RSA-OAEP
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSA-OAEP",
@@ -2604,7 +2816,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-ctr", "wrapKey", "RSA-OAEP"));
 
                         //ECDSA
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "ECDSA",
@@ -2632,7 +2846,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-ctr", "wrapKey", "ECDSA"));
 
                         //ECDH
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "ECDH",
@@ -2659,7 +2875,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-ctr", "wrapKey", "ECDH"));
 
                         //AES-CTR
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CTR", length: 256},
@@ -2677,7 +2895,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-ctr", "wrapKey", "AES-CTR"));
 
                         //AES-CBC
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CBC", length: 256},
@@ -2695,7 +2915,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-ctr", "wrapKey", "AES-CBC"));
 
                         //AES-GCM
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-GCM", length: 256},
@@ -2713,7 +2935,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-ctr", "wrapKey", "AES-GCM"));
 
                         //HMAC
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "HMAC", hash: {name: "SHA-256"}},
@@ -2734,7 +2958,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="unwrapKey unsafe">
                     <script>
                         //RSASSA-PKCS1-v1_5
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSASSA-PKCS1-v1_5",
@@ -2791,7 +3017,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-ctr", "unwrapKey", "RSASSA-PKCS1-v1_5"));
 
                         //RSA-PSS
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSA-PSS",
@@ -2851,7 +3079,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-ctr", "unwrapKey", "RSA-PSS"));
 
                         //RSA-OAEP
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSA-OAEP",
@@ -2908,7 +3138,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-ctr", "unwrapKey", "RSA-OAEP"));
 
                         //ECDSA
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "ECDSA",
@@ -2962,7 +3194,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-ctr", "unwrapKey", "ECDSA"));
 
                         //ECDH
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "ECDH",
@@ -3016,7 +3250,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-ctr", "unwrapKey", "ECDH"));
 
                         //AES-CTR
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CTR", length: 256},
@@ -3044,7 +3280,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-ctr", "unwrapKey", "AES-CTR"));
 
                         //AES-CBC
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CBC", length: 256},
@@ -3072,7 +3310,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-ctr", "unwrapKey", "AES-CBC"));
 
                         //AES-GCM
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-GCM", length: 256},
@@ -3100,7 +3340,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-ctr", "unwrapKey", "AES-GCM"));
 
                         //HMAC
-                        window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CTR", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "HMAC", hash: {name: "SHA-256"}},
@@ -3148,7 +3390,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="encrypt unsafe">
                     <script>
                         //encrypt
-                        window.crypto.subtle.generateKey(AESCBC, false, ["encrypt"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESCBC, false, ["encrypt"]);
+                        })
                         .then(function(key){
                             return window.crypto.subtle.encrypt({
                                 name: "AES-CBC",
@@ -3162,7 +3406,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="decrypt unsafe">
                     <script>
                         //decrypt
-                        window.crypto.subtle.generateKey(AESCBC, false, ["encrypt", "decrypt"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESCBC, false, ["encrypt", "decrypt"]);
+                        })
                         .then(function(key){
                             var iv = window.crypto.getRandomValues(new Uint8Array(16));
                             window.crypto.subtle.encrypt({
@@ -3189,26 +3435,32 @@ <h1>Web Cryptography API Live Table</h1>
                         //generateKey
 
                         //128 bits
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "AES-CBC",
                             length: 128,
-                        }, false, ["encrypt", "decrypt"])
+                        }, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-cbc", "generateKey", "128 bits"))
                         .catch(err("aes-cbc", "generateKey", "128 bits"));
 
                         //192 bits
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "AES-CBC",
                             length: 192,
-                        }, false, ["encrypt", "decrypt"])
+                        }, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-cbc", "generateKey", "192 bits"))
                         .catch(err("aes-cbc", "generateKey", "192 bits"));
 
                         //256 bits
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "AES-CBC",
                             length: 256,
-                        }, false, ["encrypt", "decrypt"])
+                        }, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-cbc", "generateKey", "256 bits"))
                         .catch(err("aes-cbc", "generateKey", "256 bits"));
                     </script>
@@ -3220,20 +3472,24 @@ <h1>Web Cryptography API Live Table</h1>
                         //importKey
 
                         //jwk
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "oct",
                             k: "KfKY5nueRX7eBrOddn9IerHLv1r-T7qpggaCF3MfSR4",
                             alg: "A256CBC",
                             ext: true,
-                        }, AESCBC, false, ["encrypt", "decrypt"])
+                        }, AESCBC, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-cbc", "importKey", "jwk-key"))
                         .catch(err("aes-cbc", "importKey", "jwk-key"));
 
                         //raw
-                        window.crypto.subtle.importKey("raw", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", new Uint8Array([
                             122,94,39,230,46,23,151,80,131,230,3,101,80,234,143,9,251,
                             152,229,228,89,222,31,135,214,104,55,68,67,59,5,51
-                        ]), AESCBC, false, ["encrypt", "decrypt"])
+                        ]), AESCBC, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-cbc", "importKey", "raw-key"))
                         .catch(err("aes-cbc", "importKey", "raw-key"));
                     </script>
@@ -3241,7 +3497,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="exportKey unsafe">
                     <script>
                         //exportKey
-                        window.crypto.subtle.generateKey(AESCBC, true, ["encrypt", "decrypt"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESCBC, true, ["encrypt", "decrypt"]);
+                        })
                         .then(function(key){
 
                             //jwk
@@ -3261,7 +3519,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="wrapKey unsafe">
                     <script>
                         //RSASSA-PKCS1-v1_5
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSASSA-PKCS1-v1_5",
@@ -3288,7 +3548,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-cbc", "wrapKey", "RSASSA-PKCS1-v1_5"));
 
                         //RSA-PSS
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSA-PSS",
@@ -3316,7 +3578,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-cbc", "wrapKey", "RSA-PSS"));
 
                         //RSA-OAEP
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSA-OAEP",
@@ -3343,7 +3607,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-cbc", "wrapKey", "RSA-OAEP"));
 
                         //ECDSA
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "ECDSA",
@@ -3369,7 +3635,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-cbc", "wrapKey", "ECDSA"));
 
                         //ECDH
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "ECDH",
@@ -3394,7 +3662,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-cbc", "wrapKey", "ECDH"));
 
                         //AES-CTR
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CTR", length: 256},
@@ -3411,7 +3681,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-cbc", "wrapKey", "AES-CTR"));
 
                         //AES-CBC
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CBC", length: 256},
@@ -3428,7 +3700,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-cbc", "wrapKey", "AES-CBC"));
 
                         //AES-GCM
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-GCM", length: 256},
@@ -3445,7 +3719,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-cbc", "wrapKey", "AES-GCM"));
 
                         //HMAC
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "HMAC", hash: {name: "SHA-256"}},
@@ -3465,7 +3741,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="unwrapKey unsafe">
                     <script>
                         //RSASSA-PKCS1-v1_5
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSASSA-PKCS1-v1_5",
@@ -3516,7 +3794,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-cbc", "unwrapKey", "RSASSA-PKCS1-v1_5"));
 
                         //RSA-PSS
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSA-PSS",
@@ -3570,7 +3850,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-cbc", "unwrapKey", "RSA-PSS"));
 
                         //RSA-OAEP
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "RSA-OAEP",
@@ -3621,7 +3903,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-cbc", "unwrapKey", "RSA-OAEP"));
 
                         //ECDSA
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "ECDSA",
@@ -3669,7 +3953,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-cbc", "unwrapKey", "ECDSA"));
 
                         //ECDH
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey({
                                 name: "ECDH",
@@ -3717,7 +4003,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-cbc", "unwrapKey", "ECDH"));
 
                         //AES-CTR
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CTR", length: 256},
@@ -3742,7 +4030,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-cbc", "unwrapKey", "AES-CTR"));
 
                         //AES-CBC
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-CBC", length: 256},
@@ -3767,7 +4057,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-cbc", "unwrapKey", "AES-CBC"));
 
                         //AES-GCM
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "AES-GCM", length: 256},
@@ -3792,7 +4084,9 @@ <h1>Web Cryptography API Live Table</h1>
                         .catch(err("aes-cbc", "unwrapKey", "AES-GCM"));
 
                         //HMAC
-                        window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CBC", length: 256}, false, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(function(wrappingKey){
                             return window.crypto.subtle.generateKey(
                                 {name: "HMAC", hash: {name: "SHA-256"}},
@@ -3837,7 +4131,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="encrypt unsafe">
                     <script>
                         //encrypt
-                        window.crypto.subtle.generateKey(AESCFB, false, ["encrypt"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESCFB, false, ["encrypt"]);
+                        })
                         .then(function(key){
                             return window.crypto.subtle.encrypt({
                                 name: "AES-CFB-8",
@@ -3851,7 +4147,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="decrypt unsafe">
                     <script>
                         //decrypt
-                        window.crypto.subtle.generateKey(AESCFB, false, ["encrypt", "decrypt"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESCFB, false, ["encrypt", "decrypt"]);
+                        })
                         .then(function(key){
                             var iv = window.crypto.getRandomValues(new Uint8Array(16));
                             window.crypto.subtle.encrypt({
@@ -3878,26 +4176,32 @@ <h1>Web Cryptography API Live Table</h1>
                         //generateKey
 
                         //128 bits
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "AES-CFB-8",
                             length: 128,
-                        }, false, ["encrypt", "decrypt"])
+                        }, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-cfb", "generateKey", "128 bits"))
                         .catch(err("aes-cfb", "generateKey", "128 bits"));
 
                         //192 bits
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "AES-CFB-8",
                             length: 192,
-                        }, false, ["encrypt", "decrypt"])
+                        }, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-cfb", "generateKey", "192 bits"))
                         .catch(err("aes-cfb", "generateKey", "192 bits"));
 
                         //256 bits
-                        window.crypto.subtle.generateKey({
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({
                             name: "AES-CFB-8",
                             length: 256,
-                        }, false, ["encrypt", "decrypt"])
+                        }, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-cfb", "generateKey", "256 bits"))
                         .catch(err("aes-cfb", "generateKey", "256 bits"));
                     </script>
@@ -3909,20 +4213,24 @@ <h1>Web Cryptography API Live Table</h1>
                         //importKey
 
                         //jwk
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "oct",
                             k: "Y0zt37HgOx-BY7SQjYVmrqhPkO44Ii2Jcb9yydUDPfE",
                             alg: "A256CFB8",
                             ext: true,
-                        }, AESCFB, false, ["encrypt", "decrypt"])
+                        }, AESCFB, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-cfb", "importKey", "jwk-key"))
                         .catch(err("aes-cfb", "importKey", "jwk-key"));
 
                         //raw
-                        window.crypto.subtle.importKey("raw", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", new Uint8Array([
                             122,94,39,230,46,23,151,80,131,230,3,101,80,234,143,9,251,
                             152,229,228,89,222,31,135,214,104,55,68,67,59,5,51
-                        ]), AESCFB, false, ["encrypt", "decrypt"])
+                        ]), AESCFB, false, ["encrypt", "decrypt"]);
+                        })
                         .then(ok("aes-cfb", "importKey", "raw-key"))
                         .catch(err("aes-cfb", "importKey", "raw-key"));
                     </script>
@@ -3930,7 +4238,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="exportKey unsafe">
                     <script>
                         //exportKey
-                        window.crypto.subtle.generateKey(AESCFB, true, ["encrypt", "decrypt"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESCFB, true, ["encrypt", "decrypt"]);
+                        })
                         .then(function(key){
 
                             //jwk
@@ -3949,14 +4259,18 @@ <h1>Web Cryptography API Live Table</h1>
                 </td>
                 <td class="wrapKey unsafe">
                     <script>
-                        window.crypto.subtle.generateKey(AESCFB, true, ["wrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESCFB, true, ["wrapKey"]);
+                        })
                         .then(ok("aes-cfb", "wrapKey", "TODO"))
                         .catch(err("aes-cfb", "wrapKey", "N/A"));
                     </script>
                 </td>
                 <td class="unwrapKey unsafe">
                     <script>
-                        window.crypto.subtle.generateKey(AESCFB, true, ["wrapKey", "unwrapKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESCFB, true, ["wrapKey", "unwrapKey"]);
+                        })
                         .then(ok("aes-cfb", "unwrapKey", "TODO"))
                         .catch(err("aes-cfb", "unwrapKey", "N/A"));
                     </script>
@@ -3987,7 +4301,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="sign unsafe">
                     <script>
                         //sign
-                        window.crypto.subtle.generateKey(RSASSA, false, ["sign"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(RSASSA, false, ["sign"]);
+                        })
                         .then(function(key){
                             return window.crypto.subtle.sign(RSASSA, key.privateKey, TESTBYTES);
                         })
@@ -3998,7 +4314,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="verify unsafe">
                     <script>
                         //verify
-                        window.crypto.subtle.generateKey(RSASSA, false, ["sign", "verify"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(RSASSA, false, ["sign", "verify"]);
+                        })
                         .then(function(key){
                             window.crypto.subtle.sign(RSASSA, key.privateKey, TESTBYTES)
                             .then(function(sig){
@@ -4059,17 +4377,20 @@ <h1>Web Cryptography API Live Table</h1>
                         //importKey
 
                         //jwk
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "RSA",
                             e: "AQAB",
                             n: "vGO3eU16ag9zRkJ4AK8ZUZrjbtp5xWK0LyFMNT8933evJoHeczexMUzSiXaLrEFSyQZortk81zJH3y41MBO_UFDO_X0crAquNrkjZDrf9Scc5-MdxlWU2Jl7Gc4Z18AC9aNibWVmXhgvHYkEoFdLCFG-2Sq-qIyW4KFkjan05IE",
                             alg: "RS256",
                             ext: true,
-                        }, RSASSA, false, ["verify"])
+                        }, RSASSA, false, ["verify"]);
+                        })
                         .then(ok("rsassa-pkcs1", "importKey", "jwk-pub"))
                         .catch(err("rsassa-pkcs1", "importKey", "jwk-pub"));
 
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "RSA",
                             e: "AQAB",
                             d: "n_dIVw9MD_04lANi5KnKJPoRfxKy7cGHYLG0hU5DGpsFNfx2yH0Uz9j8uU7ZARai1iHECBxcxhpi3wbckQtjmbkCUKvs4G0gKLT9UuNHcCbh0WfvadfPPec52n4z6s4zwisbgWCNbT2L-SyHt1yuFmLAYXkg0swk3y5Bt_ilA8E",
@@ -4081,12 +4402,14 @@ <h1>Web Cryptography API Live Table</h1>
                             qi: "R3CkCGVAESy_hChmDvUaLMT-R1xk6kK7RLIUQKXATPQbnDqWBMgm-vcawFVhKJ-ICJsPfmRUsv7Wt1bJ01wLGQ",
                             alg: "RS256",
                             ext: true,
-                        }, RSASSA, false, ["sign"])
+                        }, RSASSA, false, ["sign"]);
+                        })
                         .then(ok("rsassa-pkcs1", "importKey", "jwk-priv"))
                         .catch(err("rsassa-pkcs1", "importKey", "jwk-priv"));
 
                         //spki
-                        window.crypto.subtle.importKey("spki", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("spki", new Uint8Array([
                             48,129,159,48,13,6,9,42,134,72,134,247,13,1,1,1,5,0,3,
                             129,141,0,48,129,137,2,129,129,0,182,93,35,213,252,204,
                             20,103,91,238,105,199,53,114,24,221,114,210,137,173,88,
@@ -4097,12 +4420,14 @@ <h1>Web Cryptography API Live Table</h1>
                             110,3,70,202,148,95,45,228,94,95,148,2,162,79,146,137,29,
                             189,102,75,207,214,116,58,63,171,219,27,5,9,108,16,218,23,
                             169,43,181,119,31,172,95,205,180,18,255,203,2,3,1,0,1
-                        ]), RSASSA, false, ["verify"])
+                        ]), RSASSA, false, ["verify"]);
+                        })
                         .then(ok("rsassa-pkcs1", "importKey", "spki-pub"))
                         .catch(err("rsassa-pkcs1", "importKey", "spki-pub"));
 
                         //pkcs8
-                        window.crypto.subtle.importKey("pkcs8", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("pkcs8", new Uint8Array([
                             48,130,2,118,2,1,0,48,13,6,9,42,134,72,134,247,13,1,1,1,5,0,4,130,2,96,48,130,2,92,2,1,0,2,129,
                             129,0,217,78,147,218,221,152,10,66,75,127,242,108,182,142,157,44,93,58,176,193,135,103,216,179,
                             69,72,38,115,144,244,12,139,0,245,48,115,204,234,158,193,231,127,178,240,244,203,35,229,203,245,
@@ -4126,7 +4451,8 @@ <h1>Web Cryptography API Live Table</h1>
                             253,30,241,2,64,15,148,8,16,189,122,55,109,203,175,173,24,222,36,130,130,179,87,189,32,141,149,30,
                             115,211,227,79,234,78,202,253,48,173,95,167,203,20,193,160,30,146,33,109,4,221,25,212,216,183,100,
                             18,46,184,52,65,146,249,68,225,10,84,38,98,133
-                        ]), RSASSA, false, ["sign"])
+                        ]), RSASSA, false, ["sign"]);
+                        })
                         .then(ok("rsassa-pkcs1", "importKey", "pkcs8-priv"))
                         .catch(err("rsassa-pkcs1", "importKey", "pkcs8-priv"));
                     </script>
@@ -4134,7 +4460,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="exportKey unsafe">
                     <script>
                         //exportKey
-                        window.crypto.subtle.generateKey(RSASSA, true, ["sign", "verify"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(RSASSA, true, ["sign", "verify"]);
+                        })
                         .then(function(key){
 
                             //jwk
@@ -4189,7 +4517,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="sign unsafe">
                     <script>
                         //sign
-                        window.crypto.subtle.generateKey(RSAPSS, false, ["sign"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(RSAPSS, false, ["sign"]);
+                        })
                         .then(function(key){
                             return window.crypto.subtle.sign(RSAPSS, key.privateKey, TESTBYTES);
                         })
@@ -4200,7 +4530,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="verify unsafe">
                     <script>
                         //verify
-                        window.crypto.subtle.generateKey(RSAPSS, false, ["sign", "verify"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(RSAPSS, false, ["sign", "verify"]);
+                        })
                         .then(function(key){
                             window.crypto.subtle.sign(RSAPSS, key.privateKey, TESTBYTES)
                             .then(function(sig){
@@ -4264,17 +4596,20 @@ <h1>Web Cryptography API Live Table</h1>
                         //importKey
 
                         //jwk
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "RSA",
                             e: "AQAB",
                             n: "vGO3eU16ag9zRkJ4AK8ZUZrjbtp5xWK0LyFMNT8933evJoHeczexMUzSiXaLrEFSyQZortk81zJH3y41MBO_UFDO_X0crAquNrkjZDrf9Scc5-MdxlWU2Jl7Gc4Z18AC9aNibWVmXhgvHYkEoFdLCFG-2Sq-qIyW4KFkjan05IE",
                             alg: "PS256",
                             ext: true,
-                        }, RSAPSS, false, ["verify"])
+                        }, RSAPSS, false, ["verify"]);
+                        })
                         .then(ok("rsa-pss", "importKey", "jwk-pub"))
                         .catch(err("rsa-pss", "importKey", "jwk-pub"));
 
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "RSA",
                             e: "AQAB",
                             d: "n_dIVw9MD_04lANi5KnKJPoRfxKy7cGHYLG0hU5DGpsFNfx2yH0Uz9j8uU7ZARai1iHECBxcxhpi3wbckQtjmbkCUKvs4G0gKLT9UuNHcCbh0WfvadfPPec52n4z6s4zwisbgWCNbT2L-SyHt1yuFmLAYXkg0swk3y5Bt_ilA8E",
@@ -4286,12 +4621,14 @@ <h1>Web Cryptography API Live Table</h1>
                             qi: "R3CkCGVAESy_hChmDvUaLMT-R1xk6kK7RLIUQKXATPQbnDqWBMgm-vcawFVhKJ-ICJsPfmRUsv7Wt1bJ01wLGQ",
                             alg: "PS256",
                             ext: true,
-                        }, RSAPSS, false, ["sign"])
+                        }, RSAPSS, false, ["sign"]);
+                        })
                         .then(ok("rsa-pss", "importKey", "jwk-priv"))
                         .catch(err("rsa-pss", "importKey", "jwk-priv"));
 
                         //spki
-                        window.crypto.subtle.importKey("spki", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("spki", new Uint8Array([
                             48,129,159,48,13,6,9,42,134,72,134,247,13,1,1,1,5,0,3,129,141,0,
                             48,129,137,2,129,129,0,180,31,227,200,37,227,65,238,23,91,226,130,
                             51,32,165,245,1,24,244,5,184,42,181,155,23,142,249,220,222,131,
@@ -4301,12 +4638,14 @@ <h1>Web Cryptography API Live Table</h1>
                             124,200,105,75,104,158,156,158,238,214,14,81,95,130,155,146,114,
                             125,88,158,212,44,65,236,228,194,105,96,211,155,60,71,134,90,151,
                             202,68,20,228,105,249,202,170,155,2,3,1,0,1
-                        ]), RSAPSS, false, ["verify"])
+                        ]), RSAPSS, false, ["verify"]);
+                        })
                         .then(ok("rsa-pss", "importKey", "spki-pub"))
                         .catch(err("rsa-pss", "importKey", "spki-pub"));
 
                         //pkcs8
-                        window.crypto.subtle.importKey("pkcs8", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("pkcs8", new Uint8Array([
                             48,130,2,119,2,1,0,48,13,6,9,42,134,72,134,247,13,1,1,1,5,0,4,130,2,97,48,130,2,93,2,1,0,
                             2,129,129,0,180,31,227,200,37,227,65,238,23,91,226,130,51,32,165,245,1,24,244,5,184,42,181,
                             155,23,142,249,220,222,131,175,54,117,135,64,232,120,90,160,221,18,31,200,41,23,174,18,172,
@@ -4332,7 +4671,8 @@ <h1>Web Cryptography API Live Table</h1>
                             141,176,179,203,180,190,224,34,134,226,151,73,139,163,47,17,179,117,167,200,255,174,67,114,
                             158,96,195,176,163,241,96,24,72,35,38,18,132,176,76,235,8,29,225,138,155,191,97,158,3,22,114,
                             133,176,213,207,120,33,55,52,135,79,161
-                        ]), RSAPSS, false, ["sign"])
+                        ]), RSAPSS, false, ["sign"]);
+                        })
                         .then(ok("rsa-pss", "importKey", "pkcs8-priv"))
                         .catch(err("rsa-pss", "importKey", "pkcs8-priv"));
                     </script>
@@ -4340,7 +4680,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="exportKey unsafe">
                     <script>
                         //exportKey
-                        window.crypto.subtle.generateKey(RSAPSS, true, ["sign", "verify"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(RSAPSS, true, ["sign", "verify"]);
+                        })
                         .then(function(key){
 
                             //jwk
@@ -4390,7 +4732,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="sign unsafe">
                     <script>
                         //sign
-                        window.crypto.subtle.generateKey(AESCMAC, false, ["sign"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESCMAC, false, ["sign"]);
+                        })
                         .then(function(key){
                             return window.crypto.subtle.sign({name: "AES-CMAC", lenth: 256}, key, TESTBYTES);
                         })
@@ -4401,7 +4745,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="verify unsafe">
                     <script>
                         //verify
-                        window.crypto.subtle.generateKey(AESCMAC, false, ["sign", "verify"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESCMAC, false, ["sign", "verify"]);
+                        })
                         .then(function(key){
                             window.crypto.subtle.sign({name: "AES-CMAC", lenth: 256}, key, TESTBYTES)
                             .then(function(sig){
@@ -4419,17 +4765,23 @@ <h1>Web Cryptography API Live Table</h1>
                         //generateKey
 
                         //128 bits
-                        window.crypto.subtle.generateKey({name: "AES-CMAC", length: 128}, false, ["sign", "verify"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CMAC", length: 128}, false, ["sign", "verify"]);
+                        })
                         .then(ok("aes-cmac", "generateKey", "128 bits"))
                         .catch(err("aes-cmac", "generateKey", "128 bits"));
 
                         //192 bits
-                        window.crypto.subtle.generateKey({name: "AES-CMAC", length: 192}, false, ["sign", "verify"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CMAC", length: 192}, false, ["sign", "verify"]);
+                        })
                         .then(ok("aes-cmac", "generateKey", "192 bits"))
                         .catch(err("aes-cmac", "generateKey", "192 bits"));
 
                         //256 bits
-                        window.crypto.subtle.generateKey({name: "AES-CMAC", length: 256}, false, ["sign", "verify"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey({name: "AES-CMAC", length: 256}, false, ["sign", "verify"]);
+                        })
                         .then(ok("aes-cmac", "generateKey", "256 bits"))
                         .catch(err("aes-cmac", "generateKey", "256 bits"));
                     </script>
@@ -4441,20 +4793,24 @@ <h1>Web Cryptography API Live Table</h1>
                         //importKey
 
                         //jwk
-                        window.crypto.subtle.importKey("jwk", {
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("jwk", {
                             kty: "oct",
                             k: "Y0zt37HgOx-BY7SQjYVmrqhPkO44Ii2Jcb9yydUDPfE",
                             alg: "A256CMAC",
                             ext: true,
-                        }, AESCMAC, false, ["sign", "verify"])
+                        }, AESCMAC, false, ["sign", "verify"]);
+                        })
                         .then(ok("aes-cmac", "importKey", "jwk-key"))
                         .catch(err("aes-cmac", "importKey", "jwk-key"));
 
                         //raw
-                        window.crypto.subtle.importKey("raw", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", new Uint8Array([
                             122,94,39,230,46,23,151,80,131,230,3,101,80,234,143,9,251,
                             152,229,228,89,222,31,135,214,104,55,68,67,59,5,51
-                        ]), AESCMAC, false, ["sign", "verify"])
+                        ]), AESCMAC, false, ["sign", "verify"]);
+                        })
                         .then(ok("aes-cmac", "importKey", "raw-key"))
                         .catch(err("aes-cmac", "importKey", "raw-key"));
                     </script>
@@ -4462,7 +4818,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="exportKey unsafe">
                     <script>
                         //exportKey
-                        window.crypto.subtle.generateKey(AESCMAC, true, ["sign", "verify"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(AESCMAC, true, ["sign", "verify"]);
+                        })
                         .then(function(key){
 
                             //jwk
@@ -4498,7 +4856,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="digest unsafe">
                     <script>
                         //digest
-                        window.crypto.subtle.digest({name: "SHA-1"}, TESTBYTES)
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.digest({name: "SHA-1"}, TESTBYTES);
+                        })
                         .then(ok("sha-1", "digest", "Yes"))
                         .catch(err("sha-1", "digest", "No"));
                     </script>
@@ -4549,7 +4909,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="generateKey unsafe">
                     <script>
                         //generateKey
-                        window.crypto.subtle.generateKey(DH, false, ["deriveBits", "deriveKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(DH, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(ok("dh", "generateKey", "Yes"))
                         .catch(err("dh", "generateKey", "No"));
                     </script>
@@ -4557,7 +4919,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="deriveKey unsafe">
                     <script>
                         //deriveKey
-                        window.crypto.subtle.generateKey(DH, false, ["deriveKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(DH, false, ["deriveKey"]);
+                        })
                         .then(function(key1){
                             window.crypto.subtle.generateKey(DH, false, ["deriveKey"])
                             .then(function(key2){
@@ -4593,7 +4957,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="deriveBits unsafe">
                     <script>
                         //deriveBits
-                        window.crypto.subtle.generateKey(DH, false, ["deriveBits"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(DH, false, ["deriveBits"]);
+                        })
                         .then(function(key1){
                             window.crypto.subtle.generateKey(DH, false, ["deriveBits"])
                             .then(function(key2){
@@ -4631,7 +4997,8 @@ <h1>Web Cryptography API Live Table</h1>
                         //importKey
 
                         //raw
-                        window.crypto.subtle.importKey("raw", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", new Uint8Array([
                             203,25,0,203,43,75,46,159,217,37,185,181,25,220,71,187,112,195,251,233,152,56,206,
                             93,18,96,87,132,17,113,166,110,123,190,194,168,100,147,21,174,131,80,8,247,125,35,
                             210,70,103,141,152,173,99,74,34,132,92,134,216,55,171,186,89,167,189,217,164,119,
@@ -4641,12 +5008,14 @@ <h1>Web Cryptography API Live Table</h1>
                             203,118,217,91,45,58,172,165,224,122,230,50,135,120,124,37,190,186,204,103,218,19,
                             91,246,115,6,199,45,121,156,149,6,208,85,26,94,171,165,228,58,200,49,82,210,170,243,
                             154,190,15,2,225,143,159
-                        ]), DH, false, [])
+                        ]), DH, false, []);
+                        })
                         .then(ok("dh", "importKey", "raw-pub"))
                         .catch(err("dh", "importKey", "raw-pub"));
 
                         //spki
-                        window.crypto.subtle.importKey("spki", new Uint8Array([
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("spki", new Uint8Array([
                             48,130,1,160,48,129,214,6,9,42,134,72,134,247,13,1,3,1,48,129,200,2,129,192,
                             255,255,255,255,255,255,255,255,201,15,218,162,33,104,194,52,196,198,98,139,
                             128,220,28,209,41,2,78,8,138,103,204,116,2,11,190,166,59,19,155,34,81,74,8,
@@ -4666,12 +5035,15 @@ <h1>Web Cryptography API Live Table</h1>
                             197,29,246,201,146,241,249,123,67,52,67,24,167,232,249,3,191,254,50,249,76,14,237,
                             1,116,7,157,11,248,166,79,140,76,241,191,184,146,143,52,91,164,209,63,124,116,6,
                             150,123,68,137,168,229,210,250,198,7
-                        ]), DH, false, [])
+                        ]), DH, false, []);
+                        })
                         .then(ok("dh", "importKey", "spki-pub"))
                         .catch(err("dh", "importKey", "spki-pub"));
 
                         //pkcs8
-                        window.crypto.subtle.importKey("pkcs8", null, DH, false, ["deriveBits", "deriveKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("pkcs8", null, DH, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(ok("dh", "importKey", "pkcs8-priv"))
                         .catch(err("dh", "importKey", "pkcs8-priv*"));
                     </script>
@@ -4679,7 +5051,9 @@ <h1>Web Cryptography API Live Table</h1>
                 <td class="exportKey unsafe">
                     <script>
                         //exportKey
-                        window.crypto.subtle.generateKey(DH, true, ["deriveBits", "deriveKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.generateKey(DH, true, ["deriveBits", "deriveKey"]);
+                        })
                         .then(function(key){
 
                             //raw
@@ -4727,7 +5101,9 @@ <h1>Web Cryptography API Live Table</h1>
                     <script>
                         //deriveKey
                         var keydata = window.crypto.getRandomValues(new Uint8Array(16));
-                        window.crypto.subtle.importKey("raw", keydata, {name: "CONCAT"}, false, ["deriveBits", "deriveKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", keydata, {name: "CONCAT"}, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(function(key){
 
                             window.crypto.subtle.deriveBits({
@@ -4750,7 +5126,9 @@ <h1>Web Cryptography API Live Table</h1>
                     <script>
                         //deriveBits
                         var keydata = window.crypto.getRandomValues(new Uint8Array(16));
-                        window.crypto.subtle.importKey("raw", keydata, {name: "CONCAT"}, false, ["deriveBits", "deriveKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", keydata, {name: "CONCAT"}, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(function(key){
 
                             window.crypto.subtle.deriveBits({
@@ -4775,7 +5153,9 @@ <h1>Web Cryptography API Live Table</h1>
 
                         //raw
                         var keydata = window.crypto.getRandomValues(new Uint8Array(16));
-                        window.crypto.subtle.importKey("raw", keydata, {name: "CONCAT"}, false, ["deriveBits", "deriveKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", keydata, {name: "CONCAT"}, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(ok("concatkdf", "importKey", "raw"))
                         .catch(err("concatkdf", "importKey", "raw*"));
                     </script>
@@ -4803,7 +5183,9 @@ <h1>Web Cryptography API Live Table</h1>
                     <script>
                         //deriveKey
                         var keydata = window.crypto.getRandomValues(new Uint8Array(16));
-                        window.crypto.subtle.importKey("raw", keydata, {name: "HKDF-CTR"}, false, ["deriveBits", "deriveKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", keydata, {name: "HKDF-CTR"}, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(function(key){
 
                             window.crypto.subtle.deriveBits({
@@ -4823,7 +5205,9 @@ <h1>Web Cryptography API Live Table</h1>
                     <script>
                         //deriveBits
                         var keydata = window.crypto.getRandomValues(new Uint8Array(16));
-                        window.crypto.subtle.importKey("raw", keydata, {name: "HKDF-CTR"}, false, ["deriveBits", "deriveKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", keydata, {name: "HKDF-CTR"}, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(function(key){
 
                             window.crypto.subtle.deriveBits({
@@ -4845,7 +5229,9 @@ <h1>Web Cryptography API Live Table</h1>
 
                         //raw
                         var keydata = window.crypto.getRandomValues(new Uint8Array(16));
-                        window.crypto.subtle.importKey("raw", keydata, {name: "HKDF-CTR"}, false, ["deriveBits", "deriveKey"])
+                        Promise.resolve().then(function(){
+                            return window.crypto.subtle.importKey("raw", keydata, {name: "HKDF-CTR"}, false, ["deriveBits", "deriveKey"]);
+                        })
                         .then(ok("hkdf-ctr", "importKey", "raw"))
                         .catch(err("hkdf-ctr", "importKey", "raw*"));
                     </script>