bump prettier to 1.18.2 (denoland/deno_std#592)

Original: 06958a4ada

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 { filePath, reader } = tarData,
         headerArr = formatHeader(tarData);
       readers.push(new Deno.Buffer(headerArr));
@@ -403,8 +402,7 @@ export class Tar {
           )
         )
       );
-      }
+    });
-    );
 
     // append 2 empty records
     readers.push(new Deno.Buffer(clean(recordSize * 2)));
@@ -461,22 +459,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);

bundle/utils.ts

@@ -69,8 +69,7 @@ export function instantiate(
     assert(module != null);
     assert(module.factory != null);
 
-    const dependencies = module.dependencies.map(
+    const dependencies = module.dependencies.map((id): object => {
-      (id): object => {
       if (id === "require") {
         // TODO(kitsonk) support dynamic import by passing a `require()` that
         // can return a local module or dynamically import one.
@@ -81,8 +80,7 @@ export function instantiate(
       const dep = modules.get(id)!;
       assert(dep != null);
       return dep.exports;
-      }
+    });
-    );
 
     if (typeof module.factory === "function") {
       module.factory!(...dependencies);

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));

encoding/toml.ts

@@ -403,24 +403,20 @@ class Dumper {
   _parse(obj: Record<string, unknown>, path: 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];

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;
-          }
+        });
-        );
       }
     });
   }

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)
     let is = S(t[0], t[1]);
     let should = t[2];
@@ -597,8 +596,7 @@ test(function testThorough(): void {
       should,
       `failed case[${i}] : is >${is}< should >${should}<`
     );
-    }
+  });
-  );
 });
 
 test(function testWeirdos(): void {

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",

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 });

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 });
 });

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 });
 });

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 });
 });

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> {

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 {

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 {

fs/walk.ts

@@ -19,13 +19,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 => {
     let r = pattern.test(path);
     pattern.lastIndex = 0;
     return r;
-    }
+  });
-  );
 }
 
 function include(filename: string, options: WalkOptions): boolean {

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)

http/server_test.ts

@@ -504,11 +504,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);

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 {}

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 {

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);

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);
   }
 

prettier/vendor/parser_markdown.js

@@ -1,4 +1,4 @@
-// This file is copied from prettier@1.17.1
+// This file is copied from prettier@1.18.2
 /**
  * Copyright © James Long and contributors
  *

testing/README.md

@@ -89,11 +89,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);
@@ -108,11 +106,9 @@ test(function doesThrow(): void {
 
 // This test will not pass
 test(function fails(): void {
-  assertThrows(
+  assertThrows((): void => {
-    (): void => {
     console.log("Hello world");
-    }
+  });
-  );
 });
 ```
 

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;

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;

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(
@@ -322,14 +320,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);
@@ -337,15 +333,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;
       }

testing/runner.ts

@@ -85,13 +85,11 @@ export async function getMatchingUrls(
   );
   const matchingRemoteUrls = includeRemote.filter(
     (candidateUrl: string): boolean => {
-      return !excludeRemotePatterns.some(
+      return !excludeRemotePatterns.some((pattern: RegExp): boolean => {
-        (pattern: RegExp): boolean => {
         const r = pattern.test(candidateUrl);
         pattern.lastIndex = 0;
         return r;
-        }
+      });
-      );
     }
   );
 
@@ -135,11 +133,9 @@ export async function main(root: string = cwd()): Promise<void> {
 
   if (parsedArgs._.length) {
     includeFiles = (parsedArgs._ as string[])
-      .map(
+      .map((fileGlob: string): string[] => {
-        (fileGlob: string): string[] => {
         return fileGlob.split(",");
-        }
+      })
-      )
       .flat();
   } else {
     includeFiles = DEFAULT_GLOBS;

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;

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");
-      }
+    });
-    );
   }
 });
 

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)

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;
 }

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),
     "-",

ws/README.md

@@ -60,11 +60,9 @@ async function main(): Promise<void> {
           }
         }
       )
-      .catch(
+      .catch((err: Error): void => {
-        (err: Error): void => {
         console.error(`failed to accept websocket: ${err}`);
-        }
+      });
-      );
   }
 }
 

ws/example_server.ts

@@ -53,11 +53,9 @@ async function main(): Promise<void> {
           }
         }
       )
-      .catch(
+      .catch((err: Error): void => {
-        (err: Error): void => {
         console.error(`failed to accept websocket: ${err}`);
-        }
+      });
-      );
   }
 }