Update to TypeScript 3.7 (#3275)

and update to prettier 1.19

Also, update `assert()` and remove not null assertions where possibly
in `cli`.

Closes #3273

cli/js/body.ts

@@ -72,41 +72,35 @@ function concatenate(...arrays: Uint8Array[]): ArrayBuffer {
 }
 
 function bufferFromStream(stream: ReadableStreamReader): Promise<ArrayBuffer> {
-  return new Promise(
-    (resolve, reject): void => {
-      const parts: Uint8Array[] = [];
-      const encoder = new TextEncoder();
-      // recurse
-      (function pump(): void {
-        stream
-          .read()
-          .then(
-            ({ done, value }): void => {
-              if (done) {
-                return resolve(concatenate(...parts));
-              }
+  return new Promise((resolve, reject): void => {
+    const parts: Uint8Array[] = [];
+    const encoder = new TextEncoder();
+    // recurse
+    (function pump(): void {
+      stream
+        .read()
+        .then(({ done, value }): void => {
+          if (done) {
+            return resolve(concatenate(...parts));
+          }
 
-              if (typeof value === "string") {
-                parts.push(encoder.encode(value));
-              } else if (value instanceof ArrayBuffer) {
-                parts.push(new Uint8Array(value));
-              } else if (!value) {
-                // noop for undefined
-              } else {
-                reject("unhandled type on stream read");
-              }
+          if (typeof value === "string") {
+            parts.push(encoder.encode(value));
+          } else if (value instanceof ArrayBuffer) {
+            parts.push(new Uint8Array(value));
+          } else if (!value) {
+            // noop for undefined
+          } else {
+            reject("unhandled type on stream read");
+          }
 
-              return pump();
-            }
-          )
-          .catch(
-            (err): void => {
-              reject(err);
-            }
-          );
-      })();
-    }
-  );
+          return pump();
+        })
+        .catch((err): void => {
+          reject(err);
+        });
+    })();
+  });
 }
 
 function getHeaderValueParams(value: string): Map<string, string> {
@@ -275,19 +269,17 @@ export class Body implements domTypes.Body {
         body
           .trim()
           .split("&")
-          .forEach(
-            (bytes): void => {
-              if (bytes) {
-                const split = bytes.split("=");
-                const name = split.shift()!.replace(/\+/g, " ");
-                const value = split.join("=").replace(/\+/g, " ");
-                formData.append(
-                  decodeURIComponent(name),
-                  decodeURIComponent(value)
-                );
-              }
+          .forEach((bytes): void => {
+            if (bytes) {
+              const split = bytes.split("=");
+              const name = split.shift()!.replace(/\+/g, " ");
+              const value = split.join("=").replace(/\+/g, " ");
+              formData.append(
+                decodeURIComponent(name),
+                decodeURIComponent(value)
+              );
             }
-          );
+          });
       } catch (e) {
         throw new TypeError("Invalid form urlencoded format");
       }

cli/js/compiler.ts

@@ -67,7 +67,8 @@ type CompilerRequest = {
   | {
       type: CompilerRequestType.Bundle;
       outFile?: string;
-    });
+    }
+);
 
 interface ConfigureResponse {
   ignoredOptions?: string[];
@@ -186,11 +187,7 @@ class SourceFile {
       throw new Error("SourceFile has already been processed.");
     }
     assert(this.sourceCode != null);
-    const preProcessedFileInfo = ts.preProcessFile(
-      this.sourceCode!,
-      true,
-      true
-    );
+    const preProcessedFileInfo = ts.preProcessFile(this.sourceCode, true, true);
     this.processed = true;
     const files = (this.importedFiles = [] as Array<[string, string]>);
 
@@ -511,10 +508,10 @@ class Host implements ts.CompilerHost {
         ? this._getAsset(fileName)
         : SourceFile.get(fileName);
       assert(sourceFile != null);
-      if (!sourceFile!.tsSourceFile) {
-        sourceFile!.tsSourceFile = ts.createSourceFile(
+      if (!sourceFile.tsSourceFile) {
+        sourceFile.tsSourceFile = ts.createSourceFile(
           fileName,
-          sourceFile!.sourceCode,
+          sourceFile.sourceCode,
           languageVersion
         );
       }
@@ -577,7 +574,7 @@ class Host implements ts.CompilerHost {
         emitBundle(this._rootNames, this._outFile, data, sourceFiles!);
       } else {
         assert(sourceFiles.length == 1);
-        const url = sourceFiles![0].fileName;
+        const url = sourceFiles[0].fileName;
         const sourceFile = SourceFile.get(url);
 
         if (sourceFile) {
@@ -635,9 +632,9 @@ window.compilerMain = function compilerMain(): void {
     // This will recursively analyse all the code for other imports, requesting
     // those from the privileged side, populating the in memory cache which
     // will be used by the host, before resolving.
-    const resolvedRootModules = (await processImports(
-      rootNames.map(rootName => [rootName, rootName])
-    )).map(info => info.url);
+    const resolvedRootModules = (
+      await processImports(rootNames.map(rootName => [rootName, rootName]))
+    ).map(info => info.url);
 
     const host = new Host(
       request.type,
@@ -669,8 +666,9 @@ window.compilerMain = function compilerMain(): void {
       const options = host.getCompilationSettings();
       const program = ts.createProgram(rootNames, options, host);
 
-      diagnostics = ts.getPreEmitDiagnostics(program).filter(
-        ({ code }): boolean => {
+      diagnostics = ts
+        .getPreEmitDiagnostics(program)
+        .filter(({ code }): boolean => {
           // TS1103: 'for-await-of' statement is only allowed within an async
           // function or async generator.
           if (code === 1103) return false;
@@ -692,8 +690,7 @@ window.compilerMain = function compilerMain(): void {
           // so we will ignore complaints about this compiler setting.
           if (code === 5070) return false;
           return true;
-        }
-      );
+        });
 
       // We will only proceed with the emit if there are no diagnostics.
       if (diagnostics && diagnostics.length === 0) {

cli/js/console.ts

@@ -292,20 +292,18 @@ function createRawObjectString(
     shouldShowClassName = true;
   }
   const keys = Object.keys(value);
-  const entries: string[] = keys.map(
-    (key): string => {
-      if (keys.length > OBJ_ABBREVIATE_SIZE) {
-        return key;
-      } else {
-        return `${key}: ${stringifyWithQuotes(
-          value[key],
-          ctx,
-          level + 1,
-          maxLevel
-        )}`;
-      }
+  const entries: string[] = keys.map((key): string => {
+    if (keys.length > OBJ_ABBREVIATE_SIZE) {
+      return key;
+    } else {
+      return `${key}: ${stringifyWithQuotes(
+        value[key],
+        ctx,
+        level + 1,
+        maxLevel
+      )}`;
     }
-  );
+  });
 
   ctx.delete(value);
 
@@ -640,43 +638,39 @@ export class Console {
       let idx = 0;
       resultData = {};
 
-      data.forEach(
-        (v: unknown, k: unknown): void => {
-          resultData[idx] = { Key: k, Values: v };
-          idx++;
-        }
-      );
+      data.forEach((v: unknown, k: unknown): void => {
+        resultData[idx] = { Key: k, Values: v };
+        idx++;
+      });
     } else {
       resultData = data!;
     }
 
-    Object.keys(resultData).forEach(
-      (k, idx): void => {
-        const value: unknown = resultData[k]!;
+    Object.keys(resultData).forEach((k, idx): void => {
+      const value: unknown = resultData[k]!;
 
-        if (value !== null && typeof value === "object") {
-          Object.entries(value as { [key: string]: unknown }).forEach(
-            ([k, v]): void => {
-              if (properties && !properties.includes(k)) {
-                return;
-              }
-
-              if (objectValues[k]) {
-                objectValues[k].push(stringifyValue(v));
-              } else {
-                objectValues[k] = createColumn(v, idx);
-              }
+      if (value !== null && typeof value === "object") {
+        Object.entries(value as { [key: string]: unknown }).forEach(
+          ([k, v]): void => {
+            if (properties && !properties.includes(k)) {
+              return;
             }
-          );
 
-          values.push("");
-        } else {
-          values.push(stringifyValue(value));
-        }
+            if (objectValues[k]) {
+              objectValues[k].push(stringifyValue(v));
+            } else {
+              objectValues[k] = createColumn(v, idx);
+            }
+          }
+        );
 
-        indexKeys.push(k);
+        values.push("");
+      } else {
+        values.push(stringifyValue(value));
       }
-    );
+
+      indexKeys.push(k);
+    });
 
     const headerKeys = Object.keys(objectValues);
     const bodyValues = Object.values(objectValues);

cli/js/console_table.ts

@@ -72,8 +72,8 @@ export function cliTable(head: string[], columns: string[][]): string {
     }
   }
 
-  const divider = columnWidths.map(
-    (i: number): string => tableChars.middleMiddle.repeat(i + 2)
+  const divider = columnWidths.map((i: number): string =>
+    tableChars.middleMiddle.repeat(i + 2)
   );
 
   let result =

cli/js/console_test.ts

@@ -121,7 +121,12 @@ test(function consoleTestStringifyCircular(): void {
   );
   assertEquals(stringify(new Set([1, 2, 3])), "Set { 1, 2, 3 }");
   assertEquals(
-    stringify(new Map([[1, "one"], [2, "two"]])),
+    stringify(
+      new Map([
+        [1, "one"],
+        [2, "two"]
+      ])
+    ),
     `Map { 1 => "one", 2 => "two" }`
   );
   assertEquals(stringify(new WeakSet()), "WeakSet { [items unknown] }");
@@ -130,12 +135,18 @@ test(function consoleTestStringifyCircular(): void {
   assertEquals(stringify(null), "null");
   assertEquals(stringify(undefined), "undefined");
   assertEquals(stringify(new Extended()), "Extended { a: 1, b: 2 }");
-  assertEquals(stringify(function f(): void {}), "[Function: f]");
+  assertEquals(
+    stringify(function f(): void {}),
+    "[Function: f]"
+  );
   assertEquals(
     stringify(async function af(): Promise<void> {}),
     "[AsyncFunction: af]"
   );
-  assertEquals(stringify(function* gf() {}), "[GeneratorFunction: gf]");
+  assertEquals(
+    stringify(function* gf() {}),
+    "[GeneratorFunction: gf]"
+  );
   assertEquals(
     stringify(async function* agf() {}),
     "[AsyncGeneratorFunction: agf]"
@@ -410,50 +421,47 @@ function mockConsole(f: ConsoleExamineFunc): void {
 
 // console.group test
 test(function consoleGroup(): void {
-  mockConsole(
-    (console, out): void => {
-      console.group("1");
-      console.log("2");
-      console.group("3");
-      console.log("4");
-      console.groupEnd();
-      console.groupEnd();
-      console.log("5");
-      console.log("6");
+  mockConsole((console, out): void => {
+    console.group("1");
+    console.log("2");
+    console.group("3");
+    console.log("4");
+    console.groupEnd();
+    console.groupEnd();
+    console.log("5");
+    console.log("6");
 
-      assertEquals(
-        out.toString(),
-        `1
+    assertEquals(
+      out.toString(),
+      `1
   2
   3
     4
 5
 6
 `
-      );
-    }
-  );
+    );
+  });
 });
 
 // console.group with console.warn test
 test(function consoleGroupWarn(): void {
-  mockConsole(
-    (console, _out, _err, both): void => {
-      console.warn("1");
-      console.group();
-      console.warn("2");
-      console.group();
-      console.warn("3");
-      console.groupEnd();
-      console.warn("4");
-      console.groupEnd();
-      console.warn("5");
+  mockConsole((console, _out, _err, both): void => {
+    console.warn("1");
+    console.group();
+    console.warn("2");
+    console.group();
+    console.warn("3");
+    console.groupEnd();
+    console.warn("4");
+    console.groupEnd();
+    console.warn("5");
 
-      console.warn("6");
-      console.warn("7");
-      assertEquals(
-        both.toString(),
-        `1
+    console.warn("6");
+    console.warn("7");
+    assertEquals(
+      both.toString(),
+      `1
   2
     3
   4
@@ -461,49 +469,43 @@ test(function consoleGroupWarn(): void {
 6
 7
 `
-      );
-    }
-  );
+    );
+  });
 });
 
 // console.table test
 test(function consoleTable(): void {
-  mockConsole(
-    (console, out): void => {
-      console.table({ a: "test", b: 1 });
-      assertEquals(
-        out.toString(),
-        `┌─────────┬────────┐
+  mockConsole((console, out): void => {
+    console.table({ a: "test", b: 1 });
+    assertEquals(
+      out.toString(),
+      `┌─────────┬────────┐
 │ (index) │ Values │
 ├─────────┼────────┤
 │    a    │ "test" │
 │    b    │   1    │
 └─────────┴────────┘
 `
-      );
-    }
-  );
-  mockConsole(
-    (console, out): void => {
-      console.table({ a: { b: 10 }, b: { b: 20, c: 30 } }, ["c"]);
-      assertEquals(
-        out.toString(),
-        `┌─────────┬────┐
+    );
+  });
+  mockConsole((console, out): void => {
+    console.table({ a: { b: 10 }, b: { b: 20, c: 30 } }, ["c"]);
+    assertEquals(
+      out.toString(),
+      `┌─────────┬────┐
 │ (index) │ c  │
 ├─────────┼────┤
 │    a    │    │
 │    b    │ 30 │
 └─────────┴────┘
 `
-      );
-    }
-  );
-  mockConsole(
-    (console, out): void => {
-      console.table([1, 2, [3, [4]], [5, 6], [[7], [8]]]);
-      assertEquals(
-        out.toString(),
-        `┌─────────┬───────┬───────┬────────┐
+    );
+  });
+  mockConsole((console, out): void => {
+    console.table([1, 2, [3, [4]], [5, 6], [[7], [8]]]);
+    assertEquals(
+      out.toString(),
+      `┌─────────┬───────┬───────┬────────┐
 │ (index) │   0   │   1   │ Values │
 ├─────────┼───────┼───────┼────────┤
 │    0    │       │       │   1    │
@@ -513,15 +515,13 @@ test(function consoleTable(): void {
 │    4    │ [ 7 ] │ [ 8 ] │        │
 └─────────┴───────┴───────┴────────┘
 `
-      );
-    }
-  );
-  mockConsole(
-    (console, out): void => {
-      console.table(new Set([1, 2, 3, "test"]));
-      assertEquals(
-        out.toString(),
-        `┌───────────────────┬────────┐
+    );
+  });
+  mockConsole((console, out): void => {
+    console.table(new Set([1, 2, 3, "test"]));
+    assertEquals(
+      out.toString(),
+      `┌───────────────────┬────────┐
 │ (iteration index) │ Values │
 ├───────────────────┼────────┤
 │         0         │   1    │
@@ -530,36 +530,37 @@ test(function consoleTable(): void {
 │         3         │ "test" │
 └───────────────────┴────────┘
 `
-      );
-    }
-  );
-  mockConsole(
-    (console, out): void => {
-      console.table(new Map([[1, "one"], [2, "two"]]));
-      assertEquals(
-        out.toString(),
-        `┌───────────────────┬─────┬────────┐
+    );
+  });
+  mockConsole((console, out): void => {
+    console.table(
+      new Map([
+        [1, "one"],
+        [2, "two"]
+      ])
+    );
+    assertEquals(
+      out.toString(),
+      `┌───────────────────┬─────┬────────┐
 │ (iteration index) │ Key │ Values │
 ├───────────────────┼─────┼────────┤
 │         0         │  1  │ "one"  │
 │         1         │  2  │ "two"  │
 └───────────────────┴─────┴────────┘
 `
-      );
-    }
-  );
-  mockConsole(
-    (console, out): void => {
-      console.table({
-        a: true,
-        b: { c: { d: 10 }, e: [1, 2, [5, 6]] },
-        f: "test",
-        g: new Set([1, 2, 3, "test"]),
-        h: new Map([[1, "one"]])
-      });
-      assertEquals(
-        out.toString(),
-        `┌─────────┬───────────┬───────────────────┬────────┐
+    );
+  });
+  mockConsole((console, out): void => {
+    console.table({
+      a: true,
+      b: { c: { d: 10 }, e: [1, 2, [5, 6]] },
+      f: "test",
+      g: new Set([1, 2, 3, "test"]),
+      h: new Map([[1, "one"]])
+    });
+    assertEquals(
+      out.toString(),
+      `┌─────────┬───────────┬───────────────────┬────────┐
 │ (index) │     c     │         e         │ Values │
 ├─────────┼───────────┼───────────────────┼────────┤
 │    a    │           │                   │  true  │
@@ -569,21 +570,19 @@ test(function consoleTable(): void {
 │    h    │           │                   │        │
 └─────────┴───────────┴───────────────────┴────────┘
 `
-      );
-    }
-  );
-  mockConsole(
-    (console, out): void => {
-      console.table([
-        1,
-        "test",
-        false,
-        { a: 10 },
-        ["test", { b: 20, c: "test" }]
-      ]);
-      assertEquals(
-        out.toString(),
-        `┌─────────┬────────┬──────────────────────┬────┬────────┐
+    );
+  });
+  mockConsole((console, out): void => {
+    console.table([
+      1,
+      "test",
+      false,
+      { a: 10 },
+      ["test", { b: 20, c: "test" }]
+    ]);
+    assertEquals(
+      out.toString(),
+      `┌─────────┬────────┬──────────────────────┬────┬────────┐
 │ (index) │   0    │          1           │ a  │ Values │
 ├─────────┼────────┼──────────────────────┼────┼────────┤
 │    0    │        │                      │    │   1    │
@@ -593,67 +592,56 @@ test(function consoleTable(): void {
 │    4    │ "test" │ { b: 20, c: "test" } │    │        │
 └─────────┴────────┴──────────────────────┴────┴────────┘
 `
-      );
-    }
-  );
-  mockConsole(
-    (console, out): void => {
-      console.table([]);
-      assertEquals(
-        out.toString(),
-        `┌─────────┐
+    );
+  });
+  mockConsole((console, out): void => {
+    console.table([]);
+    assertEquals(
+      out.toString(),
+      `┌─────────┐
 │ (index) │
 ├─────────┤
 └─────────┘
 `
-      );
-    }
-  );
-  mockConsole(
-    (console, out): void => {
-      console.table({});
-      assertEquals(
-        out.toString(),
-        `┌─────────┐
+    );
+  });
+  mockConsole((console, out): void => {
+    console.table({});
+    assertEquals(
+      out.toString(),
+      `┌─────────┐
 │ (index) │
 ├─────────┤
 └─────────┘
 `
-      );
-    }
-  );
-  mockConsole(
-    (console, out): void => {
-      console.table(new Set());
-      assertEquals(
-        out.toString(),
-        `┌───────────────────┐
+    );
+  });
+  mockConsole((console, out): void => {
+    console.table(new Set());
+    assertEquals(
+      out.toString(),
+      `┌───────────────────┐
 │ (iteration index) │
 ├───────────────────┤
 └───────────────────┘
 `
-      );
-    }
-  );
-  mockConsole(
-    (console, out): void => {
-      console.table(new Map());
-      assertEquals(
-        out.toString(),
-        `┌───────────────────┐
+    );
+  });
+  mockConsole((console, out): void => {
+    console.table(new Map());
+    assertEquals(
+      out.toString(),
+      `┌───────────────────┐
 │ (iteration index) │
 ├───────────────────┤
 └───────────────────┘
 `
-      );
-    }
-  );
-  mockConsole(
-    (console, out): void => {
-      console.table("test");
-      assertEquals(out.toString(), "test\n");
-    }
-  );
+    );
+  });
+  mockConsole((console, out): void => {
+    console.table("test");
+    assertEquals(out.toString(), "test\n");
+  });
 });
 
 // console.log(Error) test
@@ -668,52 +656,40 @@ test(function consoleLogShouldNotThrowError(): void {
   assertEquals(result, 1);
 
   // output errors to the console should not include "Uncaught"
-  mockConsole(
-    (console, out): void => {
-      console.log(new Error("foo"));
-      assertEquals(out.toString().includes("Uncaught"), false);
-    }
-  );
+  mockConsole((console, out): void => {
+    console.log(new Error("foo"));
+    assertEquals(out.toString().includes("Uncaught"), false);
+  });
 });
 
 // console.dir test
 test(function consoleDir(): void {
-  mockConsole(
-    (console, out): void => {
-      console.dir("DIR");
-      assertEquals(out.toString(), "DIR\n");
-    }
-  );
-  mockConsole(
-    (console, out): void => {
-      console.dir("DIR", { indentLevel: 2 });
-      assertEquals(out.toString(), "  DIR\n");
-    }
-  );
+  mockConsole((console, out): void => {
+    console.dir("DIR");
+    assertEquals(out.toString(), "DIR\n");
+  });
+  mockConsole((console, out): void => {
+    console.dir("DIR", { indentLevel: 2 });
+    assertEquals(out.toString(), "  DIR\n");
+  });
 });
 
 // console.dir test
 test(function consoleDirXml(): void {
-  mockConsole(
-    (console, out): void => {
-      console.dirxml("DIRXML");
-      assertEquals(out.toString(), "DIRXML\n");
-    }
-  );
-  mockConsole(
-    (console, out): void => {
-      console.dirxml("DIRXML", { indentLevel: 2 });
-      assertEquals(out.toString(), "  DIRXML\n");
-    }
-  );
+  mockConsole((console, out): void => {
+    console.dirxml("DIRXML");
+    assertEquals(out.toString(), "DIRXML\n");
+  });
+  mockConsole((console, out): void => {
+    console.dirxml("DIRXML", { indentLevel: 2 });
+    assertEquals(out.toString(), "  DIRXML\n");
+  });
 });
 
 // console.trace test
 test(function consoleTrace(): void {
-  mockConsole(
-    (console, _out, err): void => {
-      console.trace("%s", "custom message");
-      assert(err.toString().includes("Trace: custom message"));
-    }
-  );
+  mockConsole((console, _out, err): void => {
+    console.trace("%s", "custom message");
+    assert(err.toString().includes("Trace: custom message"));
+  });
 });

cli/js/diagnostics.ts

@@ -87,9 +87,7 @@ function fromDiagnosticCategory(
       return DiagnosticCategory.Warning;
     default:
       throw new Error(
-        `Unexpected DiagnosticCategory: "${category}"/"${
-          ts.DiagnosticCategory[category]
-        }"`
+        `Unexpected DiagnosticCategory: "${category}"/"${ts.DiagnosticCategory[category]}"`
       );
   }
 }

cli/js/dispatch_json.ts

@@ -40,7 +40,7 @@ function unwrapResponse(res: JsonResponse): Ok {
     throw new DenoError(res.err!.kind, res.err!.message);
   }
   util.assert(res.ok != null);
-  return res.ok!;
+  return res.ok;
 }
 
 export function asyncMsgFromRust(opId: number, resUi8: Uint8Array): void {
@@ -50,7 +50,7 @@ export function asyncMsgFromRust(opId: number, resUi8: Uint8Array): void {
   const promise = promiseTable.get(res.promiseId!);
   util.assert(promise != null);
   promiseTable.delete(res.promiseId!);
-  promise!.resolve(res);
+  promise.resolve(res);
 }
 
 export function sendSync(

cli/js/dispatch_json_test.ts

@@ -18,11 +18,9 @@ const openErrorStackPattern = new RegExp(
 testPerm({ read: true }, async function sendAsyncStackTrace(): Promise<void> {
   await Deno.open("nonexistent.txt")
     .then(unreachable)
-    .catch(
-      (error): void => {
-        assertMatch(error.stack, openErrorStackPattern);
-      }
-    );
+    .catch((error): void => {
+      assertMatch(error.stack, openErrorStackPattern);
+    });
 });
 
 test(async function malformedJsonControlBuffer(): Promise<void> {

cli/js/dispatch_minimal.ts

@@ -79,7 +79,8 @@ export function asyncMsgFromRust(opId: number, ui8: Uint8Array): void {
   const { promiseId } = record;
   const promise = promiseTableMin.get(promiseId);
   promiseTableMin.delete(promiseId);
-  promise!.resolve(record);
+  util.assert(promise);
+  promise.resolve(record);
 }
 
 export async function sendAsyncMinimal(

cli/js/dispatch_minimal_test.ts

@@ -18,11 +18,9 @@ test(async function sendAsyncStackTrace(): Promise<void> {
   const buf = new Uint8Array(10);
   await Deno.read(10, "nonexistent.txt", buf)
     .then(unreachable)
-    .catch(
-      (error): void => {
-        assertMatch(error.stack, readErrorStackPattern);
-      }
-    );
+    .catch((error): void => {
+      assertMatch(error.stack, readErrorStackPattern);
+    });
 });
 test(async function malformedMinimalControlBuffer(): Promise<void> {
   // @ts-ignore

cli/js/event_target.ts

@@ -27,7 +27,7 @@ export const eventTargetHasActivationBehavior: unique symbol = Symbol();
 export class EventTarget implements domTypes.EventTarget {
   public [domTypes.eventTargetHost]: domTypes.EventTarget | null = null;
   public [domTypes.eventTargetListeners]: {
-    [type in string]: domTypes.EventListener[]
+    [type in string]: domTypes.EventListener[];
   } = {};
   public [domTypes.eventTargetMode] = "";
   public [domTypes.eventTargetNodeType]: domTypes.NodeType =
@@ -417,9 +417,7 @@ const eventTargetHelpers = {
       }
 
       try {
-        if (listener.callback) {
-          listener.handleEvent(eventImpl);
-        }
+        listener.handleEvent(eventImpl);
       } catch (error) {
         throw new DenoError(ErrorKind.Interrupted, error.message);
       }

cli/js/fetch.ts

@@ -188,19 +188,17 @@ class Body implements domTypes.Body, domTypes.ReadableStream, io.ReadCloser {
         body
           .trim()
           .split("&")
-          .forEach(
-            (bytes): void => {
-              if (bytes) {
-                const split = bytes.split("=");
-                const name = split.shift()!.replace(/\+/g, " ");
-                const value = split.join("=").replace(/\+/g, " ");
-                formData.append(
-                  decodeURIComponent(name),
-                  decodeURIComponent(value)
-                );
-              }
+          .forEach((bytes): void => {
+            if (bytes) {
+              const split = bytes.split("=");
+              const name = split.shift()!.replace(/\+/g, " ");
+              const value = split.join("=").replace(/\+/g, " ");
+              formData.append(
+                decodeURIComponent(name),
+                decodeURIComponent(value)
+              );
             }
-          );
+          });
       } catch (e) {
         throw new TypeError("Invalid form urlencoded format");
       }

cli/js/fetch_test.ts

@@ -60,12 +60,10 @@ testPerm({ net: true }, async function fetchBlob(): Promise<void> {
 testPerm({ net: true }, async function fetchBodyUsed(): Promise<void> {
   const response = await fetch("http://localhost:4545/cli/tests/fixture.json");
   assertEquals(response.bodyUsed, false);
-  assertThrows(
-    (): void => {
-      // Assigning to read-only property throws in the strict mode.
-      response.bodyUsed = true;
-    }
-  );
+  assertThrows((): void => {
+    // Assigning to read-only property throws in the strict mode.
+    response.bodyUsed = true;
+  });
   await response.blob();
   assertEquals(response.bodyUsed, true);
 });

cli/js/form_data_test.ts

@@ -82,20 +82,21 @@ test(function formDataSetEmptyBlobSuccess(): void {
 });
 
 test(function formDataParamsForEachSuccess(): void {
-  const init = [["a", "54"], ["b", "true"]];
+  const init = [
+    ["a", "54"],
+    ["b", "true"]
+  ];
   const formData = new FormData();
   for (const [name, value] of init) {
     formData.append(name, value);
   }
   let callNum = 0;
-  formData.forEach(
-    (value, key, parent): void => {
-      assertEquals(formData, parent);
-      assertEquals(value, init[callNum][1]);
-      assertEquals(key, init[callNum][0]);
-      callNum++;
-    }
-  );
+  formData.forEach((value, key, parent): void => {
+    assertEquals(formData, parent);
+    assertEquals(value, init[callNum][1]);
+    assertEquals(key, init[callNum][0]);
+    callNum++;
+  });
   assertEquals(callNum, init.length);
 });
 
@@ -104,73 +105,69 @@ test(function formDataParamsArgumentsCheck(): void {
 
   const methodRequireTwoParams = ["append", "set"];
 
-  methodRequireOneParam.forEach(
-    (method): void => {
-      const formData = new FormData();
-      let hasThrown = 0;
-      let errMsg = "";
-      try {
-        formData[method]();
-        hasThrown = 1;
-      } catch (err) {
-        errMsg = err.message;
-        if (err instanceof TypeError) {
-          hasThrown = 2;
-        } else {
-          hasThrown = 3;
-        }
+  methodRequireOneParam.forEach((method): void => {
+    const formData = new FormData();
+    let hasThrown = 0;
+    let errMsg = "";
+    try {
+      formData[method]();
+      hasThrown = 1;
+    } catch (err) {
+      errMsg = err.message;
+      if (err instanceof TypeError) {
+        hasThrown = 2;
+      } else {
+        hasThrown = 3;
       }
-      assertEquals(hasThrown, 2);
-      assertEquals(
-        errMsg,
-        `FormData.${method} requires at least 1 argument, but only 0 present`
-      );
     }
-  );
+    assertEquals(hasThrown, 2);
+    assertEquals(
+      errMsg,
+      `FormData.${method} requires at least 1 argument, but only 0 present`
+    );
+  });
 
-  methodRequireTwoParams.forEach(
-    (method: string): void => {
-      const formData = new FormData();
-      let hasThrown = 0;
-      let errMsg = "";
+  methodRequireTwoParams.forEach((method: string): void => {
+    const formData = new FormData();
+    let hasThrown = 0;
+    let errMsg = "";
 
-      try {
-        formData[method]();
-        hasThrown = 1;
-      } catch (err) {
-        errMsg = err.message;
-        if (err instanceof TypeError) {
-          hasThrown = 2;
-        } else {
-          hasThrown = 3;
-        }
+    try {
+      formData[method]();
+      hasThrown = 1;
+    } catch (err) {
+      errMsg = err.message;
+      if (err instanceof TypeError) {
+        hasThrown = 2;
+      } else {
+        hasThrown = 3;
       }
-      assertEquals(hasThrown, 2);
-      assertEquals(
-        errMsg,
-        `FormData.${method} requires at least 2 arguments, but only 0 present`
-      );
-
-      hasThrown = 0;
-      errMsg = "";
-      try {
-        formData[method]("foo");
-        hasThrown = 1;
-      } catch (err) {
-        errMsg = err.message;
-        if (err instanceof TypeError) {
-          hasThrown = 2;
-        } else {
-          hasThrown = 3;
-        }
-      }
-      assertEquals(hasThrown, 2);
-      assertEquals(
-        errMsg,
-        `FormData.${method} requires at least 2 arguments, but only 1 present`
-      );
     }
-  );
+    assertEquals(hasThrown, 2);
+    assertEquals(
+      errMsg,
+      `FormData.${method} requires at least 2 arguments, but only 0 present`
+    );
+
+    hasThrown = 0;
+    errMsg = "";
+    try {
+      formData[method]("foo");
+      hasThrown = 1;
+    } catch (err) {
+      errMsg = err.message;
+      if (err instanceof TypeError) {
+        hasThrown = 2;
+      } else {
+        hasThrown = 3;
+      }
+    }
+    assertEquals(hasThrown, 2);
+    assertEquals(
+      errMsg,
+      `FormData.${method} requires at least 2 arguments, but only 1 present`
+    );
+  });
 });
 
 test(function toStringShouldBeWebCompatibility(): void {

cli/js/globals.ts

@@ -162,25 +162,19 @@ window.removeEventListener =
   eventTarget.EventTarget.prototype.removeEventListener;
 
 // Registers the handler for window.onload function.
-window.addEventListener(
-  "load",
-  (e: domTypes.Event): void => {
-    const onload = window.onload;
-    if (typeof onload === "function") {
-      onload(e);
-    }
+window.addEventListener("load", (e: domTypes.Event): void => {
+  const onload = window.onload;
+  if (typeof onload === "function") {
+    onload(e);
   }
-);
+});
 // Registers the handler for window.onunload function.
-window.addEventListener(
-  "unload",
-  (e: domTypes.Event): void => {
-    const onunload = window.onunload;
-    if (typeof onunload === "function") {
-      onunload(e);
-    }
+window.addEventListener("unload", (e: domTypes.Event): void => {
+  const onunload = window.onunload;
+  if (typeof onunload === "function") {
+    onunload(e);
   }
-);
+});
 
 // below are interfaces that are available in TypeScript but
 // have different signatures

cli/js/globals_test.ts

@@ -81,22 +81,18 @@ test(async function windowQueueMicrotask(): Promise<void> {
   let resolve1: () => void | undefined;
   let resolve2: () => void | undefined;
   let microtaskDone = false;
-  const p1 = new Promise(
-    (res): void => {
-      resolve1 = (): void => {
-        microtaskDone = true;
-        res();
-      };
-    }
-  );
-  const p2 = new Promise(
-    (res): void => {
-      resolve2 = (): void => {
-        assert(microtaskDone);
-        res();
-      };
-    }
-  );
+  const p1 = new Promise((res): void => {
+    resolve1 = (): void => {
+      microtaskDone = true;
+      res();
+    };
+  });
+  const p2 = new Promise((res): void => {
+    resolve2 = (): void => {
+      assert(microtaskDone);
+      res();
+    };
+  });
   window.queueMicrotask(resolve1!);
   setTimeout(resolve2!, 0);
   await p1;

cli/js/headers_test.ts

@@ -145,21 +145,17 @@ const headerEntriesDict = {
 test(function headerForEachSuccess(): void {
   const headers = new Headers(headerEntriesDict);
   const keys = Object.keys(headerEntriesDict);
-  keys.forEach(
-    (key): void => {
-      const value = headerEntriesDict[key];
-      const newkey = key.toLowerCase();
-      headerEntriesDict[newkey] = value;
-    }
-  );
+  keys.forEach((key): void => {
+    const value = headerEntriesDict[key];
+    const newkey = key.toLowerCase();
+    headerEntriesDict[newkey] = value;
+  });
   let callNum = 0;
-  headers.forEach(
-    (value, key, container): void => {
-      assertEquals(headers, container);
-      assertEquals(value, headerEntriesDict[key]);
-      callNum++;
-    }
-  );
+  headers.forEach((value, key, container): void => {
+    assertEquals(headers, container);
+    assertEquals(value, headerEntriesDict[key]);
+    callNum++;
+  });
   assertEquals(callNum, keys.length);
 });
 
@@ -260,73 +256,69 @@ test(function headerParamsArgumentsCheck(): void {
 
   const methodRequireTwoParams = ["append", "set"];
 
-  methodRequireOneParam.forEach(
-    (method): void => {
-      const headers = new Headers();
-      let hasThrown = 0;
-      let errMsg = "";
-      try {
-        headers[method]();
-        hasThrown = 1;
-      } catch (err) {
-        errMsg = err.message;
-        if (err instanceof TypeError) {
-          hasThrown = 2;
-        } else {
-          hasThrown = 3;
-        }
+  methodRequireOneParam.forEach((method): void => {
+    const headers = new Headers();
+    let hasThrown = 0;
+    let errMsg = "";
+    try {
+      headers[method]();
+      hasThrown = 1;
+    } catch (err) {
+      errMsg = err.message;
+      if (err instanceof TypeError) {
+        hasThrown = 2;
+      } else {
+        hasThrown = 3;
       }
-      assertEquals(hasThrown, 2);
-      assertEquals(
-        errMsg,
-        `Headers.${method} requires at least 1 argument, but only 0 present`
-      );
     }
-  );
+    assertEquals(hasThrown, 2);
+    assertEquals(
+      errMsg,
+      `Headers.${method} requires at least 1 argument, but only 0 present`
+    );
+  });
 
-  methodRequireTwoParams.forEach(
-    (method): void => {
-      const headers = new Headers();
-      let hasThrown = 0;
-      let errMsg = "";
+  methodRequireTwoParams.forEach((method): void => {
+    const headers = new Headers();
+    let hasThrown = 0;
+    let errMsg = "";
 
-      try {
-        headers[method]();
-        hasThrown = 1;
-      } catch (err) {
-        errMsg = err.message;
-        if (err instanceof TypeError) {
-          hasThrown = 2;
-        } else {
-          hasThrown = 3;
-        }
+    try {
+      headers[method]();
+      hasThrown = 1;
+    } catch (err) {
+      errMsg = err.message;
+      if (err instanceof TypeError) {
+        hasThrown = 2;
+      } else {
+        hasThrown = 3;
       }
-      assertEquals(hasThrown, 2);
-      assertEquals(
-        errMsg,
-        `Headers.${method} requires at least 2 arguments, but only 0 present`
-      );
-
-      hasThrown = 0;
-      errMsg = "";
-      try {
-        headers[method]("foo");
-        hasThrown = 1;
-      } catch (err) {
-        errMsg = err.message;
-        if (err instanceof TypeError) {
-          hasThrown = 2;
-        } else {
-          hasThrown = 3;
-        }
-      }
-      assertEquals(hasThrown, 2);
-      assertEquals(
-        errMsg,
-        `Headers.${method} requires at least 2 arguments, but only 1 present`
-      );
     }
-  );
+    assertEquals(hasThrown, 2);
+    assertEquals(
+      errMsg,
+      `Headers.${method} requires at least 2 arguments, but only 0 present`
+    );
+
+    hasThrown = 0;
+    errMsg = "";
+    try {
+      headers[method]("foo");
+      hasThrown = 1;
+    } catch (err) {
+      errMsg = err.message;
+      if (err instanceof TypeError) {
+        hasThrown = 2;
+      } else {
+        hasThrown = 3;
+      }
+    }
+    assertEquals(hasThrown, 2);
+    assertEquals(
+      errMsg,
+      `Headers.${method} requires at least 2 arguments, but only 1 present`
+    );
+  });
 });
 
 test(function toStringShouldBeWebCompatibility(): void {

cli/js/lib.deno_runtime.d.ts

@@ -2268,7 +2268,7 @@ declare namespace eventTarget {
   export class EventTarget implements domTypes.EventTarget {
     [domTypes.eventTargetHost]: domTypes.EventTarget | null;
     [domTypes.eventTargetListeners]: {
-      [type in string]: domTypes.EventListener[]
+      [type in string]: domTypes.EventListener[];
     };
     [domTypes.eventTargetMode]: string;
     [domTypes.eventTargetNodeType]: domTypes.NodeType;

cli/js/mixins/dom_iterable_test.ts

@@ -28,7 +28,10 @@ function setup() {
 test(function testDomIterable(): void {
   const { DomIterable, Base } = setup();
 
-  const fixture: Array<[string, number]> = [["foo", 1], ["bar", 2]];
+  const fixture: Array<[string, number]> = [
+    ["foo", 1],
+    ["bar", 2]
+  ];
 
   const domIterable = new DomIterable(fixture);
 

cli/js/resources_test.ts

@@ -39,10 +39,8 @@ testPerm({ read: true }, async function resourcesFile(): Promise<void> {
     Object.keys(resourcesAfter).length,
     Object.keys(resourcesBefore).length + 1
   );
-  const newRid = Object.keys(resourcesAfter).find(
-    (rid): boolean => {
-      return !resourcesBefore.hasOwnProperty(rid);
-    }
-  );
+  const newRid = Object.keys(resourcesAfter).find((rid): boolean => {
+    return !resourcesBefore.hasOwnProperty(rid);
+  });
   assertEquals(resourcesAfter[newRid], "fsFile");
 });

cli/js/streams/readable-stream.ts

@@ -295,14 +295,18 @@ export function readableStreamTee<OutputType>(
       .then(({ value, done }) => {
         if (done && !closedOrErrored) {
           if (!canceled1) {
-            rs.readableStreamDefaultControllerClose(branch1![
-              rs.readableStreamController_
-            ] as ReadableStreamDefaultController<OutputType>);
+            rs.readableStreamDefaultControllerClose(
+              branch1![
+                rs.readableStreamController_
+              ] as ReadableStreamDefaultController<OutputType>
+            );
           }
           if (!canceled2) {
-            rs.readableStreamDefaultControllerClose(branch2![
-              rs.readableStreamController_
-            ] as ReadableStreamDefaultController<OutputType>);
+            rs.readableStreamDefaultControllerClose(
+              branch2![
+                rs.readableStreamController_
+              ] as ReadableStreamDefaultController<OutputType>
+            );
           }
           closedOrErrored = true;
         }

cli/js/timers_test.ts

@@ -9,12 +9,10 @@ function deferred(): {
 } {
   let resolve;
   let reject;
-  const promise = new Promise(
-    (res, rej): void => {
-      resolve = res;
-      reject = rej;
-    }
-  );
+  const promise = new Promise((res, rej): void => {
+    resolve = res;
+    reject = rej;
+  });
   return {
     promise,
     resolve,

cli/js/tls_test.ts

@@ -185,9 +185,6 @@ testPerm({ read: true, net: true }, async function dialAndListenTLS(): Promise<
   const tpr = new TextProtoReader(r);
   const statusLine = await tpr.readLine();
   assert(statusLine !== Deno.EOF, `line must be read: ${String(statusLine)}`);
-  if (statusLine === Deno.EOF) {
-    return;
-  }
   const m = statusLine.match(/^(.+?) (.+?) (.+?)$/);
   assert(m !== null, "must be matched");
   const [_, proto, status, ok] = m;
@@ -196,9 +193,6 @@ testPerm({ read: true, net: true }, async function dialAndListenTLS(): Promise<
   assertEquals(ok, "OK");
   const headers = await tpr.readMIMEHeader();
   assert(headers !== Deno.EOF);
-  if (headers === Deno.EOF) {
-    return;
-  }
   const contentLength = parseInt(headers.get("content-length"));
   const bodyBuf = new Uint8Array(contentLength);
   await r.readFull(bodyBuf);

cli/js/unit_test_runner.ts

@@ -15,17 +15,15 @@ interface TestResult {
 
 function permsToCliFlags(perms: Permissions): string[] {
   return Object.keys(perms)
-    .map(
-      (key): string => {
-        if (!perms[key]) return "";
+    .map((key): string => {
+      if (!perms[key]) return "";
 
-        const cliFlag = key.replace(
-          /\.?([A-Z])/g,
-          (x, y): string => `-${y.toLowerCase()}`
-        );
-        return `--allow-${cliFlag}`;
-      }
-    )
+      const cliFlag = key.replace(
+        /\.?([A-Z])/g,
+        (x, y): string => `-${y.toLowerCase()}`
+      );
+      return `--allow-${cliFlag}`;
+    })
     .filter((e): boolean => e.length > 0);
 }
 

cli/js/url.ts

@@ -29,9 +29,7 @@ const patterns = {
 };
 
 const urlRegExp = new RegExp(
-  `^${patterns.protocol}?${patterns.authority}?${patterns.path}${
-    patterns.query
-  }?${patterns.hash}?`
+  `^${patterns.protocol}?${patterns.authority}?${patterns.path}${patterns.query}?${patterns.hash}?`
 );
 
 const authorityRegExp = new RegExp(
@@ -70,11 +68,9 @@ function parse(url: string): URLParts | undefined {
 // Based on https://github.com/kelektiv/node-uuid
 // TODO(kevinkassimo): Use deno_std version once possible.
 function generateUUID(): string {
-  return "00000000-0000-4000-8000-000000000000".replace(
-    /[0]/g,
-    (): string =>
-      // random integer from 0 to 15 as a hex digit.
-      (getRandomValues(new Uint8Array(1))[0] % 16).toString(16)
+  return "00000000-0000-4000-8000-000000000000".replace(/[0]/g, (): string =>
+    // random integer from 0 to 15 as a hex digit.
+    (getRandomValues(new Uint8Array(1))[0] % 16).toString(16)
   );
 }
 
@@ -232,9 +228,7 @@ export class URL {
     if (this.host || this.protocol === "file:") {
       slash = "//";
     }
-    return `${this.protocol}${slash}${authentication}${this.host}${
-      this.pathname
-    }${this.search}${this.hash}`;
+    return `${this.protocol}${slash}${authentication}${this.host}${this.pathname}${this.search}${this.hash}`;
   }
 
   set href(value: string) {

cli/js/url_search_params.ts

@@ -168,8 +168,8 @@ export class URLSearchParams {
    *       searchParams.sort();
    */
   sort(): void {
-    this.params = this.params.sort(
-      (a, b): number => (a[0] === b[0] ? 0 : a[0] > b[0] ? 1 : -1)
+    this.params = this.params.sort((a, b): number =>
+      a[0] === b[0] ? 0 : a[0] > b[0] ? 1 : -1
     );
     this.updateSteps();
   }

cli/js/url_search_params_test.ts

@@ -11,7 +11,10 @@ test(function urlSearchParamsInitString(): void {
 });
 
 test(function urlSearchParamsInitIterable(): void {
-  const init = [["a", "54"], ["b", "true"]];
+  const init = [
+    ["a", "54"],
+    ["b", "true"]
+  ];
   const searchParams = new URLSearchParams(init);
   assertEquals(searchParams.toString(), "a=54&b=true");
 });
@@ -89,17 +92,18 @@ test(function urlSearchParamsSortSuccess(): void {
 });
 
 test(function urlSearchParamsForEachSuccess(): void {
-  const init = [["a", "54"], ["b", "true"]];
+  const init = [
+    ["a", "54"],
+    ["b", "true"]
+  ];
   const searchParams = new URLSearchParams(init);
   let callNum = 0;
-  searchParams.forEach(
-    (value, key, parent): void => {
-      assertEquals(searchParams, parent);
-      assertEquals(value, init[callNum][1]);
-      assertEquals(key, init[callNum][0]);
-      callNum++;
-    }
-  );
+  searchParams.forEach((value, key, parent): void => {
+    assertEquals(searchParams, parent);
+    assertEquals(value, init[callNum][1]);
+    assertEquals(key, init[callNum][0]);
+    callNum++;
+  });
   assertEquals(callNum, init.length);
 });
 
@@ -167,8 +171,9 @@ test(function urlSearchParamsAppendArgumentsCheck(): void {
 
   const methodRequireTwoParams = ["append", "set"];
 
-  methodRequireOneParam.concat(methodRequireTwoParams).forEach(
-    (method: string): void => {
+  methodRequireOneParam
+    .concat(methodRequireTwoParams)
+    .forEach((method: string): void => {
       const searchParams = new URLSearchParams();
       let hasThrown = 0;
       try {
@@ -182,26 +187,23 @@ test(function urlSearchParamsAppendArgumentsCheck(): void {
         }
       }
       assertEquals(hasThrown, 2);
-    }
-  );
+    });
 
-  methodRequireTwoParams.forEach(
-    (method: string): void => {
-      const searchParams = new URLSearchParams();
-      let hasThrown = 0;
-      try {
-        searchParams[method]("foo");
-        hasThrown = 1;
-      } catch (err) {
-        if (err instanceof TypeError) {
-          hasThrown = 2;
-        } else {
-          hasThrown = 3;
-        }
+  methodRequireTwoParams.forEach((method: string): void => {
+    const searchParams = new URLSearchParams();
+    let hasThrown = 0;
+    try {
+      searchParams[method]("foo");
+      hasThrown = 1;
+    } catch (err) {
+      if (err instanceof TypeError) {
+        hasThrown = 2;
+      } else {
+        hasThrown = 3;
       }
-      assertEquals(hasThrown, 2);
     }
-  );
+    assertEquals(hasThrown, 2);
+  });
 });
 
 // ref: https://github.com/web-platform-tests/wpt/blob/master/url/urlsearchparams-delete.any.js

cli/js/util.ts

@@ -26,7 +26,7 @@ export function log(...args: unknown[]): void {
 }
 
 // @internal
-export function assert(cond: boolean, msg = "assert"): void {
+export function assert(cond: unknown, msg = "assert"): asserts cond {
   if (!cond) {
     throw Error(msg);
   }
@@ -74,11 +74,9 @@ export type Resolvable<T> = Promise<T> & ResolvableMethods<T>;
 // @internal
 export function createResolvable<T>(): Resolvable<T> {
   let methods: ResolvableMethods<T>;
-  const promise = new Promise<T>(
-    (resolve, reject): void => {
-      methods = { resolve, reject };
-    }
-  );
+  const promise = new Promise<T>((resolve, reject): void => {
+    methods = { resolve, reject };
+  });
   // TypeScript doesn't know that the Promise callback occurs synchronously
   // therefore use of not null assertion (`!`)
   return Object.assign(promise, methods!) as Resolvable<T>;
@@ -97,12 +95,9 @@ export function unreachable(): never {
 // @internal
 export function hexdump(u8: Uint8Array): string {
   return Array.prototype.map
-    .call(
-      u8,
-      (x: number): string => {
-        return ("00" + x.toString(16)).slice(-2);
-      }
-    )
+    .call(u8, (x: number): string => {
+      return ("00" + x.toString(16)).slice(-2);
+    })
     .join(" ");
 }
 

cli/js/workers.ts

@@ -160,11 +160,9 @@ export class WorkerImpl implements Worker {
     );
     this.run();
     this.isClosedPromise = hostGetWorkerClosed(this.id);
-    this.isClosedPromise.then(
-      (): void => {
-        this.isClosing = true;
-      }
-    );
+    this.isClosedPromise.then((): void => {
+      this.isClosing = true;
+    });
   }
 
   get closed(): Promise<void> {

cli/tests/012_async.ts

@@ -1,11 +1,9 @@
 // Check that we can use the async keyword.
 async function main(): Promise<void> {
-  await new Promise(
-    (resolve): void => {
-      console.log("2");
-      setTimeout(resolve, 100);
-    }
-  );
+  await new Promise((resolve): void => {
+    console.log("2");
+    setTimeout(resolve, 100);
+  });
   console.log("3");
 }
 

cli/tests/028_args.ts

@@ -1,5 +1,3 @@
-Deno.args.forEach(
-  (arg): void => {
-    console.log(arg);
-  }
-);
+Deno.args.forEach((arg): void => {
+  console.log(arg);
+});

cli/tests/error_003_typescript.ts.out

@@ -1,13 +1,6 @@
 [WILDCARD]error TS2322: Type '{ a: { b: { c(): { d: number; }; }; }; }' is not assignable to type '{ a: { b: { c(): { d: string; }; }; }; }'.
-  Types of property 'a' are incompatible.
-    Type '{ b: { c(): { d: number; }; }; }' is not assignable to type '{ b: { c(): { d: string; }; }; }'.
-      Types of property 'b' are incompatible.
-        Type '{ c(): { d: number; }; }' is not assignable to type '{ c(): { d: string; }; }'.
-          Types of property 'c' are incompatible.
-            Type '() => { d: number; }' is not assignable to type '() => { d: string; }'.
-              Type '{ d: number; }' is not assignable to type '{ d: string; }'.
-                Types of property 'd' are incompatible.
-                  Type 'number' is not assignable to type 'string'.
+  The types of 'a.b.c().d' are incompatible between these types.
+    Type 'number' is not assignable to type 'string'.
 
 [WILDCARD]/tests/error_003_typescript.ts:20:1
 

cli/tests/integration_tests.rs

@@ -362,13 +362,11 @@ itest!(lock_check_ok {
   http_server: true,
 });
 
-/* TODO(ry) Re-enable this test. It is flaky and only fails occasionally.
 itest!(lock_check_ok2 {
   args: "run 019_media_types.ts --lock=lock_check_ok2.json",
   output: "019_media_types.ts.out",
   http_server: true,
 });
-*/
 
 itest!(lock_check_err {
   args: "run --lock=lock_check_err.json http://127.0.0.1:4545/cli/tests/003_relative_import.ts",

cli/tests/workers_round_robin_bench.ts

@@ -15,11 +15,9 @@ export type Resolvable<T> = Promise<T> & ResolvableMethods<T>;
 
 export function createResolvable<T>(): Resolvable<T> {
   let methods: ResolvableMethods<T>;
-  const promise = new Promise<T>(
-    (resolve, reject): void => {
-      methods = { resolve, reject };
-    }
-  );
+  const promise = new Promise<T>((resolve, reject): void => {
+    methods = { resolve, reject };
+  });
   // TypeScript doesn't know that the Promise callback occurs synchronously
   // therefore use of not null assertion (`!`)
   return Object.assign(promise, methods!) as Resolvable<T>;
@@ -40,13 +38,11 @@ async function main(): Promise<void> {
   const workers: Array<[Map<number, Resolvable<string>>, Worker]> = [];
   for (let i = 1; i <= workerCount; ++i) {
     const worker = new Worker("./subdir/bench_worker.ts");
-    const promise = new Promise(
-      (resolve): void => {
-        worker.onmessage = (e): void => {
-          if (e.data.cmdId === 0) resolve();
-        };
-      }
-    );
+    const promise = new Promise((resolve): void => {
+      worker.onmessage = (e): void => {
+        if (e.data.cmdId === 0) resolve();
+      };
+    });
     worker.postMessage({ cmdId: 0, action: 2 });
     await promise;
     workers.push([new Map(), worker]);

cli/tests/workers_startup_bench.ts

@@ -5,13 +5,11 @@ async function bench(): Promise<void> {
   const workers: Worker[] = [];
   for (let i = 1; i <= workerCount; ++i) {
     const worker = new Worker("./subdir/bench_worker.ts");
-    const promise = new Promise(
-      (resolve): void => {
-        worker.onmessage = (e): void => {
-          if (e.data.cmdId === 0) resolve();
-        };
-      }
-    );
+    const promise = new Promise((resolve): void => {
+      worker.onmessage = (e): void => {
+        if (e.data.cmdId === 0) resolve();
+      };
+    });
     worker.postMessage({ cmdId: 0, action: 2 });
     await promise;
     workers.push(worker);

core/libdeno/build

@@ -1 +1 @@
-Subproject commit b3fe5cb48e9399765ec103ca0c14057f77cf9fc3
+Subproject commit 6af664c48ed657b89e99a9a8692dc15d7f7a6d9c

deno_typescript/compiler_main.js

@@ -67,6 +67,7 @@ function unreachable() {
 
 /**
  * @param {unknown} cond
+ * @returns {asserts cond}
  */
 function assert(cond) {
   if (!cond) {

deno_typescript/lib.rs

@@ -257,6 +257,7 @@ pub fn get_asset(name: &str) -> Option<&'static str> {
     "lib.deno_core.d.ts" => Some(include_str!("lib.deno_core.d.ts")),
     "typescript.d.ts" => inc!("typescript.d.ts"),
     "lib.esnext.d.ts" => inc!("lib.esnext.d.ts"),
+    "lib.es2020.d.ts" => inc!("lib.es2020.d.ts"),
     "lib.es2019.d.ts" => inc!("lib.es2019.d.ts"),
     "lib.es2018.d.ts" => inc!("lib.es2018.d.ts"),
     "lib.es2017.d.ts" => inc!("lib.es2017.d.ts"),
@@ -289,8 +290,15 @@ pub fn get_asset(name: &str) -> Option<&'static str> {
     "lib.es2019.object.d.ts" => inc!("lib.es2019.object.d.ts"),
     "lib.es2019.string.d.ts" => inc!("lib.es2019.string.d.ts"),
     "lib.es2019.symbol.d.ts" => inc!("lib.es2019.symbol.d.ts"),
+    "lib.es2020.string.d.ts" => inc!("lib.es2020.string.d.ts"),
+    "lib.es2020.symbol.wellknown.d.ts" => {
+      inc!("lib.es2020.symbol.wellknown.d.ts")
+    }
+    "lib.esnext.array.d.ts" => inc!("lib.esnext.array.d.ts"),
+    "lib.esnext.asynciterable.d.ts" => inc!("lib.esnext.asynciterable.d.ts"),
     "lib.esnext.bigint.d.ts" => inc!("lib.esnext.bigint.d.ts"),
     "lib.esnext.intl.d.ts" => inc!("lib.esnext.intl.d.ts"),
+    "lib.esnext.symbol.d.ts" => inc!("lib.esnext.symbol.d.ts"),
     _ => None,
   }
 }

deno_typescript/typescript

@@ -1 +1 @@
-Subproject commit 26655db1dd04d93217002ac87f950aba812c53eb
+Subproject commit 7cf6c70d90b60e962db417d80290288eb786b5fd

std/archive/tar.ts

@@ -384,28 +384,26 @@ export class Tar {
    */
   getReader(): Deno.Reader {
     const readers: Deno.Reader[] = [];
-    this.data.forEach(
-      (tarData): void => {
-        let { reader } = tarData;
-        const { filePath } = tarData;
-        const headerArr = formatHeader(tarData);
-        readers.push(new Deno.Buffer(headerArr));
-        if (!reader) {
-          reader = new FileReader(filePath!);
-        }
-        readers.push(reader);
-
-        // to the nearest multiple of recordSize
-        readers.push(
-          new Deno.Buffer(
-            clean(
-              recordSize -
-                (parseInt(tarData.fileSize!, 8) % recordSize || recordSize)
-            )
-          )
-        );
+    this.data.forEach((tarData): void => {
+      let { reader } = tarData;
+      const { filePath } = tarData;
+      const headerArr = formatHeader(tarData);
+      readers.push(new Deno.Buffer(headerArr));
+      if (!reader) {
+        reader = new FileReader(filePath!);
       }
-    );
+      readers.push(reader);
+
+      // to the nearest multiple of recordSize
+      readers.push(
+        new Deno.Buffer(
+          clean(
+            recordSize -
+              (parseInt(tarData.fileSize!, 8) % recordSize || recordSize)
+          )
+        )
+      );
+    });
 
     // append 2 empty records
     readers.push(new Deno.Buffer(clean(recordSize * 2)));
@@ -462,22 +460,18 @@ export class Untar {
       "mtime",
       "uid",
       "gid"
-    ]).forEach(
-      (key): void => {
-        const arr = trim(header[key]);
-        if (arr.byteLength > 0) {
-          meta[key] = parseInt(decoder.decode(arr), 8);
-        }
+    ]).forEach((key): void => {
+      const arr = trim(header[key]);
+      if (arr.byteLength > 0) {
+        meta[key] = parseInt(decoder.decode(arr), 8);
       }
-    );
-    (["owner", "group"] as ["owner", "group"]).forEach(
-      (key): void => {
-        const arr = trim(header[key]);
-        if (arr.byteLength > 0) {
-          meta[key] = decoder.decode(arr);
-        }
+    });
+    (["owner", "group"] as ["owner", "group"]).forEach((key): void => {
+      const arr = trim(header[key]);
+      if (arr.byteLength > 0) {
+        meta[key] = decoder.decode(arr);
       }
-    );
+    });
 
     // read the file content
     const len = parseInt(decoder.decode(header.fileSize), 8);

std/encoding/csv.ts

@@ -84,25 +84,23 @@ async function read(
   result = line.split(opt.comma!);
 
   let quoteError = false;
-  result = result.map(
-    (r): string => {
-      if (opt.trimLeadingSpace) {
-        r = r.trimLeft();
-      }
-      if (r[0] === '"' && r[r.length - 1] === '"') {
-        r = r.substring(1, r.length - 1);
-      } else if (r[0] === '"') {
-        r = r.substring(1, r.length);
-      }
-
-      if (!opt.lazyQuotes) {
-        if (r[0] !== '"' && r.indexOf('"') !== -1) {
-          quoteError = true;
-        }
-      }
-      return r;
+  result = result.map((r): string => {
+    if (opt.trimLeadingSpace) {
+      r = r.trimLeft();
     }
-  );
+    if (r[0] === '"' && r[r.length - 1] === '"') {
+      r = r.substring(1, r.length - 1);
+    } else if (r[0] === '"') {
+      r = r.substring(1, r.length);
+    }
+
+    if (!opt.lazyQuotes) {
+      if (r[0] !== '"' && r.indexOf('"') !== -1) {
+        quoteError = true;
+      }
+    }
+    return r;
+  });
   if (quoteError) {
     throw new ParseError(Startline, lineIndex, 'bare " in non-quoted-field');
   }
@@ -226,27 +224,25 @@ export async function parse(
       );
       i++;
     }
-    return r.map(
-      (e): unknown => {
-        if (e.length !== headers.length) {
-          throw `Error number of fields line:${i}`;
-        }
-        i++;
-        const out: Record<string, unknown> = {};
-        for (let j = 0; j < e.length; j++) {
-          const h = headers[j];
-          if (h.parse) {
-            out[h.name] = h.parse(e[j]);
-          } else {
-            out[h.name] = e[j];
-          }
-        }
-        if (opt.parse) {
-          return opt.parse(out);
-        }
-        return out;
+    return r.map((e): unknown => {
+      if (e.length !== headers.length) {
+        throw `Error number of fields line:${i}`;
       }
-    );
+      i++;
+      const out: Record<string, unknown> = {};
+      for (let j = 0; j < e.length; j++) {
+        const h = headers[j];
+        if (h.parse) {
+          out[h.name] = h.parse(e[j]);
+        } else {
+          out[h.name] = e[j];
+        }
+      }
+      if (opt.parse) {
+        return opt.parse(out);
+      }
+      return out;
+    });
   }
   if (opt.parse) {
     return r.map((e: string[]): unknown => opt.parse!(e));

std/encoding/csv_test.ts

@@ -20,7 +20,10 @@ const testCases = [
   {
     Name: "CRLF",
     Input: "a,b\r\nc,d\r\n",
-    Output: [["a", "b"], ["c", "d"]]
+    Output: [
+      ["a", "b"],
+      ["c", "d"]
+    ]
   },
   {
     Name: "BareCR",
@@ -64,12 +67,18 @@ const testCases = [
   {
     Name: "BlankLine",
     Input: "a,b,c\n\nd,e,f\n\n",
-    Output: [["a", "b", "c"], ["d", "e", "f"]]
+    Output: [
+      ["a", "b", "c"],
+      ["d", "e", "f"]
+    ]
   },
   {
     Name: "BlankLineFieldCount",
     Input: "a,b,c\n\nd,e,f\n\n",
-    Output: [["a", "b", "c"], ["d", "e", "f"]],
+    Output: [
+      ["a", "b", "c"],
+      ["d", "e", "f"]
+    ],
     UseFieldsPerRecord: true,
     FieldsPerRecord: 0
   },
@@ -93,7 +102,10 @@ const testCases = [
   {
     Name: "NoComment",
     Input: "#1,2,3\na,b,c",
-    Output: [["#1", "2", "3"], ["a", "b", "c"]]
+    Output: [
+      ["#1", "2", "3"],
+      ["a", "b", "c"]
+    ]
   },
   {
     Name: "LazyQuotes",
@@ -159,7 +171,10 @@ const testCases = [
   {
     Name: "FieldCount",
     Input: "a,b,c\nd,e",
-    Output: [["a", "b", "c"], ["d", "e"]]
+    Output: [
+      ["a", "b", "c"],
+      ["d", "e"]
+    ]
   },
   {
     Name: "TrailingCommaEOF",
@@ -186,7 +201,11 @@ const testCases = [
   {
     Name: "TrailingCommaLine3",
     Input: "a,b,c\nd,e,f\ng,hi,",
-    Output: [["a", "b", "c"], ["d", "e", "f"], ["g", "hi", ""]],
+    Output: [
+      ["a", "b", "c"],
+      ["d", "e", "f"],
+      ["g", "hi", ""]
+    ],
     TrimLeadingSpace: true
   },
   {
@@ -223,13 +242,19 @@ x,,,
   {
     Name: "TrailingCommaIneffective1",
     Input: "a,b,\nc,d,e",
-    Output: [["a", "b", ""], ["c", "d", "e"]],
+    Output: [
+      ["a", "b", ""],
+      ["c", "d", "e"]
+    ],
     TrimLeadingSpace: true
   },
   {
     Name: "ReadAllReuseRecord",
     Input: "a,b\nc,d",
-    Output: [["a", "b"], ["c", "d"]],
+    Output: [
+      ["a", "b"],
+      ["c", "d"]
+    ],
     ReuseRecord: true
   },
   // {
@@ -496,7 +521,10 @@ const parseTestCases = [
     name: "multiline",
     in: "a,b,c\ne,f,g\n",
     header: false,
-    result: [["a", "b", "c"], ["e", "f", "g"]]
+    result: [
+      ["a", "b", "c"],
+      ["e", "f", "g"]
+    ]
   },
   {
     name: "header mapping boolean",

std/encoding/toml.ts

@@ -393,11 +393,9 @@ function joinKeys(keys: string[]): string {
   // Dotted keys are a sequence of bare or quoted keys joined with a dot.
   // This allows for grouping similar properties together:
   return keys
-    .map(
-      (str: string): string => {
-        return str.match(/[^A-Za-z0-9_-]/) ? `"${str}"` : str;
-      }
-    )
+    .map((str: string): string => {
+      return str.match(/[^A-Za-z0-9_-]/) ? `"${str}"` : str;
+    })
     .join(".");
 }
 
@@ -417,24 +415,20 @@ class Dumper {
   _parse(obj: Record<string, unknown>, keys: string[] = []): string[] {
     const out = [];
     const props = Object.keys(obj);
-    const propObj = props.filter(
-      (e: string): boolean => {
-        if (obj[e] instanceof Array) {
-          const d: unknown[] = obj[e] as unknown[];
-          return !this._isSimplySerializable(d[0]);
-        }
-        return !this._isSimplySerializable(obj[e]);
+    const propObj = props.filter((e: string): boolean => {
+      if (obj[e] instanceof Array) {
+        const d: unknown[] = obj[e] as unknown[];
+        return !this._isSimplySerializable(d[0]);
       }
-    );
-    const propPrim = props.filter(
-      (e: string): boolean => {
-        if (obj[e] instanceof Array) {
-          const d: unknown[] = obj[e] as unknown[];
-          return this._isSimplySerializable(d[0]);
-        }
-        return this._isSimplySerializable(obj[e]);
+      return !this._isSimplySerializable(obj[e]);
+    });
+    const propPrim = props.filter((e: string): boolean => {
+      if (obj[e] instanceof Array) {
+        const d: unknown[] = obj[e] as unknown[];
+        return this._isSimplySerializable(d[0]);
       }
-    );
+      return this._isSimplySerializable(obj[e]);
+    });
     const k = propPrim.concat(propObj);
     for (let i = 0; i < k.length; i++) {
       const prop = k[i];

std/encoding/toml_test.ts

@@ -112,7 +112,10 @@ test({
   fn(): void {
     const expected = {
       arrays: {
-        data: [["gamma", "delta"], [1, 2]],
+        data: [
+          ["gamma", "delta"],
+          [1, 2]
+        ],
         hosts: ["alpha", "omega"]
       }
     };
@@ -344,7 +347,10 @@ test({
       sf4: NaN,
       sf5: NaN,
       sf6: NaN,
-      data: [["gamma", "delta"], [1, 2]],
+      data: [
+        ["gamma", "delta"],
+        [1, 2]
+      ],
       hosts: ["alpha", "omega"]
     };
     const expected = `deno    = "is"

std/flags/mod.ts

@@ -79,11 +79,9 @@ export function parse(
           ? [options.boolean]
           : options.boolean;
 
-      booleanArgs.filter(Boolean).forEach(
-        (key: string): void => {
-          flags.bools[key] = true;
-        }
-      );
+      booleanArgs.filter(Boolean).forEach((key: string): void => {
+        flags.bools[key] = true;
+      });
     }
   }
 
@@ -114,11 +112,9 @@ export function parse(
       flags.strings[key] = true;
       const alias = get(aliases, key);
       if (alias) {
-        alias.forEach(
-          (alias: string): void => {
-            flags.strings[alias] = true;
-          }
-        );
+        alias.forEach((alias: string): void => {
+          flags.strings[alias] = true;
+        });
       }
     });
   }

std/fmt/sprintf_test.ts

@@ -587,18 +587,16 @@ const tests: Array<[string, any, string]> = [
 ];
 
 test(function testThorough(): void {
-  tests.forEach(
-    (t, i): void => {
-      //            p(t)
-      const is = S(t[0], t[1]);
-      const should = t[2];
-      assertEquals(
-        is,
-        should,
-        `failed case[${i}] : is >${is}< should >${should}<`
-      );
-    }
-  );
+  tests.forEach((t, i): void => {
+    //            p(t)
+    const is = S(t[0], t[1]);
+    const should = t[2];
+    assertEquals(
+      is,
+      should,
+      `failed case[${i}] : is >${is}< should >${should}<`
+    );
+  });
 });
 
 test(function testWeirdos(): void {

std/fs/copy_test.ts

@@ -317,11 +317,9 @@ testCopySync(
   (tempDir: string): void => {
     const srcFile = path.join(testdataDir, "copy_file_not_exists_sync.txt");
     const destFile = path.join(tempDir, "copy_file_not_exists_1_sync.txt");
-    assertThrows(
-      (): void => {
-        copySync(srcFile, destFile);
-      }
-    );
+    assertThrows((): void => {
+      copySync(srcFile, destFile);
+    });
   }
 );
 
@@ -367,50 +365,47 @@ testCopySync(
   }
 );
 
-testCopySync(
-  "[fs] copy file synchronously",
-  (tempDir: string): void => {
-    const srcFile = path.join(testdataDir, "copy_file.txt");
-    const destFile = path.join(tempDir, "copy_file_copy_sync.txt");
+testCopySync("[fs] copy file synchronously", (tempDir: string): void => {
+  const srcFile = path.join(testdataDir, "copy_file.txt");
+  const destFile = path.join(tempDir, "copy_file_copy_sync.txt");
 
-    const srcContent = new TextDecoder().decode(Deno.readFileSync(srcFile));
+  const srcContent = new TextDecoder().decode(Deno.readFileSync(srcFile));
 
-    assertEquals(existsSync(srcFile), true);
-    assertEquals(existsSync(destFile), false);
+  assertEquals(existsSync(srcFile), true);
+  assertEquals(existsSync(destFile), false);
 
-    copySync(srcFile, destFile);
+  copySync(srcFile, destFile);
 
-    assertEquals(existsSync(srcFile), true);
-    assertEquals(existsSync(destFile), true);
+  assertEquals(existsSync(srcFile), true);
+  assertEquals(existsSync(destFile), true);
 
-    const destContent = new TextDecoder().decode(Deno.readFileSync(destFile));
+  const destContent = new TextDecoder().decode(Deno.readFileSync(destFile));
 
-    assertEquals(srcContent, destContent);
+  assertEquals(srcContent, destContent);
 
-    // Copy again without overwrite option and it should throw an error.
-    assertThrows(
-      (): void => {
-        copySync(srcFile, destFile);
-      },
-      Error,
-      `'${destFile}' already exists.`
-    );
+  // Copy again without overwrite option and it should throw an error.
+  assertThrows(
+    (): void => {
+      copySync(srcFile, destFile);
+    },
+    Error,
+    `'${destFile}' already exists.`
+  );
 
-    // Modify destination file.
-    Deno.writeFileSync(destFile, new TextEncoder().encode("txt copy"));
+  // Modify destination file.
+  Deno.writeFileSync(destFile, new TextEncoder().encode("txt copy"));
 
-    assertEquals(
-      new TextDecoder().decode(Deno.readFileSync(destFile)),
-      "txt copy"
-    );
+  assertEquals(
+    new TextDecoder().decode(Deno.readFileSync(destFile)),
+    "txt copy"
+  );
 
-    // Copy again with overwrite option.
-    copySync(srcFile, destFile, { overwrite: true });
+  // Copy again with overwrite option.
+  copySync(srcFile, destFile, { overwrite: true });
 
-    // Make sure the file has been overwritten.
-    assertEquals(new TextDecoder().decode(Deno.readFileSync(destFile)), "txt");
-  }
-);
+  // Make sure the file has been overwritten.
+  assertEquals(new TextDecoder().decode(Deno.readFileSync(destFile)), "txt");
+});
 
 testCopySync(
   "[fs] copy directory synchronously to its subdirectory",
@@ -450,57 +445,54 @@ testCopySync(
   }
 );
 
-testCopySync(
-  "[fs] copy directory synchronously",
-  (tempDir: string): void => {
-    const srcDir = path.join(testdataDir, "copy_dir");
-    const destDir = path.join(tempDir, "copy_dir_copy_sync");
-    const srcFile = path.join(srcDir, "0.txt");
-    const destFile = path.join(destDir, "0.txt");
-    const srcNestFile = path.join(srcDir, "nest", "0.txt");
-    const destNestFile = path.join(destDir, "nest", "0.txt");
+testCopySync("[fs] copy directory synchronously", (tempDir: string): void => {
+  const srcDir = path.join(testdataDir, "copy_dir");
+  const destDir = path.join(tempDir, "copy_dir_copy_sync");
+  const srcFile = path.join(srcDir, "0.txt");
+  const destFile = path.join(destDir, "0.txt");
+  const srcNestFile = path.join(srcDir, "nest", "0.txt");
+  const destNestFile = path.join(destDir, "nest", "0.txt");
 
-    copySync(srcDir, destDir);
+  copySync(srcDir, destDir);
 
-    assertEquals(existsSync(destFile), true);
-    assertEquals(existsSync(destNestFile), true);
+  assertEquals(existsSync(destFile), true);
+  assertEquals(existsSync(destNestFile), true);
 
-    // After copy. The source and destination should have the same content.
-    assertEquals(
-      new TextDecoder().decode(Deno.readFileSync(srcFile)),
-      new TextDecoder().decode(Deno.readFileSync(destFile))
-    );
-    assertEquals(
-      new TextDecoder().decode(Deno.readFileSync(srcNestFile)),
-      new TextDecoder().decode(Deno.readFileSync(destNestFile))
-    );
+  // After copy. The source and destination should have the same content.
+  assertEquals(
+    new TextDecoder().decode(Deno.readFileSync(srcFile)),
+    new TextDecoder().decode(Deno.readFileSync(destFile))
+  );
+  assertEquals(
+    new TextDecoder().decode(Deno.readFileSync(srcNestFile)),
+    new TextDecoder().decode(Deno.readFileSync(destNestFile))
+  );
 
-    // Copy again without overwrite option and it should throw an error.
-    assertThrows(
-      (): void => {
-        copySync(srcDir, destDir);
-      },
-      Error,
-      `'${destDir}' already exists.`
-    );
+  // Copy again without overwrite option and it should throw an error.
+  assertThrows(
+    (): void => {
+      copySync(srcDir, destDir);
+    },
+    Error,
+    `'${destDir}' already exists.`
+  );
 
-    // Modify the file in the destination directory.
-    Deno.writeFileSync(destNestFile, new TextEncoder().encode("nest copy"));
-    assertEquals(
-      new TextDecoder().decode(Deno.readFileSync(destNestFile)),
-      "nest copy"
-    );
+  // Modify the file in the destination directory.
+  Deno.writeFileSync(destNestFile, new TextEncoder().encode("nest copy"));
+  assertEquals(
+    new TextDecoder().decode(Deno.readFileSync(destNestFile)),
+    "nest copy"
+  );
 
-    // Copy again with overwrite option.
-    copySync(srcDir, destDir, { overwrite: true });
+  // Copy again with overwrite option.
+  copySync(srcDir, destDir, { overwrite: true });
 
-    // Make sure the file has been overwritten.
-    assertEquals(
-      new TextDecoder().decode(Deno.readFileSync(destNestFile)),
-      "nest"
-    );
-  }
-);
+  // Make sure the file has been overwritten.
+  assertEquals(
+    new TextDecoder().decode(Deno.readFileSync(destNestFile)),
+    "nest"
+  );
+});
 
 testCopySync(
   "[fs] copy symlink file synchronously",

std/fs/empty_dir_test.ts

@@ -110,18 +110,14 @@ test(function emptyDirSyncIfItExist(): void {
     assertEquals(stat.isDirectory(), true);
 
     // nest directory have been remove
-    assertThrows(
-      (): void => {
-        Deno.statSync(testNestDir);
-      }
-    );
+    assertThrows((): void => {
+      Deno.statSync(testNestDir);
+    });
 
     // test file have been remove
-    assertThrows(
-      (): void => {
-        Deno.statSync(testDirFile);
-      }
-    );
+    assertThrows((): void => {
+      Deno.statSync(testDirFile);
+    });
   } finally {
     // remote test dir
     Deno.removeSync(testDir, { recursive: true });

std/fs/ensure_dir_test.ts

@@ -15,11 +15,9 @@ test(async function ensureDirIfItNotExist(): Promise<void> {
 
   await assertThrowsAsync(
     async (): Promise<void> => {
-      await Deno.stat(testDir).then(
-        (): void => {
-          throw new Error("test dir should exists.");
-        }
-      );
+      await Deno.stat(testDir).then((): void => {
+        throw new Error("test dir should exists.");
+      });
     }
   );
 
@@ -48,11 +46,9 @@ test(async function ensureDirIfItExist(): Promise<void> {
 
   await assertThrowsAsync(
     async (): Promise<void> => {
-      await Deno.stat(testDir).then(
-        (): void => {
-          throw new Error("test dir should still exists.");
-        }
-      );
+      await Deno.stat(testDir).then((): void => {
+        throw new Error("test dir should still exists.");
+      });
     }
   );
 
@@ -68,12 +64,10 @@ test(function ensureDirSyncIfItExist(): void {
 
   ensureDirSync(testDir);
 
-  assertThrows(
-    (): void => {
-      Deno.statSync(testDir);
-      throw new Error("test dir should still exists.");
-    }
-  );
+  assertThrows((): void => {
+    Deno.statSync(testDir);
+    throw new Error("test dir should still exists.");
+  });
 
   Deno.removeSync(baseDir, { recursive: true });
 });

std/fs/ensure_file_test.ts

@@ -14,11 +14,9 @@ test(async function ensureFileIfItNotExist(): Promise<void> {
 
   await assertThrowsAsync(
     async (): Promise<void> => {
-      await Deno.stat(testFile).then(
-        (): void => {
-          throw new Error("test file should exists.");
-        }
-      );
+      await Deno.stat(testFile).then((): void => {
+        throw new Error("test file should exists.");
+      });
     }
   );
 
@@ -31,12 +29,10 @@ test(function ensureFileSyncIfItNotExist(): void {
 
   ensureFileSync(testFile);
 
-  assertThrows(
-    (): void => {
-      Deno.statSync(testFile);
-      throw new Error("test file should exists.");
-    }
-  );
+  assertThrows((): void => {
+    Deno.statSync(testFile);
+    throw new Error("test file should exists.");
+  });
 
   Deno.removeSync(testDir, { recursive: true });
 });
@@ -52,11 +48,9 @@ test(async function ensureFileIfItExist(): Promise<void> {
 
   await assertThrowsAsync(
     async (): Promise<void> => {
-      await Deno.stat(testFile).then(
-        (): void => {
-          throw new Error("test file should exists.");
-        }
-      );
+      await Deno.stat(testFile).then((): void => {
+        throw new Error("test file should exists.");
+      });
     }
   );
 
@@ -72,12 +66,10 @@ test(function ensureFileSyncIfItExist(): void {
 
   ensureFileSync(testFile);
 
-  assertThrows(
-    (): void => {
-      Deno.statSync(testFile);
-      throw new Error("test file should exists.");
-    }
-  );
+  assertThrows((): void => {
+    Deno.statSync(testFile);
+    throw new Error("test file should exists.");
+  });
 
   Deno.removeSync(testDir, { recursive: true });
 });

std/fs/ensure_link_test.ts

@@ -31,11 +31,9 @@ test(function ensureLinkSyncIfItNotExist(): void {
   const testFile = path.join(testDir, "test.txt");
   const linkFile = path.join(testDir, "link.txt");
 
-  assertThrows(
-    (): void => {
-      ensureLinkSync(testFile, linkFile);
-    }
-  );
+  assertThrows((): void => {
+    ensureLinkSync(testFile, linkFile);
+  });
 
   Deno.removeSync(testDir, { recursive: true });
 });

std/fs/ensure_symlink_test.ts

@@ -24,11 +24,9 @@ test(async function ensureSymlinkIfItNotExist(): Promise<void> {
 
   assertThrowsAsync(
     async (): Promise<void> => {
-      await Deno.stat(testFile).then(
-        (): void => {
-          throw new Error("test file should exists.");
-        }
-      );
+      await Deno.stat(testFile).then((): void => {
+        throw new Error("test file should exists.");
+      });
     }
   );
 });
@@ -37,18 +35,14 @@ test(function ensureSymlinkSyncIfItNotExist(): void {
   const testDir = path.join(testdataDir, "link_file_2");
   const testFile = path.join(testDir, "test.txt");
 
-  assertThrows(
-    (): void => {
-      ensureSymlinkSync(testFile, path.join(testDir, "test1.txt"));
-    }
-  );
+  assertThrows((): void => {
+    ensureSymlinkSync(testFile, path.join(testDir, "test1.txt"));
+  });
 
-  assertThrows(
-    (): void => {
-      Deno.statSync(testFile);
-      throw new Error("test file should exists.");
-    }
-  );
+  assertThrows((): void => {
+    Deno.statSync(testFile);
+    throw new Error("test file should exists.");
+  });
 });
 
 test(async function ensureSymlinkIfItExist(): Promise<void> {

std/fs/expand_glob.ts

@@ -136,8 +136,8 @@ export async function* expandGlob(
     );
   }
   if (hasTrailingSep) {
-    currentMatches = currentMatches.filter(
-      ({ info }): boolean => info.isDirectory()
+    currentMatches = currentMatches.filter(({ info }): boolean =>
+      info.isDirectory()
     );
   }
   if (!includeDirs) {
@@ -238,8 +238,8 @@ export function* expandGlobSync(
     );
   }
   if (hasTrailingSep) {
-    currentMatches = currentMatches.filter(
-      ({ info }): boolean => info.isDirectory()
+    currentMatches = currentMatches.filter(({ info }): boolean =>
+      info.isDirectory()
     );
   }
   if (!includeDirs) {

std/fs/move_test.ts

@@ -182,11 +182,9 @@ test(function moveSyncDirectoryIfSrcNotExists(): void {
   const srcDir = path.join(testdataDir, "move_sync_test_src_1");
   const destDir = path.join(testdataDir, "move_sync_test_dest_1");
   // if src directory not exist
-  assertThrows(
-    (): void => {
-      moveSync(srcDir, destDir);
-    }
-  );
+  assertThrows((): void => {
+    moveSync(srcDir, destDir);
+  });
 });
 
 test(function moveSyncDirectoryIfDestNotExists(): void {
@@ -213,11 +211,9 @@ test(function moveSyncFileIfSrcNotExists(): void {
   const destFile = path.join(testdataDir, "move_sync_test_dest_3", "test.txt");
 
   // if src directory not exist
-  assertThrows(
-    (): void => {
-      moveSync(srcFile, destFile);
-    }
-  );
+  assertThrows((): void => {
+    moveSync(srcFile, destFile);
+  });
 });
 
 test(function moveSyncFileIfDestExists(): void {

std/fs/read_json_test.ts

@@ -65,31 +65,25 @@ test(async function readValidObjJsonFileWithRelativePath(): Promise<void> {
 test(function readJsonFileNotExistsSync(): void {
   const emptyJsonFile = path.join(testdataDir, "json_not_exists.json");
 
-  assertThrows(
-    (): void => {
-      readJsonSync(emptyJsonFile);
-    }
-  );
+  assertThrows((): void => {
+    readJsonSync(emptyJsonFile);
+  });
 });
 
 test(function readEmptyJsonFileSync(): void {
   const emptyJsonFile = path.join(testdataDir, "json_empty.json");
 
-  assertThrows(
-    (): void => {
-      readJsonSync(emptyJsonFile);
-    }
-  );
+  assertThrows((): void => {
+    readJsonSync(emptyJsonFile);
+  });
 });
 
 test(function readInvalidJsonFile(): void {
   const invalidJsonFile = path.join(testdataDir, "json_invalid.json");
 
-  assertThrows(
-    (): void => {
-      readJsonSync(invalidJsonFile);
-    }
-  );
+  assertThrows((): void => {
+    readJsonSync(invalidJsonFile);
+  });
 });
 
 test(function readValidArrayJsonFileSync(): void {

std/fs/walk.ts

@@ -21,13 +21,11 @@ function patternTest(patterns: RegExp[], path: string): boolean {
   // Forced to reset last index on regex while iterating for have
   // consistent results.
   // See: https://stackoverflow.com/a/1520853
-  return patterns.some(
-    (pattern): boolean => {
-      const r = pattern.test(path);
-      pattern.lastIndex = 0;
-      return r;
-    }
-  );
+  return patterns.some((pattern): boolean => {
+    const r = pattern.test(path);
+    pattern.lastIndex = 0;
+    return r;
+  });
 }
 
 function include(filename: string, options: WalkOptions): boolean {

std/http/file_server.ts

@@ -75,11 +75,9 @@ function modeToString(isDir: boolean, maybeMode: number | null): string {
     .split("")
     .reverse()
     .slice(0, 3)
-    .forEach(
-      (v): void => {
-        output = modeMap[+v] + output;
-      }
-    );
+    .forEach((v): void => {
+      output = modeMap[+v] + output;
+    });
   output = `(${isDir ? "d" : "-"}${output})`;
   return output;
 }
@@ -179,9 +177,8 @@ async function serveDir(
     dirViewerTemplate.replace("<%DIRNAME%>", formattedDirUrl).replace(
       "<%CONTENTS%>",
       listEntry
-        .sort(
-          (a, b): number =>
-            a.name.toLowerCase() > b.name.toLowerCase() ? 1 : -1
+        .sort((a, b): number =>
+          a.name.toLowerCase() > b.name.toLowerCase() ? 1 : -1
         )
         .map((v): string => v.template)
         .join("")

std/http/server_test.ts

@@ -505,11 +505,9 @@ test({
 
       let serverIsRunning = true;
       p.status()
-        .then(
-          (): void => {
-            serverIsRunning = false;
-          }
-        )
+        .then((): void => {
+          serverIsRunning = false;
+        })
         .catch((_): void => {}); // Ignores the error when closing the process.
 
       await delay(100);
@@ -551,11 +549,9 @@ test({
 
       let serverIsRunning = true;
       p.status()
-        .then(
-          (): void => {
-            serverIsRunning = false;
-          }
-        )
+        .then((): void => {
+          serverIsRunning = false;
+        })
         .catch((_): void => {}); // Ignores the error when closing the process.
 
       // Requests to the server and immediately closes the connection

std/io/bufio.ts

@@ -23,6 +23,7 @@ export class BufferFullError extends Error {
 
 export class UnexpectedEOFError extends Error {
   name = "UnexpectedEOFError";
+  partial?: Uint8Array;
   constructor() {
     super("Unexpected EOF");
   }

std/log/handlers.ts

@@ -37,19 +37,16 @@ export class BaseHandler {
       return this.formatter(logRecord);
     }
 
-    return this.formatter.replace(
-      /{(\S+)}/g,
-      (match, p1): string => {
-        const value = logRecord[p1 as keyof LogRecord];
+    return this.formatter.replace(/{(\S+)}/g, (match, p1): string => {
+      const value = logRecord[p1 as keyof LogRecord];
 
-        // do not interpolate missing values
-        if (!value) {
-          return match;
-        }
-
-        return String(value);
+      // do not interpolate missing values
+      if (!value) {
+        return match;
       }
-    );
+
+      return String(value);
+    });
   }
 
   log(_msg: string): void {}

std/log/logger.ts

@@ -36,11 +36,9 @@ export class Logger {
       level: level,
       levelName: getLevelName(level)
     };
-    this.handlers.forEach(
-      (handler): void => {
-        handler.handle(record);
-      }
-    );
+    this.handlers.forEach((handler): void => {
+      handler.handle(record);
+    });
   }
 
   debug(msg: string, ...args: unknown[]): void {

std/log/mod.ts

@@ -80,11 +80,9 @@ export async function setup(config: LogConfig): Promise<void> {
   };
 
   // tear down existing handlers
-  state.handlers.forEach(
-    (handler): void => {
-      handler.destroy();
-    }
-  );
+  state.handlers.forEach((handler): void => {
+    handler.destroy();
+  });
   state.handlers.clear();
 
   // setup handlers
@@ -106,13 +104,11 @@ export async function setup(config: LogConfig): Promise<void> {
     const handlerNames = loggerConfig.handlers || [];
     const handlers: BaseHandler[] = [];
 
-    handlerNames.forEach(
-      (handlerName): void => {
-        if (state.handlers.has(handlerName)) {
-          handlers.push(state.handlers.get(handlerName)!);
-        }
+    handlerNames.forEach((handlerName): void => {
+      if (state.handlers.has(handlerName)) {
+        handlers.push(state.handlers.get(handlerName)!);
       }
-    );
+    });
 
     const levelName = loggerConfig.level || DEFAULT_LEVEL;
     const logger = new Logger(levelName, handlers);

std/mime/multipart.ts

@@ -188,20 +188,18 @@ class PartReader implements Reader, Closer {
     comps
       .slice(1)
       .map((v: string): string => v.trim())
-      .map(
-        (kv: string): void => {
-          const [k, v] = kv.split("=");
-          if (v) {
-            const s = v.charAt(0);
-            const e = v.charAt(v.length - 1);
-            if ((s === e && s === '"') || s === "'") {
-              params[k] = v.substr(1, v.length - 2);
-            } else {
-              params[k] = v;
-            }
+      .map((kv: string): void => {
+        const [k, v] = kv.split("=");
+        if (v) {
+          const s = v.charAt(0);
+          const e = v.charAt(v.length - 1);
+          if ((s === e && s === '"') || s === "'") {
+            params[k] = v.substr(1, v.length - 2);
+          } else {
+            params[k] = v;
           }
         }
-      );
+      });
     return (this.contentDispositionParams = params);
   }
 

std/testing/README.md

@@ -92,11 +92,9 @@ Using `assertThrows()`:
 
 ```ts
 test(function doesThrow(): void {
-  assertThrows(
-    (): void => {
-      throw new TypeError("hello world!");
-    }
-  );
+  assertThrows((): void => {
+    throw new TypeError("hello world!");
+  });
   assertThrows((): void => {
     throw new TypeError("hello world!");
   }, TypeError);
@@ -111,11 +109,9 @@ test(function doesThrow(): void {
 
 // This test will not pass
 test(function fails(): void {
-  assertThrows(
-    (): void => {
-      console.log("Hello world");
-    }
-  );
+  assertThrows((): void => {
+    console.log("Hello world");
+  });
 });
 ```
 

std/testing/asserts.ts

@@ -56,12 +56,10 @@ function buildMessage(diffResult: ReadonlyArray<DiffResult<string>>): string[] {
   );
   messages.push("");
   messages.push("");
-  diffResult.forEach(
-    (result: DiffResult<string>): void => {
-      const c = createColor(result.type);
-      messages.push(c(`${createSign(result.type)}${result.value}`));
-    }
-  );
+  diffResult.forEach((result: DiffResult<string>): void => {
+    const c = createColor(result.type);
+    messages.push(c(`${createSign(result.type)}${result.value}`));
+  });
   messages.push("");
 
   return messages;
@@ -131,7 +129,7 @@ export function equal(c: unknown, d: unknown): boolean {
 }
 
 /** Make an assertion, if not `true`, then throw. */
-export function assert(expr: boolean, msg = ""): void {
+export function assert(expr: unknown, msg = ""): asserts expr {
   if (!expr) {
     throw new AssertionError(msg);
   }

std/testing/asserts_test.ts

@@ -51,8 +51,14 @@ test(function testingEqual(): void {
   assert(equal(new Map(), new Map()));
   assert(
     equal(
-      new Map([["foo", "bar"], ["baz", "baz"]]),
-      new Map([["foo", "bar"], ["baz", "baz"]])
+      new Map([
+        ["foo", "bar"],
+        ["baz", "baz"]
+      ]),
+      new Map([
+        ["foo", "bar"],
+        ["baz", "baz"]
+      ])
     )
   );
   assert(
@@ -69,14 +75,26 @@ test(function testingEqual(): void {
   );
   assert(
     equal(
-      new Map([["foo", "bar"], ["baz", "qux"]]),
-      new Map([["baz", "qux"], ["foo", "bar"]])
+      new Map([
+        ["foo", "bar"],
+        ["baz", "qux"]
+      ]),
+      new Map([
+        ["baz", "qux"],
+        ["foo", "bar"]
+      ])
     )
   );
   assert(equal(new Map([["foo", ["bar"]]]), new Map([["foo", ["bar"]]])));
   assert(!equal(new Map([["foo", "bar"]]), new Map([["bar", "baz"]])));
   assert(
-    !equal(new Map([["foo", "bar"]]), new Map([["foo", "bar"], ["bar", "baz"]]))
+    !equal(
+      new Map([["foo", "bar"]]),
+      new Map([
+        ["foo", "bar"],
+        ["bar", "baz"]
+      ])
+    )
   );
   assert(
     !equal(

std/testing/diff.ts

@@ -133,7 +133,7 @@ export default function diff<T>(A: T[], B: T[]): Array<DiffResult<T>> {
     k: number,
     M: number
   ): FarthestPoint {
-    if (slide && slide.y === -1 && (down && down.y === -1))
+    if (slide && slide.y === -1 && down && down.y === -1)
       return { y: 0, id: 0 };
     if (
       (down && down.y === -1) ||

std/testing/format.ts

@@ -360,13 +360,11 @@ const getKeysOfEnumerableProperties = (object: {}): Array<string | symbol> => {
   const keys: Array<string | symbol> = Object.keys(object).sort();
 
   if (Object.getOwnPropertySymbols) {
-    Object.getOwnPropertySymbols(object).forEach(
-      (symbol): void => {
-        if (Object.getOwnPropertyDescriptor(object, symbol)!.enumerable) {
-          keys.push(symbol);
-        }
+    Object.getOwnPropertySymbols(object).forEach((symbol): void => {
+      if (Object.getOwnPropertyDescriptor(object, symbol)!.enumerable) {
+        keys.push(symbol);
       }
-    );
+    });
   }
 
   return keys;

std/testing/mod.ts

@@ -203,14 +203,12 @@ function report(result: TestResult): void {
 }
 
 function printFailedSummary(results: TestResults): void {
-  results.cases.forEach(
-    (v): void => {
-      if (!v.ok) {
-        console.error(`${RED_BG_FAIL} ${red(v.name)}`);
-        console.error(v.error);
-      }
+  results.cases.forEach((v): void => {
+    if (!v.ok) {
+      console.error(`${RED_BG_FAIL} ${red(v.name)}`);
+      console.error(v.error);
     }
-  );
+  });
 }
 
 function printResults(
@@ -321,14 +319,12 @@ async function runTestsSerial(
       print(
         GREEN_OK + "     " + name + " " + promptTestTime(end - start, true)
       );
-      results.cases.forEach(
-        (v): void => {
-          if (v.name === name) {
-            v.ok = true;
-            v.printed = true;
-          }
+      results.cases.forEach((v): void => {
+        if (v.name === name) {
+          v.ok = true;
+          v.printed = true;
         }
-      );
+      });
     } catch (err) {
       if (disableLog) {
         print(CLEAR_LINE, false);
@@ -336,15 +332,13 @@ async function runTestsSerial(
       print(`${RED_FAILED} ${name}`);
       print(err.stack);
       stats.failed++;
-      results.cases.forEach(
-        (v): void => {
-          if (v.name === name) {
-            v.error = err;
-            v.ok = false;
-            v.printed = true;
-          }
+      results.cases.forEach((v): void => {
+        if (v.name === name) {
+          v.error = err;
+          v.ok = false;
+          v.printed = true;
         }
-      );
+      });
       if (exitOnFail) {
         break;
       }

std/testing/runner.ts

@@ -204,8 +204,8 @@ async function main(): Promise<void> {
 
   const include =
     parsedArgs._.length > 0
-      ? (parsedArgs._ as string[]).flatMap(
-          (fileGlob: string): string[] => fileGlob.split(",")
+      ? (parsedArgs._ as string[]).flatMap((fileGlob: string): string[] =>
+          fileGlob.split(",")
         )
       : ["."];
   const exclude =

std/testing/test.ts

@@ -51,12 +51,10 @@ test(function testingAssertNotStrictEqual(): void {
 
 test(function testingDoesThrow(): void {
   let count = 0;
-  assertThrows(
-    (): void => {
-      count++;
-      throw new Error();
-    }
-  );
+  assertThrows((): void => {
+    count++;
+    throw new Error();
+  });
   assert(count === 1);
 });
 
@@ -64,12 +62,10 @@ test(function testingDoesNotThrow(): void {
   let count = 0;
   let didThrow = false;
   try {
-    assertThrows(
-      (): void => {
-        count++;
-        console.log("Hello world");
-      }
-    );
+    assertThrows((): void => {
+      count++;
+      console.log("Hello world");
+    });
   } catch (e) {
     assert(e.message === "Expected function to throw.");
     didThrow = true;

std/textproto/reader_test.ts

@@ -114,11 +114,9 @@ test({
     assertEquals(m.get("SID"), "0");
     assertEquals(m.get("Privilege"), "127");
     // Not a legal http header
-    assertThrows(
-      (): void => {
-        assertEquals(m.get("Audio Mode"), "None");
-      }
-    );
+    assertThrows((): void => {
+      assertEquals(m.get("Audio Mode"), "None");
+    });
   }
 });
 

std/util/async.ts

@@ -20,11 +20,9 @@ export interface Deferred<T> extends Promise<T> {
  */
 export function deferred<T>(): Deferred<T> {
   let methods;
-  const promise = new Promise<T>(
-    (resolve, reject): void => {
-      methods = { resolve, reject };
-    }
-  );
+  const promise = new Promise<T>((resolve, reject): void => {
+    methods = { resolve, reject };
+  });
   return Object.assign(promise, methods)! as Deferred<T>;
 }
 
@@ -111,10 +109,9 @@ export async function collectUint8Arrays(
 
 // Delays the given milliseconds and resolves.
 export function delay(ms: number): Promise<void> {
-  return new Promise(
-    (res): number =>
-      setTimeout((): void => {
-        res();
-      }, ms)
+  return new Promise((res): number =>
+    setTimeout((): void => {
+      res();
+    }, ms)
   );
 }

std/util/deep_assign.ts

@@ -8,26 +8,24 @@ export function deepAssign(
     if (!source || typeof source !== `object`) {
       return;
     }
-    Object.entries(source).forEach(
-      ([key, value]: [string, unknown]): void => {
-        if (value instanceof Date) {
-          target[key] = new Date(value);
-          return;
-        }
-        if (!value || typeof value !== `object`) {
-          target[key] = value;
-          return;
-        }
-        if (Array.isArray(value)) {
-          target[key] = [];
-        }
-        // value is an Object
-        if (typeof target[key] !== `object` || !target[key]) {
-          target[key] = {};
-        }
-        deepAssign(target[key] as Record<string, unknown>, value!);
+    Object.entries(source).forEach(([key, value]: [string, unknown]): void => {
+      if (value instanceof Date) {
+        target[key] = new Date(value);
+        return;
       }
-    );
+      if (!value || typeof value !== `object`) {
+        target[key] = value;
+        return;
+      }
+      if (Array.isArray(value)) {
+        target[key] = [];
+      }
+      // value is an Object
+      if (typeof target[key] !== `object` || !target[key]) {
+        target[key] = {};
+      }
+      deepAssign(target[key] as Record<string, unknown>, value!);
+    });
   }
   return target;
 }

std/uuid/v4.ts

@@ -15,12 +15,10 @@ export default function generate(): string {
   rnds[6] = (rnds[6] & 0x0f) | 0x40; // Version 4
   rnds[8] = (rnds[8] & 0x3f) | 0x80; // Variant 10
 
-  const bits: string[] = [...rnds].map(
-    (bit): string => {
-      const s: string = bit.toString(16);
-      return bit < 0x10 ? "0" + s : s;
-    }
-  );
+  const bits: string[] = [...rnds].map((bit): string => {
+    const s: string = bit.toString(16);
+    return bit < 0x10 ? "0" + s : s;
+  });
   return [
     ...bits.slice(0, 4),
     "-",

std/ws/README.md

@@ -60,11 +60,9 @@ for await (const req of serve(`:${port}`)) {
         }
       }
     )
-    .catch(
-      (err: Error): void => {
-        console.error(`failed to accept websocket: ${err}`);
-      }
-    );
+    .catch((err: Error): void => {
+      console.error(`failed to accept websocket: ${err}`);
+    });
 }
 ```
 
@@ -117,11 +115,9 @@ while (true) {
   }
   // FIXME: Without this,
   // sock.receive() won't resolved though it is readable...
-  await new Promise(
-    (resolve): void => {
-      setTimeout(resolve, 0);
-    }
-  );
+  await new Promise((resolve): void => {
+    setTimeout(resolve, 0);
+  });
 }
 await sock.close(1000);
 // FIXME: conn.close() won't shutdown process...

std/ws/example_client.ts

@@ -44,11 +44,9 @@ while (true) {
   }
   // FIXME: Without this,
   // sock.receive() won't resolved though it is readable...
-  await new Promise(
-    (resolve): void => {
-      setTimeout(resolve, 0);
-    }
-  );
+  await new Promise((resolve): void => {
+    setTimeout(resolve, 0);
+  });
 }
 await sock.close(1000);
 // FIXME: conn.close() won't shutdown process...

std/ws/example_server.ts

@@ -52,9 +52,7 @@ for await (const req of serve(`:${port}`)) {
         }
       }
     )
-    .catch(
-      (err: Error): void => {
-        console.error(`failed to accept websocket: ${err}`);
-      }
-    );
+    .catch((err: Error): void => {
+      console.error(`failed to accept websocket: ${err}`);
+    });
 }

third_party

@@ -1 +1 @@
-Subproject commit 140d1666ad04fb5ddfd5fc0d55181a9c7c067327
+Subproject commit 8132faa910c498d4b52cb87fe7141058445a60b3

tools/node_http_proxy.js

@@ -14,15 +14,9 @@ http
 
     const proxy = http.request(options, proxyRes => {
       res.writeHead(proxyRes.statusCode, proxyRes.headers);
-      proxyRes.pipe(
-        res,
-        { end: true }
-      );
+      proxyRes.pipe(res, { end: true });
     });
 
-    req.pipe(
-      proxy,
-      { end: true }
-    );
+    req.pipe(proxy, { end: true });
   })
   .listen(port);