@yume-chan/stream-extra 0.0.17 → 0.0.19

package/esm/wrap-writable.js

@@ -1,53 +1,63 @@
-import { WritableStream } from "./stream.js";
-async function getWrappedWritableStream(wrapper) {
-    if ('start' in wrapper) {
-        return await wrapper.start();
-    }
-    else if (typeof wrapper === 'function') {
-        return await wrapper();
-    }
-    else {
-        // Can't use `wrapper instanceof WritableStream`
-        // Because we want to be compatible with any WritableStream-like objects
-        return wrapper;
-    }
-}
-export class WrapWritableStream extends WritableStream {
-    writable;
-    writer;
-    constructor(wrapper) {
-        super({
-            start: async () => {
-                // `start` is invoked before `ReadableStream`'s constructor finish,
-                // so using `this` synchronously causes
-                // "Must call super constructor in derived class before accessing 'this' or returning from derived constructor".
-                // Queue a microtask to avoid this.
-                await Promise.resolve();
-                this.writable = await getWrappedWritableStream(wrapper);
-                this.writer = this.writable.getWriter();
-            },
-            write: async (chunk) => {
-                // Maintain back pressure
-                await this.writer.ready;
-                await this.writer.write(chunk);
-            },
-            abort: async (reason) => {
-                await this.writer.abort(reason);
-                if ('close' in wrapper) {
-                    await wrapper.close?.();
-                }
-            },
-            close: async () => {
-                // Close the inner stream first.
-                // Usually the inner stream is a logical sub-stream over the outer stream,
-                // closing the outer stream first will make the inner stream incapable of
-                // sending data in its `close` handler.
-                await this.writer.close();
-                if ('close' in wrapper) {
-                    await wrapper.close?.();
-                }
-            },
-        });
-    }
-}
+import { WritableStream } from "./stream.js";
+async function getWrappedWritableStream(wrapper) {
+    if ("start" in wrapper) {
+        return await wrapper.start();
+    }
+    else if (typeof wrapper === "function") {
+        return await wrapper();
+    }
+    else {
+        // Can't use `wrapper instanceof WritableStream`
+        // Because we want to be compatible with any WritableStream-like objects
+        return wrapper;
+    }
+}
+export class WrapWritableStream extends WritableStream {
+    writable;
+    writer;
+    constructor(wrapper) {
+        super({
+            start: async () => {
+                // `start` is invoked before `ReadableStream`'s constructor finish,
+                // so using `this` synchronously causes
+                // "Must call super constructor in derived class before accessing 'this' or returning from derived constructor".
+                // Queue a microtask to avoid this.
+                await Promise.resolve();
+                this.writable = await getWrappedWritableStream(wrapper);
+                this.writer = this.writable.getWriter();
+            },
+            write: async (chunk) => {
+                await this.writer.write(chunk);
+            },
+            abort: async (reason) => {
+                await this.writer.abort(reason);
+                if ("close" in wrapper) {
+                    await wrapper.close?.();
+                }
+            },
+            close: async () => {
+                // Close the inner stream first.
+                // Usually the inner stream is a logical sub-stream over the outer stream,
+                // closing the outer stream first will make the inner stream incapable of
+                // sending data in its `close` handler.
+                await this.writer.close();
+                if ("close" in wrapper) {
+                    await wrapper.close?.();
+                }
+            },
+        });
+    }
+    bePipedThroughFrom(transformer) {
+        let promise;
+        return new WrapWritableStream({
+            start: () => {
+                promise = transformer.readable.pipeTo(this);
+                return transformer.writable;
+            },
+            async close() {
+                await promise;
+            },
+        });
+    }
+}
 //# sourceMappingURL=wrap-writable.js.map

package/esm/wrap-writable.js.map

@@ -1 +1 @@
-{"version":3,"file":"wrap-writable.js","sourceRoot":"","sources":["../src/wrap-writable.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAA+B,MAAM,aAAa,CAAC;AAS1E,KAAK,UAAU,wBAAwB,CACnC,OAAkF;IAElF,IAAI,OAAO,IAAI,OAAO,EAAE;QACpB,OAAO,MAAM,OAAO,CAAC,KAAK,EAAE,CAAC;KAChC;SAAM,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE;QACtC,OAAO,MAAM,OAAO,EAAE,CAAC;KAC1B;SAAM;QACH,gDAAgD;QAChD,wEAAwE;QACxE,OAAO,OAAO,CAAC;KAClB;AACL,CAAC;AAED,MAAM,OAAO,kBAAsB,SAAQ,cAAiB;IACjD,QAAQ,CAAqB;IAE5B,MAAM,CAAkC;IAEhD,YAAmB,OAAkF;QACjG,KAAK,CAAC;YACF,KAAK,EAAE,KAAK,IAAI,EAAE;gBACd,mEAAmE;gBACnE,uCAAuC;gBACvC,gHAAgH;gBAChH,mCAAmC;gBACnC,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;gBAExB,IAAI,CAAC,QAAQ,GAAG,MAAM,wBAAwB,CAAC,OAAO,CAAC,CAAC;gBACxD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;YAC5C,CAAC;YACD,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;gBACnB,yBAAyB;gBACzB,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;gBACxB,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACnC,CAAC;YACD,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;gBACpB,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;gBAChC,IAAI,OAAO,IAAI,OAAO,EAAE;oBACpB,MAAM,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;iBAC3B;YACL,CAAC;YACD,KAAK,EAAE,KAAK,IAAI,EAAE;gBACd,gCAAgC;gBAChC,0EAA0E;gBAC1E,yEAAyE;gBACzE,uCAAuC;gBACvC,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;gBAC1B,IAAI,OAAO,IAAI,OAAO,EAAE;oBACpB,MAAM,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;iBAC3B;YACL,CAAC;SACJ,CAAC,CAAC;IACP,CAAC;CACJ"}
+{"version":3,"file":"wrap-writable.js","sourceRoot":"","sources":["../src/wrap-writable.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAW7C,KAAK,UAAU,wBAAwB,CACnC,OAG8B;IAE9B,IAAI,OAAO,IAAI,OAAO,EAAE;QACpB,OAAO,MAAM,OAAO,CAAC,KAAK,EAAE,CAAC;KAChC;SAAM,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE;QACtC,OAAO,MAAM,OAAO,EAAE,CAAC;KAC1B;SAAM;QACH,gDAAgD;QAChD,wEAAwE;QACxE,OAAO,OAAO,CAAC;KAClB;AACL,CAAC;AAED,MAAM,OAAO,kBAAsB,SAAQ,cAAiB;IACjD,QAAQ,CAAqB;IAE5B,MAAM,CAAkC;IAEhD,YACI,OAG8B;QAE9B,KAAK,CAAC;YACF,KAAK,EAAE,KAAK,IAAI,EAAE;gBACd,mEAAmE;gBACnE,uCAAuC;gBACvC,gHAAgH;gBAChH,mCAAmC;gBACnC,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;gBAExB,IAAI,CAAC,QAAQ,GAAG,MAAM,wBAAwB,CAAC,OAAO,CAAC,CAAC;gBACxD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;YAC5C,CAAC;YACD,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;gBACnB,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACnC,CAAC;YACD,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;gBACpB,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;gBAChC,IAAI,OAAO,IAAI,OAAO,EAAE;oBACpB,MAAM,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;iBAC3B;YACL,CAAC;YACD,KAAK,EAAE,KAAK,IAAI,EAAE;gBACd,gCAAgC;gBAChC,0EAA0E;gBAC1E,yEAAyE;gBACzE,uCAAuC;gBACvC,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;gBAC1B,IAAI,OAAO,IAAI,OAAO,EAAE;oBACpB,MAAM,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;iBAC3B;YACL,CAAC;SACJ,CAAC,CAAC;IACP,CAAC;IAEM,kBAAkB,CAAI,WAAkC;QAC3D,IAAI,OAAsB,CAAC;QAC3B,OAAO,IAAI,kBAAkB,CAAI;YAC7B,KAAK,EAAE,GAAG,EAAE;gBACR,OAAO,GAAG,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBAC5C,OAAO,WAAW,CAAC,QAAQ,CAAC;YAChC,CAAC;YACD,KAAK,CAAC,KAAK;gBACP,MAAM,OAAO,CAAC;YAClB,CAAC;SACJ,CAAC,CAAC;IACP,CAAC;CACJ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yume-chan/stream-extra",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Extensions to Web Streams API",
   "keywords": [
     "stream",
@@ -26,21 +26,25 @@
   "types": "esm/index.d.ts",
   "dependencies": {
     "@yume-chan/async": "^2.2.0",
-    "@yume-chan/struct": "^0.0.17",
-    "tslib": "^2.4.0",
+    "@yume-chan/struct": "^0.0.19",
+    "tslib": "^2.4.1",
     "web-streams-polyfill": "^4.0.0-beta.3"
   },
   "devDependencies": {
-    "@jest/globals": "^28.1.2",
-    "@yume-chan/ts-package-builder": "^1.0.0",
+    "@jest/globals": "^29.5.0",
+    "@yume-chan/eslint-config": "^1.0.0",
+    "@yume-chan/tsconfig": "^1.0.0",
     "cross-env": "^7.0.3",
-    "jest": "^28.1.2",
-    "ts-jest": "^28.0.5",
-    "typescript": "^4.7.4"
+    "eslint": "^8.36.0",
+    "jest": "^29.5.0",
+    "prettier": "^2.8.4",
+    "ts-jest": "^29.0.4",
+    "typescript": "^4.9.4"
   },
   "scripts": {
     "build": "tsc -b tsconfig.build.json",
     "build:watch": "tsc -b tsconfig.build.json",
-    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --coverage"
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --coverage",
+    "lint": "eslint src/**/*.ts --fix && prettier src/**/*.ts --write --tab-width 4"
   }
 }

package/src/buffered-transform.ts

@@ -1,24 +1,39 @@
-import type { ValueOrPromise } from '@yume-chan/struct';
-import { BufferedReadableStream, BufferedReadableStreamEndedError } from './buffered.js';
-import { PushReadableStream, PushReadableStreamController } from './push-readable.js';
-import { ReadableStream, ReadableWritablePair, WritableStream } from './stream.js';
+import type { ValueOrPromise } from "@yume-chan/struct";
+
+import {
+    BufferedReadableStream,
+    BufferedReadableStreamEndedError,
+} from "./buffered.js";
+import type { PushReadableStreamController } from "./push-readable.js";
+import { PushReadableStream } from "./push-readable.js";
+import type { ReadableWritablePair } from "./stream.js";
+import { ReadableStream, WritableStream } from "./stream.js";
 
 // TODO: BufferedTransformStream: find better implementation
-export class BufferedTransformStream<T> implements ReadableWritablePair<T, Uint8Array> {
+export class BufferedTransformStream<T>
+    implements ReadableWritablePair<T, Uint8Array>
+{
     private _readable: ReadableStream<T>;
-    public get readable() { return this._readable; }
+    public get readable() {
+        return this._readable;
+    }
 
     private _writable: WritableStream<Uint8Array>;
-    public get writable() { return this._writable; }
+    public get writable() {
+        return this._writable;
+    }
 
-    constructor(transform: (stream: BufferedReadableStream) => ValueOrPromise<T>) {
+    constructor(
+        transform: (stream: BufferedReadableStream) => ValueOrPromise<T>
+    ) {
         // Convert incoming chunks to a `BufferedReadableStream`
         let sourceStreamController!: PushReadableStreamController<Uint8Array>;
 
-        const buffered = new BufferedReadableStream(new PushReadableStream<Uint8Array>(
-            controller =>
-                sourceStreamController = controller,
-        ));
+        const buffered = new BufferedReadableStream(
+            new PushReadableStream<Uint8Array>((controller) => {
+                sourceStreamController = controller;
+            })
+        );
 
         this._readable = new ReadableStream<T>({
             async pull(controller) {
@@ -26,9 +41,9 @@ export class BufferedTransformStream<T> implements ReadableWritablePair<T, Uint8
                     const value = await transform(buffered);
                     controller.enqueue(value);
                 } catch (e) {
-                    // TODO: BufferedTransformStream: The semantic of stream ending is not clear
-                    // If the `transform` started but did not finish, it should really be an error?
-                    // But we can't detect that, unless there is a `peek` method on buffered stream.
+                    // Treat `BufferedReadableStreamEndedError` as a normal end.
+                    // If the `transform` method doesn't have enough data to return a value,
+                    // it should throw another error to indicate that.
                     if (e instanceof BufferedReadableStreamEndedError) {
                         controller.close();
                         return;
@@ -39,8 +54,8 @@ export class BufferedTransformStream<T> implements ReadableWritablePair<T, Uint8
             cancel: (reason) => {
                 // Propagate cancel to the source stream
                 // So future writes will be rejected
-                buffered.cancel(reason);
-            }
+                return buffered.cancel(reason);
+            },
         });
 
         this._writable = new WritableStream({

package/src/buffered.ts

@@ -3,7 +3,7 @@ import type { ReadableStream, ReadableStreamDefaultReader } from "./stream.js";
 
 export class BufferedReadableStreamEndedError extends Error {
     public constructor() {
-        super('Stream ended');
+        super("Stream ended");
 
         // Fix Error's prototype chain when compiling to ES5
         Object.setPrototypeOf(this, new.target.prototype);
@@ -15,8 +15,12 @@ export class BufferedReadableStream {
     private bufferedOffset = 0;
     private bufferedLength = 0;
 
-    protected readonly stream: ReadableStream<Uint8Array>;
+    private _position = 0;
+    public get position() {
+        return this._position;
+    }
 
+    protected readonly stream: ReadableStream<Uint8Array>;
     protected readonly reader: ReadableStreamDefaultReader<Uint8Array>;
 
     public constructor(stream: ReadableStream<Uint8Array>) {
@@ -29,6 +33,7 @@ export class BufferedReadableStream {
         if (done) {
             throw new BufferedReadableStreamEndedError();
         }
+        this._position += value.byteLength;
         return value;
     }
 
@@ -115,23 +120,17 @@ export class BufferedReadableStream {
      */
     public release(): ReadableStream<Uint8Array> {
         if (this.buffered) {
-            return new PushReadableStream<Uint8Array>(async controller => {
+            return new PushReadableStream<Uint8Array>(async (controller) => {
                 // Put the remaining data back to the stream
                 await controller.enqueue(this.buffered!);
 
                 // Manually pipe the stream
                 while (true) {
-                    try {
-                        const { done, value } = await this.reader.read();
-                        if (done) {
-                            controller.close();
-                            break;
-                        } else {
-                            await controller.enqueue(value);
-                        }
-                    } catch (e) {
-                        controller.error(e);
-                        break;
+                    const { done, value } = await this.reader.read();
+                    if (done) {
+                        return;
+                    } else {
+                        await controller.enqueue(value);
                     }
                 }
             });
@@ -142,7 +141,7 @@ export class BufferedReadableStream {
         }
     }
 
-    public cancel(reason?: any) {
+    public cancel(reason?: unknown) {
         return this.reader.cancel(reason);
     }
 }

package/src/consumable.ts

@@ -0,0 +1,281 @@
+import { PromiseResolver } from "@yume-chan/async";
+
+import type { QueuingStrategy, WritableStreamDefaultWriter } from "./stream.js";
+import { ReadableStream, TransformStream, WritableStream } from "./stream.js";
+
+interface Task {
+    run<T>(callback: () => T): T;
+}
+
+interface Console {
+    createTask(name: string): Task;
+}
+
+interface GlobalEx {
+    console: Console;
+}
+
+// `createTask` allows browser DevTools to track the call stack across async boundaries.
+const { console } = globalThis as unknown as GlobalEx;
+const createTask: Console["createTask"] =
+    console.createTask?.bind(console) ??
+    (() => ({
+        run(callback) {
+            return callback();
+        },
+    }));
+
+export class Consumable<T> {
+    private readonly task: Task;
+    private readonly resolver: PromiseResolver<void>;
+
+    public readonly value: T;
+    public readonly consumed: Promise<void>;
+
+    public constructor(value: T) {
+        this.task = createTask("Consumable");
+        this.value = value;
+        this.resolver = new PromiseResolver<void>();
+        this.consumed = this.resolver.promise;
+    }
+
+    public consume() {
+        this.resolver.resolve();
+    }
+
+    public error(error: any) {
+        this.resolver.reject(error);
+    }
+
+    public async tryConsume<U>(callback: (value: T) => U) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/await-thenable
+            const result = await this.task.run(() => callback(this.value));
+            this.consume();
+            return result;
+        } catch (e) {
+            this.resolver.reject(e);
+            throw e;
+        }
+    }
+}
+
+async function enqueue<T>(
+    controller: { enqueue: (chunk: Consumable<T>) => void },
+    chunk: T
+) {
+    const output = new Consumable(chunk);
+    controller.enqueue(output);
+    await output.consumed;
+}
+
+export class WrapConsumableStream<T> extends TransformStream<T, Consumable<T>> {
+    public constructor() {
+        super({
+            async transform(chunk, controller) {
+                await enqueue(controller, chunk);
+            },
+        });
+    }
+}
+
+export class UnwrapConsumableStream<T> extends TransformStream<
+    Consumable<T>,
+    T
+> {
+    public constructor() {
+        super({
+            transform(chunk, controller) {
+                controller.enqueue(chunk.value);
+                chunk.consume();
+            },
+        });
+    }
+}
+
+export interface ConsumableReadableStreamController<T> {
+    enqueue(chunk: T): Promise<void>;
+    close(): void;
+    error(reason: any): void;
+}
+
+export interface ConsumableReadableStreamSource<T> {
+    start?(
+        controller: ConsumableReadableStreamController<T>
+    ): void | PromiseLike<void>;
+    pull?(
+        controller: ConsumableReadableStreamController<T>
+    ): void | PromiseLike<void>;
+    cancel?(reason: any): void | PromiseLike<void>;
+}
+
+export class ConsumableReadableStream<T> extends ReadableStream<Consumable<T>> {
+    public constructor(
+        source: ConsumableReadableStreamSource<T>,
+        strategy?: QueuingStrategy<T>
+    ) {
+        let wrappedController:
+            | ConsumableReadableStreamController<T>
+            | undefined;
+
+        let wrappedStrategy: QueuingStrategy<Consumable<T>> | undefined;
+        if (strategy) {
+            wrappedStrategy = {};
+            if ("highWaterMark" in strategy) {
+                wrappedStrategy.highWaterMark = strategy.highWaterMark;
+            }
+            if ("size" in strategy) {
+                wrappedStrategy.size = (chunk) => {
+                    return strategy.size!(chunk.value);
+                };
+            }
+        }
+
+        super(
+            {
+                async start(controller) {
+                    wrappedController = {
+                        async enqueue(chunk) {
+                            await enqueue(controller, chunk);
+                        },
+                        close() {
+                            controller.close();
+                        },
+                        error(reason) {
+                            controller.error(reason);
+                        },
+                    };
+
+                    await source.start?.(wrappedController);
+                },
+                async pull() {
+                    await source.pull?.(wrappedController!);
+                },
+                async cancel(reason) {
+                    await source.cancel?.(reason);
+                },
+            },
+            wrappedStrategy
+        );
+    }
+}
+
+export interface ConsumableWritableStreamSink<T> {
+    start?(): void | PromiseLike<void>;
+    write?(chunk: T): void | PromiseLike<void>;
+    abort?(reason: any): void | PromiseLike<void>;
+    close?(): void | PromiseLike<void>;
+}
+
+export class ConsumableWritableStream<T> extends WritableStream<Consumable<T>> {
+    public static async write<T>(
+        writer: WritableStreamDefaultWriter<Consumable<T>>,
+        value: T
+    ) {
+        const consumable = new Consumable(value);
+        await writer.write(consumable);
+        await consumable.consumed;
+    }
+
+    public constructor(
+        sink: ConsumableWritableStreamSink<T>,
+        strategy?: QueuingStrategy<T>
+    ) {
+        let wrappedStrategy: QueuingStrategy<Consumable<T>> | undefined;
+        if (strategy) {
+            wrappedStrategy = {};
+            if ("highWaterMark" in strategy) {
+                wrappedStrategy.highWaterMark = strategy.highWaterMark;
+            }
+            if ("size" in strategy) {
+                wrappedStrategy.size = (chunk) => {
+                    return strategy.size!(chunk.value);
+                };
+            }
+        }
+
+        super(
+            {
+                start() {
+                    return sink.start?.();
+                },
+                async write(chunk) {
+                    await chunk.tryConsume((value) => sink.write?.(value));
+                    chunk.consume();
+                },
+                abort(reason) {
+                    return sink.abort?.(reason);
+                },
+                close() {
+                    return sink.close?.();
+                },
+            },
+            wrappedStrategy
+        );
+    }
+}
+
+export interface ConsumableTransformer<I, O> {
+    start?(
+        controller: ConsumableReadableStreamController<O>
+    ): void | PromiseLike<void>;
+    transform?(
+        chunk: I,
+        controller: ConsumableReadableStreamController<O>
+    ): void | PromiseLike<void>;
+    flush?(
+        controller: ConsumableReadableStreamController<O>
+    ): void | PromiseLike<void>;
+}
+
+export class ConsumableTransformStream<I, O> extends TransformStream<
+    Consumable<I>,
+    Consumable<O>
+> {
+    public constructor(transformer: ConsumableTransformer<I, O>) {
+        let wrappedController:
+            | ConsumableReadableStreamController<O>
+            | undefined;
+
+        super({
+            async start(controller) {
+                wrappedController = {
+                    async enqueue(chunk) {
+                        await enqueue(controller, chunk);
+                    },
+                    close() {
+                        controller.terminate();
+                    },
+                    error(reason) {
+                        controller.error(reason);
+                    },
+                };
+
+                await transformer.start?.(wrappedController);
+            },
+            async transform(chunk) {
+                await chunk.tryConsume((value) =>
+                    transformer.transform?.(value, wrappedController!)
+                );
+                chunk.consume();
+            },
+            async flush() {
+                await transformer.flush?.(wrappedController!);
+            },
+        });
+    }
+}
+
+export class ConsumableInspectStream<T> extends TransformStream<
+    Consumable<T>,
+    Consumable<T>
+> {
+    public constructor(callback: (value: T) => void) {
+        super({
+            transform(chunk, controller) {
+                callback(chunk.value);
+                controller.enqueue(chunk);
+            },
+        });
+    }
+}

package/src/decode-utf8.ts

@@ -1,7 +1,8 @@
-import { decodeUtf8 } from '@yume-chan/struct';
+import { decodeUtf8 } from "@yume-chan/struct";
+
 import { TransformStream } from "./stream.js";
 
-export class DecodeUtf8Stream extends TransformStream<Uint8Array, string>{
+export class DecodeUtf8Stream extends TransformStream<Uint8Array, string> {
     public constructor() {
         super({
             transform(chunk, controller) {