@slicemachine/adapter-next 0.0.9 → 0.0.10

package/dist/node_modules/web-streams-polyfill/dist/ponyfill.es2018.js

@@ -96,6 +96,10 @@ function requirePonyfill_es2018() {
         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) {
           const oldBack = this._back;
           let newBack = oldBack;
@@ -112,6 +116,8 @@ function requirePonyfill_es2018() {
           }
           ++this._size;
         }
+        // Like push(), shift() follows the read -> calculate -> mutate pattern for
+        // exception safety.
         shift() {
           const oldFront = this._front;
           let newFront = oldFront;
@@ -131,6 +137,14 @@ function requirePonyfill_es2018() {
           elements[oldCursor] = void 0;
           return 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 i = this._cursor;
           let node = this._front;
@@ -148,6 +162,8 @@ function requirePonyfill_es2018() {
             ++i;
           }
         }
+        // Return the element that would be returned if shift() was called now,
+        // without modifying the queue.
         peek() {
           const front = this._front;
           const cursor = this._cursor;
@@ -325,12 +341,19 @@ function requirePonyfill_es2018() {
           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"));
@@ -340,6 +363,11 @@ function requirePonyfill_es2018() {
           }
           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"));
@@ -361,6 +389,15 @@ function requirePonyfill_es2018() {
           ReadableStreamDefaultReaderRead(this, readRequest);
           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");
@@ -587,6 +624,9 @@ function requirePonyfill_es2018() {
         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");
@@ -637,18 +677,29 @@ function requirePonyfill_es2018() {
         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");
@@ -685,12 +736,16 @@ function requirePonyfill_es2018() {
           }
           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);
@@ -698,6 +753,7 @@ function requirePonyfill_es2018() {
           ReadableByteStreamControllerClearAlgorithms(this);
           return result;
         }
+        /** @internal */
         [PullSteps](readRequest) {
           const stream = this._controlledReadableByteStream;
           if (this._queueTotalSize > 0) {
@@ -1205,12 +1261,19 @@ function requirePonyfill_es2018() {
           ReadableStreamReaderGenericInitialize(this, stream);
           this._readIntoRequests = 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 (!IsReadableStreamBYOBReader(this)) {
             return promiseRejectedWith(byobReaderBrandCheckException("closed"));
           }
           return this._closedPromise;
         }
+        /**
+         * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
+         */
         cancel(reason = void 0) {
           if (!IsReadableStreamBYOBReader(this)) {
             return promiseRejectedWith(byobReaderBrandCheckException("cancel"));
@@ -1220,6 +1283,11 @@ function requirePonyfill_es2018() {
           }
           return ReadableStreamReaderGenericCancel(this, reason);
         }
+        /**
+         * Attempts to reads bytes into view, and returns a promise resolved with the result.
+         *
+         * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
+         */
         read(view) {
           if (!IsReadableStreamBYOBReader(this)) {
             return promiseRejectedWith(byobReaderBrandCheckException("read"));
@@ -1252,6 +1320,15 @@ function requirePonyfill_es2018() {
           ReadableStreamBYOBReaderRead(this, view, readIntoRequest);
           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 ReadableStreamBYOBReader.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 (!IsReadableStreamBYOBReader(this)) {
             throw byobReaderBrandCheckException("releaseLock");
@@ -1399,12 +1476,24 @@ function requirePonyfill_es2018() {
           const highWaterMark = ExtractHighWaterMark(strategy, 1);
           SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm);
         }
+        /**
+         * Returns whether or not the writable stream is locked to a writer.
+         */
         get locked() {
           if (!IsWritableStream(this)) {
             throw streamBrandCheckException$2("locked");
           }
           return IsWritableStreamLocked(this);
         }
+        /**
+         * Aborts the stream, signaling that the producer can no longer successfully write to the stream and it is to be
+         * immediately moved to an errored state, with any queued-up writes discarded. This will also execute any abort
+         * mechanism of the underlying sink.
+         *
+         * The returned promise will fulfill if the stream shuts down successfully, or reject if the underlying sink signaled
+         * that there was an error doing so. Additionally, it will reject with a `TypeError` (without attempting to cancel
+         * the stream) if the stream is currently locked.
+         */
         abort(reason = void 0) {
           if (!IsWritableStream(this)) {
             return promiseRejectedWith(streamBrandCheckException$2("abort"));
@@ -1414,6 +1503,14 @@ function requirePonyfill_es2018() {
           }
           return WritableStreamAbort(this, reason);
         }
+        /**
+         * Closes the stream. The underlying sink will finish processing any previously-written chunks, before invoking its
+         * close behavior. During this time any further attempts to write will fail (without erroring the stream).
+         *
+         * The method returns a promise that will fulfill if all remaining chunks are successfully written and the stream
+         * successfully closes, or rejects if an error is encountered during this process. Additionally, it will reject with
+         * a `TypeError` (without attempting to cancel the stream) if the stream is currently locked.
+         */
         close() {
           if (!IsWritableStream(this)) {
             return promiseRejectedWith(streamBrandCheckException$2("close"));
@@ -1426,6 +1523,14 @@ function requirePonyfill_es2018() {
           }
           return WritableStreamClose(this);
         }
+        /**
+         * Creates a {@link WritableStreamDefaultWriter | writer} and locks the stream to the new writer. While the stream
+         * is locked, no other writer can be acquired until this one is released.
+         *
+         * This functionality is especially useful for creating abstractions that desire the ability to write to a stream
+         * without interruption or interleaving. By getting a writer for the stream, you can ensure nobody else can write at
+         * the same time, which would cause the resulting written data to be unpredictable and probably useless.
+         */
         getWriter() {
           if (!IsWritableStream(this)) {
             throw streamBrandCheckException$2("getWriter");
@@ -1697,12 +1802,24 @@ function requirePonyfill_es2018() {
             defaultWriterClosedPromiseInitializeAsRejected(this, storedError);
           }
         }
+        /**
+         * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
+         * the writer’s lock is released before the stream finishes closing.
+         */
         get closed() {
           if (!IsWritableStreamDefaultWriter(this)) {
             return promiseRejectedWith(defaultWriterBrandCheckException("closed"));
           }
           return this._closedPromise;
         }
+        /**
+         * Returns the desired size to fill the stream’s internal queue. It can be negative, if the queue is over-full.
+         * A producer can use this information to determine the right amount of data to write.
+         *
+         * It will be `null` if the stream cannot be successfully written to (due to either being errored, or having an abort
+         * queued up). It will return zero if the stream is closed. And the getter will throw an exception if invoked when
+         * the writer’s lock is released.
+         */
         get desiredSize() {
           if (!IsWritableStreamDefaultWriter(this)) {
             throw defaultWriterBrandCheckException("desiredSize");
@@ -1712,12 +1829,23 @@ function requirePonyfill_es2018() {
           }
           return WritableStreamDefaultWriterGetDesiredSize(this);
         }
+        /**
+         * Returns a promise that will be fulfilled when the desired size to fill the stream’s internal queue transitions
+         * from non-positive to positive, signaling that it is no longer applying backpressure. Once the desired size dips
+         * back to zero or below, the getter will return a new promise that stays pending until the next transition.
+         *
+         * If the stream becomes errored or aborted, or the writer’s lock is released, the returned promise will become
+         * rejected.
+         */
         get ready() {
           if (!IsWritableStreamDefaultWriter(this)) {
             return promiseRejectedWith(defaultWriterBrandCheckException("ready"));
           }
           return this._readyPromise;
         }
+        /**
+         * If the reader is active, behaves the same as {@link WritableStream.abort | stream.abort(reason)}.
+         */
         abort(reason = void 0) {
           if (!IsWritableStreamDefaultWriter(this)) {
             return promiseRejectedWith(defaultWriterBrandCheckException("abort"));
@@ -1727,6 +1855,9 @@ function requirePonyfill_es2018() {
           }
           return WritableStreamDefaultWriterAbort(this, reason);
         }
+        /**
+         * If the reader is active, behaves the same as {@link WritableStream.close | stream.close()}.
+         */
         close() {
           if (!IsWritableStreamDefaultWriter(this)) {
             return promiseRejectedWith(defaultWriterBrandCheckException("close"));
@@ -1740,6 +1871,16 @@ function requirePonyfill_es2018() {
           }
           return WritableStreamDefaultWriterClose(this);
         }
+        /**
+         * Releases the writer’s lock on the corresponding stream. After the lock is released, the writer is no longer active.
+         * If the associated stream is errored when the lock is released, the writer will appear errored in the same way from
+         * now on; otherwise, the writer will appear closed.
+         *
+         * Note that the lock can still be released even if some ongoing writes have not yet finished (i.e. even if the
+         * promises returned from previous calls to {@link WritableStreamDefaultWriter.write | write()} have not yet settled).
+         * It’s not necessary to hold the lock on the writer for the duration of the write; the lock instead simply prevents
+         * other producers from writing in an interleaved manner.
+         */
         releaseLock() {
           if (!IsWritableStreamDefaultWriter(this)) {
             throw defaultWriterBrandCheckException("releaseLock");
@@ -1862,12 +2003,22 @@ function requirePonyfill_es2018() {
         constructor() {
           throw new TypeError("Illegal constructor");
         }
+        /**
+         * The reason which was passed to `WritableStream.abort(reason)` when the stream was aborted.
+         *
+         * @deprecated
+         *  This property has been removed from the specification, see https://github.com/whatwg/streams/pull/1177.
+         *  Use {@link WritableStreamDefaultController.signal}'s `reason` instead.
+         */
         get abortReason() {
           if (!IsWritableStreamDefaultController(this)) {
             throw defaultControllerBrandCheckException$2("abortReason");
           }
           return this._abortReason;
         }
+        /**
+         * An `AbortSignal` that can be used to abort the pending write or close operation when the stream is aborted.
+         */
         get signal() {
           if (!IsWritableStreamDefaultController(this)) {
             throw defaultControllerBrandCheckException$2("signal");
@@ -1877,6 +2028,13 @@ function requirePonyfill_es2018() {
           }
           return this._abortController.signal;
         }
+        /**
+         * Closes the controlled writable stream, making all future interactions with it fail with the given error `e`.
+         *
+         * This method is rarely used, since usually it suffices to return a rejected promise from one of the underlying
+         * sink's methods. However, it can be useful for suddenly shutting down a stream in response to an event outside the
+         * normal lifecycle of interactions with the underlying sink.
+         */
         error(e = void 0) {
           if (!IsWritableStreamDefaultController(this)) {
             throw defaultControllerBrandCheckException$2("error");
@@ -1887,11 +2045,13 @@ function requirePonyfill_es2018() {
           }
           WritableStreamDefaultControllerError(this, e);
         }
+        /** @internal */
         [AbortSteps](reason) {
           const result = this._abortAlgorithm(reason);
           WritableStreamDefaultControllerClearAlgorithms(this);
           return result;
         }
+        /** @internal */
         [ErrorSteps]() {
           ResetQueue(this);
         }
@@ -2336,12 +2496,20 @@ function requirePonyfill_es2018() {
         constructor() {
           throw new TypeError("Illegal constructor");
         }
+        /**
+         * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
+         * over-full. An underlying source ought to use this information to determine when and how to apply backpressure.
+         */
         get desiredSize() {
           if (!IsReadableStreamDefaultController(this)) {
             throw defaultControllerBrandCheckException$1("desiredSize");
           }
           return ReadableStreamDefaultControllerGetDesiredSize(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 (!IsReadableStreamDefaultController(this)) {
             throw defaultControllerBrandCheckException$1("close");
@@ -2360,18 +2528,23 @@ function requirePonyfill_es2018() {
           }
           return ReadableStreamDefaultControllerEnqueue(this, chunk);
         }
+        /**
+         * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
+         */
         error(e = void 0) {
           if (!IsReadableStreamDefaultController(this)) {
             throw defaultControllerBrandCheckException$1("error");
           }
           ReadableStreamDefaultControllerError(this, e);
         }
+        /** @internal */
         [CancelSteps](reason) {
           ResetQueue(this);
           const result = this._cancelAlgorithm(reason);
           ReadableStreamDefaultControllerClearAlgorithms(this);
           return result;
         }
+        /** @internal */
         [PullSteps](readRequest) {
           const stream = this._controlledReadableStream;
           if (this._queue.length > 0) {
@@ -2976,12 +3149,21 @@ function requirePonyfill_es2018() {
             SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, highWaterMark, sizeAlgorithm);
           }
         }
+        /**
+         * Whether or not the readable stream is locked to a {@link ReadableStreamDefaultReader | reader}.
+         */
         get locked() {
           if (!IsReadableStream(this)) {
             throw streamBrandCheckException$1("locked");
           }
           return IsReadableStreamLocked(this);
         }
+        /**
+         * Cancels the stream, signaling a loss of interest in the stream by a consumer.
+         *
+         * The supplied `reason` argument will be given to the underlying source's {@link UnderlyingSource.cancel | cancel()}
+         * method, which might or might not use it.
+         */
         cancel(reason = void 0) {
           if (!IsReadableStream(this)) {
             return promiseRejectedWith(streamBrandCheckException$1("cancel"));
@@ -3042,6 +3224,17 @@ function requirePonyfill_es2018() {
           }
           return ReadableStreamPipeTo(this, destination, options.preventClose, options.preventAbort, options.preventCancel, options.signal);
         }
+        /**
+         * Tees this readable stream, returning a two-element array containing the two resulting branches as
+         * new {@link ReadableStream} instances.
+         *
+         * Teeing a stream will lock it, preventing any other consumer from acquiring a reader.
+         * To cancel the stream, cancel both of the resulting branches; a composite cancellation reason will then be
+         * propagated to the stream's underlying source.
+         *
+         * Note that the chunks seen in each branch will be the same object. If the chunks are not immutable,
+         * this could allow interference between the two branches.
+         */
         tee() {
           if (!IsReadableStream(this)) {
             throw streamBrandCheckException$1("tee");
@@ -3194,12 +3387,18 @@ function requirePonyfill_es2018() {
           options = convertQueuingStrategyInit(options, "First parameter");
           this._byteLengthQueuingStrategyHighWaterMark = options.highWaterMark;
         }
+        /**
+         * Returns the high water mark provided to the constructor.
+         */
         get highWaterMark() {
           if (!IsByteLengthQueuingStrategy(this)) {
             throw byteLengthBrandCheckException("highWaterMark");
           }
           return this._byteLengthQueuingStrategyHighWaterMark;
         }
+        /**
+         * Measures the size of `chunk` by returning the value of its `byteLength` property.
+         */
         get size() {
           if (!IsByteLengthQueuingStrategy(this)) {
             throw byteLengthBrandCheckException("size");
@@ -3245,12 +3444,19 @@ function requirePonyfill_es2018() {
           options = convertQueuingStrategyInit(options, "First parameter");
           this._countQueuingStrategyHighWaterMark = options.highWaterMark;
         }
+        /**
+         * Returns the high water mark provided to the constructor.
+         */
         get highWaterMark() {
           if (!IsCountQueuingStrategy(this)) {
             throw countBrandCheckException("highWaterMark");
           }
           return this._countQueuingStrategyHighWaterMark;
         }
+        /**
+         * Measures the size of `chunk` by always returning 1.
+         * This ensures that the total queue size is a count of the number of chunks in the queue.
+         */
         get size() {
           if (!IsCountQueuingStrategy(this)) {
             throw countBrandCheckException("size");
@@ -3337,12 +3543,18 @@ function requirePonyfill_es2018() {
             startPromise_resolve(void 0);
           }
         }
+        /**
+         * The readable side of the transform stream.
+         */
         get readable() {
           if (!IsTransformStream(this)) {
             throw streamBrandCheckException("readable");
           }
           return this._readable;
         }
+        /**
+         * The writable side of the transform stream.
+         */
         get writable() {
           if (!IsTransformStream(this)) {
             throw streamBrandCheckException("writable");
@@ -3421,6 +3633,9 @@ function requirePonyfill_es2018() {
         constructor() {
           throw new TypeError("Illegal constructor");
         }
+        /**
+         * Returns the desired size to fill the readable side’s internal queue. It can be negative, if the queue is over-full.
+         */
         get desiredSize() {
           if (!IsTransformStreamDefaultController(this)) {
             throw defaultControllerBrandCheckException("desiredSize");
@@ -3434,12 +3649,20 @@ function requirePonyfill_es2018() {
           }
           TransformStreamDefaultControllerEnqueue(this, chunk);
         }
+        /**
+         * Errors both the readable side and the writable side of the controlled transform stream, making all future
+         * interactions with it fail with the given error `e`. Any chunks queued for transformation will be discarded.
+         */
         error(reason = void 0) {
           if (!IsTransformStreamDefaultController(this)) {
             throw defaultControllerBrandCheckException("error");
           }
           TransformStreamDefaultControllerError(this, reason);
         }
+        /**
+         * Closes the readable side and errors the writable side of the controlled transform stream. This is useful when the
+         * transformer only needs to consume a portion of the chunks written to the writable side.
+         */
         terminate() {
           if (!IsTransformStreamDefaultController(this)) {
             throw defaultControllerBrandCheckException("terminate");