@run0/jiki 0.1.0

package/dist/polyfills/stream.d.ts

@@ -0,0 +1,106 @@
+import { EventEmitter } from "./events";
+export declare class BufferImpl extends Uint8Array {
+    static alloc(size: number, fill?: number): BufferImpl;
+    static allocUnsafe(size: number): BufferImpl;
+    static allocUnsafeSlow(size: number): BufferImpl;
+    static from(data: string | ArrayBuffer | ArrayLike<number> | Uint8Array | Iterable<number>, encoding?: string | ((v: any, k: number) => number), thisArg?: any): BufferImpl;
+    static concat(list: (Uint8Array | BufferImpl)[], totalLength?: number): BufferImpl;
+    static isBuffer(obj: unknown): obj is BufferImpl;
+    static isEncoding(encoding: string): boolean;
+    static byteLength(str: string, encoding?: string): number;
+    toString(encoding?: string, start?: number, end?: number): string;
+    write(string: string, offset?: number, length?: number, encoding?: string): number;
+    copy(target: Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
+    equals(other: Uint8Array): boolean;
+    compare(other: Uint8Array): number;
+    readUInt8(offset: number): number;
+    readUInt16BE(offset: number): number;
+    readUInt16LE(offset: number): number;
+    readUInt32BE(offset: number): number;
+    readUInt32LE(offset: number): number;
+    readInt8(offset: number): number;
+    readInt16BE(offset: number): number;
+    readInt16LE(offset: number): number;
+    readInt32BE(offset: number): number;
+    readInt32LE(offset: number): number;
+    writeUInt8(value: number, offset: number): number;
+    writeUInt16BE(value: number, offset: number): number;
+    writeUInt16LE(value: number, offset: number): number;
+    writeUInt32BE(value: number, offset: number): number;
+    writeUInt32LE(value: number, offset: number): number;
+    readFloatBE(offset: number): number;
+    readFloatLE(offset: number): number;
+    readDoubleBE(offset: number): number;
+    readDoubleLE(offset: number): number;
+    writeFloatBE(value: number, offset: number): number;
+    writeFloatLE(value: number, offset: number): number;
+    writeDoubleBE(value: number, offset: number): number;
+    writeDoubleLE(value: number, offset: number): number;
+    toJSON(): {
+        type: "Buffer";
+        data: number[];
+    };
+    slice(start?: number, end?: number): BufferImpl;
+}
+export declare class Readable extends EventEmitter {
+    readable: boolean;
+    readableEnded: boolean;
+    readableFlowing: boolean | null;
+    private _buffer;
+    private _ended;
+    readableHighWaterMark: number;
+    read(_size?: number): unknown;
+    push(chunk: unknown): boolean;
+    on(event: string, listener: (...args: unknown[]) => void): this;
+    pipe<T extends Writable>(dest: T): T;
+    unpipe(_dest?: Writable): this;
+    pause(): this;
+    resume(): this;
+    destroy(): this;
+    setEncoding(_enc: string): this;
+    [Symbol.asyncIterator](): AsyncIterableIterator<unknown>;
+}
+export declare class Writable extends EventEmitter {
+    writable: boolean;
+    writableEnded: boolean;
+    writableFinished: boolean;
+    write(chunk: string | Uint8Array, encodingOrCb?: string | (() => void), cb?: () => void): boolean;
+    _write(_chunk: unknown, _encoding: string, callback: () => void): void;
+    end(chunkOrCb?: unknown, encodingOrCb?: string | (() => void), cb?: () => void): this;
+    destroy(): this;
+}
+export declare class Duplex extends Readable {
+    writable: boolean;
+    writableEnded: boolean;
+    writableFinished: boolean;
+    write(chunk: string | Uint8Array, encodingOrCb?: string | (() => void), cb?: () => void): boolean;
+    _write(_chunk: unknown, _encoding: string, callback: () => void): void;
+    end(chunkOrCb?: unknown, encodingOrCb?: string | (() => void), cb?: () => void): this;
+}
+export declare class Transform extends Duplex {
+    _transform(chunk: unknown, _encoding: string, callback: (err?: Error | null, data?: unknown) => void): void;
+    _write(chunk: unknown, encoding: string, callback: () => void): void;
+}
+export declare class PassThrough extends Transform {
+}
+export declare function pipeline(...args: unknown[]): unknown;
+export declare function finished(stream: unknown, cb: (err?: Error) => void): () => void;
+export { BufferImpl as Buffer };
+export declare const bufferModule: {
+    Buffer: typeof BufferImpl;
+};
+export declare class Stream extends EventEmitter {
+    pipe<T extends Writable>(dest: T): T;
+}
+declare const streamModule: typeof Stream & {
+    Readable: typeof Readable;
+    Writable: typeof Writable;
+    Duplex: typeof Duplex;
+    Transform: typeof Transform;
+    PassThrough: typeof PassThrough;
+    pipeline: typeof pipeline;
+    finished: typeof finished;
+    Stream: typeof Stream;
+    Buffer: typeof BufferImpl;
+};
+export default streamModule;