initial commit

node_modules/unenv/runtime/node/stream/consumers/index.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.text = exports.json = exports.default = exports.buffer = exports.blob = exports.arrayBuffer = void 0;
+
+var _utils = require("../../../_internal/utils.cjs");
+
+const arrayBuffer = (0, _utils.notImplemented)("stream.consumers.arrayBuffer");
+exports.arrayBuffer = arrayBuffer;
+const blob = (0, _utils.notImplemented)("stream.consumers.blob");
+exports.blob = blob;
+const buffer = (0, _utils.notImplemented)("stream.consumers.buffer");
+exports.buffer = buffer;
+const text = (0, _utils.notImplemented)("stream.consumers.text");
+exports.text = text;
+const json = (0, _utils.notImplemented)("stream.consumers.json");
+exports.json = json;
+var _default = {
+  arrayBuffer,
+  blob,
+  buffer,
+  text,
+  json
+};
+module.exports = _default;

node_modules/unenv/runtime/node/stream/consumers/index.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import type * as stramConsumers from "node:stream/consumers";
+export declare const arrayBuffer: () => any;
+export declare const blob: () => any;
+export declare const buffer: () => any;
+export declare const text: () => any;
+export declare const json: () => any;
+declare const _default: typeof stramConsumers;
+export default _default;

node_modules/unenv/runtime/node/stream/consumers/index.mjs

@@ -0,0 +1,13 @@
+import { notImplemented } from "../../../_internal/utils.mjs";
+export const arrayBuffer = notImplemented("stream.consumers.arrayBuffer");
+export const blob = notImplemented("stream.consumers.blob");
+export const buffer = notImplemented("stream.consumers.buffer");
+export const text = notImplemented("stream.consumers.text");
+export const json = notImplemented("stream.consumers.json");
+export default {
+  arrayBuffer,
+  blob,
+  buffer,
+  text,
+  json
+};

node_modules/unenv/runtime/node/stream/duplex.cjs

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Duplex = void 0;
+
+var _utils = require("../../_internal/utils.cjs");
+
+var _readable = require("./readable.cjs");
+
+var _writable = require("./writable.cjs");
+
+const Duplex = class {
+  constructor(readable = new _readable.Readable(), writable = new _writable.Writable()) {
+    this.allowHalfOpen = true;
+    Object.assign(this, readable);
+    Object.assign(this, writable);
+    this._destroy = (0, _utils.mergeFns)(readable._destroy, writable._destroy);
+  }
+
+};
+exports.Duplex = Duplex;
+Object.assign(Duplex.prototype, _readable.Readable.prototype);
+Object.assign(Duplex.prototype, _writable.Writable.prototype);

node_modules/unenv/runtime/node/stream/duplex.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import type * as stream from "node:stream";
+declare type DuplexClass = new () => stream.Duplex;
+export declare const Duplex: DuplexClass;
+export {};

node_modules/unenv/runtime/node/stream/duplex.mjs

@@ -0,0 +1,13 @@
+import { mergeFns } from "../../_internal/utils.mjs";
+import { Readable } from "./readable.mjs";
+import { Writable } from "./writable.mjs";
+export const Duplex = class {
+  constructor(readable = new Readable(), writable = new Writable()) {
+    this.allowHalfOpen = true;
+    Object.assign(this, readable);
+    Object.assign(this, writable);
+    this._destroy = mergeFns(readable._destroy, writable._destroy);
+  }
+};
+Object.assign(Duplex.prototype, Readable.prototype);
+Object.assign(Duplex.prototype, Writable.prototype);

node_modules/unenv/runtime/node/stream/index.cjs

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Duplex", {
+  enumerable: true,
+  get: function () {
+    return _duplex.Duplex;
+  }
+});
+exports.PassThrough = void 0;
+Object.defineProperty(exports, "Readable", {
+  enumerable: true,
+  get: function () {
+    return _readable.Readable;
+  }
+});
+exports.Stream = void 0;
+Object.defineProperty(exports, "Transform", {
+  enumerable: true,
+  get: function () {
+    return _transform.Transform;
+  }
+});
+Object.defineProperty(exports, "Writable", {
+  enumerable: true,
+  get: function () {
+    return _writable.Writable;
+  }
+});
+exports.pipeline = exports.isReadable = exports.isErrored = exports.isDisturbed = exports.finished = exports.destroy = exports.default = exports.compose = exports.addAbortSignal = exports._uint8ArrayToBuffer = exports._isUint8Array = void 0;
+
+var _proxy = _interopRequireDefault(require("../../mock/proxy.cjs"));
+
+var _utils = require("../../_internal/utils.cjs");
+
+var _readable = require("./readable.cjs");
+
+var _writable = require("./writable.cjs");
+
+var _duplex = require("./duplex.cjs");
+
+var _transform = require("./transform.cjs");
+
+var _index = _interopRequireDefault(require("./promises/index.cjs"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const Stream = _proxy.default.__createMock__("Stream");
+
+exports.Stream = Stream;
+
+const PassThrough = _proxy.default.__createMock__("PassThrough");
+
+exports.PassThrough = PassThrough;
+const pipeline = (0, _utils.notImplemented)("stream.pipeline");
+exports.pipeline = pipeline;
+const finished = (0, _utils.notImplemented)("stream.finished");
+exports.finished = finished;
+const addAbortSignal = (0, _utils.notImplemented)("stream.addAbortSignal");
+exports.addAbortSignal = addAbortSignal;
+const isDisturbed = (0, _utils.notImplemented)("stream.isDisturbed");
+exports.isDisturbed = isDisturbed;
+const isReadable = (0, _utils.notImplemented)("stream.isReadable");
+exports.isReadable = isReadable;
+const compose = (0, _utils.notImplemented)("stream.compose");
+exports.compose = compose;
+const isErrored = (0, _utils.notImplemented)("stream.isErrored");
+exports.isErrored = isErrored;
+const destroy = (0, _utils.notImplemented)("stream.destroy");
+exports.destroy = destroy;
+
+const _isUint8Array = (0, _utils.notImplemented)("stream._isUint8Array");
+
+exports._isUint8Array = _isUint8Array;
+
+const _uint8ArrayToBuffer = (0, _utils.notImplemented)("stream._uint8ArrayToBuffer");
+
+exports._uint8ArrayToBuffer = _uint8ArrayToBuffer;
+var _default = {
+  Readable: _readable.Readable,
+  Writable: _writable.Writable,
+  Duplex: _duplex.Duplex,
+  Transform: _transform.Transform,
+  Stream,
+  PassThrough,
+  pipeline,
+  finished,
+  addAbortSignal,
+  promises: _index.default,
+  isDisturbed,
+  isReadable,
+  compose,
+  _uint8ArrayToBuffer,
+  isErrored,
+  destroy,
+  _isUint8Array
+};
+module.exports = _default;

node_modules/unenv/runtime/node/stream/index.d.ts

@@ -0,0 +1,19 @@
+import stream from "node:stream";
+export { Readable } from "./readable";
+export { Writable } from "./writable";
+export { Duplex } from "./duplex";
+export { Transform } from "./transform";
+export declare const Stream: stream.Stream;
+export declare const PassThrough: stream.PassThrough;
+export declare const pipeline: typeof stream.pipeline;
+export declare const finished: typeof stream.finished;
+export declare const addAbortSignal: typeof stream.addAbortSignal;
+export declare const isDisturbed: () => any;
+export declare const isReadable: () => any;
+export declare const compose: () => any;
+export declare const isErrored: () => any;
+export declare const destroy: () => any;
+export declare const _isUint8Array: () => any;
+export declare const _uint8ArrayToBuffer: () => any;
+declare const _default: any;
+export default _default;

node_modules/unenv/runtime/node/stream/index.mjs

@@ -0,0 +1,42 @@
+import mock from "../../mock/proxy.mjs";
+import { notImplemented } from "../../_internal/utils.mjs";
+import { Readable } from "./readable.mjs";
+import { Writable } from "./writable.mjs";
+import { Duplex } from "./duplex.mjs";
+import { Transform } from "./transform.mjs";
+import promises from "./promises/index.mjs";
+export { Readable } from "./readable.mjs";
+export { Writable } from "./writable.mjs";
+export { Duplex } from "./duplex.mjs";
+export { Transform } from "./transform.mjs";
+export const Stream = mock.__createMock__("Stream");
+export const PassThrough = mock.__createMock__("PassThrough");
+export const pipeline = notImplemented("stream.pipeline");
+export const finished = notImplemented("stream.finished");
+export const addAbortSignal = notImplemented("stream.addAbortSignal");
+export const isDisturbed = notImplemented("stream.isDisturbed");
+export const isReadable = notImplemented("stream.isReadable");
+export const compose = notImplemented("stream.compose");
+export const isErrored = notImplemented("stream.isErrored");
+export const destroy = notImplemented("stream.destroy");
+export const _isUint8Array = notImplemented("stream._isUint8Array");
+export const _uint8ArrayToBuffer = notImplemented("stream._uint8ArrayToBuffer");
+export default {
+  Readable,
+  Writable,
+  Duplex,
+  Transform,
+  Stream,
+  PassThrough,
+  pipeline,
+  finished,
+  addAbortSignal,
+  promises,
+  isDisturbed,
+  isReadable,
+  compose,
+  _uint8ArrayToBuffer,
+  isErrored,
+  destroy,
+  _isUint8Array
+};

node_modules/unenv/runtime/node/stream/promises/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pipeline = exports.finished = exports.default = void 0;
+
+var _utils = require("../../../_internal/utils.cjs");
+
+const finished = (0, _utils.notImplemented)("stream.promises.finished");
+exports.finished = finished;
+const pipeline = (0, _utils.notImplemented)("stream.promises.pipeline");
+exports.pipeline = pipeline;
+var _default = {
+  finished,
+  pipeline
+};
+module.exports = _default;

node_modules/unenv/runtime/node/stream/promises/index.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import type * as stramPromises from "node:stream/promises";
+export declare const finished: () => any;
+export declare const pipeline: () => any;
+declare const _default: typeof stramPromises;
+export default _default;

node_modules/unenv/runtime/node/stream/promises/index.mjs

@@ -0,0 +1,7 @@
+import { notImplemented } from "../../../_internal/utils.mjs";
+export const finished = notImplemented("stream.promises.finished");
+export const pipeline = notImplemented("stream.promises.pipeline");
+export default {
+  finished,
+  pipeline
+};

node_modules/unenv/runtime/node/stream/readable.cjs

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Readable = void 0;
+
+var _nodeEvents = require("node:events");
+
+class Readable extends _nodeEvents.EventEmitter {
+  constructor(_opts) {
+    super();
+    this.readableEncoding = null;
+    this.readableEnded = true;
+    this.readableFlowing = false;
+    this.readableHighWaterMark = 0;
+    this.readableLength = 0;
+    this.readableObjectMode = false;
+    this.readableAborted = false;
+    this.readableDidRead = false;
+    this.readable = false;
+    this.destroyed = false;
+  }
+
+  static from(_iterable, options) {
+    return new Readable(options);
+  }
+
+  _read(_size) {}
+
+  read(_size) {}
+
+  setEncoding(_encoding) {
+    return this;
+  }
+
+  pause() {
+    return this;
+  }
+
+  resume() {
+    return this;
+  }
+
+  isPaused() {
+    return true;
+  }
+
+  unpipe(_destination) {
+    return this;
+  }
+
+  unshift(_chunk, _encoding) {}
+
+  wrap(_oldStream) {
+    return this;
+  }
+
+  push(_chunk, _encoding) {
+    return false;
+  }
+
+  _destroy(_error, _callback) {
+    this.removeAllListeners();
+  }
+
+  destroy(error) {
+    this.destroyed = true;
+
+    this._destroy(error);
+
+    return this;
+  }
+
+  pipe(_destenition, _options) {
+    return {};
+  }
+
+  async *[Symbol.asyncIterator]() {}
+
+}
+
+exports.Readable = Readable;

node_modules/unenv/runtime/node/stream/readable.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from "node:events";
+import type * as stream from "node:stream";
+import type { BufferEncoding, Callback } from "../../_internal/types";
+export declare class Readable extends EventEmitter implements stream.Readable {
+    readonly readableEncoding: BufferEncoding | null;
+    readonly readableEnded: boolean;
+    readonly readableFlowing: boolean | null;
+    readonly readableHighWaterMark: number;
+    readonly readableLength: number;
+    readonly readableObjectMode: boolean;
+    readonly readableAborted: boolean;
+    readonly readableDidRead: boolean;
+    readable: boolean;
+    destroyed: boolean;
+    static from(_iterable: Iterable<any> | AsyncIterable<any>, options?: stream.ReadableOptions): Readable;
+    constructor(_opts?: stream.ReadableOptions);
+    _read(_size: number): void;
+    read(_size?: number): void;
+    setEncoding(_encoding: BufferEncoding): this;
+    pause(): this;
+    resume(): this;
+    isPaused(): boolean;
+    unpipe(_destination?: any): this;
+    unshift(_chunk: any, _encoding?: BufferEncoding): void;
+    wrap(_oldStream: any): this;
+    push(_chunk: any, _encoding?: BufferEncoding): boolean;
+    _destroy(_error?: any, _callback?: Callback<any>): void;
+    destroy(error?: Error): this;
+    pipe<T>(_destenition: T, _options?: {
+        end?: boolean;
+    }): T;
+    [Symbol.asyncIterator](): AsyncIterableIterator<any>;
+}

node_modules/unenv/runtime/node/stream/readable.mjs

@@ -0,0 +1,59 @@
+import { EventEmitter } from "node:events";
+export class Readable extends EventEmitter {
+  constructor(_opts) {
+    super();
+    this.readableEncoding = null;
+    this.readableEnded = true;
+    this.readableFlowing = false;
+    this.readableHighWaterMark = 0;
+    this.readableLength = 0;
+    this.readableObjectMode = false;
+    this.readableAborted = false;
+    this.readableDidRead = false;
+    this.readable = false;
+    this.destroyed = false;
+  }
+  static from(_iterable, options) {
+    return new Readable(options);
+  }
+  _read(_size) {
+  }
+  read(_size) {
+  }
+  setEncoding(_encoding) {
+    return this;
+  }
+  pause() {
+    return this;
+  }
+  resume() {
+    return this;
+  }
+  isPaused() {
+    return true;
+  }
+  unpipe(_destination) {
+    return this;
+  }
+  unshift(_chunk, _encoding) {
+  }
+  wrap(_oldStream) {
+    return this;
+  }
+  push(_chunk, _encoding) {
+    return false;
+  }
+  _destroy(_error, _callback) {
+    this.removeAllListeners();
+  }
+  destroy(error) {
+    this.destroyed = true;
+    this._destroy(error);
+    return this;
+  }
+  pipe(_destenition, _options) {
+    return {};
+  }
+  async *[Symbol.asyncIterator]() {
+  }
+}

node_modules/unenv/runtime/node/stream/transform.cjs

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Transform = void 0;
+
+var _duplex = require("./duplex.cjs");
+
+class Transform extends _duplex.Duplex {
+  _transform(chunk, encoding, callback) {}
+
+  _flush(callback) {}
+
+}
+
+exports.Transform = Transform;

node_modules/unenv/runtime/node/stream/transform.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type * as stream from "node:stream";
+import { Duplex } from "./duplex";
+export declare class Transform extends Duplex implements stream.Transform {
+    _transform(chunk: any, encoding: globalThis.BufferEncoding, callback: stream.TransformCallback): void;
+    _flush(callback: stream.TransformCallback): void;
+}

node_modules/unenv/runtime/node/stream/transform.mjs

@@ -0,0 +1,7 @@
+import { Duplex } from "./duplex.mjs";
+export class Transform extends Duplex {
+  _transform(chunk, encoding, callback) {
+  }
+  _flush(callback) {
+  }
+}

node_modules/unenv/runtime/node/stream/web/index.cjs

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = exports.WritableStreamDefaultWriter = exports.WritableStreamDefaultController = exports.WritableStream = exports.TransformStreamDefaultController = exports.TransformStream = exports.TextEncoderStream = exports.TextDecoderStream = exports.ReadableStreamDefaultReader = exports.ReadableStreamDefaultController = exports.ReadableStreamBYOBRequest = exports.ReadableStreamBYOBReader = exports.ReadableStream = exports.ReadableByteStreamController = exports.CountQueuingStrategy = exports.ByteLengthQueuingStrategy = void 0;
+
+var _utils = require("../../../_internal/utils.cjs");
+
+const ReadableStream = globalThis.ReadableStream || (0, _utils.notImplemented)("stream.web.ReadableStream");
+exports.ReadableStream = ReadableStream;
+const ReadableStreamDefaultReader = globalThis.ReadableStreamDefaultReader || (0, _utils.notImplemented)("stream.web.ReadableStreamDefaultReader");
+exports.ReadableStreamDefaultReader = ReadableStreamDefaultReader;
+const ReadableStreamBYOBReader = globalThis.ReadableStreamBYOBReader || (0, _utils.notImplemented)("stream.web.ReadableStreamBYOBReader");
+exports.ReadableStreamBYOBReader = ReadableStreamBYOBReader;
+const ReadableStreamBYOBRequest = globalThis.ReadableStreamBYOBRequest || (0, _utils.notImplemented)("stream.web.ReadableStreamBYOBRequest");
+exports.ReadableStreamBYOBRequest = ReadableStreamBYOBRequest;
+const ReadableByteStreamController = globalThis.ReadableByteStreamController || (0, _utils.notImplemented)("stream.web.ReadableByteStreamController");
+exports.ReadableByteStreamController = ReadableByteStreamController;
+const ReadableStreamDefaultController = globalThis.ReadableStreamDefaultController || (0, _utils.notImplemented)("stream.web.ReadableStreamDefaultController");
+exports.ReadableStreamDefaultController = ReadableStreamDefaultController;
+const TransformStream = globalThis.TransformStream || (0, _utils.notImplemented)("stream.web.TransformStream");
+exports.TransformStream = TransformStream;
+const TransformStreamDefaultController = globalThis.TransformStreamDefaultController || (0, _utils.notImplemented)("stream.web.TransformStreamDefaultController");
+exports.TransformStreamDefaultController = TransformStreamDefaultController;
+const WritableStream = globalThis.WritableStream || (0, _utils.notImplemented)("stream.web.WritableStream");
+exports.WritableStream = WritableStream;
+const WritableStreamDefaultWriter = globalThis.WritableStreamDefaultWriter || (0, _utils.notImplemented)("stream.web.WritableStreamDefaultWriter");
+exports.WritableStreamDefaultWriter = WritableStreamDefaultWriter;
+const WritableStreamDefaultController = globalThis.WritableStreamDefaultController || (0, _utils.notImplemented)("stream.web.WritableStreamDefaultController");
+exports.WritableStreamDefaultController = WritableStreamDefaultController;
+const ByteLengthQueuingStrategy = globalThis.ByteLengthQueuingStrategy || (0, _utils.notImplemented)("stream.web.ByteLengthQueuingStrategy");
+exports.ByteLengthQueuingStrategy = ByteLengthQueuingStrategy;
+const CountQueuingStrategy = globalThis.CountQueuingStrategy || (0, _utils.notImplemented)("stream.web.CountQueuingStrategy");
+exports.CountQueuingStrategy = CountQueuingStrategy;
+const TextEncoderStream = globalThis.TextEncoderStream || (0, _utils.notImplemented)("stream.web.TextEncoderStream");
+exports.TextEncoderStream = TextEncoderStream;
+const TextDecoderStream = globalThis.TextDecoderStream || (0, _utils.notImplemented)("stream.web.TextDecoderStream");
+exports.TextDecoderStream = TextDecoderStream;
+var _default = {
+  ReadableStream,
+  ReadableStreamDefaultReader,
+  ReadableStreamBYOBReader,
+  ReadableStreamBYOBRequest,
+  ReadableByteStreamController,
+  ReadableStreamDefaultController,
+  TransformStream,
+  TransformStreamDefaultController,
+  WritableStream,
+  WritableStreamDefaultWriter,
+  WritableStreamDefaultController,
+  ByteLengthQueuingStrategy,
+  CountQueuingStrategy,
+  TextEncoderStream,
+  TextDecoderStream
+};
+module.exports = _default;

node_modules/unenv/runtime/node/stream/web/index.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import type * as stramWeb from "node:stream/web";
+export declare const ReadableStream: (() => any) | {
+    new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
+    prototype: ReadableStream<any>;
+};
+export declare const ReadableStreamDefaultReader: (() => any) | {
+    new <R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
+    prototype: ReadableStreamDefaultReader<any>;
+};
+export declare const ReadableStreamBYOBReader: (() => any) | {
+    new (stream: ReadableStream<any>): ReadableStreamBYOBReader;
+    prototype: ReadableStreamBYOBReader;
+};
+export declare const ReadableStreamBYOBRequest: (() => any) | {
+    new (): ReadableStreamBYOBRequest;
+    prototype: ReadableStreamBYOBRequest;
+};
+export declare const ReadableByteStreamController: (() => any) | {
+    new (): ReadableByteStreamController;
+    prototype: ReadableByteStreamController;
+};
+export declare const ReadableStreamDefaultController: (() => any) | {
+    new (): ReadableStreamDefaultController<any>;
+    prototype: ReadableStreamDefaultController<any>;
+};
+export declare const TransformStream: (() => any) | {
+    new <I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
+    prototype: TransformStream<any, any>;
+};
+export declare const TransformStreamDefaultController: (() => any) | {
+    new (): TransformStreamDefaultController<any>;
+    prototype: TransformStreamDefaultController<any>;
+};
+export declare const WritableStream: (() => any) | {
+    new <W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
+    prototype: WritableStream<any>;
+};
+export declare const WritableStreamDefaultWriter: (() => any) | {
+    new <W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
+    prototype: WritableStreamDefaultWriter<any>;
+};
+export declare const WritableStreamDefaultController: (() => any) | {
+    new (): WritableStreamDefaultController;
+    prototype: WritableStreamDefaultController;
+};
+export declare const ByteLengthQueuingStrategy: (() => any) | {
+    new (init: QueuingStrategyInit): ByteLengthQueuingStrategy;
+    prototype: ByteLengthQueuingStrategy;
+};
+export declare const CountQueuingStrategy: (() => any) | {
+    new (init: QueuingStrategyInit): CountQueuingStrategy;
+    prototype: CountQueuingStrategy;
+};
+export declare const TextEncoderStream: (() => any) | {
+    new (): TextEncoderStream;
+    prototype: TextEncoderStream;
+};
+export declare const TextDecoderStream: (() => any) | {
+    new (label?: string, options?: TextDecoderOptions): TextDecoderStream;
+    prototype: TextDecoderStream;
+};
+declare const _default: typeof stramWeb;
+export default _default;

node_modules/unenv/runtime/node/stream/web/index.mjs

@@ -0,0 +1,33 @@
+import { notImplemented } from "../../../_internal/utils.mjs";
+export const ReadableStream = globalThis.ReadableStream || notImplemented("stream.web.ReadableStream");
+export const ReadableStreamDefaultReader = globalThis.ReadableStreamDefaultReader || notImplemented("stream.web.ReadableStreamDefaultReader");
+export const ReadableStreamBYOBReader = globalThis.ReadableStreamBYOBReader || notImplemented("stream.web.ReadableStreamBYOBReader");
+export const ReadableStreamBYOBRequest = globalThis.ReadableStreamBYOBRequest || notImplemented("stream.web.ReadableStreamBYOBRequest");
+export const ReadableByteStreamController = globalThis.ReadableByteStreamController || notImplemented("stream.web.ReadableByteStreamController");
+export const ReadableStreamDefaultController = globalThis.ReadableStreamDefaultController || notImplemented("stream.web.ReadableStreamDefaultController");
+export const TransformStream = globalThis.TransformStream || notImplemented("stream.web.TransformStream");
+export const TransformStreamDefaultController = globalThis.TransformStreamDefaultController || notImplemented("stream.web.TransformStreamDefaultController");
+export const WritableStream = globalThis.WritableStream || notImplemented("stream.web.WritableStream");
+export const WritableStreamDefaultWriter = globalThis.WritableStreamDefaultWriter || notImplemented("stream.web.WritableStreamDefaultWriter");
+export const WritableStreamDefaultController = globalThis.WritableStreamDefaultController || notImplemented("stream.web.WritableStreamDefaultController");
+export const ByteLengthQueuingStrategy = globalThis.ByteLengthQueuingStrategy || notImplemented("stream.web.ByteLengthQueuingStrategy");
+export const CountQueuingStrategy = globalThis.CountQueuingStrategy || notImplemented("stream.web.CountQueuingStrategy");
+export const TextEncoderStream = globalThis.TextEncoderStream || notImplemented("stream.web.TextEncoderStream");
+export const TextDecoderStream = globalThis.TextDecoderStream || notImplemented("stream.web.TextDecoderStream");
+export default {
+  ReadableStream,
+  ReadableStreamDefaultReader,
+  ReadableStreamBYOBReader,
+  ReadableStreamBYOBRequest,
+  ReadableByteStreamController,
+  ReadableStreamDefaultController,
+  TransformStream,
+  TransformStreamDefaultController,
+  WritableStream,
+  WritableStreamDefaultWriter,
+  WritableStreamDefaultController,
+  ByteLengthQueuingStrategy,
+  CountQueuingStrategy,
+  TextEncoderStream,
+  TextDecoderStream
+};

node_modules/unenv/runtime/node/stream/writable.cjs

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Writable = void 0;
+
+var _nodeEvents = require("node:events");
+
+class Writable extends _nodeEvents.EventEmitter {
+  constructor(_opts) {
+    super();
+    this.writable = true;
+    this.writableEnded = false;
+    this.writableFinished = false;
+    this.writableHighWaterMark = 0;
+    this.writableLength = 0;
+    this.writableObjectMode = false;
+    this.writableCorked = 0;
+    this.destroyed = false;
+    this._encoding = "utf-8";
+  }
+
+  pipe(_destenition, _options) {
+    return {};
+  }
+
+  _write(chunk, encoding, callback) {
+    this._data = chunk;
+    this._encoding = encoding;
+
+    if (callback) {
+      callback();
+    }
+  }
+
+  _writev(_chunks, _callback) {}
+
+  _destroy(_error, _callback) {}
+
+  _final(_callback) {}
+
+  write(chunk, arg2, arg3) {
+    const encoding = typeof arg2 === "string" ? this._encoding : "utf-8";
+    const cb = typeof arg2 === "function" ? arg2 : typeof arg3 === "function" ? arg3 : void 0;
+
+    this._write(chunk, encoding, cb);
+
+    return true;
+  }
+
+  setDefaultEncoding(_encoding) {
+    return this;
+  }
+
+  end(arg1, arg2, arg3) {
+    const cb = typeof arg1 === "function" ? arg1 : typeof arg2 === "function" ? arg2 : typeof arg3 === "function" ? arg3 : void 0;
+    const data = arg1 !== cb ? arg1 : void 0;
+
+    if (data) {
+      const encoding = arg2 !== cb ? arg2 : void 0;
+      this.write(data, encoding, cb);
+    }
+
+    this.writableEnded = true;
+    this.writableFinished = true;
+    this.emit("close");
+    this.emit("finish");
+    return this;
+  }
+
+  cork() {}
+
+  uncork() {}
+
+  destroy(_error) {
+    this.destroyed = true;
+    delete this._data;
+    this.removeAllListeners();
+    return this;
+  }
+
+}
+
+exports.Writable = Writable;

node_modules/unenv/runtime/node/stream/writable.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from "node:events";
+import type * as stream from "node:stream";
+import type { BufferEncoding, Callback } from "../../_internal/types";
+export declare class Writable extends EventEmitter implements stream.Writable {
+    readonly writable: boolean;
+    writableEnded: boolean;
+    writableFinished: boolean;
+    readonly writableHighWaterMark: number;
+    readonly writableLength: number;
+    readonly writableObjectMode: boolean;
+    readonly writableCorked: number;
+    destroyed: boolean;
+    _data: unknown;
+    _encoding: BufferEncoding;
+    constructor(_opts?: stream.WritableOptions);
+    pipe<T>(_destenition: T, _options?: {
+        end?: boolean;
+    }): T;
+    _write(chunk: any, encoding: BufferEncoding, callback?: Callback): void;
+    _writev?(_chunks: Array<{
+        chunk: any;
+        encoding: BufferEncoding;
+    }>, _callback: (error?: Error | null) => void): void;
+    _destroy(_error: any, _callback: Callback<any>): void;
+    _final(_callback: Callback): void;
+    write(chunk: any, arg2?: BufferEncoding | Callback, arg3?: Callback): boolean;
+    setDefaultEncoding(_encoding: BufferEncoding): this;
+    end(arg1: Callback | any, arg2?: Callback | BufferEncoding, arg3?: Callback): this;
+    cork(): void;
+    uncork(): void;
+    destroy(_error?: Error): this;
+}

node_modules/unenv/runtime/node/stream/writable.mjs

@@ -0,0 +1,63 @@
+import { EventEmitter } from "node:events";
+export class Writable extends EventEmitter {
+  constructor(_opts) {
+    super();
+    this.writable = true;
+    this.writableEnded = false;
+    this.writableFinished = false;
+    this.writableHighWaterMark = 0;
+    this.writableLength = 0;
+    this.writableObjectMode = false;
+    this.writableCorked = 0;
+    this.destroyed = false;
+    this._encoding = "utf-8";
+  }
+  pipe(_destenition, _options) {
+    return {};
+  }
+  _write(chunk, encoding, callback) {
+    this._data = chunk;
+    this._encoding = encoding;
+    if (callback) {
+      callback();
+    }
+  }
+  _writev(_chunks, _callback) {
+  }
+  _destroy(_error, _callback) {
+  }
+  _final(_callback) {
+  }
+  write(chunk, arg2, arg3) {
+    const encoding = typeof arg2 === "string" ? this._encoding : "utf-8";
+    const cb = typeof arg2 === "function" ? arg2 : typeof arg3 === "function" ? arg3 : void 0;
+    this._write(chunk, encoding, cb);
+    return true;
+  }
+  setDefaultEncoding(_encoding) {
+    return this;
+  }
+  end(arg1, arg2, arg3) {
+    const cb = typeof arg1 === "function" ? arg1 : typeof arg2 === "function" ? arg2 : typeof arg3 === "function" ? arg3 : void 0;
+    const data = arg1 !== cb ? arg1 : void 0;
+    if (data) {
+      const encoding = arg2 !== cb ? arg2 : void 0;
+      this.write(data, encoding, cb);
+    }
+    this.writableEnded = true;
+    this.writableFinished = true;
+    this.emit("close");
+    this.emit("finish");
+    return this;
+  }
+  cork() {
+  }
+  uncork() {
+  }
+  destroy(_error) {
+    this.destroyed = true;
+    delete this._data;
+    this.removeAllListeners();
+    return this;
+  }
+}