Update to Prettier 2 and use ES Private Fields

cli/js/buffer.ts

@@ -28,37 +28,37 @@ function copyBytes(dst: Uint8Array, src: Uint8Array, off = 0): number {
 }
 
 export class Buffer implements Reader, SyncReader, Writer, SyncWriter {
-  private buf: Uint8Array; // contents are the bytes buf[off : len(buf)]
-  private off = 0; // read at buf[off], write at buf[buf.byteLength]
+  #buf: Uint8Array; // contents are the bytes buf[off : len(buf)]
+  #off = 0; // read at buf[off], write at buf[buf.byteLength]
 
   constructor(ab?: ArrayBuffer) {
     if (ab == null) {
-      this.buf = new Uint8Array(0);
+      this.#buf = new Uint8Array(0);
       return;
     }
 
-    this.buf = new Uint8Array(ab);
+    this.#buf = new Uint8Array(ab);
   }
 
   bytes(): Uint8Array {
-    return this.buf.subarray(this.off);
+    return this.#buf.subarray(this.#off);
   }
 
   toString(): string {
     const decoder = new TextDecoder();
-    return decoder.decode(this.buf.subarray(this.off));
+    return decoder.decode(this.#buf.subarray(this.#off));
   }
 
   empty(): boolean {
-    return this.buf.byteLength <= this.off;
+    return this.#buf.byteLength <= this.#off;
   }
 
   get length(): number {
-    return this.buf.byteLength - this.off;
+    return this.#buf.byteLength - this.#off;
   }
 
   get capacity(): number {
-    return this.buf.buffer.byteLength;
+    return this.#buf.buffer.byteLength;
   }
 
   truncate(n: number): void {
@@ -69,27 +69,27 @@ export class Buffer implements Reader, SyncReader, Writer, SyncWriter {
     if (n < 0 || n > this.length) {
       throw Error("bytes.Buffer: truncation out of range");
     }
-    this._reslice(this.off + n);
+    this.#reslice(this.#off + n);
   }
 
   reset(): void {
-    this._reslice(0);
-    this.off = 0;
+    this.#reslice(0);
+    this.#off = 0;
   }
 
-  private _tryGrowByReslice(n: number): number {
-    const l = this.buf.byteLength;
+  #tryGrowByReslice = (n: number): number => {
+    const l = this.#buf.byteLength;
     if (n <= this.capacity - l) {
-      this._reslice(l + n);
+      this.#reslice(l + n);
       return l;
     }
     return -1;
-  }
+  };
 
-  private _reslice(len: number): void {
-    assert(len <= this.buf.buffer.byteLength);
-    this.buf = new Uint8Array(this.buf.buffer, 0, len);
-  }
+  #reslice = (len: number): void => {
+    assert(len <= this.#buf.buffer.byteLength);
+    this.#buf = new Uint8Array(this.#buf.buffer, 0, len);
+  };
 
   readSync(p: Uint8Array): number | EOF {
     if (this.empty()) {
@@ -101,8 +101,8 @@ export class Buffer implements Reader, SyncReader, Writer, SyncWriter {
       }
       return EOF;
     }
-    const nread = copyBytes(p, this.buf.subarray(this.off));
-    this.off += nread;
+    const nread = copyBytes(p, this.#buf.subarray(this.#off));
+    this.#off += nread;
     return nread;
   }
 
@@ -112,23 +112,23 @@ export class Buffer implements Reader, SyncReader, Writer, SyncWriter {
   }
 
   writeSync(p: Uint8Array): number {
-    const m = this._grow(p.byteLength);
-    return copyBytes(this.buf, p, m);
+    const m = this.#grow(p.byteLength);
+    return copyBytes(this.#buf, p, m);
   }
 
   write(p: Uint8Array): Promise<number> {
     const n = this.writeSync(p);
     return Promise.resolve(n);
   }
 
-  private _grow(n: number): number {
+  #grow = (n: number): number => {
     const m = this.length;
     // If buffer is empty, reset to recover space.
-    if (m === 0 && this.off !== 0) {
+    if (m === 0 && this.#off !== 0) {
       this.reset();
     }
     // Fast: Try to grow by means of a reslice.
-    const i = this._tryGrowByReslice(n);
+    const i = this.#tryGrowByReslice(n);
     if (i >= 0) {
       return i;
     }
@@ -138,41 +138,41 @@ export class Buffer implements Reader, SyncReader, Writer, SyncWriter {
       // ArrayBuffer. We only need m+n <= c to slide, but
       // we instead let capacity get twice as large so we
       // don't spend all our time copying.
-      copyBytes(this.buf, this.buf.subarray(this.off));
+      copyBytes(this.#buf, this.#buf.subarray(this.#off));
     } else if (c > MAX_SIZE - c - n) {
       throw new Error("The buffer cannot be grown beyond the maximum size.");
     } else {
       // Not enough space anywhere, we need to allocate.
       const buf = new Uint8Array(2 * c + n);
-      copyBytes(buf, this.buf.subarray(this.off));
-      this.buf = buf;
+      copyBytes(buf, this.#buf.subarray(this.#off));
+      this.#buf = buf;
     }
-    // Restore this.off and len(this.buf).
-    this.off = 0;
-    this._reslice(m + n);
+    // Restore this.#off and len(this.#buf).
+    this.#off = 0;
+    this.#reslice(m + n);
     return m;
-  }
+  };
 
   grow(n: number): void {
     if (n < 0) {
       throw Error("Buffer.grow: negative count");
     }
-    const m = this._grow(n);
-    this._reslice(m);
+    const m = this.#grow(n);
+    this.#reslice(m);
   }
 
   async readFrom(r: Reader): Promise<number> {
     let n = 0;
     while (true) {
       try {
-        const i = this._grow(MIN_READ);
-        this._reslice(i);
-        const fub = new Uint8Array(this.buf.buffer, i);
+        const i = this.#grow(MIN_READ);
+        this.#reslice(i);
+        const fub = new Uint8Array(this.#buf.buffer, i);
         const nread = await r.read(fub);
         if (nread === EOF) {
           return n;
         }
-        this._reslice(i + nread);
+        this.#reslice(i + nread);
         n += nread;
       } catch (e) {
         return n;
@@ -184,14 +184,14 @@ export class Buffer implements Reader, SyncReader, Writer, SyncWriter {
     let n = 0;
     while (true) {
       try {
-        const i = this._grow(MIN_READ);
-        this._reslice(i);
-        const fub = new Uint8Array(this.buf.buffer, i);
+        const i = this.#grow(MIN_READ);
+        this.#reslice(i);
+        const fub = new Uint8Array(this.#buf.buffer, i);
         const nread = r.readSync(fub);
         if (nread === EOF) {
           return n;
         }
-        this._reslice(i + nread);
+        this.#reslice(i + nread);
         n += nread;
       } catch (e) {
         return n;

cli/js/build.ts

@@ -13,7 +13,7 @@ export interface BuildInfo {
 
 export const build: BuildInfo = {
   arch: "" as Arch,
-  os: "" as OperatingSystem
+  os: "" as OperatingSystem,
 };
 
 export function setBuildInfo(os: OperatingSystem, arch: Arch): void {

cli/js/colors.ts

@@ -17,7 +17,7 @@ function code(open: number, close: number): Code {
   return {
     open: `\x1b[${open}m`,
     close: `\x1b[${close}m`,
-    regexp: new RegExp(`\\x1b\\[${close}m`, "g")
+    regexp: new RegExp(`\\x1b\\[${close}m`, "g"),
   };
 }
 

cli/js/compiler.ts

@@ -21,12 +21,12 @@ import {
   defaultBundlerOptions,
   defaultRuntimeCompileOptions,
   defaultTranspileOptions,
-  Host
+  Host,
 } from "./compiler/host.ts";
 import {
   processImports,
   processLocalImports,
-  resolveModules
+  resolveModules,
 } from "./compiler/imports.ts";
 import {
   createWriteFile,
@@ -35,7 +35,7 @@ import {
   ignoredDiagnostics,
   WriteFileState,
   processConfigureResponse,
-  base64ToUint8Array
+  base64ToUint8Array,
 } from "./compiler/util.ts";
 import { Diagnostic, DiagnosticItem } from "./diagnostics.ts";
 import { fromTypeScriptDiagnostic } from "./diagnostics_util.ts";
@@ -93,7 +93,7 @@ async function compile(
   const { bundle, config, configPath, outFile, rootNames, target } = request;
   util.log(">>> compile start", {
     rootNames,
-    type: CompilerRequestType[request.type]
+    type: CompilerRequestType[request.type],
   });
 
   // When a programme is emitted, TypeScript will call `writeFile` with
@@ -108,14 +108,14 @@ async function compile(
     bundle,
     host: undefined,
     outFile,
-    rootNames
+    rootNames,
   };
   const writeFile = createWriteFile(state);
 
   const host = (state.host = new Host({
     bundle,
     target,
-    writeFile
+    writeFile,
   }));
   let diagnostics: readonly ts.Diagnostic[] | undefined;
 
@@ -129,7 +129,7 @@ async function compile(
   // 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]),
+    rootNames.map((rootName) => [rootName, rootName]),
     undefined,
     bundle || host.getCompilationSettings().checkJs
   );
@@ -143,7 +143,7 @@ async function compile(
       rootNames,
       options,
       host,
-      oldProgram: TS_SNAPSHOT_PROGRAM
+      oldProgram: TS_SNAPSHOT_PROGRAM,
     });
 
     diagnostics = ts
@@ -171,12 +171,12 @@ async function compile(
     emitSkipped,
     diagnostics: diagnostics.length
       ? fromTypeScriptDiagnostic(diagnostics)
-      : undefined
+      : undefined,
   };
 
   util.log("<<< compile end", {
     rootNames,
-    type: CompilerRequestType[request.type]
+    type: CompilerRequestType[request.type],
   });
 
   return result;
@@ -190,7 +190,7 @@ async function runtimeCompile(
   util.log(">>> runtime compile start", {
     rootName,
     bundle,
-    sources: sources ? Object.keys(sources) : undefined
+    sources: sources ? Object.keys(sources) : undefined,
   });
 
   // resolve the root name, if there are sources, the root name does not
@@ -232,7 +232,7 @@ async function runtimeCompile(
     const resolvedNames = resolveModules(additionalFiles);
     rootNames.push(
       ...(await processImports(
-        resolvedNames.map(rn => [rn, rn]),
+        resolvedNames.map((rn) => [rn, rn]),
         undefined,
         checkJsImports
       ))
@@ -246,14 +246,14 @@ async function runtimeCompile(
     rootNames,
     sources,
     emitMap: {},
-    emitBundle: undefined
+    emitBundle: undefined,
   };
   const writeFile = createWriteFile(state);
 
   const host = (state.host = new Host({
     bundle,
     target,
-    writeFile
+    writeFile,
   }));
   const compilerOptions = [defaultRuntimeCompileOptions];
   if (convertedOptions) {
@@ -268,7 +268,7 @@ async function runtimeCompile(
     rootNames,
     options: host.getCompilationSettings(),
     host,
-    oldProgram: TS_SNAPSHOT_PROGRAM
+    oldProgram: TS_SNAPSHOT_PROGRAM,
   });
 
   if (bundle) {
@@ -288,7 +288,7 @@ async function runtimeCompile(
     rootName,
     sources: sources ? Object.keys(sources) : undefined,
     bundle,
-    emitMap: Object.keys(state.emitMap)
+    emitMap: Object.keys(state.emitMap),
   });
 
   const maybeDiagnostics = diagnostics.length
@@ -320,7 +320,7 @@ function runtimeTranspile(
       inputText,
       {
         fileName,
-        compilerOptions
+        compilerOptions,
       }
     );
     result[fileName] = { source, map };
@@ -329,7 +329,7 @@ function runtimeTranspile(
 }
 
 async function tsCompilerOnMessage({
-  data: request
+  data: request,
 }: {
   data: CompilerRequest;
 }): Promise<void> {
@@ -364,7 +364,7 @@ async function tsCompilerOnMessage({
 }
 
 async function wasmCompilerOnMessage({
-  data: binary
+  data: binary,
 }: {
   data: string;
 }): Promise<void> {
@@ -411,12 +411,12 @@ Object.defineProperties(globalThis, {
     value: bootstrapWasmCompilerRuntime,
     enumerable: false,
     writable: false,
-    configurable: false
+    configurable: false,
   },
   bootstrapTsCompilerRuntime: {
     value: bootstrapTsCompilerRuntime,
     enumerable: false,
     writable: false,
-    configurable: false
-  }
+    configurable: false,
+  },
 });