@shopify/cli
Version:
A CLI tool to build for the Shopify platform
866 lines (864 loc) • 177 kB
JavaScript
import {
__commonJS,
__require,
__toESM,
init_cjs_shims
} from "./chunk-PKR7KJ6P.js";
// ../../node_modules/.pnpm/web-streams-polyfill@3.3.3/node_modules/web-streams-polyfill/dist/ponyfill.es2018.js
var require_ponyfill_es2018 = __commonJS({
"../../node_modules/.pnpm/web-streams-polyfill@3.3.3/node_modules/web-streams-polyfill/dist/ponyfill.es2018.js"(exports, module) {
init_cjs_shims();
(function(global2, factory) {
typeof exports == "object" && typeof module < "u" ? factory(exports) : typeof define == "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis < "u" ? globalThis : global2 || self, factory(global2.WebStreamsPolyfill = {}));
})(exports, (function(exports2) {
"use strict";
function noop() {
}
function typeIsObject(x2) {
return typeof x2 == "object" && x2 !== null || typeof x2 == "function";
}
let rethrowAssertionErrorRejection = noop;
function setFunctionName(fn, name) {
try {
Object.defineProperty(fn, "name", {
value: name,
configurable: !0
});
} catch {
}
}
let originalPromise = Promise, originalPromiseThen = Promise.prototype.then, originalPromiseReject = Promise.reject.bind(originalPromise);
function newPromise(executor) {
return new originalPromise(executor);
}
function promiseResolvedWith(value) {
return newPromise((resolve) => resolve(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 {
let 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);
}
}
let QUEUE_MAX_ARRAY_SIZE = 16384;
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;
}
// For exception safety, this method is structured in order:
// 1. Read state
// 2. Calculate required state mutations
// 3. Perform state mutations
push(element) {
let oldBack = this._back, newBack = oldBack;
oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1 && (newBack = {
_elements: [],
_next: void 0
}), oldBack._elements.push(element), newBack !== oldBack && (this._back = newBack, oldBack._next = newBack), ++this._size;
}
// Like push(), shift() follows the read -> calculate -> mutate pattern for
// exception safety.
shift() {
let oldFront = this._front, newFront = oldFront, oldCursor = this._cursor, newCursor = oldCursor + 1, elements = oldFront._elements, element = elements[oldCursor];
return newCursor === QUEUE_MAX_ARRAY_SIZE && (newFront = oldFront._next, newCursor = 0), --this._size, this._cursor = newCursor, oldFront !== newFront && (this._front = newFront), elements[oldCursor] = void 0, element;
}
// The tricky thing about forEach() is that it can be called
// re-entrantly. The queue may be mutated inside the callback. It is easy to
// see that push() within the callback has no negative effects since the end
// of the queue is checked for on every iteration. If shift() is called
// repeatedly within the callback then the next iteration may return an
// element that has been removed. In this case the callback will be called
// with undefined values until we either "catch up" with elements that still
// exist or reach the back of the queue.
forEach(callback) {
let i2 = this._cursor, node = this._front, elements = node._elements;
for (; (i2 !== elements.length || node._next !== void 0) && !(i2 === elements.length && (node = node._next, elements = node._elements, i2 = 0, elements.length === 0)); )
callback(elements[i2]), ++i2;
}
// Return the element that would be returned if shift() was called now,
// without modifying the queue.
peek() {
let front = this._front, cursor = this._cursor;
return front._elements[cursor];
}
}
let AbortSteps = Symbol("[[AbortSteps]]"), ErrorSteps = Symbol("[[ErrorSteps]]"), CancelSteps = Symbol("[[CancelSteps]]"), PullSteps = Symbol("[[PullSteps]]"), ReleaseSteps = Symbol("[[ReleaseSteps]]");
function ReadableStreamReaderGenericInitialize(reader, stream) {
reader._ownerReadableStream = stream, stream._reader = reader, stream._state === "readable" ? defaultReaderClosedPromiseInitialize(reader) : stream._state === "closed" ? defaultReaderClosedPromiseInitializeAsResolved(reader) : defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
}
function ReadableStreamReaderGenericCancel(reader, reason) {
let stream = reader._ownerReadableStream;
return ReadableStreamCancel(stream, reason);
}
function ReadableStreamReaderGenericRelease(reader) {
let stream = reader._ownerReadableStream;
stream._state === "readable" ? defaultReaderClosedPromiseReject(reader, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")) : defaultReaderClosedPromiseResetToRejected(reader, 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 new TypeError("Cannot " + name + " a stream using a released reader");
}
function defaultReaderClosedPromiseInitialize(reader) {
reader._closedPromise = newPromise((resolve, reject) => {
reader._closedPromise_resolve = resolve, reader._closedPromise_reject = reject;
});
}
function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
defaultReaderClosedPromiseInitialize(reader), defaultReaderClosedPromiseReject(reader, reason);
}
function defaultReaderClosedPromiseInitializeAsResolved(reader) {
defaultReaderClosedPromiseInitialize(reader), defaultReaderClosedPromiseResolve(reader);
}
function defaultReaderClosedPromiseReject(reader, reason) {
reader._closedPromise_reject !== void 0 && (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) {
reader._closedPromise_resolve !== void 0 && (reader._closedPromise_resolve(void 0), reader._closedPromise_resolve = void 0, reader._closedPromise_reject = void 0);
}
let NumberIsFinite = Number.isFinite || function(x2) {
return typeof x2 == "number" && isFinite(x2);
}, MathTrunc = Math.trunc || function(v) {
return v < 0 ? Math.ceil(v) : Math.floor(v);
};
function isDictionary(x2) {
return typeof x2 == "object" || typeof x2 == "function";
}
function assertDictionary(obj, context) {
if (obj !== void 0 && !isDictionary(obj))
throw new TypeError(`${context} is not an object.`);
}
function assertFunction(x2, context) {
if (typeof x2 != "function")
throw new TypeError(`${context} is not a function.`);
}
function isObject(x2) {
return typeof x2 == "object" && x2 !== null || typeof x2 == "function";
}
function assertObject(x2, context) {
if (!isObject(x2))
throw new TypeError(`${context} is not an object.`);
}
function assertRequiredArgument(x2, position, context) {
if (x2 === void 0)
throw new TypeError(`Parameter ${position} is required in '${context}'.`);
}
function assertRequiredField(x2, field, context) {
if (x2 === void 0)
throw new TypeError(`${field} is required in '${context}'.`);
}
function convertUnrestrictedDouble(value) {
return Number(value);
}
function censorNegativeZero(x2) {
return x2 === 0 ? 0 : x2;
}
function integerPart(x2) {
return censorNegativeZero(MathTrunc(x2));
}
function convertUnsignedLongLongWithEnforceRange(value, context) {
let upperBound = Number.MAX_SAFE_INTEGER, x2 = Number(value);
if (x2 = censorNegativeZero(x2), !NumberIsFinite(x2))
throw new TypeError(`${context} is not a finite number`);
if (x2 = integerPart(x2), x2 < 0 || x2 > upperBound)
throw new TypeError(`${context} is outside the accepted range of 0 to ${upperBound}, inclusive`);
return !NumberIsFinite(x2) || x2 === 0 ? 0 : x2;
}
function assertReadableStream(x2, context) {
if (!IsReadableStream(x2))
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) {
let readRequest = stream._reader._readRequests.shift();
done ? readRequest._closeSteps() : readRequest._chunkSteps(chunk);
}
function ReadableStreamGetNumReadRequests(stream) {
return stream._reader._readRequests.length;
}
function ReadableStreamHasDefaultReader(stream) {
let reader = stream._reader;
return !(reader === void 0 || !IsReadableStreamDefaultReader(reader));
}
class ReadableStreamDefaultReader {
constructor(stream) {
if (assertRequiredArgument(stream, 1, "ReadableStreamDefaultReader"), assertReadableStream(stream, "First parameter"), 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() {
return IsReadableStreamDefaultReader(this) ? this._closedPromise : promiseRejectedWith(defaultReaderBrandCheckException("closed"));
}
/**
* If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
*/
cancel(reason = void 0) {
return IsReadableStreamDefaultReader(this) ? this._ownerReadableStream === void 0 ? promiseRejectedWith(readerLockException("cancel")) : ReadableStreamReaderGenericCancel(this, reason) : promiseRejectedWith(defaultReaderBrandCheckException("cancel"));
}
/**
* 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, rejectPromise, promise = newPromise((resolve, reject) => {
resolvePromise = resolve, rejectPromise = reject;
});
return ReadableStreamDefaultReaderRead(this, {
_chunkSteps: (chunk) => resolvePromise({ value: chunk, done: !1 }),
_closeSteps: () => resolvePromise({ value: void 0, done: !0 }),
_errorSteps: (e2) => rejectPromise(e2)
}), 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");
this._ownerReadableStream !== void 0 && ReadableStreamDefaultReaderRelease(this);
}
}
Object.defineProperties(ReadableStreamDefaultReader.prototype, {
cancel: { enumerable: !0 },
read: { enumerable: !0 },
releaseLock: { enumerable: !0 },
closed: { enumerable: !0 }
}), setFunctionName(ReadableStreamDefaultReader.prototype.cancel, "cancel"), setFunctionName(ReadableStreamDefaultReader.prototype.read, "read"), setFunctionName(ReadableStreamDefaultReader.prototype.releaseLock, "releaseLock"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ReadableStreamDefaultReader.prototype, Symbol.toStringTag, {
value: "ReadableStreamDefaultReader",
configurable: !0
});
function IsReadableStreamDefaultReader(x2) {
return !typeIsObject(x2) || !Object.prototype.hasOwnProperty.call(x2, "_readRequests") ? !1 : x2 instanceof ReadableStreamDefaultReader;
}
function ReadableStreamDefaultReaderRead(reader, readRequest) {
let stream = reader._ownerReadableStream;
stream._disturbed = !0, stream._state === "closed" ? readRequest._closeSteps() : stream._state === "errored" ? readRequest._errorSteps(stream._storedError) : stream._readableStreamController[PullSteps](readRequest);
}
function ReadableStreamDefaultReaderRelease(reader) {
ReadableStreamReaderGenericRelease(reader);
let e2 = new TypeError("Reader was released");
ReadableStreamDefaultReaderErrorReadRequests(reader, e2);
}
function ReadableStreamDefaultReaderErrorReadRequests(reader, e2) {
let readRequests = reader._readRequests;
reader._readRequests = new SimpleQueue(), readRequests.forEach((readRequest) => {
readRequest._errorSteps(e2);
});
}
function defaultReaderBrandCheckException(name) {
return new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);
}
let AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {
}).prototype);
class ReadableStreamAsyncIteratorImpl {
constructor(reader, preventCancel) {
this._ongoingPromise = void 0, this._isFinished = !1, this._reader = reader, this._preventCancel = preventCancel;
}
next() {
let nextSteps = () => this._nextSteps();
return this._ongoingPromise = this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) : nextSteps(), this._ongoingPromise;
}
return(value) {
let returnSteps = () => this._returnSteps(value);
return this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) : returnSteps();
}
_nextSteps() {
if (this._isFinished)
return Promise.resolve({ value: void 0, done: !0 });
let reader = this._reader, resolvePromise, rejectPromise, promise = newPromise((resolve, reject) => {
resolvePromise = resolve, rejectPromise = reject;
});
return ReadableStreamDefaultReaderRead(reader, {
_chunkSteps: (chunk) => {
this._ongoingPromise = void 0, _queueMicrotask(() => resolvePromise({ value: chunk, done: !1 }));
},
_closeSteps: () => {
this._ongoingPromise = void 0, this._isFinished = !0, ReadableStreamReaderGenericRelease(reader), resolvePromise({ value: void 0, done: !0 });
},
_errorSteps: (reason) => {
this._ongoingPromise = void 0, this._isFinished = !0, ReadableStreamReaderGenericRelease(reader), rejectPromise(reason);
}
}), promise;
}
_returnSteps(value) {
if (this._isFinished)
return Promise.resolve({ value, done: !0 });
this._isFinished = !0;
let reader = this._reader;
if (!this._preventCancel) {
let result = ReadableStreamReaderGenericCancel(reader, value);
return ReadableStreamReaderGenericRelease(reader), transformPromiseWith(result, () => ({ value, done: !0 }));
}
return ReadableStreamReaderGenericRelease(reader), promiseResolvedWith({ value, done: !0 });
}
}
let ReadableStreamAsyncIteratorPrototype = {
next() {
return IsReadableStreamAsyncIterator(this) ? this._asyncIteratorImpl.next() : promiseRejectedWith(streamAsyncIteratorBrandCheckException("next"));
},
return(value) {
return IsReadableStreamAsyncIterator(this) ? this._asyncIteratorImpl.return(value) : promiseRejectedWith(streamAsyncIteratorBrandCheckException("return"));
}
};
Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
function AcquireReadableStreamAsyncIterator(stream, preventCancel) {
let reader = AcquireReadableStreamDefaultReader(stream), impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel), iterator = Object.create(ReadableStreamAsyncIteratorPrototype);
return iterator._asyncIteratorImpl = impl, iterator;
}
function IsReadableStreamAsyncIterator(x2) {
if (!typeIsObject(x2) || !Object.prototype.hasOwnProperty.call(x2, "_asyncIteratorImpl"))
return !1;
try {
return x2._asyncIteratorImpl instanceof ReadableStreamAsyncIteratorImpl;
} catch {
return !1;
}
}
function streamAsyncIteratorBrandCheckException(name) {
return new TypeError(`ReadableStreamAsyncIterator.${name} can only be used on a ReadableSteamAsyncIterator`);
}
let NumberIsNaN = Number.isNaN || function(x2) {
return x2 !== x2;
};
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) => (typeof O.transfer == "function" ? TransferArrayBuffer = (buffer) => buffer.transfer() : typeof structuredClone == "function" ? TransferArrayBuffer = (buffer) => structuredClone(buffer, { transfer: [buffer] }) : TransferArrayBuffer = (buffer) => buffer, TransferArrayBuffer(O)), IsDetachedBuffer = (O) => (typeof O.detached == "boolean" ? IsDetachedBuffer = (buffer) => buffer.detached : IsDetachedBuffer = (buffer) => buffer.byteLength === 0, IsDetachedBuffer(O));
function ArrayBufferSlice(buffer, begin, end) {
if (buffer.slice)
return buffer.slice(begin, end);
let length = end - begin, slice = new ArrayBuffer(length);
return CopyDataBlockBytes(slice, 0, buffer, begin, length), slice;
}
function GetMethod(receiver, prop) {
let func = receiver[prop];
if (func != null) {
if (typeof func != "function")
throw new TypeError(`${String(prop)} is not a function`);
return func;
}
}
function CreateAsyncFromSyncIterator(syncIteratorRecord) {
let syncIterable = {
[Symbol.iterator]: () => syncIteratorRecord.iterator
}, asyncIterator = (async function* () {
return yield* syncIterable;
})(), nextMethod = asyncIterator.next;
return { iterator: asyncIterator, nextMethod, done: !1 };
}
let 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") {
if (method = GetMethod(obj, SymbolAsyncIterator), method === void 0) {
let syncMethod = GetMethod(obj, Symbol.iterator), syncIteratorRecord = GetIterator(obj, "sync", syncMethod);
return CreateAsyncFromSyncIterator(syncIteratorRecord);
}
} else
method = GetMethod(obj, Symbol.iterator);
if (method === void 0)
throw new TypeError("The object is not iterable");
let iterator = reflectCall(method, obj, []);
if (!typeIsObject(iterator))
throw new TypeError("The iterator method must return an object");
let nextMethod = iterator.next;
return { iterator, nextMethod, done: !1 };
}
function IteratorNext(iteratorRecord) {
let 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 !!iterResult.done;
}
function IteratorValue(iterResult) {
return iterResult.value;
}
function IsNonNegativeNumber(v) {
return !(typeof v != "number" || NumberIsNaN(v) || v < 0);
}
function CloneAsUint8Array(O) {
let buffer = ArrayBufferSlice(O.buffer, O.byteOffset, O.byteOffset + O.byteLength);
return new Uint8Array(buffer);
}
function DequeueValue(container) {
let pair = container._queue.shift();
return container._queueTotalSize -= pair.size, container._queueTotalSize < 0 && (container._queueTotalSize = 0), pair.value;
}
function EnqueueValueWithSize(container, value, size) {
if (!IsNonNegativeNumber(size) || size === 1 / 0)
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) {
return isDataViewConstructor(ctor) ? 1 : ctor.BYTES_PER_ELEMENT;
}
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");
if (assertRequiredArgument(bytesWritten, 1, "respond"), bytesWritten = convertUnsignedLongLongWithEnforceRange(bytesWritten, "First parameter"), 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");
if (assertRequiredArgument(view, 1, "respondWithNewView"), !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: !0 },
respondWithNewView: { enumerable: !0 },
view: { enumerable: !0 }
}), setFunctionName(ReadableStreamBYOBRequest.prototype.respond, "respond"), setFunctionName(ReadableStreamBYOBRequest.prototype.respondWithNewView, "respondWithNewView"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ReadableStreamBYOBRequest.prototype, Symbol.toStringTag, {
value: "ReadableStreamBYOBRequest",
configurable: !0
});
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!");
let 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");
if (assertRequiredArgument(chunk, 1, "enqueue"), !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");
let 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(e2 = void 0) {
if (!IsReadableByteStreamController(this))
throw byteStreamControllerBrandCheckException("error");
ReadableByteStreamControllerError(this, e2);
}
/** @internal */
[CancelSteps](reason) {
ReadableByteStreamControllerClearPendingPullIntos(this), ResetQueue(this);
let result = this._cancelAlgorithm(reason);
return ReadableByteStreamControllerClearAlgorithms(this), result;
}
/** @internal */
[PullSteps](readRequest) {
let stream = this._controlledReadableByteStream;
if (this._queueTotalSize > 0) {
ReadableByteStreamControllerFillReadRequestFromQueue(this, readRequest);
return;
}
let autoAllocateChunkSize = this._autoAllocateChunkSize;
if (autoAllocateChunkSize !== void 0) {
let buffer;
try {
buffer = new ArrayBuffer(autoAllocateChunkSize);
} catch (bufferE) {
readRequest._errorSteps(bufferE);
return;
}
let 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) {
let firstPullInto = this._pendingPullIntos.peek();
firstPullInto.readerType = "none", this._pendingPullIntos = new SimpleQueue(), this._pendingPullIntos.push(firstPullInto);
}
}
}
Object.defineProperties(ReadableByteStreamController.prototype, {
close: { enumerable: !0 },
enqueue: { enumerable: !0 },
error: { enumerable: !0 },
byobRequest: { enumerable: !0 },
desiredSize: { enumerable: !0 }
}), setFunctionName(ReadableByteStreamController.prototype.close, "close"), setFunctionName(ReadableByteStreamController.prototype.enqueue, "enqueue"), setFunctionName(ReadableByteStreamController.prototype.error, "error"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ReadableByteStreamController.prototype, Symbol.toStringTag, {
value: "ReadableByteStreamController",
configurable: !0
});
function IsReadableByteStreamController(x2) {
return !typeIsObject(x2) || !Object.prototype.hasOwnProperty.call(x2, "_controlledReadableByteStream") ? !1 : x2 instanceof ReadableByteStreamController;
}
function IsReadableStreamBYOBRequest(x2) {
return !typeIsObject(x2) || !Object.prototype.hasOwnProperty.call(x2, "_associatedReadableByteStreamController") ? !1 : x2 instanceof ReadableStreamBYOBRequest;
}
function ReadableByteStreamControllerCallPullIfNeeded(controller) {
if (!ReadableByteStreamControllerShouldCallPull(controller))
return;
if (controller._pulling) {
controller._pullAgain = !0;
return;
}
controller._pulling = !0;
let pullPromise = controller._pullAlgorithm();
uponPromise(pullPromise, () => (controller._pulling = !1, controller._pullAgain && (controller._pullAgain = !1, ReadableByteStreamControllerCallPullIfNeeded(controller)), null), (e2) => (ReadableByteStreamControllerError(controller, e2), null));
}
function ReadableByteStreamControllerClearPendingPullIntos(controller) {
ReadableByteStreamControllerInvalidateBYOBRequest(controller), controller._pendingPullIntos = new SimpleQueue();
}
function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {
let done = !1;
stream._state === "closed" && (done = !0);
let filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
pullIntoDescriptor.readerType === "default" ? ReadableStreamFulfillReadRequest(stream, filledView, done) : ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
}
function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {
let bytesFilled = pullIntoDescriptor.bytesFilled, 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) {
throw ReadableByteStreamControllerError(controller, cloneE), cloneE;
}
ReadableByteStreamControllerEnqueueChunkToQueue(controller, clonedChunk, 0, byteLength);
}
function ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstDescriptor) {
firstDescriptor.bytesFilled > 0 && ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, firstDescriptor.buffer, firstDescriptor.byteOffset, firstDescriptor.bytesFilled), ReadableByteStreamControllerShiftPendingPullInto(controller);
}
function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {
let maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled), maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy, totalBytesToCopyRemaining = maxBytesToCopy, ready = !1, remainderBytes = maxBytesFilled % pullIntoDescriptor.elementSize, maxAlignedBytes = maxBytesFilled - remainderBytes;
maxAlignedBytes >= pullIntoDescriptor.minimumFill && (totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled, ready = !0);
let queue = controller._queue;
for (; totalBytesToCopyRemaining > 0; ) {
let headOfQueue = queue.peek(), bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength), destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
CopyDataBlockBytes(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy), headOfQueue.byteLength === bytesToCopy ? queue.shift() : (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) {
controller._queueTotalSize === 0 && controller._closeRequested ? (ReadableByteStreamControllerClearAlgorithms(controller), ReadableStreamClose(controller._controlledReadableByteStream)) : ReadableByteStreamControllerCallPullIfNeeded(controller);
}
function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {
controller._byobRequest !== null && (controller._byobRequest._associatedReadableByteStreamController = void 0, controller._byobRequest._view = null, controller._byobRequest = null);
}
function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {
for (; controller._pendingPullIntos.length > 0; ) {
if (controller._queueTotalSize === 0)
return;
let pullIntoDescriptor = controller._pendingPullIntos.peek();
ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) && (ReadableByteStreamControllerShiftPendingPullInto(controller), ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor));
}
}
function ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller) {
let reader = controller._controlledReadableByteStream._reader;
for (; reader._readRequests.length > 0; ) {
if (controller._queueTotalSize === 0)
return;
let readRequest = reader._readRequests.shift();
ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest);
}
}
function ReadableByteStreamControllerPullInto(controller, view, min, readIntoRequest) {
let stream = controller._controlledReadableByteStream, ctor = view.constructor, elementSize = arrayBufferViewElementSize(ctor), { byteOffset, byteLength } = view, minimumFill = min * elementSize, buffer;
try {
buffer = TransferArrayBuffer(view.buffer);
} catch (e2) {
readIntoRequest._errorSteps(e2);
return;
}
let 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") {
let emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);
readIntoRequest._closeSteps(emptyView);
return;
}
if (controller._queueTotalSize > 0) {
if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {
let filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
ReadableByteStreamControllerHandleQueueDrain(controller), readIntoRequest._chunkSteps(filledView);
return;
}
if (controller._closeRequested) {
let e2 = new TypeError("Insufficient bytes to fill elements in the given buffer");
ReadableByteStreamControllerError(controller, e2), readIntoRequest._errorSteps(e2);
return;
}
}
controller._pendingPullIntos.push(pullIntoDescriptor), ReadableStreamAddReadIntoRequest(stream, readIntoRequest), ReadableByteStreamControllerCallPullIfNeeded(controller);
}
function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
firstDescriptor.readerType === "none" && ReadableByteStreamControllerShiftPendingPullInto(controller);
let stream = controller._controlledReadableByteStream;
if (ReadableStreamHasBYOBReader(stream))
for (; ReadableStreamGetNumReadIntoRequests(stream) > 0; ) {
let pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);
ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);
}
}
function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
if (ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor), pullIntoDescriptor.readerType === "none") {
ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, pullIntoDescriptor), ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
return;
}
if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.minimumFill)
return;
ReadableByteStreamControllerShiftPendingPullInto(controller);
let remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
if (remainderSize > 0) {
let 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) {
let firstDescriptor = controller._pendingPullIntos.peek();
ReadableByteStreamControllerInvalidateBYOBRequest(controller), controller._controlledReadableByteStream._state === "closed" ? ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) : ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor), ReadableByteStreamControllerCallPullIfNeeded(controller);
}
function ReadableByteStreamControllerShiftPendingPullInto(controller) {
return controller._pendingPullIntos.shift();
}
function ReadableByteStreamControllerShouldCallPull(controller) {
let stream = controller._controlledReadableByteStream;
return stream._state !== "readable" || controller._closeRequested || !controller._started ? !1 : !!(ReadableStreamHasDefaultReader(stream) && ReadableStreamGetNumReadRequests(stream) > 0 || ReadableStreamHasBYOBReader(stream) && ReadableStreamGetNumReadIntoRequests(stream) > 0 || ReadableByteStreamControllerGetDesiredSize(controller) > 0);
}
function ReadableByteStreamControllerClearAlgorithms(controller) {
controller._pullAlgorithm = void 0, controller._cancelAlgorithm = void 0;
}
function ReadableByteStreamControllerClose(controller) {
let stream = controller._controlledReadableByteStream;
if (!(controller._closeRequested || stream._state !== "readable")) {
if (controller._queueTotalSize > 0) {
controller._closeRequested = !0;
return;
}
if (controller._pendingPullIntos.length > 0) {
let firstPendingPullInto = controller._pendingPullIntos.peek();
if (firstPendingPullInto.bytesFilled % firstPendingPullInto.elementSize !== 0) {
let e2 = new TypeError("Insufficient bytes to fill elements in the given buffer");
throw ReadableByteStreamControllerError(controller, e2), e2;
}
}
ReadableByteStreamControllerClearAlgorithms(controller), ReadableStreamClose(stream);
}
}
function ReadableByteStreamControllerEnqueue(controller, chunk) {
let stream = controller._controlledReadableByteStream;
if (controller._closeRequested || stream._state !== "readable")
return;
let { buffer, byteOffset, byteLength } = chunk;
if (IsDetachedBuffer(buffer))
throw new TypeError("chunk's buffer is detached and so cannot be enqueued");
let transferredBuffer = TransferArrayBuffer(buffer);
if (controller._pendingPullIntos.length > 0) {
let 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), firstPendingPullInto.readerType === "none" && ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstPendingPullInto);
}
if (ReadableStreamHasDefaultReader(stream))
if (ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller), ReadableStreamGetNumReadRequests(stream) === 0)
ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
else {
controller._pendingPullIntos.length > 0 && ReadableByteStreamControllerShiftPendingPullInto(controller);
let transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);
ReadableStreamFulfillReadRequest(stream, transferredView, !1);
}
else ReadableStreamHasBYOBReader(stream) ? (ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength), ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller)) : ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
ReadableByteStreamControllerCallPullIfNeeded(controller);
}
function ReadableByteStreamControllerError(controller, e2) {
let stream = controller._controlledReadableByteStream;
stream._state === "readable" && (ReadableByteStreamControllerClearPendingPullIntos(controller), ResetQueue(controller), ReadableByteStreamControllerClearAlgorithms(controller), ReadableStreamError(stream, e2));
}
function ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest) {
let entry = controller._queue.shift();
controller._queueTotalSize -= entry.byteLength, ReadableByteStreamControllerHandleQueueDrain(controller);
let view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
readRequest._chunkSteps(view);
}
function ReadableByteStreamControllerGetBYOBRequest(controller) {
if (controller._byobRequest === null && controller._pendingPullIntos.length > 0) {
let firstDescriptor = controller._pendingPullIntos.peek(), view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled), byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);
SetUpReadableStreamBYOBRequest(byobRequest, controller, view), controller._byobRequest = byobRequest;
}
return controller._byobRequest;
}
function ReadableByteStreamControllerGetDesiredSize(controller) {
let state = controller._controlledReadableByteStream._state;
return state === "errored" ? null : state === "closed" ? 0 : controller._strategyHWM - controller._queueTotalSize;
}
function ReadableByteStreamControllerRespond(controller, bytesWritten) {
let 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)