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,16 +72,14 @@ function concatenate(...arrays: Uint8Array[]): ArrayBuffer {
 }
 
 function bufferFromStream(stream: ReadableStreamReader): Promise<ArrayBuffer> {
-  return new Promise(
+  return new Promise((resolve, reject): void => {
-    (resolve, reject): void => {
     const parts: Uint8Array[] = [];
     const encoder = new TextEncoder();
     // recurse
     (function pump(): void {
       stream
         .read()
-          .then(
+        .then(({ done, value }): void => {
-            ({ done, value }): void => {
           if (done) {
             return resolve(concatenate(...parts));
           }
@@ -97,16 +95,12 @@ function bufferFromStream(stream: ReadableStreamReader): Promise<ArrayBuffer> {
           }
 
           return pump();
-            }
+        })
-          )
+        .catch((err): void => {
-          .catch(
-            (err): void => {
           reject(err);
-            }
+        });
-          );
     })();
-    }
+  });
-  );
 }
 
 function getHeaderValueParams(value: string): Map<string, string> {
@@ -275,8 +269,7 @@ export class Body implements domTypes.Body {
         body
           .trim()
           .split("&")
-          .forEach(
+          .forEach((bytes): void => {
-            (bytes): void => {
             if (bytes) {
               const split = bytes.split("=");
               const name = split.shift()!.replace(/\+/g, " ");
@@ -286,8 +279,7 @@ export class Body implements domTypes.Body {
                 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(
+    const preProcessedFileInfo = ts.preProcessFile(this.sourceCode, true, true);
-      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) {
+      if (!sourceFile.tsSourceFile) {
-        sourceFile!.tsSourceFile = ts.createSourceFile(
+        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(
+    const resolvedRootModules = (
-      rootNames.map(rootName => [rootName, rootName])
+      await processImports(rootNames.map(rootName => [rootName, rootName]))
-    )).map(info => info.url);
+    ).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(
+      diagnostics = ts
-        ({ code }): boolean => {
+        .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,8 +292,7 @@ function createRawObjectString(
     shouldShowClassName = true;
   }
   const keys = Object.keys(value);
-  const entries: string[] = keys.map(
+  const entries: string[] = keys.map((key): string => {
-    (key): string => {
     if (keys.length > OBJ_ABBREVIATE_SIZE) {
       return key;
     } else {
@@ -304,8 +303,7 @@ function createRawObjectString(
         maxLevel
       )}`;
     }
-    }
+  });
-  );
 
   ctx.delete(value);
 
@@ -640,18 +638,15 @@ export class Console {
       let idx = 0;
       resultData = {};
 
-      data.forEach(
+      data.forEach((v: unknown, k: unknown): void => {
-        (v: unknown, k: unknown): void => {
         resultData[idx] = { Key: k, Values: v };
         idx++;
-        }
+      });
-      );
     } else {
       resultData = data!;
     }
 
-    Object.keys(resultData).forEach(
+    Object.keys(resultData).forEach((k, idx): void => {
-      (k, idx): void => {
       const value: unknown = resultData[k]!;
 
       if (value !== null && typeof value === "object") {
@@ -675,8 +670,7 @@ export class Console {
       }
 
       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(
+  const divider = columnWidths.map((i: number): string =>
-    (i: number): string => tableChars.middleMiddle.repeat(i + 2)
+    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,8 +421,7 @@ function mockConsole(f: ConsoleExamineFunc): void {
 
 // console.group test
 test(function consoleGroup(): void {
-  mockConsole(
+  mockConsole((console, out): void => {
-    (console, out): void => {
     console.group("1");
     console.log("2");
     console.group("3");
@@ -431,14 +441,12 @@ test(function consoleGroup(): void {
 6
 `
     );
-    }
+  });
-  );
 });
 
 // console.group with console.warn test
 test(function consoleGroupWarn(): void {
-  mockConsole(
+  mockConsole((console, _out, _err, both): void => {
-    (console, _out, _err, both): void => {
     console.warn("1");
     console.group();
     console.warn("2");
@@ -462,14 +470,12 @@ test(function consoleGroupWarn(): void {
 7
 `
     );
-    }
+  });
-  );
 });
 
 // console.table test
 test(function consoleTable(): void {
-  mockConsole(
+  mockConsole((console, out): void => {
-    (console, out): void => {
     console.table({ a: "test", b: 1 });
     assertEquals(
       out.toString(),
@@ -481,10 +487,8 @@ test(function consoleTable(): void {
 └─────────┴────────┘
 `
     );
-    }
+  });
-  );
+  mockConsole((console, out): void => {
-  mockConsole(
-    (console, out): void => {
     console.table({ a: { b: 10 }, b: { b: 20, c: 30 } }, ["c"]);
     assertEquals(
       out.toString(),
@@ -496,10 +500,8 @@ test(function consoleTable(): void {
 └─────────┴────┘
 `
     );
-    }
+  });
-  );
+  mockConsole((console, out): void => {
-  mockConsole(
-    (console, out): void => {
     console.table([1, 2, [3, [4]], [5, 6], [[7], [8]]]);
     assertEquals(
       out.toString(),
@@ -514,10 +516,8 @@ test(function consoleTable(): void {
 └─────────┴───────┴───────┴────────┘
 `
     );
-    }
+  });
-  );
+  mockConsole((console, out): void => {
-  mockConsole(
-    (console, out): void => {
     console.table(new Set([1, 2, 3, "test"]));
     assertEquals(
       out.toString(),
@@ -531,11 +531,14 @@ test(function consoleTable(): void {
 └───────────────────┴────────┘
 `
     );
-    }
+  });
+  mockConsole((console, out): void => {
+    console.table(
+      new Map([
+        [1, "one"],
+        [2, "two"]
+      ])
     );
-  mockConsole(
-    (console, out): void => {
-      console.table(new Map([[1, "one"], [2, "two"]]));
     assertEquals(
       out.toString(),
       `┌───────────────────┬─────┬────────┐
@@ -546,10 +549,8 @@ test(function consoleTable(): void {
 └───────────────────┴─────┴────────┘
 `
     );
-    }
+  });
-  );
+  mockConsole((console, out): void => {
-  mockConsole(
-    (console, out): void => {
     console.table({
       a: true,
       b: { c: { d: 10 }, e: [1, 2, [5, 6]] },
@@ -570,10 +571,8 @@ test(function consoleTable(): void {
 └─────────┴───────────┴───────────────────┴────────┘
 `
     );
-    }
+  });
-  );
+  mockConsole((console, out): void => {
-  mockConsole(
-    (console, out): void => {
     console.table([
       1,
       "test",
@@ -594,10 +593,8 @@ test(function consoleTable(): void {
 └─────────┴────────┴──────────────────────┴────┴────────┘
 `
     );
-    }
+  });
-  );
+  mockConsole((console, out): void => {
-  mockConsole(
-    (console, out): void => {
     console.table([]);
     assertEquals(
       out.toString(),
@@ -607,10 +604,8 @@ test(function consoleTable(): void {
 └─────────┘
 `
     );
-    }
+  });
-  );
+  mockConsole((console, out): void => {
-  mockConsole(
-    (console, out): void => {
     console.table({});
     assertEquals(
       out.toString(),
@@ -620,10 +615,8 @@ test(function consoleTable(): void {
 └─────────┘
 `
     );
-    }
+  });
-  );
+  mockConsole((console, out): void => {
-  mockConsole(
-    (console, out): void => {
     console.table(new Set());
     assertEquals(
       out.toString(),
@@ -633,10 +626,8 @@ test(function consoleTable(): void {
 └───────────────────┘
 `
     );
-    }
+  });
-  );
+  mockConsole((console, out): void => {
-  mockConsole(
-    (console, out): void => {
     console.table(new Map());
     assertEquals(
       out.toString(),
@@ -646,14 +637,11 @@ test(function consoleTable(): void {
 └───────────────────┘
 `
     );
-    }
+  });
-  );
+  mockConsole((console, out): void => {
-  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(
+  mockConsole((console, out): void => {
-    (console, out): void => {
     console.log(new Error("foo"));
     assertEquals(out.toString().includes("Uncaught"), false);
-    }
+  });
-  );
 });
 
 // console.dir test
 test(function consoleDir(): void {
-  mockConsole(
+  mockConsole((console, out): void => {
-    (console, out): void => {
     console.dir("DIR");
     assertEquals(out.toString(), "DIR\n");
-    }
+  });
-  );
+  mockConsole((console, out): void => {
-  mockConsole(
-    (console, out): void => {
     console.dir("DIR", { indentLevel: 2 });
     assertEquals(out.toString(), "  DIR\n");
-    }
+  });
-  );
 });
 
 // console.dir test
 test(function consoleDirXml(): void {
-  mockConsole(
+  mockConsole((console, out): void => {
-    (console, out): void => {
     console.dirxml("DIRXML");
     assertEquals(out.toString(), "DIRXML\n");
-    }
+  });
-  );
+  mockConsole((console, out): void => {
-  mockConsole(
-    (console, out): void => {
     console.dirxml("DIRXML", { indentLevel: 2 });
     assertEquals(out.toString(), "  DIRXML\n");
-    }
+  });
-  );
 });
 
 // console.trace test
 test(function consoleTrace(): void {
-  mockConsole(
+  mockConsole((console, _out, err): void => {
-    (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}"/"${
+        `Unexpected DiagnosticCategory: "${category}"/"${ts.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(
+    .catch((error): void => {
-      (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(
+    .catch((error): void => {
-      (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);
-        }
       } catch (error) {
         throw new DenoError(ErrorKind.Interrupted, error.message);
       }

cli/js/fetch.ts

@@ -188,8 +188,7 @@ class Body implements domTypes.Body, domTypes.ReadableStream, io.ReadCloser {
         body
           .trim()
           .split("&")
-          .forEach(
+          .forEach((bytes): void => {
-            (bytes): void => {
             if (bytes) {
               const split = bytes.split("=");
               const name = split.shift()!.replace(/\+/g, " ");
@@ -199,8 +198,7 @@ class Body implements domTypes.Body, domTypes.ReadableStream, io.ReadCloser {
                 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(
+  assertThrows((): void => {
-    (): 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(
+  formData.forEach((value, key, parent): void => {
-    (value, key, parent): void => {
     assertEquals(formData, parent);
     assertEquals(value, init[callNum][1]);
     assertEquals(key, init[callNum][0]);
     callNum++;
-    }
+  });
-  );
   assertEquals(callNum, init.length);
 });
 
@@ -104,8 +105,7 @@ test(function formDataParamsArgumentsCheck(): void {
 
   const methodRequireTwoParams = ["append", "set"];
 
-  methodRequireOneParam.forEach(
+  methodRequireOneParam.forEach((method): void => {
-    (method): void => {
     const formData = new FormData();
     let hasThrown = 0;
     let errMsg = "";
@@ -125,11 +125,9 @@ test(function formDataParamsArgumentsCheck(): void {
       errMsg,
       `FormData.${method} requires at least 1 argument, but only 0 present`
     );
-    }
+  });
-  );
 
-  methodRequireTwoParams.forEach(
+  methodRequireTwoParams.forEach((method: string): void => {
-    (method: string): void => {
     const formData = new FormData();
     let hasThrown = 0;
     let errMsg = "";
@@ -169,8 +167,7 @@ test(function formDataParamsArgumentsCheck(): void {
       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(
+window.addEventListener("load", (e: domTypes.Event): void => {
-  "load",
-  (e: domTypes.Event): void => {
   const onload = window.onload;
   if (typeof onload === "function") {
     onload(e);
   }
-  }
+});
-);
 // Registers the handler for window.onunload function.
-window.addEventListener(
+window.addEventListener("unload", (e: domTypes.Event): void => {
-  "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(
+  const p1 = new Promise((res): void => {
-    (res): void => {
     resolve1 = (): void => {
       microtaskDone = true;
       res();
     };
-    }
+  });
-  );
+  const p2 = new Promise((res): void => {
-  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(
+  keys.forEach((key): void => {
-    (key): void => {
     const value = headerEntriesDict[key];
     const newkey = key.toLowerCase();
     headerEntriesDict[newkey] = value;
-    }
+  });
-  );
   let callNum = 0;
-  headers.forEach(
+  headers.forEach((value, key, container): void => {
-    (value, key, container): void => {
     assertEquals(headers, container);
     assertEquals(value, headerEntriesDict[key]);
     callNum++;
-    }
+  });
-  );
   assertEquals(callNum, keys.length);
 });
 
@@ -260,8 +256,7 @@ test(function headerParamsArgumentsCheck(): void {
 
   const methodRequireTwoParams = ["append", "set"];
 
-  methodRequireOneParam.forEach(
+  methodRequireOneParam.forEach((method): void => {
-    (method): void => {
     const headers = new Headers();
     let hasThrown = 0;
     let errMsg = "";
@@ -281,11 +276,9 @@ test(function headerParamsArgumentsCheck(): void {
       errMsg,
       `Headers.${method} requires at least 1 argument, but only 0 present`
     );
-    }
+  });
-  );
 
-  methodRequireTwoParams.forEach(
+  methodRequireTwoParams.forEach((method): void => {
-    (method): void => {
     const headers = new Headers();
     let hasThrown = 0;
     let errMsg = "";
@@ -325,8 +318,7 @@ test(function headerParamsArgumentsCheck(): void {
       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(
+  const newRid = Object.keys(resourcesAfter).find((rid): boolean => {
-    (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.readableStreamDefaultControllerClose(
+              branch1![
                 rs.readableStreamController_
-            ] as ReadableStreamDefaultController<OutputType>);
+              ] as ReadableStreamDefaultController<OutputType>
+            );
           }
           if (!canceled2) {
-            rs.readableStreamDefaultControllerClose(branch2![
+            rs.readableStreamDefaultControllerClose(
+              branch2![
                 rs.readableStreamController_
-            ] as ReadableStreamDefaultController<OutputType>);
+              ] as ReadableStreamDefaultController<OutputType>
+            );
           }
           closedOrErrored = true;
         }

cli/js/timers_test.ts

@@ -9,12 +9,10 @@ function deferred(): {
 } {
   let resolve;
   let reject;
-  const promise = new Promise(
+  const promise = new Promise((res, rej): void => {
-    (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,8 +15,7 @@ interface TestResult {
 
 function permsToCliFlags(perms: Permissions): string[] {
   return Object.keys(perms)
-    .map(
+    .map((key): string => {
-      (key): string => {
       if (!perms[key]) return "";
 
       const cliFlag = key.replace(
@@ -24,8 +23,7 @@ function permsToCliFlags(perms: Permissions): string[] {
         (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.protocol}?${patterns.authority}?${patterns.path}${patterns.query}?${patterns.hash}?`
-    patterns.query
-  }?${patterns.hash}?`
 );
 
 const authorityRegExp = new RegExp(
@@ -70,9 +68,7 @@ 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(
+  return "00000000-0000-4000-8000-000000000000".replace(/[0]/g, (): string =>
-    /[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}${
+    return `${this.protocol}${slash}${authentication}${this.host}${this.pathname}${this.search}${this.hash}`;
-      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(
+    this.params = this.params.sort((a, b): number =>
-      (a, b): number => (a[0] === b[0] ? 0 : a[0] > b[0] ? 1 : -1)
+      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(
+  searchParams.forEach((value, key, parent): void => {
-    (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(
+  methodRequireOneParam
-    (method: string): void => {
+    .concat(methodRequireTwoParams)
+    .forEach((method: string): void => {
       const searchParams = new URLSearchParams();
       let hasThrown = 0;
       try {
@@ -182,11 +187,9 @@ test(function urlSearchParamsAppendArgumentsCheck(): void {
         }
       }
       assertEquals(hasThrown, 2);
-    }
+    });
-  );
 
-  methodRequireTwoParams.forEach(
+  methodRequireTwoParams.forEach((method: string): void => {
-    (method: string): void => {
     const searchParams = new URLSearchParams();
     let hasThrown = 0;
     try {
@@ -200,8 +203,7 @@ test(function urlSearchParamsAppendArgumentsCheck(): void {
       }
     }
     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>(
+  const promise = new Promise<T>((resolve, reject): void => {
-    (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(
+    .call(u8, (x: number): string => {
-      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(
+    this.isClosedPromise.then((): void => {
-      (): 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(
+  await new Promise((resolve): void => {
-    (resolve): void => {
     console.log("2");
     setTimeout(resolve, 100);
-    }
+  });
-  );
   console.log("3");
 }
 

cli/tests/028_args.ts

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

cli/tests/error_003_typescript.ts.out

@@ -1,12 +1,5 @@
 [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.
+  The types of 'a.b.c().d' are incompatible between these types.
-    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'.
 
 [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>(
+  const promise = new Promise<T>((resolve, reject): void => {
-    (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(
+    const promise = new Promise((resolve): void => {
-      (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(
+    const promise = new Promise((resolve): void => {
-      (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,8 +384,7 @@ export class Tar {
    */
   getReader(): Deno.Reader {
     const readers: Deno.Reader[] = [];
-    this.data.forEach(
+    this.data.forEach((tarData): void => {
-      (tarData): void => {
       let { reader } = tarData;
       const { filePath } = tarData;
       const headerArr = formatHeader(tarData);
@@ -404,8 +403,7 @@ export class Tar {
           )
         )
       );
-      }
+    });
-    );
 
     // append 2 empty records
     readers.push(new Deno.Buffer(clean(recordSize * 2)));
@@ -462,22 +460,18 @@ export class Untar {
       "mtime",
       "uid",
       "gid"
-    ]).forEach(
+    ]).forEach((key): void => {
-      (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 => {
-    (["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,8 +84,7 @@ async function read(
   result = line.split(opt.comma!);
 
   let quoteError = false;
-  result = result.map(
+  result = result.map((r): string => {
-    (r): string => {
     if (opt.trimLeadingSpace) {
       r = r.trimLeft();
     }
@@ -101,8 +100,7 @@ async function read(
       }
     }
     return r;
-    }
+  });
-  );
   if (quoteError) {
     throw new ParseError(Startline, lineIndex, 'bare " in non-quoted-field');
   }
@@ -226,8 +224,7 @@ export async function parse(
       );
       i++;
     }
-    return r.map(
+    return r.map((e): unknown => {
-      (e): unknown => {
       if (e.length !== headers.length) {
         throw `Error number of fields line:${i}`;
       }
@@ -245,8 +242,7 @@ export async function 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(
+    .map((str: string): string => {
-      (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(
+    const propObj = props.filter((e: string): boolean => {
-      (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 propPrim = props.filter((e: string): boolean => {
-    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(
+      booleanArgs.filter(Boolean).forEach((key: string): void => {
-        (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.forEach((alias: string): void => {
-          (alias: string): void => {
           flags.strings[alias] = true;
-          }
+        });
-        );
       }
     });
   }

std/fmt/sprintf_test.ts

@@ -587,8 +587,7 @@ const tests: Array<[string, any, string]> = [
 ];
 
 test(function testThorough(): void {
-  tests.forEach(
+  tests.forEach((t, i): void => {
-    (t, i): void => {
     //            p(t)
     const is = S(t[0], t[1]);
     const should = t[2];
@@ -597,8 +596,7 @@ test(function testThorough(): void {
       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(
+    assertThrows((): void => {
-      (): void => {
       copySync(srcFile, destFile);
-      }
+    });
-    );
   }
 );
 
@@ -367,9 +365,7 @@ testCopySync(
   }
 );
 
-testCopySync(
+testCopySync("[fs] copy file synchronously", (tempDir: string): void => {
-  "[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");
 
@@ -409,8 +405,7 @@ testCopySync(
 
   // Make sure the file has been overwritten.
   assertEquals(new TextDecoder().decode(Deno.readFileSync(destFile)), "txt");
-  }
+});
-);
 
 testCopySync(
   "[fs] copy directory synchronously to its subdirectory",
@@ -450,9 +445,7 @@ testCopySync(
   }
 );
 
-testCopySync(
+testCopySync("[fs] copy directory synchronously", (tempDir: string): void => {
-  "[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");
@@ -499,8 +492,7 @@ testCopySync(
     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(
+    assertThrows((): void => {
-      (): void => {
       Deno.statSync(testNestDir);
-      }
+    });
-    );
 
     // test file have been remove
-    assertThrows(
+    assertThrows((): void => {
-      (): 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(
+      await Deno.stat(testDir).then((): void => {
-        (): 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(
+      await Deno.stat(testDir).then((): void => {
-        (): void => {
         throw new Error("test dir should still exists.");
-        }
+      });
-      );
     }
   );
 
@@ -68,12 +64,10 @@ test(function ensureDirSyncIfItExist(): void {
 
   ensureDirSync(testDir);
 
-  assertThrows(
+  assertThrows((): void => {
-    (): 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(
+      await Deno.stat(testFile).then((): void => {
-        (): void => {
         throw new Error("test file should exists.");
-        }
+      });
-      );
     }
   );
 
@@ -31,12 +29,10 @@ test(function ensureFileSyncIfItNotExist(): void {
 
   ensureFileSync(testFile);
 
-  assertThrows(
+  assertThrows((): void => {
-    (): 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(
+      await Deno.stat(testFile).then((): void => {
-        (): void => {
         throw new Error("test file should exists.");
-        }
+      });
-      );
     }
   );
 
@@ -72,12 +66,10 @@ test(function ensureFileSyncIfItExist(): void {
 
   ensureFileSync(testFile);
 
-  assertThrows(
+  assertThrows((): void => {
-    (): 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(
+  assertThrows((): void => {
-    (): 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(
+      await Deno.stat(testFile).then((): void => {
-        (): 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(
+  assertThrows((): void => {
-    (): void => {
     ensureSymlinkSync(testFile, path.join(testDir, "test1.txt"));
-    }
+  });
-  );
 
-  assertThrows(
+  assertThrows((): void => {
-    (): 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(
+    currentMatches = currentMatches.filter(({ info }): boolean =>
-      ({ info }): boolean => info.isDirectory()
+      info.isDirectory()
     );
   }
   if (!includeDirs) {
@@ -238,8 +238,8 @@ export function* expandGlobSync(
     );
   }
   if (hasTrailingSep) {
-    currentMatches = currentMatches.filter(
+    currentMatches = currentMatches.filter(({ info }): boolean =>
-      ({ info }): boolean => info.isDirectory()
+      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(
+  assertThrows((): void => {
-    (): 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(
+  assertThrows((): void => {
-    (): 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(
+  assertThrows((): void => {
-    (): void => {
     readJsonSync(emptyJsonFile);
-    }
+  });
-  );
 });
 
 test(function readEmptyJsonFileSync(): void {
   const emptyJsonFile = path.join(testdataDir, "json_empty.json");
 
-  assertThrows(
+  assertThrows((): void => {
-    (): void => {
     readJsonSync(emptyJsonFile);
-    }
+  });
-  );
 });
 
 test(function readInvalidJsonFile(): void {
   const invalidJsonFile = path.join(testdataDir, "json_invalid.json");
 
-  assertThrows(
+  assertThrows((): void => {
-    (): 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(
+  return patterns.some((pattern): boolean => {
-    (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(
+    .forEach((v): void => {
-      (v): void => {
       output = modeMap[+v] + output;
-      }
+    });
-    );
   output = `(${isDir ? "d" : "-"}${output})`;
   return output;
 }
@@ -179,8 +177,7 @@ async function serveDir(
     dirViewerTemplate.replace("<%DIRNAME%>", formattedDirUrl).replace(
       "<%CONTENTS%>",
       listEntry
-        .sort(
+        .sort((a, b): number =>
-          (a, b): number =>
           a.name.toLowerCase() > b.name.toLowerCase() ? 1 : -1
         )
         .map((v): string => v.template)

std/http/server_test.ts

@@ -505,11 +505,9 @@ test({
 
       let serverIsRunning = true;
       p.status()
-        .then(
+        .then((): void => {
-          (): 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(
+        .then((): void => {
-          (): 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,9 +37,7 @@ export class BaseHandler {
       return this.formatter(logRecord);
     }
 
-    return this.formatter.replace(
+    return this.formatter.replace(/{(\S+)}/g, (match, p1): string => {
-      /{(\S+)}/g,
-      (match, p1): string => {
       const value = logRecord[p1 as keyof LogRecord];
 
       // do not interpolate missing values
@@ -48,8 +46,7 @@ export class BaseHandler {
       }
 
       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(
+    this.handlers.forEach((handler): void => {
-      (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(
+  state.handlers.forEach((handler): void => {
-    (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(
+    handlerNames.forEach((handlerName): void => {
-      (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,8 +188,7 @@ class PartReader implements Reader, Closer {
     comps
       .slice(1)
       .map((v: string): string => v.trim())
-      .map(
+      .map((kv: string): void => {
-        (kv: string): void => {
         const [k, v] = kv.split("=");
         if (v) {
           const s = v.charAt(0);
@@ -200,8 +199,7 @@ class PartReader implements Reader, Closer {
             params[k] = v;
           }
         }
-        }
+      });
-      );
     return (this.contentDispositionParams = params);
   }
 

std/testing/README.md

@@ -92,11 +92,9 @@ Using `assertThrows()`:
 
 ```ts
 test(function doesThrow(): void {
-  assertThrows(
+  assertThrows((): void => {
-    (): 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(
+  assertThrows((): void => {
-    (): 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(
+  diffResult.forEach((result: DiffResult<string>): void => {
-    (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([
-      new Map([["foo", "bar"], ["baz", "baz"]])
+        ["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([
-      new Map([["baz", "qux"], ["foo", "bar"]])
+        ["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(
+    Object.getOwnPropertySymbols(object).forEach((symbol): void => {
-      (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(
+  results.cases.forEach((v): void => {
-    (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(
+      results.cases.forEach((v): void => {
-        (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(
+      results.cases.forEach((v): void => {
-        (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(
+      ? (parsedArgs._ as string[]).flatMap((fileGlob: string): string[] =>
-          (fileGlob: string): string[] => fileGlob.split(",")
+          fileGlob.split(",")
         )
       : ["."];
   const exclude =

std/testing/test.ts

@@ -51,12 +51,10 @@ test(function testingAssertNotStrictEqual(): void {
 
 test(function testingDoesThrow(): void {
   let count = 0;
-  assertThrows(
+  assertThrows((): void => {
-    (): void => {
     count++;
     throw new Error();
-    }
+  });
-  );
   assert(count === 1);
 });
 
@@ -64,12 +62,10 @@ test(function testingDoesNotThrow(): void {
   let count = 0;
   let didThrow = false;
   try {
-    assertThrows(
+    assertThrows((): void => {
-      (): 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(
+    assertThrows((): void => {
-      (): 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>(
+  const promise = new Promise<T>((resolve, reject): void => {
-    (resolve, reject): void => {
     methods = { resolve, reject };
-    }
+  });
-  );
   return Object.assign(promise, methods)! as Deferred<T>;
 }
 
@@ -111,8 +109,7 @@ export async function collectUint8Arrays(
 
 // Delays the given milliseconds and resolves.
 export function delay(ms: number): Promise<void> {
-  return new Promise(
+  return new Promise((res): number =>
-    (res): number =>
     setTimeout((): void => {
       res();
     }, ms)

std/util/deep_assign.ts

@@ -8,8 +8,7 @@ export function deepAssign(
     if (!source || typeof source !== `object`) {
       return;
     }
-    Object.entries(source).forEach(
+    Object.entries(source).forEach(([key, value]: [string, unknown]): void => {
-      ([key, value]: [string, unknown]): void => {
       if (value instanceof Date) {
         target[key] = new Date(value);
         return;
@@ -26,8 +25,7 @@ export function deepAssign(
         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(
+  const bits: string[] = [...rnds].map((bit): string => {
-    (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(
+    .catch((err: Error): void => {
-      (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(
+  await new Promise((resolve): void => {
-    (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(
+  await new Promise((resolve): void => {
-    (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(
+    .catch((err: Error): void => {
-      (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(
+      proxyRes.pipe(res, { end: true });
-        res,
-        { end: true }
-      );
     });
 
-    req.pipe(
+    req.pipe(proxy, { end: true });
-      proxy,
-      { end: true }
-    );
   })
   .listen(port);