chaite
Version:
core for chatgpt-plugin and karin-plugin-chatgpt
1,122 lines (1,119 loc) • 170 kB
JavaScript
import { i as __require, n as __esm, s as __toESM, t as __commonJS } from "../../rolldown-runtime-DVriDoez.mjs";
import { createReadStream, promises } from "node:fs";
//#region node_modules/.pnpm/node-domexception@1.0.0/node_modules/node-domexception/index.js
var require_node_domexception = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/node-domexception@1.0.0/node_modules/node-domexception/index.js": ((exports, module) => {
/*! node-domexception. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
if (!globalThis.DOMException) try {
const { MessageChannel } = __require("worker_threads"), port = new MessageChannel().port1, ab = /* @__PURE__ */ new ArrayBuffer();
port.postMessage(ab, [ab, ab]);
} catch (err) {
err.constructor.name === "DOMException" && (globalThis.DOMException = err.constructor);
}
module.exports = globalThis.DOMException;
}) });
//#endregion
//#region node_modules/.pnpm/web-streams-polyfill@3.3.3/node_modules/web-streams-polyfill/dist/ponyfill.es2018.js
var require_ponyfill_es2018 = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/web-streams-polyfill@3.3.3/node_modules/web-streams-polyfill/dist/ponyfill.es2018.js": ((exports, module) => {
/**
* @license
* web-streams-polyfill v3.3.3
* Copyright 2024 Mattias Buelens, Diwank Singh Tomer and other contributors.
* This code is released under the MIT license.
* SPDX-License-Identifier: MIT
*/
(function(global$1, factory) {
typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global$1 = typeof globalThis !== "undefined" ? globalThis : global$1 || self, factory(global$1.WebStreamsPolyfill = {}));
})(exports, (function(exports$1) {
function noop() {}
function typeIsObject(x) {
return typeof x === "object" && x !== null || typeof x === "function";
}
const rethrowAssertionErrorRejection = noop;
function setFunctionName(fn, name) {
try {
Object.defineProperty(fn, "name", {
value: name,
configurable: true
});
} catch (_a$1) {}
}
const originalPromise = Promise;
const originalPromiseThen = Promise.prototype.then;
const originalPromiseReject = Promise.reject.bind(originalPromise);
function newPromise(executor) {
return new originalPromise(executor);
}
function promiseResolvedWith(value) {
return newPromise((resolve$1) => resolve$1(value));
}
function promiseRejectedWith(reason) {
return originalPromiseReject(reason);
}
function PerformPromiseThen(promise, onFulfilled, onRejected) {
return originalPromiseThen.call(promise, onFulfilled, onRejected);
}
function uponPromise(promise, onFulfilled, onRejected) {
PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), void 0, rethrowAssertionErrorRejection);
}
function uponFulfillment(promise, onFulfilled) {
uponPromise(promise, onFulfilled);
}
function uponRejection(promise, onRejected) {
uponPromise(promise, void 0, onRejected);
}
function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) {
return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler);
}
function setPromiseIsHandledToTrue(promise) {
PerformPromiseThen(promise, void 0, rethrowAssertionErrorRejection);
}
let _queueMicrotask = (callback) => {
if (typeof queueMicrotask === "function") _queueMicrotask = queueMicrotask;
else {
const resolvedPromise = promiseResolvedWith(void 0);
_queueMicrotask = (cb) => PerformPromiseThen(resolvedPromise, cb);
}
return _queueMicrotask(callback);
};
function reflectCall(F, V, args) {
if (typeof F !== "function") throw new TypeError("Argument is not a function");
return Function.prototype.apply.call(F, V, args);
}
function promiseCall(F, V, args) {
try {
return promiseResolvedWith(reflectCall(F, V, args));
} catch (value) {
return promiseRejectedWith(value);
}
}
const QUEUE_MAX_ARRAY_SIZE = 16384;
/**
* Simple queue structure.
*
* Avoids scalability issues with using a packed array directly by using
* multiple arrays in a linked list and keeping the array size bounded.
*/
class SimpleQueue {
constructor() {
this._cursor = 0;
this._size = 0;
this._front = {
_elements: [],
_next: void 0
};
this._back = this._front;
this._cursor = 0;
this._size = 0;
}
get length() {
return this._size;
}
push(element) {
const oldBack = this._back;
let newBack = oldBack;
if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) newBack = {
_elements: [],
_next: void 0
};
oldBack._elements.push(element);
if (newBack !== oldBack) {
this._back = newBack;
oldBack._next = newBack;
}
++this._size;
}
shift() {
const oldFront = this._front;
let newFront = oldFront;
const oldCursor = this._cursor;
let newCursor = oldCursor + 1;
const elements = oldFront._elements;
const element = elements[oldCursor];
if (newCursor === QUEUE_MAX_ARRAY_SIZE) {
newFront = oldFront._next;
newCursor = 0;
}
--this._size;
this._cursor = newCursor;
if (oldFront !== newFront) this._front = newFront;
elements[oldCursor] = void 0;
return element;
}
forEach(callback) {
let i = this._cursor;
let node = this._front;
let elements = node._elements;
while (i !== elements.length || node._next !== void 0) {
if (i === elements.length) {
node = node._next;
elements = node._elements;
i = 0;
if (elements.length === 0) break;
}
callback(elements[i]);
++i;
}
}
peek() {
const front = this._front;
const cursor = this._cursor;
return front._elements[cursor];
}
}
const AbortSteps = Symbol("[[AbortSteps]]");
const ErrorSteps = Symbol("[[ErrorSteps]]");
const CancelSteps = Symbol("[[CancelSteps]]");
const PullSteps = Symbol("[[PullSteps]]");
const ReleaseSteps = Symbol("[[ReleaseSteps]]");
function ReadableStreamReaderGenericInitialize(reader, stream) {
reader._ownerReadableStream = stream;
stream._reader = reader;
if (stream._state === "readable") defaultReaderClosedPromiseInitialize(reader);
else if (stream._state === "closed") defaultReaderClosedPromiseInitializeAsResolved(reader);
else defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
}
function ReadableStreamReaderGenericCancel(reader, reason) {
const stream = reader._ownerReadableStream;
return ReadableStreamCancel(stream, reason);
}
function ReadableStreamReaderGenericRelease(reader) {
const stream = reader._ownerReadableStream;
if (stream._state === "readable") defaultReaderClosedPromiseReject(reader, /* @__PURE__ */ new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
else defaultReaderClosedPromiseResetToRejected(reader, /* @__PURE__ */ new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
stream._readableStreamController[ReleaseSteps]();
stream._reader = void 0;
reader._ownerReadableStream = void 0;
}
function readerLockException(name) {
return /* @__PURE__ */ new TypeError("Cannot " + name + " a stream using a released reader");
}
function defaultReaderClosedPromiseInitialize(reader) {
reader._closedPromise = newPromise((resolve$1, reject) => {
reader._closedPromise_resolve = resolve$1;
reader._closedPromise_reject = reject;
});
}
function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
defaultReaderClosedPromiseInitialize(reader);
defaultReaderClosedPromiseReject(reader, reason);
}
function defaultReaderClosedPromiseInitializeAsResolved(reader) {
defaultReaderClosedPromiseInitialize(reader);
defaultReaderClosedPromiseResolve(reader);
}
function defaultReaderClosedPromiseReject(reader, reason) {
if (reader._closedPromise_reject === void 0) return;
setPromiseIsHandledToTrue(reader._closedPromise);
reader._closedPromise_reject(reason);
reader._closedPromise_resolve = void 0;
reader._closedPromise_reject = void 0;
}
function defaultReaderClosedPromiseResetToRejected(reader, reason) {
defaultReaderClosedPromiseInitializeAsRejected(reader, reason);
}
function defaultReaderClosedPromiseResolve(reader) {
if (reader._closedPromise_resolve === void 0) return;
reader._closedPromise_resolve(void 0);
reader._closedPromise_resolve = void 0;
reader._closedPromise_reject = void 0;
}
const NumberIsFinite = Number.isFinite || function(x) {
return typeof x === "number" && isFinite(x);
};
const MathTrunc = Math.trunc || function(v) {
return v < 0 ? Math.ceil(v) : Math.floor(v);
};
function isDictionary(x) {
return typeof x === "object" || typeof x === "function";
}
function assertDictionary(obj, context) {
if (obj !== void 0 && !isDictionary(obj)) throw new TypeError(`${context} is not an object.`);
}
function assertFunction(x, context) {
if (typeof x !== "function") throw new TypeError(`${context} is not a function.`);
}
function isObject(x) {
return typeof x === "object" && x !== null || typeof x === "function";
}
function assertObject(x, context) {
if (!isObject(x)) throw new TypeError(`${context} is not an object.`);
}
function assertRequiredArgument(x, position, context) {
if (x === void 0) throw new TypeError(`Parameter ${position} is required in '${context}'.`);
}
function assertRequiredField(x, field, context) {
if (x === void 0) throw new TypeError(`${field} is required in '${context}'.`);
}
function convertUnrestrictedDouble(value) {
return Number(value);
}
function censorNegativeZero(x) {
return x === 0 ? 0 : x;
}
function integerPart(x) {
return censorNegativeZero(MathTrunc(x));
}
function convertUnsignedLongLongWithEnforceRange(value, context) {
const lowerBound = 0;
const upperBound = Number.MAX_SAFE_INTEGER;
let x = Number(value);
x = censorNegativeZero(x);
if (!NumberIsFinite(x)) throw new TypeError(`${context} is not a finite number`);
x = integerPart(x);
if (x < lowerBound || x > upperBound) throw new TypeError(`${context} is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`);
if (!NumberIsFinite(x) || x === 0) return 0;
return x;
}
function assertReadableStream(x, context) {
if (!IsReadableStream(x)) throw new TypeError(`${context} is not a ReadableStream.`);
}
function AcquireReadableStreamDefaultReader(stream) {
return new ReadableStreamDefaultReader(stream);
}
function ReadableStreamAddReadRequest(stream, readRequest) {
stream._reader._readRequests.push(readRequest);
}
function ReadableStreamFulfillReadRequest(stream, chunk, done) {
const readRequest = stream._reader._readRequests.shift();
if (done) readRequest._closeSteps();
else readRequest._chunkSteps(chunk);
}
function ReadableStreamGetNumReadRequests(stream) {
return stream._reader._readRequests.length;
}
function ReadableStreamHasDefaultReader(stream) {
const reader = stream._reader;
if (reader === void 0) return false;
if (!IsReadableStreamDefaultReader(reader)) return false;
return true;
}
/**
* A default reader vended by a {@link ReadableStream}.
*
* @public
*/
class ReadableStreamDefaultReader {
constructor(stream) {
assertRequiredArgument(stream, 1, "ReadableStreamDefaultReader");
assertReadableStream(stream, "First parameter");
if (IsReadableStreamLocked(stream)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
ReadableStreamReaderGenericInitialize(this, stream);
this._readRequests = new SimpleQueue();
}
/**
* Returns a promise that will be fulfilled when the stream becomes closed,
* or rejected if the stream ever errors or the reader's lock is released before the stream finishes closing.
*/
get closed() {
if (!IsReadableStreamDefaultReader(this)) return promiseRejectedWith(defaultReaderBrandCheckException("closed"));
return this._closedPromise;
}
/**
* If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
*/
cancel(reason = void 0) {
if (!IsReadableStreamDefaultReader(this)) return promiseRejectedWith(defaultReaderBrandCheckException("cancel"));
if (this._ownerReadableStream === void 0) return promiseRejectedWith(readerLockException("cancel"));
return ReadableStreamReaderGenericCancel(this, reason);
}
/**
* Returns a promise that allows access to the next chunk from the stream's internal queue, if available.
*
* If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
*/
read() {
if (!IsReadableStreamDefaultReader(this)) return promiseRejectedWith(defaultReaderBrandCheckException("read"));
if (this._ownerReadableStream === void 0) return promiseRejectedWith(readerLockException("read from"));
let resolvePromise;
let rejectPromise;
const promise = newPromise((resolve$1, reject) => {
resolvePromise = resolve$1;
rejectPromise = reject;
});
ReadableStreamDefaultReaderRead(this, {
_chunkSteps: (chunk) => resolvePromise({
value: chunk,
done: false
}),
_closeSteps: () => resolvePromise({
value: void 0,
done: true
}),
_errorSteps: (e) => rejectPromise(e)
});
return promise;
}
/**
* Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
* If the associated stream is errored when the lock is released, the reader will appear errored in the same way
* from now on; otherwise, the reader will appear closed.
*
* A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
* the reader's {@link ReadableStreamDefaultReader.read | read()} method has not yet been settled. Attempting to
* do so will throw a `TypeError` and leave the reader locked to the stream.
*/
releaseLock() {
if (!IsReadableStreamDefaultReader(this)) throw defaultReaderBrandCheckException("releaseLock");
if (this._ownerReadableStream === void 0) return;
ReadableStreamDefaultReaderRelease(this);
}
}
Object.defineProperties(ReadableStreamDefaultReader.prototype, {
cancel: { enumerable: true },
read: { enumerable: true },
releaseLock: { enumerable: true },
closed: { enumerable: true }
});
setFunctionName(ReadableStreamDefaultReader.prototype.cancel, "cancel");
setFunctionName(ReadableStreamDefaultReader.prototype.read, "read");
setFunctionName(ReadableStreamDefaultReader.prototype.releaseLock, "releaseLock");
if (typeof Symbol.toStringTag === "symbol") Object.defineProperty(ReadableStreamDefaultReader.prototype, Symbol.toStringTag, {
value: "ReadableStreamDefaultReader",
configurable: true
});
function IsReadableStreamDefaultReader(x) {
if (!typeIsObject(x)) return false;
if (!Object.prototype.hasOwnProperty.call(x, "_readRequests")) return false;
return x instanceof ReadableStreamDefaultReader;
}
function ReadableStreamDefaultReaderRead(reader, readRequest) {
const stream = reader._ownerReadableStream;
stream._disturbed = true;
if (stream._state === "closed") readRequest._closeSteps();
else if (stream._state === "errored") readRequest._errorSteps(stream._storedError);
else stream._readableStreamController[PullSteps](readRequest);
}
function ReadableStreamDefaultReaderRelease(reader) {
ReadableStreamReaderGenericRelease(reader);
ReadableStreamDefaultReaderErrorReadRequests(reader, /* @__PURE__ */ new TypeError("Reader was released"));
}
function ReadableStreamDefaultReaderErrorReadRequests(reader, e) {
const readRequests = reader._readRequests;
reader._readRequests = new SimpleQueue();
readRequests.forEach((readRequest) => {
readRequest._errorSteps(e);
});
}
function defaultReaderBrandCheckException(name) {
return /* @__PURE__ */ new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);
}
const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {}).prototype);
class ReadableStreamAsyncIteratorImpl {
constructor(reader, preventCancel) {
this._ongoingPromise = void 0;
this._isFinished = false;
this._reader = reader;
this._preventCancel = preventCancel;
}
next() {
const nextSteps = () => this._nextSteps();
this._ongoingPromise = this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) : nextSteps();
return this._ongoingPromise;
}
return(value) {
const returnSteps = () => this._returnSteps(value);
return this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) : returnSteps();
}
_nextSteps() {
if (this._isFinished) return Promise.resolve({
value: void 0,
done: true
});
const reader = this._reader;
let resolvePromise;
let rejectPromise;
const promise = newPromise((resolve$1, reject) => {
resolvePromise = resolve$1;
rejectPromise = reject;
});
ReadableStreamDefaultReaderRead(reader, {
_chunkSteps: (chunk) => {
this._ongoingPromise = void 0;
_queueMicrotask(() => resolvePromise({
value: chunk,
done: false
}));
},
_closeSteps: () => {
this._ongoingPromise = void 0;
this._isFinished = true;
ReadableStreamReaderGenericRelease(reader);
resolvePromise({
value: void 0,
done: true
});
},
_errorSteps: (reason) => {
this._ongoingPromise = void 0;
this._isFinished = true;
ReadableStreamReaderGenericRelease(reader);
rejectPromise(reason);
}
});
return promise;
}
_returnSteps(value) {
if (this._isFinished) return Promise.resolve({
value,
done: true
});
this._isFinished = true;
const reader = this._reader;
if (!this._preventCancel) {
const result = ReadableStreamReaderGenericCancel(reader, value);
ReadableStreamReaderGenericRelease(reader);
return transformPromiseWith(result, () => ({
value,
done: true
}));
}
ReadableStreamReaderGenericRelease(reader);
return promiseResolvedWith({
value,
done: true
});
}
}
const ReadableStreamAsyncIteratorPrototype = {
next() {
if (!IsReadableStreamAsyncIterator(this)) return promiseRejectedWith(streamAsyncIteratorBrandCheckException("next"));
return this._asyncIteratorImpl.next();
},
return(value) {
if (!IsReadableStreamAsyncIterator(this)) return promiseRejectedWith(streamAsyncIteratorBrandCheckException("return"));
return this._asyncIteratorImpl.return(value);
}
};
Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
function AcquireReadableStreamAsyncIterator(stream, preventCancel) {
const impl = new ReadableStreamAsyncIteratorImpl(AcquireReadableStreamDefaultReader(stream), preventCancel);
const iterator = Object.create(ReadableStreamAsyncIteratorPrototype);
iterator._asyncIteratorImpl = impl;
return iterator;
}
function IsReadableStreamAsyncIterator(x) {
if (!typeIsObject(x)) return false;
if (!Object.prototype.hasOwnProperty.call(x, "_asyncIteratorImpl")) return false;
try {
return x._asyncIteratorImpl instanceof ReadableStreamAsyncIteratorImpl;
} catch (_a$1) {
return false;
}
}
function streamAsyncIteratorBrandCheckException(name) {
return /* @__PURE__ */ new TypeError(`ReadableStreamAsyncIterator.${name} can only be used on a ReadableSteamAsyncIterator`);
}
const NumberIsNaN = Number.isNaN || function(x) {
return x !== x;
};
var _a, _b, _c;
function CreateArrayFromList(elements) {
return elements.slice();
}
function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) {
new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
}
let TransferArrayBuffer = (O) => {
if (typeof O.transfer === "function") TransferArrayBuffer = (buffer) => buffer.transfer();
else if (typeof structuredClone === "function") TransferArrayBuffer = (buffer) => structuredClone(buffer, { transfer: [buffer] });
else TransferArrayBuffer = (buffer) => buffer;
return TransferArrayBuffer(O);
};
let IsDetachedBuffer = (O) => {
if (typeof O.detached === "boolean") IsDetachedBuffer = (buffer) => buffer.detached;
else IsDetachedBuffer = (buffer) => buffer.byteLength === 0;
return IsDetachedBuffer(O);
};
function ArrayBufferSlice(buffer, begin, end) {
if (buffer.slice) return buffer.slice(begin, end);
const length = end - begin;
const slice = new ArrayBuffer(length);
CopyDataBlockBytes(slice, 0, buffer, begin, length);
return slice;
}
function GetMethod(receiver, prop) {
const func = receiver[prop];
if (func === void 0 || func === null) return;
if (typeof func !== "function") throw new TypeError(`${String(prop)} is not a function`);
return func;
}
function CreateAsyncFromSyncIterator(syncIteratorRecord) {
const syncIterable = { [Symbol.iterator]: () => syncIteratorRecord.iterator };
const asyncIterator = async function* () {
return yield* syncIterable;
}();
return {
iterator: asyncIterator,
nextMethod: asyncIterator.next,
done: false
};
}
const SymbolAsyncIterator = (_c = (_a = Symbol.asyncIterator) !== null && _a !== void 0 ? _a : (_b = Symbol.for) === null || _b === void 0 ? void 0 : _b.call(Symbol, "Symbol.asyncIterator")) !== null && _c !== void 0 ? _c : "@@asyncIterator";
function GetIterator(obj, hint = "sync", method) {
if (method === void 0) if (hint === "async") {
method = GetMethod(obj, SymbolAsyncIterator);
if (method === void 0) return CreateAsyncFromSyncIterator(GetIterator(obj, "sync", GetMethod(obj, Symbol.iterator)));
} else method = GetMethod(obj, Symbol.iterator);
if (method === void 0) throw new TypeError("The object is not iterable");
const iterator = reflectCall(method, obj, []);
if (!typeIsObject(iterator)) throw new TypeError("The iterator method must return an object");
return {
iterator,
nextMethod: iterator.next,
done: false
};
}
function IteratorNext(iteratorRecord) {
const result = reflectCall(iteratorRecord.nextMethod, iteratorRecord.iterator, []);
if (!typeIsObject(result)) throw new TypeError("The iterator.next() method must return an object");
return result;
}
function IteratorComplete(iterResult) {
return Boolean(iterResult.done);
}
function IteratorValue(iterResult) {
return iterResult.value;
}
function IsNonNegativeNumber(v) {
if (typeof v !== "number") return false;
if (NumberIsNaN(v)) return false;
if (v < 0) return false;
return true;
}
function CloneAsUint8Array(O) {
const buffer = ArrayBufferSlice(O.buffer, O.byteOffset, O.byteOffset + O.byteLength);
return new Uint8Array(buffer);
}
function DequeueValue(container) {
const pair = container._queue.shift();
container._queueTotalSize -= pair.size;
if (container._queueTotalSize < 0) container._queueTotalSize = 0;
return pair.value;
}
function EnqueueValueWithSize(container, value, size) {
if (!IsNonNegativeNumber(size) || size === Infinity) throw new RangeError("Size must be a finite, non-NaN, non-negative number.");
container._queue.push({
value,
size
});
container._queueTotalSize += size;
}
function PeekQueueValue(container) {
return container._queue.peek().value;
}
function ResetQueue(container) {
container._queue = new SimpleQueue();
container._queueTotalSize = 0;
}
function isDataViewConstructor(ctor) {
return ctor === DataView;
}
function isDataView(view) {
return isDataViewConstructor(view.constructor);
}
function arrayBufferViewElementSize(ctor) {
if (isDataViewConstructor(ctor)) return 1;
return ctor.BYTES_PER_ELEMENT;
}
/**
* A pull-into request in a {@link ReadableByteStreamController}.
*
* @public
*/
class ReadableStreamBYOBRequest {
constructor() {
throw new TypeError("Illegal constructor");
}
/**
* Returns the view for writing in to, or `null` if the BYOB request has already been responded to.
*/
get view() {
if (!IsReadableStreamBYOBRequest(this)) throw byobRequestBrandCheckException("view");
return this._view;
}
respond(bytesWritten) {
if (!IsReadableStreamBYOBRequest(this)) throw byobRequestBrandCheckException("respond");
assertRequiredArgument(bytesWritten, 1, "respond");
bytesWritten = convertUnsignedLongLongWithEnforceRange(bytesWritten, "First parameter");
if (this._associatedReadableByteStreamController === void 0) throw new TypeError("This BYOB request has been invalidated");
if (IsDetachedBuffer(this._view.buffer)) throw new TypeError(`The BYOB request's buffer has been detached and so cannot be used as a response`);
ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);
}
respondWithNewView(view) {
if (!IsReadableStreamBYOBRequest(this)) throw byobRequestBrandCheckException("respondWithNewView");
assertRequiredArgument(view, 1, "respondWithNewView");
if (!ArrayBuffer.isView(view)) throw new TypeError("You can only respond with array buffer views");
if (this._associatedReadableByteStreamController === void 0) throw new TypeError("This BYOB request has been invalidated");
if (IsDetachedBuffer(view.buffer)) throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");
ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
}
}
Object.defineProperties(ReadableStreamBYOBRequest.prototype, {
respond: { enumerable: true },
respondWithNewView: { enumerable: true },
view: { enumerable: true }
});
setFunctionName(ReadableStreamBYOBRequest.prototype.respond, "respond");
setFunctionName(ReadableStreamBYOBRequest.prototype.respondWithNewView, "respondWithNewView");
if (typeof Symbol.toStringTag === "symbol") Object.defineProperty(ReadableStreamBYOBRequest.prototype, Symbol.toStringTag, {
value: "ReadableStreamBYOBRequest",
configurable: true
});
/**
* Allows control of a {@link ReadableStream | readable byte stream}'s state and internal queue.
*
* @public
*/
class ReadableByteStreamController {
constructor() {
throw new TypeError("Illegal constructor");
}
/**
* Returns the current BYOB pull request, or `null` if there isn't one.
*/
get byobRequest() {
if (!IsReadableByteStreamController(this)) throw byteStreamControllerBrandCheckException("byobRequest");
return ReadableByteStreamControllerGetBYOBRequest(this);
}
/**
* Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
* over-full. An underlying byte source ought to use this information to determine when and how to apply backpressure.
*/
get desiredSize() {
if (!IsReadableByteStreamController(this)) throw byteStreamControllerBrandCheckException("desiredSize");
return ReadableByteStreamControllerGetDesiredSize(this);
}
/**
* Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from
* the stream, but once those are read, the stream will become closed.
*/
close() {
if (!IsReadableByteStreamController(this)) throw byteStreamControllerBrandCheckException("close");
if (this._closeRequested) throw new TypeError("The stream has already been closed; do not close it again!");
const state = this._controlledReadableByteStream._state;
if (state !== "readable") throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be closed`);
ReadableByteStreamControllerClose(this);
}
enqueue(chunk) {
if (!IsReadableByteStreamController(this)) throw byteStreamControllerBrandCheckException("enqueue");
assertRequiredArgument(chunk, 1, "enqueue");
if (!ArrayBuffer.isView(chunk)) throw new TypeError("chunk must be an array buffer view");
if (chunk.byteLength === 0) throw new TypeError("chunk must have non-zero byteLength");
if (chunk.buffer.byteLength === 0) throw new TypeError(`chunk's buffer must have non-zero byteLength`);
if (this._closeRequested) throw new TypeError("stream is closed or draining");
const state = this._controlledReadableByteStream._state;
if (state !== "readable") throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be enqueued to`);
ReadableByteStreamControllerEnqueue(this, chunk);
}
/**
* Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
*/
error(e = void 0) {
if (!IsReadableByteStreamController(this)) throw byteStreamControllerBrandCheckException("error");
ReadableByteStreamControllerError(this, e);
}
/** @internal */
[CancelSteps](reason) {
ReadableByteStreamControllerClearPendingPullIntos(this);
ResetQueue(this);
const result = this._cancelAlgorithm(reason);
ReadableByteStreamControllerClearAlgorithms(this);
return result;
}
/** @internal */
[PullSteps](readRequest) {
const stream = this._controlledReadableByteStream;
if (this._queueTotalSize > 0) {
ReadableByteStreamControllerFillReadRequestFromQueue(this, readRequest);
return;
}
const autoAllocateChunkSize = this._autoAllocateChunkSize;
if (autoAllocateChunkSize !== void 0) {
let buffer;
try {
buffer = new ArrayBuffer(autoAllocateChunkSize);
} catch (bufferE) {
readRequest._errorSteps(bufferE);
return;
}
const pullIntoDescriptor = {
buffer,
bufferByteLength: autoAllocateChunkSize,
byteOffset: 0,
byteLength: autoAllocateChunkSize,
bytesFilled: 0,
minimumFill: 1,
elementSize: 1,
viewConstructor: Uint8Array,
readerType: "default"
};
this._pendingPullIntos.push(pullIntoDescriptor);
}
ReadableStreamAddReadRequest(stream, readRequest);
ReadableByteStreamControllerCallPullIfNeeded(this);
}
/** @internal */
[ReleaseSteps]() {
if (this._pendingPullIntos.length > 0) {
const firstPullInto = this._pendingPullIntos.peek();
firstPullInto.readerType = "none";
this._pendingPullIntos = new SimpleQueue();
this._pendingPullIntos.push(firstPullInto);
}
}
}
Object.defineProperties(ReadableByteStreamController.prototype, {
close: { enumerable: true },
enqueue: { enumerable: true },
error: { enumerable: true },
byobRequest: { enumerable: true },
desiredSize: { enumerable: true }
});
setFunctionName(ReadableByteStreamController.prototype.close, "close");
setFunctionName(ReadableByteStreamController.prototype.enqueue, "enqueue");
setFunctionName(ReadableByteStreamController.prototype.error, "error");
if (typeof Symbol.toStringTag === "symbol") Object.defineProperty(ReadableByteStreamController.prototype, Symbol.toStringTag, {
value: "ReadableByteStreamController",
configurable: true
});
function IsReadableByteStreamController(x) {
if (!typeIsObject(x)) return false;
if (!Object.prototype.hasOwnProperty.call(x, "_controlledReadableByteStream")) return false;
return x instanceof ReadableByteStreamController;
}
function IsReadableStreamBYOBRequest(x) {
if (!typeIsObject(x)) return false;
if (!Object.prototype.hasOwnProperty.call(x, "_associatedReadableByteStreamController")) return false;
return x instanceof ReadableStreamBYOBRequest;
}
function ReadableByteStreamControllerCallPullIfNeeded(controller) {
if (!ReadableByteStreamControllerShouldCallPull(controller)) return;
if (controller._pulling) {
controller._pullAgain = true;
return;
}
controller._pulling = true;
uponPromise(controller._pullAlgorithm(), () => {
controller._pulling = false;
if (controller._pullAgain) {
controller._pullAgain = false;
ReadableByteStreamControllerCallPullIfNeeded(controller);
}
return null;
}, (e) => {
ReadableByteStreamControllerError(controller, e);
return null;
});
}
function ReadableByteStreamControllerClearPendingPullIntos(controller) {
ReadableByteStreamControllerInvalidateBYOBRequest(controller);
controller._pendingPullIntos = new SimpleQueue();
}
function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {
let done = false;
if (stream._state === "closed") done = true;
const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
if (pullIntoDescriptor.readerType === "default") ReadableStreamFulfillReadRequest(stream, filledView, done);
else ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
}
function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {
const bytesFilled = pullIntoDescriptor.bytesFilled;
const elementSize = pullIntoDescriptor.elementSize;
return new pullIntoDescriptor.viewConstructor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize);
}
function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) {
controller._queue.push({
buffer,
byteOffset,
byteLength
});
controller._queueTotalSize += byteLength;
}
function ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, buffer, byteOffset, byteLength) {
let clonedChunk;
try {
clonedChunk = ArrayBufferSlice(buffer, byteOffset, byteOffset + byteLength);
} catch (cloneE) {
ReadableByteStreamControllerError(controller, cloneE);
throw cloneE;
}
ReadableByteStreamControllerEnqueueChunkToQueue(controller, clonedChunk, 0, byteLength);
}
function ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstDescriptor) {
if (firstDescriptor.bytesFilled > 0) ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, firstDescriptor.buffer, firstDescriptor.byteOffset, firstDescriptor.bytesFilled);
ReadableByteStreamControllerShiftPendingPullInto(controller);
}
function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {
const maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
const maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
let totalBytesToCopyRemaining = maxBytesToCopy;
let ready = false;
const maxAlignedBytes = maxBytesFilled - maxBytesFilled % pullIntoDescriptor.elementSize;
if (maxAlignedBytes >= pullIntoDescriptor.minimumFill) {
totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
ready = true;
}
const queue = controller._queue;
while (totalBytesToCopyRemaining > 0) {
const headOfQueue = queue.peek();
const bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength);
const destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
CopyDataBlockBytes(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy);
if (headOfQueue.byteLength === bytesToCopy) queue.shift();
else {
headOfQueue.byteOffset += bytesToCopy;
headOfQueue.byteLength -= bytesToCopy;
}
controller._queueTotalSize -= bytesToCopy;
ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor);
totalBytesToCopyRemaining -= bytesToCopy;
}
return ready;
}
function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
pullIntoDescriptor.bytesFilled += size;
}
function ReadableByteStreamControllerHandleQueueDrain(controller) {
if (controller._queueTotalSize === 0 && controller._closeRequested) {
ReadableByteStreamControllerClearAlgorithms(controller);
ReadableStreamClose(controller._controlledReadableByteStream);
} else ReadableByteStreamControllerCallPullIfNeeded(controller);
}
function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {
if (controller._byobRequest === null) return;
controller._byobRequest._associatedReadableByteStreamController = void 0;
controller._byobRequest._view = null;
controller._byobRequest = null;
}
function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {
while (controller._pendingPullIntos.length > 0) {
if (controller._queueTotalSize === 0) return;
const pullIntoDescriptor = controller._pendingPullIntos.peek();
if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {
ReadableByteStreamControllerShiftPendingPullInto(controller);
ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
}
}
}
function ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller) {
const reader = controller._controlledReadableByteStream._reader;
while (reader._readRequests.length > 0) {
if (controller._queueTotalSize === 0) return;
ReadableByteStreamControllerFillReadRequestFromQueue(controller, reader._readRequests.shift());
}
}
function ReadableByteStreamControllerPullInto(controller, view, min, readIntoRequest) {
const stream = controller._controlledReadableByteStream;
const ctor = view.constructor;
const elementSize = arrayBufferViewElementSize(ctor);
const { byteOffset, byteLength } = view;
const minimumFill = min * elementSize;
let buffer;
try {
buffer = TransferArrayBuffer(view.buffer);
} catch (e) {
readIntoRequest._errorSteps(e);
return;
}
const pullIntoDescriptor = {
buffer,
bufferByteLength: buffer.byteLength,
byteOffset,
byteLength,
bytesFilled: 0,
minimumFill,
elementSize,
viewConstructor: ctor,
readerType: "byob"
};
if (controller._pendingPullIntos.length > 0) {
controller._pendingPullIntos.push(pullIntoDescriptor);
ReadableStreamAddReadIntoRequest(stream, readIntoRequest);
return;
}
if (stream._state === "closed") {
const emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);
readIntoRequest._closeSteps(emptyView);
return;
}
if (controller._queueTotalSize > 0) {
if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {
const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
ReadableByteStreamControllerHandleQueueDrain(controller);
readIntoRequest._chunkSteps(filledView);
return;
}
if (controller._closeRequested) {
const e = /* @__PURE__ */ new TypeError("Insufficient bytes to fill elements in the given buffer");
ReadableByteStreamControllerError(controller, e);
readIntoRequest._errorSteps(e);
return;
}
}
controller._pendingPullIntos.push(pullIntoDescriptor);
ReadableStreamAddReadIntoRequest(stream, readIntoRequest);
ReadableByteStreamControllerCallPullIfNeeded(controller);
}
function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
if (firstDescriptor.readerType === "none") ReadableByteStreamControllerShiftPendingPullInto(controller);
const stream = controller._controlledReadableByteStream;
if (ReadableStreamHasBYOBReader(stream)) while (ReadableStreamGetNumReadIntoRequests(stream) > 0) ReadableByteStreamControllerCommitPullIntoDescriptor(stream, ReadableByteStreamControllerShiftPendingPullInto(controller));
}
function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
if (pullIntoDescriptor.readerType === "none") {
ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, pullIntoDescriptor);
ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
return;
}
if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.minimumFill) return;
ReadableByteStreamControllerShiftPendingPullInto(controller);
const remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
if (remainderSize > 0) {
const end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, pullIntoDescriptor.buffer, end - remainderSize, remainderSize);
}
pullIntoDescriptor.bytesFilled -= remainderSize;
ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
}
function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
const firstDescriptor = controller._pendingPullIntos.peek();
ReadableByteStreamControllerInvalidateBYOBRequest(controller);
if (controller._controlledReadableByteStream._state === "closed") ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
else ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
ReadableByteStreamControllerCallPullIfNeeded(controller);
}
function ReadableByteStreamControllerShiftPendingPullInto(controller) {
return controller._pendingPullIntos.shift();
}
function ReadableByteStreamControllerShouldCallPull(controller) {
const stream = controller._controlledReadableByteStream;
if (stream._state !== "readable") return false;
if (controller._closeRequested) return false;
if (!controller._started) return false;
if (ReadableStreamHasDefaultReader(stream) && ReadableStreamGetNumReadRequests(stream) > 0) return true;
if (ReadableStreamHasBYOBReader(stream) && ReadableStreamGetNumReadIntoRequests(stream) > 0) return true;
if (ReadableByteStreamControllerGetDesiredSize(controller) > 0) return true;
return false;
}
function ReadableByteStreamControllerClearAlgorithms(controller) {
controller._pullAlgorithm = void 0;
controller._cancelAlgorithm = void 0;
}
function ReadableByteStreamControllerClose(controller) {
const stream = controller._controlledReadableByteStream;
if (controller._closeRequested || stream._state !== "readable") return;
if (controller._queueTotalSize > 0) {
controller._closeRequested = true;
return;
}
if (controller._pendingPullIntos.length > 0) {
const firstPendingPullInto = controller._pendingPullIntos.peek();
if (firstPendingPullInto.bytesFilled % firstPendingPullInto.elementSize !== 0) {
const e = /* @__PURE__ */ new TypeError("Insufficient bytes to fill elements in the given buffer");
ReadableByteStreamControllerError(controller, e);
throw e;
}
}
ReadableByteStreamControllerClearAlgorithms(controller);
ReadableStreamClose(stream);
}
function ReadableByteStreamControllerEnqueue(controller, chunk) {
const stream = controller._controlledReadableByteStream;
if (controller._closeRequested || stream._state !== "readable") return;
const { buffer, byteOffset, byteLength } = chunk;
if (IsDetachedBuffer(buffer)) throw new TypeError("chunk's buffer is detached and so cannot be enqueued");
const transferredBuffer = TransferArrayBuffer(buffer);
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");
ReadableByteStreamControllerInvalidateBYOBRequest(controller);
firstPendingPullInto.buffer = TransferArrayBuffer(firstPendingPullInto.buffer);
if (firstPendingPullInto.readerType === "none") ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstPendingPullInto);
}
if (ReadableStreamHasDefaultReader(stream)) {
ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller);
if (ReadableStreamGetNumReadRequests(stream) === 0) ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
else {
if (controller._pendingPullIntos.length > 0) ReadableByteStreamControllerShiftPendingPullInto(controller);
ReadableStreamFulfillReadRequest(stream, new Uint8Array(transferredBuffer, byteOffset, byteLength), false);
}
} else if (ReadableStreamHasBYOBReader(stream)) {
ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
} else ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
ReadableByteStreamControllerCallPullIfNeeded(controller);
}
function ReadableByteStreamControllerError(controller, e) {
const stream = controller._controlledReadableByteStream;
if (stream._state !== "readable") return;
ReadableByteStreamControllerClearPendingPullIntos(controller);
ResetQueue(controller);
ReadableByteStreamControllerClearAlgorithms(controller);
ReadableStreamError(stream, e);
}
function ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest) {
const entry = controller._queue.shift();
controller._queueTotalSize -= entry.byteLength;
ReadableByteStreamControllerHandleQueueDrain(controller);
const view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
readRequest._chunkSteps(view);
}
function ReadableByteStreamControllerGetBYOBRequest(controller) {
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 byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);
SetUpReadableStreamBYOBRequest(byobRequest, controller, view);
controller._byobRequest = byobRequest;
}
return controller._byobRequest;
}
function ReadableByteStreamControllerGetDesiredSize(controller) {
const state = controller._controlledReadableByteStream._state;
if (state === "errored") return null;
if (state === "closed") return 0;
return controller._strategyHWM - controller._queueTotalSize;
}
function ReadableByteStreamControllerRespond(controller, bytesWritten) {
const firstDescriptor = controller._pendingPullIntos.peek();
if (controller._controlledReadableByteStream._state === "closed") {
if (bytesWritten !== 0) throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream");
} else {
if (bytesWritten === 0) throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");
if (firstDescriptor.bytesFilled + bytesWritten > firstDescriptor.byteLength) throw new RangeError("bytesWritten out of range");
}
firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
}
function ReadableByteStreamControllerRespondWithNewView(controller, view) {
const firstDescriptor = controller._pendingPullIntos.peek();
if (controller._controlledReadableByteStream._state === "closed") {
if (view.byteLength !== 0) throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream");
} else if (view.byteLength === 0) throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");
if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) throw new RangeError("The region specified by view does not match byobRequest");
if (firstDescriptor.bufferByteLength !== view.buffer.byteLength) throw new RangeError("The buffer of view has different capacity than byobRequest");
if (firstDescriptor.bytesFilled + view.byteLength > firstDescriptor.byteLength) throw new RangeError("The region specified by view is larger than byobRequest");
const viewByteLength = view.byteLength;
firstDescriptor.buffer = TransferArrayBuffer(view.buffer);
ReadableByteStreamControllerRespondInternal(controller, viewByteLength);
}
function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) {
controller._controlledReadableByteStream = stream;
controller._pullAgain = false;
controller._pulling = false;
controller._byobRequest = null;
controller._queue = controller._queueTotalSize = void 0;
ResetQueue(controller);
controller._closeRequested = false;
controller._started = false;
controller._strategyHWM = highWaterMark;
controller._pullAlgorithm = pullAlgorithm;
controller._cancelAlgorithm = cancelAlgorithm;
controller._autoAllocateChunkSize = autoAllocateChunkSize;
controller._pendingPullIntos = new SimpleQueue();
stream._readableStreamController = controller;
uponPromise(promiseResolvedWith(startAlgorithm()), () => {
controller._started = true;
ReadableByteStreamControllerCallPullIfNeeded(controller);