diff --git a/src/lib/abstract-ops/ecmascript.ts b/src/lib/abstract-ops/ecmascript.ts
index ec15cb0..d7b9414 100644
--- a/src/lib/abstract-ops/ecmascript.ts
+++ b/src/lib/abstract-ops/ecmascript.ts
@@ -24,11 +24,13 @@ export function CreateArrayFromList<T extends any[]>(elements: T): T {
   return elements.slice() as T;
 }
 
-export function CopyDataBlockBytes(dest: ArrayBuffer,
-                                   destOffset: number,
-                                   src: ArrayBuffer,
-                                   srcOffset: number,
-                                   n: number) {
+export function CopyDataBlockBytes(
+  dest: ArrayBuffer,
+  destOffset: number,
+  src: ArrayBuffer,
+  srcOffset: number,
+  n: number
+) {
   new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
 }
 
@@ -102,9 +104,7 @@ export interface AsyncIteratorRecord<T> {
 
 export type SyncOrAsyncIteratorRecord<T> = SyncIteratorRecord<T> | AsyncIteratorRecord<T>;
 
-export function CreateAsyncFromSyncIterator<T>(
-  syncIteratorRecord: SyncIteratorRecord<SyncOrAsync<T>>
-): AsyncIteratorRecord<T> {
+export function CreateAsyncFromSyncIterator<T>(syncIteratorRecord: SyncIteratorRecord<SyncOrAsync<T>>): AsyncIteratorRecord<T> {
   const asyncIterator: AsyncIterator<T> = {
     // https://tc39.es/ecma262/#sec-%asyncfromsynciteratorprototype%.next
     next() {
@@ -154,10 +154,10 @@ function AsyncFromSyncIteratorContinuation<T>(result: IteratorResult<SyncOrAsync
 }
 
 // Aligns with core-js/modules/es.symbol.async-iterator.js
-export const SymbolAsyncIterator: (typeof Symbol)['asyncIterator'] =
-  Symbol.asyncIterator ??
-  Symbol.for?.('Symbol.asyncIterator') ??
-  '@@asyncIterator';
+export const SymbolAsyncIterator: (typeof Symbol)['asyncIterator']
+  = Symbol.asyncIterator
+  ?? Symbol.for?.('Symbol.asyncIterator')
+  ?? '@@asyncIterator';
 
 export type SyncOrAsyncIterable<T> = Iterable<T> | AsyncIterable<T>;
 export type SyncOrAsyncIteratorMethod<T> = () => (Iterator<T> | AsyncIterator<T>);
@@ -205,9 +205,7 @@ export { GetIterator };
 
 export function IteratorNext<T>(iteratorRecord: SyncIteratorRecord<T>): IteratorResult<T>;
 export function IteratorNext<T>(iteratorRecord: AsyncIteratorRecord<T>): Promise<IteratorResult<T>>;
-export function IteratorNext<T>(
-  iteratorRecord: SyncOrAsyncIteratorRecord<T>
-): SyncOrAsync<IteratorResult<SyncOrAsync<T>>> {
+export function IteratorNext<T>(iteratorRecord: SyncOrAsyncIteratorRecord<T>): SyncOrAsync<IteratorResult<SyncOrAsync<T>>> {
   const result = reflectCall(iteratorRecord.nextMethod, iteratorRecord.iterator, []);
   if (!typeIsObject(result)) {
     throw new TypeError('The iterator.next() method must return an object');
diff --git a/src/lib/helpers/miscellaneous.ts b/src/lib/helpers/miscellaneous.ts
index 2af112c..93f2a61 100644
--- a/src/lib/helpers/miscellaneous.ts
+++ b/src/lib/helpers/miscellaneous.ts
@@ -5,19 +5,19 @@ export function typeIsObject(x: any): x is object {
   return (typeof x === 'object' && x !== null) || typeof x === 'function';
 }
 
-export const rethrowAssertionErrorRejection: (e: any) => void =
-  DEBUG ?
-    (e) => {
-    // Used throughout the reference implementation, as `.catch(rethrowAssertionErrorRejection)`, to ensure any errors
-    // get shown. There are places in the spec where we do promise transformations and purposefully ignore or don't
-    // expect any errors, but assertion errors are always problematic.
-      if (e && e instanceof AssertionError) {
-        setTimeout(() => {
-          throw e;
-        }, 0);
+export const rethrowAssertionErrorRejection: (e: any) => void
+  = DEBUG
+    ? (e) => {
+        // Used throughout the reference implementation, as `.catch(rethrowAssertionErrorRejection)`, to ensure any errors
+        // get shown. There are places in the spec where we do promise transformations and purposefully ignore or don't
+        // expect any errors, but assertion errors are always problematic.
+        if (e && e instanceof AssertionError) {
+          setTimeout(() => {
+            throw e;
+          }, 0);
+        }
       }
-    } :
-    noop;
+    : noop;
 
 export function setFunctionName(fn: (...args: any[]) => any, name: string): void {
   try {
diff --git a/src/lib/helpers/webidl.ts b/src/lib/helpers/webidl.ts
index 2da37ab..bce6b50 100644
--- a/src/lib/helpers/webidl.ts
+++ b/src/lib/helpers/webidl.ts
@@ -29,7 +29,8 @@ export function promiseRejectedWith<T = never>(reason: any): Promise<T> {
 export function PerformPromiseThen<T, TResult1 = T, TResult2 = never>(
   promise: Promise<T>,
   onFulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>,
-  onRejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2> {
+  onRejected?: (reason: any) => TResult2 | PromiseLike<TResult2>
+): Promise<TResult1 | TResult2> {
   // There doesn't appear to be any way to correctly emulate the behaviour from JavaScript, so this is just an
   // approximation.
   return originalPromiseThen.call(promise, onFulfilled, onRejected) as Promise<TResult1 | TResult2>;
@@ -41,7 +42,8 @@ export function PerformPromiseThen<T, TResult1 = T, TResult2 = never>(
 export function uponPromise<T>(
   promise: Promise<T>,
   onFulfilled?: (value: T) => null | PromiseLike<null>,
-  onRejected?: (reason: any) => null | PromiseLike<null>): void {
+  onRejected?: (reason: any) => null | PromiseLike<null>
+): void {
   PerformPromiseThen(
     PerformPromiseThen(promise, onFulfilled, onRejected),
     undefined,
@@ -60,7 +62,8 @@ export function uponRejection(promise: Promise<unknown>, onRejected: (reason: an
 export function transformPromiseWith<T, TResult1 = T, TResult2 = never>(
   promise: Promise<T>,
   fulfillmentHandler?: (value: T) => TResult1 | PromiseLike<TResult1>,
-  rejectionHandler?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2> {
+  rejectionHandler?: (reason: any) => TResult2 | PromiseLike<TResult2>
+): Promise<TResult1 | TResult2> {
   return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler);
 }
 
@@ -87,9 +90,11 @@ export function reflectCall<T, A extends any[], R>(F: (this: T, ...fnArgs: A) =>
   return Function.prototype.apply.call(F, V, args);
 }
 
-export function promiseCall<T, A extends any[], R>(F: (this: T, ...fnArgs: A) => R | PromiseLike<R>,
-                                                   V: T,
-                                                   args: A): Promise<R> {
+export function promiseCall<T, A extends any[], R>(
+  F: (this: T, ...fnArgs: A) => R | PromiseLike<R>,
+  V: T,
+  args: A
+): Promise<R> {
   assert(typeof F === 'function');
   assert(V !== undefined);
   assert(Array.isArray(args));
diff --git a/src/lib/readable-stream.ts b/src/lib/readable-stream.ts
index e1035db..bd6ef8f 100644
--- a/src/lib/readable-stream.ts
+++ b/src/lib/readable-stream.ts
@@ -99,8 +99,10 @@ export class ReadableStream<R = any> implements AsyncIterable<R> {
 
   constructor(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number; size?: undefined });
   constructor(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>);
-  constructor(rawUnderlyingSource: UnderlyingSource<R> | UnderlyingByteSource | null | undefined = {},
-              rawStrategy: QueuingStrategy<R> | null | undefined = {}) {
+  constructor(
+rawUnderlyingSource: UnderlyingSource<R> | UnderlyingByteSource | null | undefined = {},
+              rawStrategy: QueuingStrategy<R> | null | undefined = {}
+  ) {
     if (rawUnderlyingSource === undefined) {
       rawUnderlyingSource = null;
     } else {
@@ -183,9 +185,7 @@ export class ReadableStream<R = any> implements AsyncIterable<R> {
    * or cancel the stream, which would interfere with your abstraction.
    */
   getReader(): ReadableStreamDefaultReader<R>;
-  getReader(
-    rawOptions: ReadableStreamGetReaderOptions | null | undefined = undefined
-  ): ReadableStreamDefaultReader<R> | ReadableStreamBYOBReader {
+  getReader(rawOptions: ReadableStreamGetReaderOptions | null | undefined = undefined): ReadableStreamDefaultReader<R> | ReadableStreamBYOBReader {
     if (!IsReadableStream(this)) {
       throw streamBrandCheckException('getReader');
     }
@@ -230,9 +230,7 @@ export class ReadableStream<R = any> implements AsyncIterable<R> {
       throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream');
     }
 
-    const promise = ReadableStreamPipeTo(
-      this, transform.writable, options.preventClose, options.preventAbort, options.preventCancel, options.signal
-    );
+    const promise = ReadableStreamPipeTo(this, transform.writable, options.preventClose, options.preventAbort, options.preventCancel, options.signal);
 
     setPromiseIsHandledToTrue(promise);
 
@@ -247,8 +245,10 @@ export class ReadableStream<R = any> implements AsyncIterable<R> {
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
-  pipeTo(destination: WritableStream<R> | null | undefined,
-         rawOptions: StreamPipeOptions | null | undefined = {}): Promise<void> {
+  pipeTo(
+    destination: WritableStream<R> | null | undefined,
+         rawOptions: StreamPipeOptions | null | undefined = {}
+  ): Promise<void> {
     if (!IsReadableStream(this)) {
       return promiseRejectedWith(streamBrandCheckException('pipeTo'));
     }
@@ -257,9 +257,7 @@ export class ReadableStream<R = any> implements AsyncIterable<R> {
       return promiseRejectedWith(`Parameter 1 is required in 'pipeTo'.`);
     }
     if (!IsWritableStream(destination)) {
-      return promiseRejectedWith(
-        new TypeError(`ReadableStream.prototype.pipeTo's first argument must be a WritableStream`)
-      );
+      return promiseRejectedWith(new TypeError(`ReadableStream.prototype.pipeTo's first argument must be a WritableStream`));
     }
 
     let options: ValidatedStreamPipeOptions;
@@ -270,19 +268,13 @@ export class ReadableStream<R = any> implements AsyncIterable<R> {
     }
 
     if (IsReadableStreamLocked(this)) {
-      return promiseRejectedWith(
-        new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream')
-      );
+      return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream'));
     }
     if (IsWritableStreamLocked(destination)) {
-      return promiseRejectedWith(
-        new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream')
-      );
+      return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream'));
     }
 
-    return ReadableStreamPipeTo<R>(
-      this, destination, options.preventClose, options.preventAbort, options.preventCancel, options.signal
-    );
+    return ReadableStreamPipeTo<R>(this, destination, options.preventClose, options.preventAbort, options.preventCancel, options.signal);
   }
 
   /**
@@ -413,9 +405,7 @@ export function CreateReadableStream<R>(
   InitializeReadableStream(stream);
 
   const controller: ReadableStreamDefaultController<R> = Object.create(ReadableStreamDefaultController.prototype);
-  SetUpReadableStreamDefaultController(
-    stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm
-  );
+  SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
 
   return stream;
 }
diff --git a/src/lib/readable-stream/async-iterator.ts b/src/lib/readable-stream/async-iterator.ts
index 65029f5..590271b 100644
--- a/src/lib/readable-stream/async-iterator.ts
+++ b/src/lib/readable-stream/async-iterator.ts
@@ -44,17 +44,17 @@ export class ReadableStreamAsyncIteratorImpl<R> {
 
   next(): Promise<ReadableStreamDefaultReadResult<R>> {
     const nextSteps = () => this._nextSteps();
-    this._ongoingPromise = this._ongoingPromise ?
-      transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) :
-      nextSteps();
+    this._ongoingPromise = this._ongoingPromise
+      ? transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps)
+      : nextSteps();
     return this._ongoingPromise;
   }
 
   return(value: any): Promise<ReadableStreamDefaultReadResult<any>> {
     const returnSteps = () => this._returnSteps(value);
-    return this._ongoingPromise ?
-      transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) :
-      returnSteps();
+    return this._ongoingPromise
+      ? transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps)
+      : returnSteps();
   }
 
   private _nextSteps(): Promise<ReadableStreamDefaultReadResult<R>> {
@@ -153,8 +153,10 @@ Object.defineProperty(ReadableStreamAsyncIteratorPrototype, SymbolAsyncIterator,
 
 // Abstract operations for the ReadableStream.
 
-export function AcquireReadableStreamAsyncIterator<R>(stream: ReadableStream<R>,
-                                                      preventCancel: boolean): ReadableStreamAsyncIterator<R> {
+export function AcquireReadableStreamAsyncIterator<R>(
+  stream: ReadableStream<R>,
+  preventCancel: boolean
+): ReadableStreamAsyncIterator<R> {
   const reader = AcquireReadableStreamDefaultReader<R>(stream);
   const impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel);
   const iterator: ReadableStreamAsyncIteratorInstance<R> = Object.create(ReadableStreamAsyncIteratorPrototype);
@@ -173,8 +175,8 @@ function IsReadableStreamAsyncIterator<R = any>(x: any): x is ReadableStreamAsyn
 
   try {
     // noinspection SuspiciousTypeOfGuard
-    return (x as ReadableStreamAsyncIteratorInstance<any>)._asyncIteratorImpl instanceof
-      ReadableStreamAsyncIteratorImpl;
+    return (x as ReadableStreamAsyncIteratorInstance<any>)._asyncIteratorImpl
+      instanceof ReadableStreamAsyncIteratorImpl;
   } catch {
     return false;
   }
diff --git a/src/lib/readable-stream/byob-reader.ts b/src/lib/readable-stream/byob-reader.ts
index aad4f68..3419c3a 100644
--- a/src/lib/readable-stream/byob-reader.ts
+++ b/src/lib/readable-stream/byob-reader.ts
@@ -55,9 +55,11 @@ export function ReadableStreamAddReadIntoRequest<T extends NonShared<ArrayBuffer
   (stream._reader! as ReadableStreamBYOBReader)._readIntoRequests.push(readIntoRequest);
 }
 
-export function ReadableStreamFulfillReadIntoRequest(stream: ReadableByteStream,
-                                                     chunk: ArrayBufferView,
-                                                     done: boolean) {
+export function ReadableStreamFulfillReadIntoRequest(
+  stream: ReadableByteStream,
+  chunk: ArrayBufferView,
+  done: boolean
+) {
   const reader = stream._reader as ReadableStreamBYOBReader;
 
   assert(reader._readIntoRequests.length > 0);
@@ -124,8 +126,8 @@ export class ReadableStreamBYOBReader {
     }
 
     if (!IsReadableByteStreamController(stream._readableStreamController)) {
-      throw new TypeError('Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte ' +
-        'source');
+      throw new TypeError('Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte '
+        + 'source');
     }
 
     ReadableStreamReaderGenericInitialize(this, stream);
@@ -320,6 +322,5 @@ export function ReadableStreamBYOBReaderErrorReadIntoRequests(reader: ReadableSt
 // Helper functions for the ReadableStreamBYOBReader.
 
 function byobReaderBrandCheckException(name: string): TypeError {
-  return new TypeError(
-    `ReadableStreamBYOBReader.prototype.${name} can only be used on a ReadableStreamBYOBReader`);
+  return new TypeError(`ReadableStreamBYOBReader.prototype.${name} can only be used on a ReadableStreamBYOBReader`);
 }
diff --git a/src/lib/readable-stream/byte-stream-controller.ts b/src/lib/readable-stream/byte-stream-controller.ts
index 53528bb..6c951a1 100644
--- a/src/lib/readable-stream/byte-stream-controller.ts
+++ b/src/lib/readable-stream/byte-stream-controller.ts
@@ -470,31 +470,32 @@ function ReadableByteStreamControllerCommitPullIntoDescriptor<T extends NonShare
   }
 }
 
-function ReadableByteStreamControllerConvertPullIntoDescriptor<T extends NonShared<ArrayBufferView>>(
-  pullIntoDescriptor: PullIntoDescriptor<T>
-): T {
+function ReadableByteStreamControllerConvertPullIntoDescriptor<T extends NonShared<ArrayBufferView>>(pullIntoDescriptor: PullIntoDescriptor<T>): T {
   const bytesFilled = pullIntoDescriptor.bytesFilled;
   const elementSize = pullIntoDescriptor.elementSize;
 
   assert(bytesFilled <= pullIntoDescriptor.byteLength);
   assert(bytesFilled % elementSize === 0);
 
-  return new pullIntoDescriptor.viewConstructor(
-    pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize) as T;
+  return new pullIntoDescriptor.viewConstructor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize) as T;
 }
 
-function ReadableByteStreamControllerEnqueueChunkToQueue(controller: ReadableByteStreamController,
-                                                         buffer: ArrayBuffer,
-                                                         byteOffset: number,
-                                                         byteLength: number) {
+function ReadableByteStreamControllerEnqueueChunkToQueue(
+  controller: ReadableByteStreamController,
+  buffer: ArrayBuffer,
+  byteOffset: number,
+  byteLength: number
+) {
   controller._queue.push({ buffer, byteOffset, byteLength });
   controller._queueTotalSize += byteLength;
 }
 
-function ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller: ReadableByteStreamController,
-                                                               buffer: ArrayBuffer,
-                                                               byteOffset: number,
-                                                               byteLength: number) {
+function ReadableByteStreamControllerEnqueueClonedChunkToQueue(
+  controller: ReadableByteStreamController,
+  buffer: ArrayBuffer,
+  byteOffset: number,
+  byteLength: number
+) {
   let clonedChunk;
   try {
     clonedChunk = ArrayBufferSlice(buffer, byteOffset, byteOffset + byteLength);
@@ -505,8 +506,10 @@ function ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller: Reada
   ReadableByteStreamControllerEnqueueChunkToQueue(controller, clonedChunk, 0, byteLength);
 }
 
-function ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller: ReadableByteStreamController,
-                                                                    firstDescriptor: PullIntoDescriptor) {
+function ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(
+  controller: ReadableByteStreamController,
+  firstDescriptor: PullIntoDescriptor
+) {
   assert(firstDescriptor.readerType === 'none');
   if (firstDescriptor.bytesFilled > 0) {
     ReadableByteStreamControllerEnqueueClonedChunkToQueue(
@@ -519,10 +522,14 @@ function ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller:
   ReadableByteStreamControllerShiftPendingPullInto(controller);
 }
 
-function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller: ReadableByteStreamController,
-                                                                     pullIntoDescriptor: PullIntoDescriptor) {
-  const maxBytesToCopy = Math.min(controller._queueTotalSize,
-                                  pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
+function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(
+  controller: ReadableByteStreamController,
+  pullIntoDescriptor: PullIntoDescriptor
+) {
+  const maxBytesToCopy = Math.min(
+    controller._queueTotalSize,
+    pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled
+  );
   const maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
 
   let totalBytesToCopyRemaining = maxBytesToCopy;
@@ -569,9 +576,11 @@ function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller:
   return ready;
 }
 
-function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller: ReadableByteStreamController,
-                                                                size: number,
-                                                                pullIntoDescriptor: PullIntoDescriptor) {
+function ReadableByteStreamControllerFillHeadPullIntoDescriptor(
+  controller: ReadableByteStreamController,
+  size: number,
+  pullIntoDescriptor: PullIntoDescriptor
+) {
   assert(controller._pendingPullIntos.length === 0 || controller._pendingPullIntos.peek() === pullIntoDescriptor);
   assert(controller._byobRequest === null);
   pullIntoDescriptor.bytesFilled += size;
@@ -711,8 +720,10 @@ export function ReadableByteStreamControllerPullInto<T extends NonShared<ArrayBu
   ReadableByteStreamControllerCallPullIfNeeded(controller);
 }
 
-function ReadableByteStreamControllerRespondInClosedState(controller: ReadableByteStreamController,
-                                                          firstDescriptor: PullIntoDescriptor) {
+function ReadableByteStreamControllerRespondInClosedState(
+  controller: ReadableByteStreamController,
+  firstDescriptor: PullIntoDescriptor
+) {
   assert(firstDescriptor.bytesFilled % firstDescriptor.elementSize === 0);
 
   if (firstDescriptor.readerType === 'none') {
@@ -728,9 +739,11 @@ function ReadableByteStreamControllerRespondInClosedState(controller: ReadableBy
   }
 }
 
-function ReadableByteStreamControllerRespondInReadableState(controller: ReadableByteStreamController,
-                                                            bytesWritten: number,
-                                                            pullIntoDescriptor: PullIntoDescriptor) {
+function ReadableByteStreamControllerRespondInReadableState(
+  controller: ReadableByteStreamController,
+  bytesWritten: number,
+  pullIntoDescriptor: PullIntoDescriptor
+) {
   assert(pullIntoDescriptor.bytesFilled + bytesWritten <= pullIntoDescriptor.byteLength);
 
   ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
@@ -785,9 +798,7 @@ function ReadableByteStreamControllerRespondInternal(controller: ReadableByteStr
   ReadableByteStreamControllerCallPullIfNeeded(controller);
 }
 
-function ReadableByteStreamControllerShiftPendingPullInto(
-  controller: ReadableByteStreamController
-): PullIntoDescriptor {
+function ReadableByteStreamControllerShiftPendingPullInto(controller: ReadableByteStreamController): PullIntoDescriptor {
   assert(controller._byobRequest === null);
   const descriptor = controller._pendingPullIntos.shift()!;
   return descriptor;
@@ -878,9 +889,7 @@ export function ReadableByteStreamControllerEnqueue(
   if (controller._pendingPullIntos.length > 0) {
     const firstPendingPullInto = controller._pendingPullIntos.peek();
     if (IsDetachedBuffer(firstPendingPullInto.buffer)) {
-      throw new TypeError(
-        'The BYOB request\'s buffer has been detached and so cannot be filled with an enqueued chunk'
-      );
+      throw new TypeError('The BYOB request\'s buffer has been detached and so cannot be filled with an enqueued chunk');
     }
     ReadableByteStreamControllerInvalidateBYOBRequest(controller);
     firstPendingPullInto.buffer = TransferArrayBuffer(firstPendingPullInto.buffer);
@@ -944,14 +953,14 @@ export function ReadableByteStreamControllerFillReadRequestFromQueue(
   readRequest._chunkSteps(view as NonShared<Uint8Array>);
 }
 
-export function ReadableByteStreamControllerGetBYOBRequest(
-  controller: ReadableByteStreamController
-): ReadableStreamBYOBRequest | null {
+export function ReadableByteStreamControllerGetBYOBRequest(controller: ReadableByteStreamController): ReadableStreamBYOBRequest | null {
   if (controller._byobRequest === null && controller._pendingPullIntos.length > 0) {
     const firstDescriptor = controller._pendingPullIntos.peek();
-    const view = new Uint8Array(firstDescriptor.buffer,
-                                firstDescriptor.byteOffset + firstDescriptor.bytesFilled,
-                                firstDescriptor.byteLength - firstDescriptor.bytesFilled);
+    const view = new Uint8Array(
+      firstDescriptor.buffer,
+      firstDescriptor.byteOffset + firstDescriptor.bytesFilled,
+      firstDescriptor.byteLength - firstDescriptor.bytesFilled
+    );
 
     const byobRequest: ReadableStreamBYOBRequest = Object.create(ReadableStreamBYOBRequest.prototype);
     SetUpReadableStreamBYOBRequest(byobRequest, controller, view as NonShared<Uint8Array>);
@@ -998,8 +1007,10 @@ export function ReadableByteStreamControllerRespond(controller: ReadableByteStre
   ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
 }
 
-export function ReadableByteStreamControllerRespondWithNewView(controller: ReadableByteStreamController,
-                                                               view: NonShared<ArrayBufferView>) {
+export function ReadableByteStreamControllerRespondWithNewView(
+  controller: ReadableByteStreamController,
+  view: NonShared<ArrayBufferView>
+) {
   assert(controller._pendingPullIntos.length > 0);
   assert(!IsDetachedBuffer(view.buffer));
 
@@ -1013,9 +1024,7 @@ export function ReadableByteStreamControllerRespondWithNewView(controller: Reada
   } else {
     assert(state === 'readable');
     if (view.byteLength === 0) {
-      throw new TypeError(
-        'The view\'s length must be greater than 0 when calling respondWithNewView() on a readable stream'
-      );
+      throw new TypeError('The view\'s length must be greater than 0 when calling respondWithNewView() on a readable stream');
     }
   }
 
@@ -1034,13 +1043,15 @@ export function ReadableByteStreamControllerRespondWithNewView(controller: Reada
   ReadableByteStreamControllerRespondInternal(controller, viewByteLength);
 }
 
-export function SetUpReadableByteStreamController(stream: ReadableByteStream,
-                                                  controller: ReadableByteStreamController,
-                                                  startAlgorithm: () => void | PromiseLike<void>,
-                                                  pullAlgorithm: () => Promise<void>,
-                                                  cancelAlgorithm: (reason: any) => Promise<void>,
-                                                  highWaterMark: number,
-                                                  autoAllocateChunkSize: number | undefined) {
+export function SetUpReadableByteStreamController(
+  stream: ReadableByteStream,
+  controller: ReadableByteStreamController,
+  startAlgorithm: () => void | PromiseLike<void>,
+  pullAlgorithm: () => Promise<void>,
+  cancelAlgorithm: (reason: any) => Promise<void>,
+  highWaterMark: number,
+  autoAllocateChunkSize: number | undefined
+) {
   assert(stream._readableStreamController === undefined);
   if (autoAllocateChunkSize !== undefined) {
     assert(NumberIsInteger(autoAllocateChunkSize));
@@ -1123,14 +1134,14 @@ export function SetUpReadableByteStreamControllerFromUnderlyingSource(
     throw new TypeError('autoAllocateChunkSize must be greater than 0');
   }
 
-  SetUpReadableByteStreamController(
-    stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize
-  );
+  SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize);
 }
 
-function SetUpReadableStreamBYOBRequest(request: ReadableStreamBYOBRequest,
-                                        controller: ReadableByteStreamController,
-                                        view: NonShared<ArrayBufferView>) {
+function SetUpReadableStreamBYOBRequest(
+  request: ReadableStreamBYOBRequest,
+  controller: ReadableByteStreamController,
+  view: NonShared<ArrayBufferView>
+) {
   assert(IsReadableByteStreamController(controller));
   assert(typeof view === 'object');
   assert(ArrayBuffer.isView(view));
@@ -1142,13 +1153,11 @@ function SetUpReadableStreamBYOBRequest(request: ReadableStreamBYOBRequest,
 // Helper functions for the ReadableStreamBYOBRequest.
 
 function byobRequestBrandCheckException(name: string): TypeError {
-  return new TypeError(
-    `ReadableStreamBYOBRequest.prototype.${name} can only be used on a ReadableStreamBYOBRequest`);
+  return new TypeError(`ReadableStreamBYOBRequest.prototype.${name} can only be used on a ReadableStreamBYOBRequest`);
 }
 
 // Helper functions for the ReadableByteStreamController.
 
 function byteStreamControllerBrandCheckException(name: string): TypeError {
-  return new TypeError(
-    `ReadableByteStreamController.prototype.${name} can only be used on a ReadableByteStreamController`);
+  return new TypeError(`ReadableByteStreamController.prototype.${name} can only be used on a ReadableByteStreamController`);
 }
diff --git a/src/lib/readable-stream/default-controller.ts b/src/lib/readable-stream/default-controller.ts
index 6ad8812..91f48d7 100644
--- a/src/lib/readable-stream/default-controller.ts
+++ b/src/lib/readable-stream/default-controller.ts
@@ -294,9 +294,7 @@ export function ReadableStreamDefaultControllerError(controller: ReadableStreamD
   ReadableStreamError(stream, e);
 }
 
-export function ReadableStreamDefaultControllerGetDesiredSize(
-  controller: ReadableStreamDefaultController<any>
-): number | null {
+export function ReadableStreamDefaultControllerGetDesiredSize(controller: ReadableStreamDefaultController<any>): number | null {
   const state = controller._controlledReadableStream._state;
 
   if (state === 'errored') {
@@ -310,9 +308,7 @@ export function ReadableStreamDefaultControllerGetDesiredSize(
 }
 
 // This is used in the implementation of TransformStream.
-export function ReadableStreamDefaultControllerHasBackpressure(
-  controller: ReadableStreamDefaultController<any>
-): boolean {
+export function ReadableStreamDefaultControllerHasBackpressure(controller: ReadableStreamDefaultController<any>): boolean {
   if (ReadableStreamDefaultControllerShouldCallPull(controller)) {
     return false;
   }
@@ -320,9 +316,7 @@ export function ReadableStreamDefaultControllerHasBackpressure(
   return true;
 }
 
-export function ReadableStreamDefaultControllerCanCloseOrEnqueue(
-  controller: ReadableStreamDefaultController<any>
-): boolean {
+export function ReadableStreamDefaultControllerCanCloseOrEnqueue(controller: ReadableStreamDefaultController<any>): boolean {
   const state = controller._controlledReadableStream._state;
 
   if (!controller._closeRequested && state === 'readable') {
@@ -332,13 +326,15 @@ export function ReadableStreamDefaultControllerCanCloseOrEnqueue(
   return false;
 }
 
-export function SetUpReadableStreamDefaultController<R>(stream: ReadableStream<R>,
-                                                        controller: ReadableStreamDefaultController<R>,
-                                                        startAlgorithm: () => void | PromiseLike<void>,
-                                                        pullAlgorithm: () => Promise<void>,
-                                                        cancelAlgorithm: (reason: any) => Promise<void>,
-                                                        highWaterMark: number,
-                                                        sizeAlgorithm: QueuingStrategySizeCallback<R>) {
+export function SetUpReadableStreamDefaultController<R>(
+  stream: ReadableStream<R>,
+  controller: ReadableStreamDefaultController<R>,
+  startAlgorithm: () => void | PromiseLike<void>,
+  pullAlgorithm: () => Promise<void>,
+  cancelAlgorithm: (reason: any) => Promise<void>,
+  highWaterMark: number,
+  sizeAlgorithm: QueuingStrategySizeCallback<R>
+) {
   assert(stream._readableStreamController === undefined);
 
   controller._controlledReadableStream = stream;
@@ -407,14 +403,11 @@ export function SetUpReadableStreamDefaultControllerFromUnderlyingSource<R>(
     cancelAlgorithm = () => promiseResolvedWith(undefined);
   }
 
-  SetUpReadableStreamDefaultController(
-    stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm
-  );
+  SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
 }
 
 // Helper functions for the ReadableStreamDefaultController.
 
 function defaultControllerBrandCheckException(name: string): TypeError {
-  return new TypeError(
-    `ReadableStreamDefaultController.prototype.${name} can only be used on a ReadableStreamDefaultController`);
+  return new TypeError(`ReadableStreamDefaultController.prototype.${name} can only be used on a ReadableStreamDefaultController`);
 }
diff --git a/src/lib/readable-stream/default-reader.ts b/src/lib/readable-stream/default-reader.ts
index 48023dd..d48b0ad 100644
--- a/src/lib/readable-stream/default-reader.ts
+++ b/src/lib/readable-stream/default-reader.ts
@@ -34,8 +34,10 @@ export function AcquireReadableStreamDefaultReader<R>(stream: ReadableStream): R
 
 // ReadableStream API exposed for controllers.
 
-export function ReadableStreamAddReadRequest<R>(stream: ReadableStream<R>,
-                                                readRequest: ReadRequest<R>): void {
+export function ReadableStreamAddReadRequest<R>(
+  stream: ReadableStream<R>,
+  readRequest: ReadRequest<R>
+): void {
   assert(IsReadableStreamDefaultReader(stream._reader));
   assert(stream._state === 'readable');
 
@@ -221,8 +223,10 @@ export function IsReadableStreamDefaultReader<R = any>(x: any): x is ReadableStr
   return x instanceof ReadableStreamDefaultReader;
 }
 
-export function ReadableStreamDefaultReaderRead<R>(reader: ReadableStreamDefaultReader<R>,
-                                                   readRequest: ReadRequest<R>): void {
+export function ReadableStreamDefaultReaderRead<R>(
+  reader: ReadableStreamDefaultReader<R>,
+  readRequest: ReadRequest<R>
+): void {
   const stream = reader._ownerReadableStream;
 
   assert(stream !== undefined);
@@ -256,6 +260,5 @@ export function ReadableStreamDefaultReaderErrorReadRequests(reader: ReadableStr
 // Helper functions for the ReadableStreamDefaultReader.
 
 function defaultReaderBrandCheckException(name: string): TypeError {
-  return new TypeError(
-    `ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);
+  return new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);
 }
diff --git a/src/lib/readable-stream/from.ts b/src/lib/readable-stream/from.ts
index d36cea5..d745178 100644
--- a/src/lib/readable-stream/from.ts
+++ b/src/lib/readable-stream/from.ts
@@ -10,9 +10,7 @@ import { promiseCall, promiseRejectedWith, promiseResolvedWith, transformPromise
 import { typeIsObject } from '../helpers/miscellaneous';
 import { noop } from '../../utils';
 
-export function ReadableStreamFrom<R>(
-  source: Iterable<R> | AsyncIterable<R> | ReadableStreamLike<R>
-): DefaultReadableStream<R> {
+export function ReadableStreamFrom<R>(source: Iterable<R> | AsyncIterable<R> | ReadableStreamLike<R>): DefaultReadableStream<R> {
   if (isReadableStreamLike(source)) {
     return ReadableStreamFromDefaultReader(source.getReader());
   }
@@ -71,9 +69,7 @@ export function ReadableStreamFromIterable<R>(asyncIterable: Iterable<R> | Async
   return stream;
 }
 
-export function ReadableStreamFromDefaultReader<R>(
-  reader: ReadableStreamDefaultReaderLike<R>
-): DefaultReadableStream<R> {
+export function ReadableStreamFromDefaultReader<R>(reader: ReadableStreamDefaultReaderLike<R>): DefaultReadableStream<R> {
   let stream: DefaultReadableStream<R>;
 
   const startAlgorithm = noop;
diff --git a/src/lib/readable-stream/generic-reader.ts b/src/lib/readable-stream/generic-reader.ts
index 4563ee9..0ce7120 100644
--- a/src/lib/readable-stream/generic-reader.ts
+++ b/src/lib/readable-stream/generic-reader.ts
@@ -35,11 +35,13 @@ export function ReadableStreamReaderGenericRelease(reader: ReadableStreamReader<
   if (stream._state === 'readable') {
     defaultReaderClosedPromiseReject(
       reader,
-      new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
+      new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`)
+    );
   } else {
     defaultReaderClosedPromiseResetToRejected(
       reader,
-      new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
+      new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`)
+    );
   }
 
   stream._readableStreamController[ReleaseSteps]();
diff --git a/src/lib/readable-stream/pipe.ts b/src/lib/readable-stream/pipe.ts
index c84e203..fb3379c 100644
--- a/src/lib/readable-stream/pipe.ts
+++ b/src/lib/readable-stream/pipe.ts
@@ -26,12 +26,14 @@ import { noop } from '../../utils';
 import { type AbortSignal, isAbortSignal } from '../abort-signal';
 import { DOMException } from '../../stub/dom-exception';
 
-export function ReadableStreamPipeTo<T>(source: ReadableStream<T>,
-                                        dest: WritableStream<T>,
-                                        preventClose: boolean,
-                                        preventAbort: boolean,
-                                        preventCancel: boolean,
-                                        signal: AbortSignal | undefined): Promise<undefined> {
+export function ReadableStreamPipeTo<T>(
+  source: ReadableStream<T>,
+  dest: WritableStream<T>,
+  preventClose: boolean,
+  preventAbort: boolean,
+  preventCancel: boolean,
+  signal: AbortSignal | undefined
+): Promise<undefined> {
   assert(IsReadableStream(source));
   assert(IsWritableStream(dest));
   assert(typeof preventClose === 'boolean');
@@ -178,9 +180,11 @@ export function ReadableStreamPipeTo<T>(source: ReadableStream<T>,
       );
     }
 
-    function isOrBecomesErrored(stream: ReadableStream | WritableStream,
-                                promise: Promise<void>,
-                                action: (reason: any) => null) {
+    function isOrBecomesErrored(
+      stream: ReadableStream | WritableStream,
+      promise: Promise<void>,
+      action: (reason: any) => null
+    ) {
       if (stream._state === 'errored') {
         action(stream._storedError);
       } else {
diff --git a/src/lib/readable-stream/tee.ts b/src/lib/readable-stream/tee.ts
index ad8f4ba..578c02c 100644
--- a/src/lib/readable-stream/tee.ts
+++ b/src/lib/readable-stream/tee.ts
@@ -41,8 +41,10 @@ import { CreateArrayFromList } from '../abstract-ops/ecmascript';
 import { CloneAsUint8Array } from '../abstract-ops/miscellaneous';
 import type { NonShared } from '../helpers/array-buffer-view';
 
-export function ReadableStreamTee<R>(stream: ReadableStream<R>,
-                                     cloneForBranch2: boolean): [ReadableStream<R>, ReadableStream<R>] {
+export function ReadableStreamTee<R>(
+  stream: ReadableStream<R>,
+  cloneForBranch2: boolean
+): [ReadableStream<R>, ReadableStream<R>] {
   assert(IsReadableStream(stream));
   assert(typeof cloneForBranch2 === 'boolean');
   if (IsReadableByteStreamController(stream._readableStreamController)) {
diff --git a/src/lib/transform-stream.ts b/src/lib/transform-stream.ts
index 2d292be..d30c99c 100644
--- a/src/lib/transform-stream.ts
+++ b/src/lib/transform-stream.ts
@@ -61,9 +61,11 @@ export class TransformStream<I = any, O = any> {
     writableStrategy?: QueuingStrategy<I>,
     readableStrategy?: QueuingStrategy<O>
   );
-  constructor(rawTransformer: Transformer<I, O> | null | undefined = {},
+  constructor(
+rawTransformer: Transformer<I, O> | null | undefined = {},
               rawWritableStrategy: QueuingStrategy<I> | null | undefined = {},
-              rawReadableStrategy: QueuingStrategy<O> | null | undefined = {}) {
+              rawReadableStrategy: QueuingStrategy<O> | null | undefined = {}
+  ) {
     if (rawTransformer === undefined) {
       rawTransformer = null;
     }
@@ -89,9 +91,7 @@ export class TransformStream<I = any, O = any> {
       startPromise_resolve = resolve;
     });
 
-    InitializeTransformStream(
-      this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm
-    );
+    InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
     SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);
 
     if (transformer.start !== undefined) {
@@ -145,14 +145,16 @@ export type {
 
 // Transform Stream Abstract Operations
 
-export function CreateTransformStream<I, O>(startAlgorithm: () => void | PromiseLike<void>,
-                                            transformAlgorithm: (chunk: I) => Promise<void>,
-                                            flushAlgorithm: () => Promise<void>,
-                                            cancelAlgorithm: (reason: any) => Promise<void>,
-                                            writableHighWaterMark = 1,
-                                            writableSizeAlgorithm: QueuingStrategySizeCallback<I> = () => 1,
-                                            readableHighWaterMark = 0,
-                                            readableSizeAlgorithm: QueuingStrategySizeCallback<O> = () => 1) {
+export function CreateTransformStream<I, O>(
+  startAlgorithm: () => void | PromiseLike<void>,
+  transformAlgorithm: (chunk: I) => Promise<void>,
+  flushAlgorithm: () => Promise<void>,
+  cancelAlgorithm: (reason: any) => Promise<void>,
+  writableHighWaterMark = 1,
+  writableSizeAlgorithm: QueuingStrategySizeCallback<I> = () => 1,
+  readableHighWaterMark = 0,
+  readableSizeAlgorithm: QueuingStrategySizeCallback<O> = () => 1
+) {
   assert(IsNonNegativeNumber(writableHighWaterMark));
   assert(IsNonNegativeNumber(readableHighWaterMark));
 
@@ -163,8 +165,10 @@ export function CreateTransformStream<I, O>(startAlgorithm: () => void | Promise
     startPromise_resolve = resolve;
   });
 
-  InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark,
-                            readableSizeAlgorithm);
+  InitializeTransformStream(
+    stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark,
+    readableSizeAlgorithm
+  );
 
   const controller: TransformStreamDefaultController<O> = Object.create(TransformStreamDefaultController.prototype);
 
@@ -175,12 +179,14 @@ export function CreateTransformStream<I, O>(startAlgorithm: () => void | Promise
   return stream;
 }
 
-function InitializeTransformStream<I, O>(stream: TransformStream<I, O>,
-                                         startPromise: Promise<void>,
-                                         writableHighWaterMark: number,
-                                         writableSizeAlgorithm: QueuingStrategySizeCallback<I>,
-                                         readableHighWaterMark: number,
-                                         readableSizeAlgorithm: QueuingStrategySizeCallback<O>) {
+function InitializeTransformStream<I, O>(
+  stream: TransformStream<I, O>,
+  startPromise: Promise<void>,
+  writableHighWaterMark: number,
+  writableSizeAlgorithm: QueuingStrategySizeCallback<I>,
+  readableHighWaterMark: number,
+  readableSizeAlgorithm: QueuingStrategySizeCallback<O>
+) {
   function startAlgorithm(): Promise<void> {
     return startPromise;
   }
@@ -197,8 +203,10 @@ function InitializeTransformStream<I, O>(stream: TransformStream<I, O>,
     return TransformStreamDefaultSinkCloseAlgorithm(stream);
   }
 
-  stream._writable = CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm,
-                                          writableHighWaterMark, writableSizeAlgorithm);
+  stream._writable = CreateWritableStream(
+    startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm,
+    writableHighWaterMark, writableSizeAlgorithm
+  );
 
   function pullAlgorithm(): Promise<void> {
     return TransformStreamDefaultSourcePullAlgorithm(stream);
@@ -208,8 +216,10 @@ function InitializeTransformStream<I, O>(stream: TransformStream<I, O>,
     return TransformStreamDefaultSourceCancelAlgorithm(stream, reason);
   }
 
-  stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark,
-                                          readableSizeAlgorithm);
+  stream._readable = CreateReadableStream(
+    startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark,
+    readableSizeAlgorithm
+  );
 
   // The [[backpressure]] slot is set to undefined so that it can be initialised by TransformStreamSetBackpressure.
   stream._backpressure = undefined!;
@@ -374,11 +384,13 @@ function IsTransformStreamDefaultController<O = any>(x: any): x is TransformStre
   return x instanceof TransformStreamDefaultController;
 }
 
-function SetUpTransformStreamDefaultController<I, O>(stream: TransformStream<I, O>,
-                                                     controller: TransformStreamDefaultController<O>,
-                                                     transformAlgorithm: (chunk: I) => Promise<void>,
-                                                     flushAlgorithm: () => Promise<void>,
-                                                     cancelAlgorithm: (reason: any) => Promise<void>) {
+function SetUpTransformStreamDefaultController<I, O>(
+  stream: TransformStream<I, O>,
+  controller: TransformStreamDefaultController<O>,
+  transformAlgorithm: (chunk: I) => Promise<void>,
+  flushAlgorithm: () => Promise<void>,
+  cancelAlgorithm: (reason: any) => Promise<void>
+) {
   assert(IsTransformStream(stream));
   assert(stream._transformStreamController === undefined);
 
@@ -394,8 +406,10 @@ function SetUpTransformStreamDefaultController<I, O>(stream: TransformStream<I,
   controller._finishPromise_reject = undefined;
 }
 
-function SetUpTransformStreamDefaultControllerFromTransformer<I, O>(stream: TransformStream<I, O>,
-                                                                    transformer: ValidatedTransformer<I, O>) {
+function SetUpTransformStreamDefaultControllerFromTransformer<I, O>(
+  stream: TransformStream<I, O>,
+  transformer: ValidatedTransformer<I, O>
+) {
   const controller: TransformStreamDefaultController<O> = Object.create(TransformStreamDefaultController.prototype);
 
   let transformAlgorithm: (chunk: I) => Promise<void>;
@@ -466,8 +480,10 @@ function TransformStreamDefaultControllerError(controller: TransformStreamDefaul
   TransformStreamError(controller._controlledTransformStream, e);
 }
 
-function TransformStreamDefaultControllerPerformTransform<I, O>(controller: TransformStreamDefaultController<O>,
-                                                                chunk: I) {
+function TransformStreamDefaultControllerPerformTransform<I, O>(
+  controller: TransformStreamDefaultController<O>,
+  chunk: I
+) {
   const transformPromise = controller._transformAlgorithm(chunk);
   return transformPromiseWith(transformPromise, undefined, (r) => {
     TransformStreamError(controller._controlledTransformStream, r);
@@ -637,8 +653,7 @@ function TransformStreamDefaultSourceCancelAlgorithm<I, O>(stream: TransformStre
 // Helper functions for the TransformStreamDefaultController.
 
 function defaultControllerBrandCheckException(name: string): TypeError {
-  return new TypeError(
-    `TransformStreamDefaultController.prototype.${name} can only be used on a TransformStreamDefaultController`);
+  return new TypeError(`TransformStreamDefaultController.prototype.${name} can only be used on a TransformStreamDefaultController`);
 }
 
 export function defaultControllerFinishPromiseResolve(controller: TransformStreamDefaultController<any>) {
@@ -665,6 +680,5 @@ export function defaultControllerFinishPromiseReject(controller: TransformStream
 // Helper functions for the TransformStream.
 
 function streamBrandCheckException(name: string): TypeError {
-  return new TypeError(
-    `TransformStream.prototype.${name} can only be used on a TransformStream`);
+  return new TypeError(`TransformStream.prototype.${name} can only be used on a TransformStream`);
 }
diff --git a/src/lib/validators/basic.ts b/src/lib/validators/basic.ts
index 4e58084..a310b3f 100644
--- a/src/lib/validators/basic.ts
+++ b/src/lib/validators/basic.ts
@@ -6,8 +6,10 @@ export function isDictionary(x: any): x is object | null {
   return typeof x === 'object' || typeof x === 'function';
 }
 
-export function assertDictionary(obj: unknown,
-                                 context: string): asserts obj is object | null | undefined {
+export function assertDictionary(
+  obj: unknown,
+  context: string
+): asserts obj is object | null | undefined {
   if (obj !== undefined && !isDictionary(obj)) {
     throw new TypeError(`${context} is not an object.`);
   }
@@ -27,24 +29,30 @@ export function isObject(x: any): x is object {
   return (typeof x === 'object' && x !== null) || typeof x === 'function';
 }
 
-export function assertObject(x: unknown,
-                             context: string): asserts x is object {
+export function assertObject(
+  x: unknown,
+  context: string
+): asserts x is object {
   if (!isObject(x)) {
     throw new TypeError(`${context} is not an object.`);
   }
 }
 
-export function assertRequiredArgument<T>(x: T | undefined,
-                                          position: number,
-                                          context: string): asserts x is T {
+export function assertRequiredArgument<T>(
+  x: T | undefined,
+  position: number,
+  context: string
+): asserts x is T {
   if (x === undefined) {
     throw new TypeError(`Parameter ${position} is required in '${context}'.`);
   }
 }
 
-export function assertRequiredField<T>(x: T | undefined,
-                                       field: string,
-                                       context: string): asserts x is T {
+export function assertRequiredField<T>(
+  x: T | undefined,
+  field: string,
+  context: string
+): asserts x is T {
   if (x === undefined) {
     throw new TypeError(`${field} is required in '${context}'.`);
   }
diff --git a/src/lib/validators/iterator-options.ts b/src/lib/validators/iterator-options.ts
index f2d3a41..55de514 100644
--- a/src/lib/validators/iterator-options.ts
+++ b/src/lib/validators/iterator-options.ts
@@ -4,8 +4,10 @@ import type {
   ValidatedReadableStreamIteratorOptions
 } from '../readable-stream/iterator-options';
 
-export function convertIteratorOptions(options: ReadableStreamIteratorOptions | null | undefined,
-                                       context: string): ValidatedReadableStreamIteratorOptions {
+export function convertIteratorOptions(
+  options: ReadableStreamIteratorOptions | null | undefined,
+  context: string
+): ValidatedReadableStreamIteratorOptions {
   assertDictionary(options, context);
   const preventCancel = options?.preventCancel;
   return { preventCancel: Boolean(preventCancel) };
diff --git a/src/lib/validators/pipe-options.ts b/src/lib/validators/pipe-options.ts
index 4e53130..70defdc 100644
--- a/src/lib/validators/pipe-options.ts
+++ b/src/lib/validators/pipe-options.ts
@@ -2,8 +2,10 @@ import { assertDictionary } from './basic';
 import type { StreamPipeOptions, ValidatedStreamPipeOptions } from '../readable-stream/pipe-options';
 import { type AbortSignal, isAbortSignal } from '../abort-signal';
 
-export function convertPipeOptions(options: StreamPipeOptions | null | undefined,
-                                   context: string): ValidatedStreamPipeOptions {
+export function convertPipeOptions(
+  options: StreamPipeOptions | null | undefined,
+  context: string
+): ValidatedStreamPipeOptions {
   assertDictionary(options, context);
   const preventAbort = options?.preventAbort;
   const preventCancel = options?.preventCancel;
diff --git a/src/lib/validators/queuing-strategy-init.ts b/src/lib/validators/queuing-strategy-init.ts
index a4d74cc..fbcae89 100644
--- a/src/lib/validators/queuing-strategy-init.ts
+++ b/src/lib/validators/queuing-strategy-init.ts
@@ -1,8 +1,10 @@
 import type { QueuingStrategyInit } from '../queuing-strategy';
 import { assertDictionary, assertRequiredField, convertUnrestrictedDouble } from './basic';
 
-export function convertQueuingStrategyInit(init: QueuingStrategyInit | null | undefined,
-                                           context: string): QueuingStrategyInit {
+export function convertQueuingStrategyInit(
+  init: QueuingStrategyInit | null | undefined,
+  context: string
+): QueuingStrategyInit {
   assertDictionary(init, context);
   const highWaterMark = init?.highWaterMark;
   assertRequiredField(highWaterMark, 'highWaterMark', 'QueuingStrategyInit');
diff --git a/src/lib/validators/queuing-strategy.ts b/src/lib/validators/queuing-strategy.ts
index 3f88a5f..5e36579 100644
--- a/src/lib/validators/queuing-strategy.ts
+++ b/src/lib/validators/queuing-strategy.ts
@@ -1,8 +1,10 @@
 import type { QueuingStrategy, QueuingStrategySizeCallback } from '../queuing-strategy';
 import { assertDictionary, assertFunction, convertUnrestrictedDouble } from './basic';
 
-export function convertQueuingStrategy<T>(init: QueuingStrategy<T> | null | undefined,
-                                          context: string): QueuingStrategy<T> {
+export function convertQueuingStrategy<T>(
+  init: QueuingStrategy<T> | null | undefined,
+  context: string
+): QueuingStrategy<T> {
   assertDictionary(init, context);
   const highWaterMark = init?.highWaterMark;
   const size = init?.size;
@@ -12,8 +14,10 @@ export function convertQueuingStrategy<T>(init: QueuingStrategy<T> | null | unde
   };
 }
 
-function convertQueuingStrategySize<T>(fn: QueuingStrategySizeCallback<T>,
-                                       context: string): QueuingStrategySizeCallback<T> {
+function convertQueuingStrategySize<T>(
+  fn: QueuingStrategySizeCallback<T>,
+  context: string
+): QueuingStrategySizeCallback<T> {
   assertFunction(fn, context);
   return chunk => convertUnrestrictedDouble(fn(chunk));
 }
diff --git a/src/lib/validators/reader-options.ts b/src/lib/validators/reader-options.ts
index a34ee63..7f4b228 100644
--- a/src/lib/validators/reader-options.ts
+++ b/src/lib/validators/reader-options.ts
@@ -5,8 +5,10 @@ import type {
   ValidatedReadableStreamBYOBReaderReadOptions
 } from '../readable-stream/reader-options';
 
-export function convertReaderOptions(options: ReadableStreamGetReaderOptions | null | undefined,
-                                     context: string): ReadableStreamGetReaderOptions {
+export function convertReaderOptions(
+  options: ReadableStreamGetReaderOptions | null | undefined,
+  context: string
+): ReadableStreamGetReaderOptions {
   assertDictionary(options, context);
   const mode = options?.mode;
   return {
diff --git a/src/lib/validators/transformer.ts b/src/lib/validators/transformer.ts
index 5fef086..25025e2 100644
--- a/src/lib/validators/transformer.ts
+++ b/src/lib/validators/transformer.ts
@@ -10,8 +10,10 @@ import type {
 } from '../transform-stream/transformer';
 import { TransformStreamDefaultController } from '../transform-stream';
 
-export function convertTransformer<I, O>(original: Transformer<I, O> | null,
-                                         context: string): ValidatedTransformer<I, O> {
+export function convertTransformer<I, O>(
+  original: Transformer<I, O> | null,
+  context: string
+): ValidatedTransformer<I, O> {
   assertDictionary(original, context);
   const cancel = original?.cancel;
   const flush = original?.flush;
@@ -20,19 +22,19 @@ export function convertTransformer<I, O>(original: Transformer<I, O> | null,
   const transform = original?.transform;
   const writableType = original?.writableType;
   return {
-    cancel: cancel === undefined ?
-      undefined :
-      convertTransformerCancelCallback(cancel, original!, `${context} has member 'cancel' that`),
-    flush: flush === undefined ?
-      undefined :
-      convertTransformerFlushCallback(flush, original!, `${context} has member 'flush' that`),
+    cancel: cancel === undefined
+      ? undefined
+      : convertTransformerCancelCallback(cancel, original!, `${context} has member 'cancel' that`),
+    flush: flush === undefined
+      ? undefined
+      : convertTransformerFlushCallback(flush, original!, `${context} has member 'flush' that`),
     readableType,
-    start: start === undefined ?
-      undefined :
-      convertTransformerStartCallback(start, original!, `${context} has member 'start' that`),
-    transform: transform === undefined ?
-      undefined :
-      convertTransformerTransformCallback(transform, original!, `${context} has member 'transform' that`),
+    start: start === undefined
+      ? undefined
+      : convertTransformerStartCallback(start, original!, `${context} has member 'start' that`),
+    transform: transform === undefined
+      ? undefined
+      : convertTransformerTransformCallback(transform, original!, `${context} has member 'transform' that`),
     writableType
   };
 }
diff --git a/src/lib/validators/underlying-sink.ts b/src/lib/validators/underlying-sink.ts
index a804ef0..7502a55 100644
--- a/src/lib/validators/underlying-sink.ts
+++ b/src/lib/validators/underlying-sink.ts
@@ -10,8 +10,10 @@ import type {
 } from '../writable-stream/underlying-sink';
 import { WritableStreamDefaultController } from '../writable-stream';
 
-export function convertUnderlyingSink<W>(original: UnderlyingSink<W> | null,
-                                         context: string): ValidatedUnderlyingSink<W> {
+export function convertUnderlyingSink<W>(
+  original: UnderlyingSink<W> | null,
+  context: string
+): ValidatedUnderlyingSink<W> {
   assertDictionary(original, context);
   const abort = original?.abort;
   const close = original?.close;
@@ -19,18 +21,18 @@ export function convertUnderlyingSink<W>(original: UnderlyingSink<W> | null,
   const type = original?.type;
   const write = original?.write;
   return {
-    abort: abort === undefined ?
-      undefined :
-      convertUnderlyingSinkAbortCallback(abort, original!, `${context} has member 'abort' that`),
-    close: close === undefined ?
-      undefined :
-      convertUnderlyingSinkCloseCallback(close, original!, `${context} has member 'close' that`),
-    start: start === undefined ?
-      undefined :
-      convertUnderlyingSinkStartCallback(start, original!, `${context} has member 'start' that`),
-    write: write === undefined ?
-      undefined :
-      convertUnderlyingSinkWriteCallback(write, original!, `${context} has member 'write' that`),
+    abort: abort === undefined
+      ? undefined
+      : convertUnderlyingSinkAbortCallback(abort, original!, `${context} has member 'abort' that`),
+    close: close === undefined
+      ? undefined
+      : convertUnderlyingSinkCloseCallback(close, original!, `${context} has member 'close' that`),
+    start: start === undefined
+      ? undefined
+      : convertUnderlyingSinkStartCallback(start, original!, `${context} has member 'start' that`),
+    write: write === undefined
+      ? undefined
+      : convertUnderlyingSinkWriteCallback(write, original!, `${context} has member 'write' that`),
     type
   };
 }
diff --git a/src/lib/validators/underlying-source.ts b/src/lib/validators/underlying-source.ts
index 5b1f94c..b70e34f 100644
--- a/src/lib/validators/underlying-source.ts
+++ b/src/lib/validators/underlying-source.ts
@@ -23,21 +23,21 @@ export function convertUnderlyingDefaultOrByteSource<R>(
   const start = original?.start;
   const type = original?.type;
   return {
-    autoAllocateChunkSize: autoAllocateChunkSize === undefined ?
-      undefined :
-      convertUnsignedLongLongWithEnforceRange(
+    autoAllocateChunkSize: autoAllocateChunkSize === undefined
+      ? undefined
+      : convertUnsignedLongLongWithEnforceRange(
         autoAllocateChunkSize,
         `${context} has member 'autoAllocateChunkSize' that`
       ),
-    cancel: cancel === undefined ?
-      undefined :
-      convertUnderlyingSourceCancelCallback(cancel, original!, `${context} has member 'cancel' that`),
-    pull: pull === undefined ?
-      undefined :
-      convertUnderlyingSourcePullCallback(pull, original!, `${context} has member 'pull' that`),
-    start: start === undefined ?
-      undefined :
-      convertUnderlyingSourceStartCallback(start, original!, `${context} has member 'start' that`),
+    cancel: cancel === undefined
+      ? undefined
+      : convertUnderlyingSourceCancelCallback(cancel, original!, `${context} has member 'cancel' that`),
+    pull: pull === undefined
+      ? undefined
+      : convertUnderlyingSourcePullCallback(pull, original!, `${context} has member 'pull' that`),
+    start: start === undefined
+      ? undefined
+      : convertUnderlyingSourceStartCallback(start, original!, `${context} has member 'start' that`),
     type: type === undefined ? undefined : convertReadableStreamType(type, `${context} has member 'type' that`)
   };
 }
diff --git a/src/lib/writable-stream.ts b/src/lib/writable-stream.ts
index 87e484f..495fa55 100644
--- a/src/lib/writable-stream.ts
+++ b/src/lib/writable-stream.ts
@@ -79,8 +79,10 @@ class WritableStream<W = any> {
   _backpressure!: boolean;
 
   constructor(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>);
-  constructor(rawUnderlyingSink: UnderlyingSink<W> | null | undefined = {},
-              rawStrategy: QueuingStrategy<W> | null | undefined = {}) {
+  constructor(
+rawUnderlyingSink: UnderlyingSink<W> | null | undefined = {},
+              rawStrategy: QueuingStrategy<W> | null | undefined = {}
+  ) {
     if (rawUnderlyingSink === undefined) {
       rawUnderlyingSink = null;
     } else {
@@ -221,12 +223,14 @@ function AcquireWritableStreamDefaultWriter<W>(stream: WritableStream<W>): Writa
 }
 
 // Throws if and only if startAlgorithm throws.
-function CreateWritableStream<W>(startAlgorithm: () => void | PromiseLike<void>,
-                                 writeAlgorithm: (chunk: W) => Promise<void>,
-                                 closeAlgorithm: () => Promise<void>,
-                                 abortAlgorithm: (reason: any) => Promise<void>,
-                                 highWaterMark = 1,
-                                 sizeAlgorithm: QueuingStrategySizeCallback<W> = () => 1) {
+function CreateWritableStream<W>(
+  startAlgorithm: () => void | PromiseLike<void>,
+  writeAlgorithm: (chunk: W) => Promise<void>,
+  closeAlgorithm: () => Promise<void>,
+  abortAlgorithm: (reason: any) => Promise<void>,
+  highWaterMark = 1,
+  sizeAlgorithm: QueuingStrategySizeCallback<W> = () => 1
+) {
   assert(IsNonNegativeNumber(highWaterMark));
 
   const stream: WritableStream<W> = Object.create(WritableStream.prototype);
@@ -234,8 +238,10 @@ function CreateWritableStream<W>(startAlgorithm: () => void | PromiseLike<void>,
 
   const controller: WritableStreamDefaultController<W> = Object.create(WritableStreamDefaultController.prototype);
 
-  SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm,
-                                       abortAlgorithm, highWaterMark, sizeAlgorithm);
+  SetUpWritableStreamDefaultController(
+    stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm,
+    abortAlgorithm, highWaterMark, sizeAlgorithm
+  );
   return stream;
 }
 
@@ -346,8 +352,7 @@ function WritableStreamAbort(stream: WritableStream, reason: any): Promise<undef
 function WritableStreamClose(stream: WritableStream<any>): Promise<undefined> {
   const state = stream._state;
   if (state === 'closed' || state === 'errored') {
-    return promiseRejectedWith(new TypeError(
-      `The stream (in ${state} state) is not in the writable state and cannot be closed`));
+    return promiseRejectedWith(new TypeError(`The stream (in ${state} state) is not in the writable state and cannot be closed`));
   }
 
   assert(state === 'writable' || state === 'erroring');
@@ -459,7 +464,8 @@ function WritableStreamFinishErroring(stream: WritableStream) {
       abortRequest._reject(reason);
       WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
       return null;
-    });
+    }
+  );
 }
 
 function WritableStreamFinishInFlightWrite(stream: WritableStream) {
@@ -885,8 +891,7 @@ function WritableStreamDefaultWriterRelease(writer: WritableStreamDefaultWriter)
   assert(stream !== undefined);
   assert(stream._writer === writer);
 
-  const releasedError = new TypeError(
-    `Writer was released and can no longer be used to monitor the stream's closedness`);
+  const releasedError = new TypeError(`Writer was released and can no longer be used to monitor the stream's closedness`);
 
   WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);
 
@@ -1058,14 +1063,16 @@ function IsWritableStreamDefaultController(x: any): x is WritableStreamDefaultCo
   return x instanceof WritableStreamDefaultController;
 }
 
-function SetUpWritableStreamDefaultController<W>(stream: WritableStream<W>,
-                                                 controller: WritableStreamDefaultController<W>,
-                                                 startAlgorithm: () => void | PromiseLike<void>,
-                                                 writeAlgorithm: (chunk: W) => Promise<void>,
-                                                 closeAlgorithm: () => Promise<void>,
-                                                 abortAlgorithm: (reason: any) => Promise<void>,
-                                                 highWaterMark: number,
-                                                 sizeAlgorithm: QueuingStrategySizeCallback<W>) {
+function SetUpWritableStreamDefaultController<W>(
+  stream: WritableStream<W>,
+  controller: WritableStreamDefaultController<W>,
+  startAlgorithm: () => void | PromiseLike<void>,
+  writeAlgorithm: (chunk: W) => Promise<void>,
+  closeAlgorithm: () => Promise<void>,
+  abortAlgorithm: (reason: any) => Promise<void>,
+  highWaterMark: number,
+  sizeAlgorithm: QueuingStrategySizeCallback<W>
+) {
   assert(IsWritableStream(stream));
   assert(stream._writableStreamController === undefined);
 
@@ -1110,10 +1117,12 @@ function SetUpWritableStreamDefaultController<W>(stream: WritableStream<W>,
   );
 }
 
-function SetUpWritableStreamDefaultControllerFromUnderlyingSink<W>(stream: WritableStream<W>,
-                                                                   underlyingSink: ValidatedUnderlyingSink<W>,
-                                                                   highWaterMark: number,
-                                                                   sizeAlgorithm: QueuingStrategySizeCallback<W>) {
+function SetUpWritableStreamDefaultControllerFromUnderlyingSink<W>(
+  stream: WritableStream<W>,
+  underlyingSink: ValidatedUnderlyingSink<W>,
+  highWaterMark: number,
+  sizeAlgorithm: QueuingStrategySizeCallback<W>
+) {
   const controller = Object.create(WritableStreamDefaultController.prototype);
 
   let startAlgorithm: () => void | PromiseLike<void>;
@@ -1142,9 +1151,7 @@ function SetUpWritableStreamDefaultControllerFromUnderlyingSink<W>(stream: Writa
     abortAlgorithm = () => promiseResolvedWith(undefined);
   }
 
-  SetUpWritableStreamDefaultController(
-    stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm
-  );
+  SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
 }
 
 // ClearAlgorithms may be called twice. Erroring the same stream in multiple ways will often result in redundant calls.
@@ -1160,8 +1167,10 @@ function WritableStreamDefaultControllerClose<W>(controller: WritableStreamDefau
   WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
 }
 
-function WritableStreamDefaultControllerGetChunkSize<W>(controller: WritableStreamDefaultController<W>,
-                                                        chunk: W): number {
+function WritableStreamDefaultControllerGetChunkSize<W>(
+  controller: WritableStreamDefaultController<W>,
+  chunk: W
+): number {
   try {
     return controller._strategySizeAlgorithm(chunk);
   } catch (chunkSizeE) {
@@ -1174,9 +1183,11 @@ function WritableStreamDefaultControllerGetDesiredSize(controller: WritableStrea
   return controller._strategyHWM - controller._queueTotalSize;
 }
 
-function WritableStreamDefaultControllerWrite<W>(controller: WritableStreamDefaultController<W>,
-                                                 chunk: W,
-                                                 chunkSize: number) {
+function WritableStreamDefaultControllerWrite<W>(
+  controller: WritableStreamDefaultController<W>,
+  chunk: W,
+  chunkSize: number
+) {
   try {
     EnqueueValueWithSize(controller, chunk, chunkSize);
   } catch (enqueueE) {
@@ -1313,15 +1324,13 @@ function streamBrandCheckException(name: string): TypeError {
 // Helper functions for the WritableStreamDefaultController.
 
 function defaultControllerBrandCheckException(name: string): TypeError {
-  return new TypeError(
-    `WritableStreamDefaultController.prototype.${name} can only be used on a WritableStreamDefaultController`);
+  return new TypeError(`WritableStreamDefaultController.prototype.${name} can only be used on a WritableStreamDefaultController`);
 }
 
 // Helper functions for the WritableStreamDefaultWriter.
 
 function defaultWriterBrandCheckException(name: string): TypeError {
-  return new TypeError(
-    `WritableStreamDefaultWriter.prototype.${name} can only be used on a WritableStreamDefaultWriter`);
+  return new TypeError(`WritableStreamDefaultWriter.prototype.${name} can only be used on a WritableStreamDefaultWriter`);
 }
 
 function defaultWriterLockException(name: string): TypeError {
diff --git a/src/stub/number-isinteger.ts b/src/stub/number-isinteger.ts
index b533419..939e4b8 100644
--- a/src/stub/number-isinteger.ts
+++ b/src/stub/number-isinteger.ts
@@ -2,9 +2,9 @@
 
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger#Polyfill
 const NumberIsInteger: typeof Number.isInteger = Number.isInteger || function (value) {
-  return typeof value === 'number' &&
-    isFinite(value) &&
-    Math.floor(value) === value;
+  return typeof value === 'number'
+    && isFinite(value)
+    && Math.floor(value) === value;
 };
 
 export default NumberIsInteger;
diff --git a/src/stub/symbol.ts b/src/stub/symbol.ts
index 8138416..fbdcc79 100644
--- a/src/stub/symbol.ts
+++ b/src/stub/symbol.ts
@@ -1,8 +1,8 @@
 /// <reference lib="es2015.symbol" />
 
-const SymbolPolyfill: (description?: string) => symbol =
-  typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ?
-    Symbol :
-    description => `Symbol(${description})` as any as symbol;
+const SymbolPolyfill: (description?: string) => symbol
+  = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol'
+    ? Symbol
+    : description => `Symbol(${description})` as any as symbol;
 
 export default SymbolPolyfill;