strong-tie/inbound-calls
0
1/**2 * @license3 * web-streams-polyfill v3.3.34 * Copyright 2024 Mattias Buelens, Diwank Singh Tomer and other contributors.5 * This code is released under the MIT license.6 * SPDX-License-Identifier: MIT7 */8/// <reference lib="es2015.symbol" />9var SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ?10 Symbol :11 function (description) { return "Symbol(".concat(description, ")"); };12 13/******************************************************************************
14Copyright (c) Microsoft Corporation.
15
16Permission to use, copy, modify, and/or distribute this software for any
17purpose with or without fee is hereby granted.
18
19THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
20REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
21AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
22INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
23LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
24OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
25PERFORMANCE OF THIS SOFTWARE.
26***************************************************************************** */
27/* global Reflect, Promise, SuppressedError, Symbol */
28
29
30function __generator(thisArg, body) {
31 var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
32 return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
33 function verb(n) { return function (v) { return step([n, v]); }; }
34 function step(op) {
35 if (f) throw new TypeError("Generator is already executing.");
36 while (g && (g = 0, op[0] && (_ = 0)), _) try {
37 if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
38 if (y = 0, t) op = [op[0] & 2, t.value];
39 switch (op[0]) {
40 case 0: case 1: t = op; break;
41 case 4: _.label++; return { value: op[1], done: false };
42 case 5: _.label++; y = op[1]; op = [0]; continue;
43 case 7: op = _.ops.pop(); _.trys.pop(); continue;
44 default:
45 if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
46 if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
47 if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
48 if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
49 if (t[2]) _.ops.pop();
50 _.trys.pop(); continue;
51 }
52 op = body.call(thisArg, _);
53 } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
54 if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
55 }
56}
57
58function __values(o) {
59 var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
60 if (m) return m.call(o);
61 if (o && typeof o.length === "number") return {
62 next: function () {
63 if (o && i >= o.length) o = void 0;
64 return { value: o && o[i++], done: !o };
65 }
66 };
67 throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
68}
69
70function __await(v) {
71 return this instanceof __await ? (this.v = v, this) : new __await(v);
72}
73
74function __asyncGenerator(thisArg, _arguments, generator) {
75 if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
76 var g = generator.apply(thisArg, _arguments || []), i, q = [];
77 return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
78 function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
79 function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
80 function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
81 function fulfill(value) { resume("next", value); }
82 function reject(value) { resume("throw", value); }
83 function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
84}
85
86function __asyncDelegator(o) {
87 var i, p;
88 return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
89 function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
90}
91
92function __asyncValues(o) {
93 if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
94 var m = o[Symbol.asyncIterator], i;
95 return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
96 function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
97 function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
98}
99
100typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
101 var e = new Error(message);
102 return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
103};104 105function noop() {106 return undefined;107}108 109function typeIsObject(x) {110 return (typeof x === 'object' && x !== null) || typeof x === 'function';111}112var rethrowAssertionErrorRejection = noop;113function setFunctionName(fn, name) {114 try {115 Object.defineProperty(fn, 'name', {116 value: name,117 configurable: true118 });119 }120 catch (_a) {121 // This property is non-configurable in older browsers, so ignore if this throws.122 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#browser_compatibility123 }124}125 126var originalPromise = Promise;127var originalPromiseThen = Promise.prototype.then;128var originalPromiseReject = Promise.reject.bind(originalPromise);129// https://webidl.spec.whatwg.org/#a-new-promise130function newPromise(executor) {131 return new originalPromise(executor);132}133// https://webidl.spec.whatwg.org/#a-promise-resolved-with134function promiseResolvedWith(value) {135 return newPromise(function (resolve) { return resolve(value); });136}137// https://webidl.spec.whatwg.org/#a-promise-rejected-with138function promiseRejectedWith(reason) {139 return originalPromiseReject(reason);140}141function PerformPromiseThen(promise, onFulfilled, onRejected) {142 // There doesn't appear to be any way to correctly emulate the behaviour from JavaScript, so this is just an143 // approximation.144 return originalPromiseThen.call(promise, onFulfilled, onRejected);145}146// Bluebird logs a warning when a promise is created within a fulfillment handler, but then isn't returned147// from that handler. To prevent this, return null instead of void from all handlers.148// http://bluebirdjs.com/docs/warning-explanations.html#warning-a-promise-was-created-in-a-handler-but-was-not-returned-from-it149function uponPromise(promise, onFulfilled, onRejected) {150 PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), undefined, rethrowAssertionErrorRejection);151}152function uponFulfillment(promise, onFulfilled) {153 uponPromise(promise, onFulfilled);154}155function uponRejection(promise, onRejected) {156 uponPromise(promise, undefined, onRejected);157}158function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) {159 return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler);160}161function setPromiseIsHandledToTrue(promise) {162 PerformPromiseThen(promise, undefined, rethrowAssertionErrorRejection);163}164var _queueMicrotask = function (callback) {165 if (typeof queueMicrotask === 'function') {166 _queueMicrotask = queueMicrotask;167 }168 else {169 var resolvedPromise_1 = promiseResolvedWith(undefined);170 _queueMicrotask = function (cb) { return PerformPromiseThen(resolvedPromise_1, cb); };171 }172 return _queueMicrotask(callback);173};174function reflectCall(F, V, args) {175 if (typeof F !== 'function') {176 throw new TypeError('Argument is not a function');177 }178 return Function.prototype.apply.call(F, V, args);179}180function promiseCall(F, V, args) {181 try {182 return promiseResolvedWith(reflectCall(F, V, args));183 }184 catch (value) {185 return promiseRejectedWith(value);186 }187}188 189// Original from Chromium190// https://chromium.googlesource.com/chromium/src/+/0aee4434a4dba42a42abaea9bfbc0cd196a63bc1/third_party/blink/renderer/core/streams/SimpleQueue.js191var QUEUE_MAX_ARRAY_SIZE = 16384;192/**193 * Simple queue structure.194 *195 * Avoids scalability issues with using a packed array directly by using196 * multiple arrays in a linked list and keeping the array size bounded.197 */198var SimpleQueue = /** @class */ (function () {199 function SimpleQueue() {200 this._cursor = 0;201 this._size = 0;202 // _front and _back are always defined.203 this._front = {204 _elements: [],205 _next: undefined206 };207 this._back = this._front;208 // The cursor is used to avoid calling Array.shift().209 // It contains the index of the front element of the array inside the210 // front-most node. It is always in the range [0, QUEUE_MAX_ARRAY_SIZE).211 this._cursor = 0;212 // When there is only one node, size === elements.length - cursor.213 this._size = 0;214 }215 Object.defineProperty(SimpleQueue.prototype, "length", {216 get: function () {217 return this._size;218 },219 enumerable: false,220 configurable: true221 });222 // For exception safety, this method is structured in order:223 // 1. Read state224 // 2. Calculate required state mutations225 // 3. Perform state mutations226 SimpleQueue.prototype.push = function (element) {227 var oldBack = this._back;228 var newBack = oldBack;229 if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) {230 newBack = {231 _elements: [],232 _next: undefined233 };234 }235 // push() is the mutation most likely to throw an exception, so it236 // goes first.237 oldBack._elements.push(element);238 if (newBack !== oldBack) {239 this._back = newBack;240 oldBack._next = newBack;241 }242 ++this._size;243 };244 // Like push(), shift() follows the read -> calculate -> mutate pattern for245 // exception safety.246 SimpleQueue.prototype.shift = function () { // must not be called on an empty queue247 var oldFront = this._front;248 var newFront = oldFront;249 var oldCursor = this._cursor;250 var newCursor = oldCursor + 1;251 var elements = oldFront._elements;252 var element = elements[oldCursor];253 if (newCursor === QUEUE_MAX_ARRAY_SIZE) {254 newFront = oldFront._next;255 newCursor = 0;256 }257 // No mutations before this point.258 --this._size;259 this._cursor = newCursor;260 if (oldFront !== newFront) {261 this._front = newFront;262 }263 // Permit shifted element to be garbage collected.264 elements[oldCursor] = undefined;265 return element;266 };267 // The tricky thing about forEach() is that it can be called268 // re-entrantly. The queue may be mutated inside the callback. It is easy to269 // see that push() within the callback has no negative effects since the end270 // of the queue is checked for on every iteration. If shift() is called271 // repeatedly within the callback then the next iteration may return an272 // element that has been removed. In this case the callback will be called273 // with undefined values until we either "catch up" with elements that still274 // exist or reach the back of the queue.275 SimpleQueue.prototype.forEach = function (callback) {276 var i = this._cursor;277 var node = this._front;278 var elements = node._elements;279 while (i !== elements.length || node._next !== undefined) {280 if (i === elements.length) {281 node = node._next;282 elements = node._elements;283 i = 0;284 if (elements.length === 0) {285 break;286 }287 }288 callback(elements[i]);289 ++i;290 }291 };292 // Return the element that would be returned if shift() was called now,293 // without modifying the queue.294 SimpleQueue.prototype.peek = function () { // must not be called on an empty queue295 var front = this._front;296 var cursor = this._cursor;297 return front._elements[cursor];298 };299 return SimpleQueue;300}());301 302var AbortSteps = SymbolPolyfill('[[AbortSteps]]');303var ErrorSteps = SymbolPolyfill('[[ErrorSteps]]');304var CancelSteps = SymbolPolyfill('[[CancelSteps]]');305var PullSteps = SymbolPolyfill('[[PullSteps]]');306var ReleaseSteps = SymbolPolyfill('[[ReleaseSteps]]');307 308function ReadableStreamReaderGenericInitialize(reader, stream) {309 reader._ownerReadableStream = stream;310 stream._reader = reader;311 if (stream._state === 'readable') {312 defaultReaderClosedPromiseInitialize(reader);313 }314 else if (stream._state === 'closed') {315 defaultReaderClosedPromiseInitializeAsResolved(reader);316 }317 else {318 defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);319 }320}321// A client of ReadableStreamDefaultReader and ReadableStreamBYOBReader may use these functions directly to bypass state322// check.323function ReadableStreamReaderGenericCancel(reader, reason) {324 var stream = reader._ownerReadableStream;325 return ReadableStreamCancel(stream, reason);326}327function ReadableStreamReaderGenericRelease(reader) {328 var stream = reader._ownerReadableStream;329 if (stream._state === 'readable') {330 defaultReaderClosedPromiseReject(reader, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness"));331 }332 else {333 defaultReaderClosedPromiseResetToRejected(reader, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness"));334 }335 stream._readableStreamController[ReleaseSteps]();336 stream._reader = undefined;337 reader._ownerReadableStream = undefined;338}339// Helper functions for the readers.340function readerLockException(name) {341 return new TypeError('Cannot ' + name + ' a stream using a released reader');342}343// Helper functions for the ReadableStreamDefaultReader.344function defaultReaderClosedPromiseInitialize(reader) {345 reader._closedPromise = newPromise(function (resolve, reject) {346 reader._closedPromise_resolve = resolve;347 reader._closedPromise_reject = reject;348 });349}350function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {351 defaultReaderClosedPromiseInitialize(reader);352 defaultReaderClosedPromiseReject(reader, reason);353}354function defaultReaderClosedPromiseInitializeAsResolved(reader) {355 defaultReaderClosedPromiseInitialize(reader);356 defaultReaderClosedPromiseResolve(reader);357}358function defaultReaderClosedPromiseReject(reader, reason) {359 if (reader._closedPromise_reject === undefined) {360 return;361 }362 setPromiseIsHandledToTrue(reader._closedPromise);363 reader._closedPromise_reject(reason);364 reader._closedPromise_resolve = undefined;365 reader._closedPromise_reject = undefined;366}367function defaultReaderClosedPromiseResetToRejected(reader, reason) {368 defaultReaderClosedPromiseInitializeAsRejected(reader, reason);369}370function defaultReaderClosedPromiseResolve(reader) {371 if (reader._closedPromise_resolve === undefined) {372 return;373 }374 reader._closedPromise_resolve(undefined);375 reader._closedPromise_resolve = undefined;376 reader._closedPromise_reject = undefined;377}378 379/// <reference lib="es2015.core" />380// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite#Polyfill381var NumberIsFinite = Number.isFinite || function (x) {382 return typeof x === 'number' && isFinite(x);383};384 385/// <reference lib="es2015.core" />386// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc#Polyfill387var MathTrunc = Math.trunc || function (v) {388 return v < 0 ? Math.ceil(v) : Math.floor(v);389};390 391// https://heycam.github.io/webidl/#idl-dictionaries392function isDictionary(x) {393 return typeof x === 'object' || typeof x === 'function';394}395function assertDictionary(obj, context) {396 if (obj !== undefined && !isDictionary(obj)) {397 throw new TypeError("".concat(context, " is not an object."));398 }399}400// https://heycam.github.io/webidl/#idl-callback-functions401function assertFunction(x, context) {402 if (typeof x !== 'function') {403 throw new TypeError("".concat(context, " is not a function."));404 }405}406// https://heycam.github.io/webidl/#idl-object407function isObject(x) {408 return (typeof x === 'object' && x !== null) || typeof x === 'function';409}410function assertObject(x, context) {411 if (!isObject(x)) {412 throw new TypeError("".concat(context, " is not an object."));413 }414}415function assertRequiredArgument(x, position, context) {416 if (x === undefined) {417 throw new TypeError("Parameter ".concat(position, " is required in '").concat(context, "'."));418 }419}420function assertRequiredField(x, field, context) {421 if (x === undefined) {422 throw new TypeError("".concat(field, " is required in '").concat(context, "'."));423 }424}425// https://heycam.github.io/webidl/#idl-unrestricted-double426function convertUnrestrictedDouble(value) {427 return Number(value);428}429function censorNegativeZero(x) {430 return x === 0 ? 0 : x;431}432function integerPart(x) {433 return censorNegativeZero(MathTrunc(x));434}435// https://heycam.github.io/webidl/#idl-unsigned-long-long436function convertUnsignedLongLongWithEnforceRange(value, context) {437 var lowerBound = 0;438 var upperBound = Number.MAX_SAFE_INTEGER;439 var x = Number(value);440 x = censorNegativeZero(x);441 if (!NumberIsFinite(x)) {442 throw new TypeError("".concat(context, " is not a finite number"));443 }444 x = integerPart(x);445 if (x < lowerBound || x > upperBound) {446 throw new TypeError("".concat(context, " is outside the accepted range of ").concat(lowerBound, " to ").concat(upperBound, ", inclusive"));447 }448 if (!NumberIsFinite(x) || x === 0) {449 return 0;450 }451 // TODO Use BigInt if supported?452 // let xBigInt = BigInt(integerPart(x));453 // xBigInt = BigInt.asUintN(64, xBigInt);454 // return Number(xBigInt);455 return x;456}457 458function assertReadableStream(x, context) {459 if (!IsReadableStream(x)) {460 throw new TypeError("".concat(context, " is not a ReadableStream."));461 }462}463 464// Abstract operations for the ReadableStream.465function AcquireReadableStreamDefaultReader(stream) {466 return new ReadableStreamDefaultReader(stream);467}468// ReadableStream API exposed for controllers.469function ReadableStreamAddReadRequest(stream, readRequest) {470 stream._reader._readRequests.push(readRequest);471}472function ReadableStreamFulfillReadRequest(stream, chunk, done) {473 var reader = stream._reader;474 var readRequest = reader._readRequests.shift();475 if (done) {476 readRequest._closeSteps();477 }478 else {479 readRequest._chunkSteps(chunk);480 }481}482function ReadableStreamGetNumReadRequests(stream) {483 return stream._reader._readRequests.length;484}485function ReadableStreamHasDefaultReader(stream) {486 var reader = stream._reader;487 if (reader === undefined) {488 return false;489 }490 if (!IsReadableStreamDefaultReader(reader)) {491 return false;492 }493 return true;494}495/**496 * A default reader vended by a {@link ReadableStream}.497 *498 * @public499 */500var ReadableStreamDefaultReader = /** @class */ (function () {501 function ReadableStreamDefaultReader(stream) {502 assertRequiredArgument(stream, 1, 'ReadableStreamDefaultReader');503 assertReadableStream(stream, 'First parameter');504 if (IsReadableStreamLocked(stream)) {505 throw new TypeError('This stream has already been locked for exclusive reading by another reader');506 }507 ReadableStreamReaderGenericInitialize(this, stream);508 this._readRequests = new SimpleQueue();509 }510 Object.defineProperty(ReadableStreamDefaultReader.prototype, "closed", {511 /**512 * Returns a promise that will be fulfilled when the stream becomes closed,513 * or rejected if the stream ever errors or the reader's lock is released before the stream finishes closing.514 */515 get: function () {516 if (!IsReadableStreamDefaultReader(this)) {517 return promiseRejectedWith(defaultReaderBrandCheckException('closed'));518 }519 return this._closedPromise;520 },521 enumerable: false,522 configurable: true523 });524 /**525 * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.526 */527 ReadableStreamDefaultReader.prototype.cancel = function (reason) {528 if (reason === void 0) { reason = undefined; }529 if (!IsReadableStreamDefaultReader(this)) {530 return promiseRejectedWith(defaultReaderBrandCheckException('cancel'));531 }532 if (this._ownerReadableStream === undefined) {533 return promiseRejectedWith(readerLockException('cancel'));534 }535 return ReadableStreamReaderGenericCancel(this, reason);536 };537 /**538 * Returns a promise that allows access to the next chunk from the stream's internal queue, if available.539 *540 * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.541 */542 ReadableStreamDefaultReader.prototype.read = function () {543 if (!IsReadableStreamDefaultReader(this)) {544 return promiseRejectedWith(defaultReaderBrandCheckException('read'));545 }546 if (this._ownerReadableStream === undefined) {547 return promiseRejectedWith(readerLockException('read from'));548 }549 var resolvePromise;550 var rejectPromise;551 var promise = newPromise(function (resolve, reject) {552 resolvePromise = resolve;553 rejectPromise = reject;554 });555 var readRequest = {556 _chunkSteps: function (chunk) { return resolvePromise({ value: chunk, done: false }); },557 _closeSteps: function () { return resolvePromise({ value: undefined, done: true }); },558 _errorSteps: function (e) { return rejectPromise(e); }559 };560 ReadableStreamDefaultReaderRead(this, readRequest);561 return promise;562 };563 /**564 * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.565 * If the associated stream is errored when the lock is released, the reader will appear errored in the same way566 * from now on; otherwise, the reader will appear closed.567 *568 * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by569 * the reader's {@link ReadableStreamDefaultReader.read | read()} method has not yet been settled. Attempting to570 * do so will throw a `TypeError` and leave the reader locked to the stream.571 */572 ReadableStreamDefaultReader.prototype.releaseLock = function () {573 if (!IsReadableStreamDefaultReader(this)) {574 throw defaultReaderBrandCheckException('releaseLock');575 }576 if (this._ownerReadableStream === undefined) {577 return;578 }579 ReadableStreamDefaultReaderRelease(this);580 };581 return ReadableStreamDefaultReader;582}());583Object.defineProperties(ReadableStreamDefaultReader.prototype, {584 cancel: { enumerable: true },585 read: { enumerable: true },586 releaseLock: { enumerable: true },587 closed: { enumerable: true }588});589setFunctionName(ReadableStreamDefaultReader.prototype.cancel, 'cancel');590setFunctionName(ReadableStreamDefaultReader.prototype.read, 'read');591setFunctionName(ReadableStreamDefaultReader.prototype.releaseLock, 'releaseLock');592if (typeof SymbolPolyfill.toStringTag === 'symbol') {593 Object.defineProperty(ReadableStreamDefaultReader.prototype, SymbolPolyfill.toStringTag, {594 value: 'ReadableStreamDefaultReader',595 configurable: true596 });597}598// Abstract operations for the readers.599function IsReadableStreamDefaultReader(x) {600 if (!typeIsObject(x)) {601 return false;602 }603 if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {604 return false;605 }606 return x instanceof ReadableStreamDefaultReader;607}608function ReadableStreamDefaultReaderRead(reader, readRequest) {609 var stream = reader._ownerReadableStream;610 stream._disturbed = true;611 if (stream._state === 'closed') {612 readRequest._closeSteps();613 }614 else if (stream._state === 'errored') {615 readRequest._errorSteps(stream._storedError);616 }617 else {618 stream._readableStreamController[PullSteps](readRequest);619 }620}621function ReadableStreamDefaultReaderRelease(reader) {622 ReadableStreamReaderGenericRelease(reader);623 var e = new TypeError('Reader was released');624 ReadableStreamDefaultReaderErrorReadRequests(reader, e);625}626function ReadableStreamDefaultReaderErrorReadRequests(reader, e) {627 var readRequests = reader._readRequests;628 reader._readRequests = new SimpleQueue();629 readRequests.forEach(function (readRequest) {630 readRequest._errorSteps(e);631 });632}633// Helper functions for the ReadableStreamDefaultReader.634function defaultReaderBrandCheckException(name) {635 return new TypeError("ReadableStreamDefaultReader.prototype.".concat(name, " can only be used on a ReadableStreamDefaultReader"));636}637 638var _a$1, _b, _c;639function CreateArrayFromList(elements) {640 // We use arrays to represent lists, so this is basically a no-op.641 // Do a slice though just in case we happen to depend on the unique-ness.642 return elements.slice();643}644function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) {645 new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);646}647var TransferArrayBuffer = function (O) {648 if (typeof O.transfer === 'function') {649 TransferArrayBuffer = function (buffer) { return buffer.transfer(); };650 }651 else if (typeof structuredClone === 'function') {652 TransferArrayBuffer = function (buffer) { return structuredClone(buffer, { transfer: [buffer] }); };653 }654 else {655 // Not implemented correctly656 TransferArrayBuffer = function (buffer) { return buffer; };657 }658 return TransferArrayBuffer(O);659};660var IsDetachedBuffer = function (O) {661 if (typeof O.detached === 'boolean') {662 IsDetachedBuffer = function (buffer) { return buffer.detached; };663 }664 else {665 // Not implemented correctly666 IsDetachedBuffer = function (buffer) { return buffer.byteLength === 0; };667 }668 return IsDetachedBuffer(O);669};670function ArrayBufferSlice(buffer, begin, end) {671 // ArrayBuffer.prototype.slice is not available on IE10672 // https://www.caniuse.com/mdn-javascript_builtins_arraybuffer_slice673 if (buffer.slice) {674 return buffer.slice(begin, end);675 }676 var length = end - begin;677 var slice = new ArrayBuffer(length);678 CopyDataBlockBytes(slice, 0, buffer, begin, length);679 return slice;680}681function GetMethod(receiver, prop) {682 var func = receiver[prop];683 if (func === undefined || func === null) {684 return undefined;685 }686 if (typeof func !== 'function') {687 throw new TypeError("".concat(String(prop), " is not a function"));688 }689 return func;690}691function CreateAsyncFromSyncIterator(syncIteratorRecord) {692 // Instead of re-implementing CreateAsyncFromSyncIterator and %AsyncFromSyncIteratorPrototype%,693 // we use yield* inside an async generator function to achieve the same result.694 var _a;695 // Wrap the sync iterator inside a sync iterable, so we can use it with yield*.696 var syncIterable = (_a = {},697 _a[SymbolPolyfill.iterator] = function () { return syncIteratorRecord.iterator; },698 _a);699 // Create an async generator function and immediately invoke it.700 var asyncIterator = (function () {701 return __asyncGenerator(this, arguments, function () {702 return __generator(this, function (_a) {703 switch (_a.label) {704 case 0: return [5 /*yield**/, __values(__asyncDelegator(__asyncValues(syncIterable)))];705 case 1: return [4 /*yield*/, __await.apply(void 0, [_a.sent()])];706 case 2: return [4 /*yield*/, __await.apply(void 0, [_a.sent()])];707 case 3: return [2 /*return*/, _a.sent()];708 }709 });710 });711 }());712 // Return as an async iterator record.713 var nextMethod = asyncIterator.next;714 return { iterator: asyncIterator, nextMethod: nextMethod, done: false };715}716// Aligns with core-js/modules/es.symbol.async-iterator.js717var SymbolAsyncIterator = (_c = (_a$1 = SymbolPolyfill.asyncIterator) !== null && _a$1 !== void 0 ? _a$1 : (_b = SymbolPolyfill.for) === null || _b === void 0 ? void 0 : _b.call(SymbolPolyfill, 'Symbol.asyncIterator')) !== null && _c !== void 0 ? _c : '@@asyncIterator';718function GetIterator(obj, hint, method) {719 if (hint === void 0) { hint = 'sync'; }720 if (method === undefined) {721 if (hint === 'async') {722 method = GetMethod(obj, SymbolAsyncIterator);723 if (method === undefined) {724 var syncMethod = GetMethod(obj, SymbolPolyfill.iterator);725 var syncIteratorRecord = GetIterator(obj, 'sync', syncMethod);726 return CreateAsyncFromSyncIterator(syncIteratorRecord);727 }728 }729 else {730 method = GetMethod(obj, SymbolPolyfill.iterator);731 }732 }733 if (method === undefined) {734 throw new TypeError('The object is not iterable');735 }736 var iterator = reflectCall(method, obj, []);737 if (!typeIsObject(iterator)) {738 throw new TypeError('The iterator method must return an object');739 }740 var nextMethod = iterator.next;741 return { iterator: iterator, nextMethod: nextMethod, done: false };742}743function IteratorNext(iteratorRecord) {744 var result = reflectCall(iteratorRecord.nextMethod, iteratorRecord.iterator, []);745 if (!typeIsObject(result)) {746 throw new TypeError('The iterator.next() method must return an object');747 }748 return result;749}750function IteratorComplete(iterResult) {751 return Boolean(iterResult.done);752}753function IteratorValue(iterResult) {754 return iterResult.value;755}756 757/// <reference lib="es2018.asynciterable" />758var _a;759// We cannot access %AsyncIteratorPrototype% without non-ES2018 syntax, but we can re-create it.760var AsyncIteratorPrototype = (_a = {},761 // 25.1.3.1 %AsyncIteratorPrototype% [ @@asyncIterator ] ( )762 // https://tc39.github.io/ecma262/#sec-asynciteratorprototype-asynciterator763 _a[SymbolAsyncIterator] = function () {764 return this;765 },766 _a);767Object.defineProperty(AsyncIteratorPrototype, SymbolAsyncIterator, { enumerable: false });768 769/// <reference lib="es2018.asynciterable" />770var ReadableStreamAsyncIteratorImpl = /** @class */ (function () {771 function ReadableStreamAsyncIteratorImpl(reader, preventCancel) {772 this._ongoingPromise = undefined;773 this._isFinished = false;774 this._reader = reader;775 this._preventCancel = preventCancel;776 }777 ReadableStreamAsyncIteratorImpl.prototype.next = function () {778 var _this = this;779 var nextSteps = function () { return _this._nextSteps(); };780 this._ongoingPromise = this._ongoingPromise ?781 transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) :782 nextSteps();783 return this._ongoingPromise;784 };785 ReadableStreamAsyncIteratorImpl.prototype.return = function (value) {786 var _this = this;787 var returnSteps = function () { return _this._returnSteps(value); };788 return this._ongoingPromise ?789 transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) :790 returnSteps();791 };792 ReadableStreamAsyncIteratorImpl.prototype._nextSteps = function () {793 var _this = this;794 if (this._isFinished) {795 return Promise.resolve({ value: undefined, done: true });796 }797 var reader = this._reader;798 var resolvePromise;799 var rejectPromise;800 var promise = newPromise(function (resolve, reject) {801 resolvePromise = resolve;802 rejectPromise = reject;803 });804 var readRequest = {805 _chunkSteps: function (chunk) {806 _this._ongoingPromise = undefined;807 // This needs to be delayed by one microtask, otherwise we stop pulling too early which breaks a test.808 // FIXME Is this a bug in the specification, or in the test?809 _queueMicrotask(function () { return resolvePromise({ value: chunk, done: false }); });810 },811 _closeSteps: function () {812 _this._ongoingPromise = undefined;813 _this._isFinished = true;814 ReadableStreamReaderGenericRelease(reader);815 resolvePromise({ value: undefined, done: true });816 },817 _errorSteps: function (reason) {818 _this._ongoingPromise = undefined;819 _this._isFinished = true;820 ReadableStreamReaderGenericRelease(reader);821 rejectPromise(reason);822 }823 };824 ReadableStreamDefaultReaderRead(reader, readRequest);825 return promise;826 };827 ReadableStreamAsyncIteratorImpl.prototype._returnSteps = function (value) {828 if (this._isFinished) {829 return Promise.resolve({ value: value, done: true });830 }831 this._isFinished = true;832 var reader = this._reader;833 if (!this._preventCancel) {834 var result = ReadableStreamReaderGenericCancel(reader, value);835 ReadableStreamReaderGenericRelease(reader);836 return transformPromiseWith(result, function () { return ({ value: value, done: true }); });837 }838 ReadableStreamReaderGenericRelease(reader);839 return promiseResolvedWith({ value: value, done: true });840 };841 return ReadableStreamAsyncIteratorImpl;842}());843var ReadableStreamAsyncIteratorPrototype = {844 next: function () {845 if (!IsReadableStreamAsyncIterator(this)) {846 return promiseRejectedWith(streamAsyncIteratorBrandCheckException('next'));847 }848 return this._asyncIteratorImpl.next();849 },850 return: function (value) {851 if (!IsReadableStreamAsyncIterator(this)) {852 return promiseRejectedWith(streamAsyncIteratorBrandCheckException('return'));853 }854 return this._asyncIteratorImpl.return(value);855 }856};857Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);858// Abstract operations for the ReadableStream.859function AcquireReadableStreamAsyncIterator(stream, preventCancel) {860 var reader = AcquireReadableStreamDefaultReader(stream);861 var impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel);862 var iterator = Object.create(ReadableStreamAsyncIteratorPrototype);863 iterator._asyncIteratorImpl = impl;864 return iterator;865}866function IsReadableStreamAsyncIterator(x) {867 if (!typeIsObject(x)) {868 return false;869 }870 if (!Object.prototype.hasOwnProperty.call(x, '_asyncIteratorImpl')) {871 return false;872 }873 try {874 // noinspection SuspiciousTypeOfGuard875 return x._asyncIteratorImpl instanceof876 ReadableStreamAsyncIteratorImpl;877 }878 catch (_a) {879 return false;880 }881}882// Helper functions for the ReadableStream.883function streamAsyncIteratorBrandCheckException(name) {884 return new TypeError("ReadableStreamAsyncIterator.".concat(name, " can only be used on a ReadableSteamAsyncIterator"));885}886 887/// <reference lib="es2015.core" />888// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN#Polyfill889var NumberIsNaN = Number.isNaN || function (x) {890 // eslint-disable-next-line no-self-compare891 return x !== x;892};893 894function IsNonNegativeNumber(v) {895 if (typeof v !== 'number') {896 return false;897 }898 if (NumberIsNaN(v)) {899 return false;900 }901 if (v < 0) {902 return false;903 }904 return true;905}906function CloneAsUint8Array(O) {907 var buffer = ArrayBufferSlice(O.buffer, O.byteOffset, O.byteOffset + O.byteLength);908 return new Uint8Array(buffer);909}910 911function DequeueValue(container) {912 var pair = container._queue.shift();913 container._queueTotalSize -= pair.size;914 if (container._queueTotalSize < 0) {915 container._queueTotalSize = 0;916 }917 return pair.value;918}919function EnqueueValueWithSize(container, value, size) {920 if (!IsNonNegativeNumber(size) || size === Infinity) {921 throw new RangeError('Size must be a finite, non-NaN, non-negative number.');922 }923 container._queue.push({ value: value, size: size });924 container._queueTotalSize += size;925}926function PeekQueueValue(container) {927 var pair = container._queue.peek();928 return pair.value;929}930function ResetQueue(container) {931 container._queue = new SimpleQueue();932 container._queueTotalSize = 0;933}934 935function isDataViewConstructor(ctor) {936 return ctor === DataView;937}938function isDataView(view) {939 return isDataViewConstructor(view.constructor);940}941function arrayBufferViewElementSize(ctor) {942 if (isDataViewConstructor(ctor)) {943 return 1;944 }945 return ctor.BYTES_PER_ELEMENT;946}947 948/**949 * A pull-into request in a {@link ReadableByteStreamController}.950 *951 * @public952 */953var ReadableStreamBYOBRequest = /** @class */ (function () {954 function ReadableStreamBYOBRequest() {955 throw new TypeError('Illegal constructor');956 }957 Object.defineProperty(ReadableStreamBYOBRequest.prototype, "view", {958 /**959 * Returns the view for writing in to, or `null` if the BYOB request has already been responded to.960 */961 get: function () {962 if (!IsReadableStreamBYOBRequest(this)) {963 throw byobRequestBrandCheckException('view');964 }965 return this._view;966 },967 enumerable: false,968 configurable: true969 });970 ReadableStreamBYOBRequest.prototype.respond = function (bytesWritten) {971 if (!IsReadableStreamBYOBRequest(this)) {972 throw byobRequestBrandCheckException('respond');973 }974 assertRequiredArgument(bytesWritten, 1, 'respond');975 bytesWritten = convertUnsignedLongLongWithEnforceRange(bytesWritten, 'First parameter');976 if (this._associatedReadableByteStreamController === undefined) {977 throw new TypeError('This BYOB request has been invalidated');978 }979 if (IsDetachedBuffer(this._view.buffer)) {980 throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");981 }982 ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);983 };984 ReadableStreamBYOBRequest.prototype.respondWithNewView = function (view) {985 if (!IsReadableStreamBYOBRequest(this)) {986 throw byobRequestBrandCheckException('respondWithNewView');987 }988 assertRequiredArgument(view, 1, 'respondWithNewView');989 if (!ArrayBuffer.isView(view)) {990 throw new TypeError('You can only respond with array buffer views');991 }992 if (this._associatedReadableByteStreamController === undefined) {993 throw new TypeError('This BYOB request has been invalidated');994 }995 if (IsDetachedBuffer(view.buffer)) {996 throw new TypeError('The given view\'s buffer has been detached and so cannot be used as a response');997 }998 ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);999 };1000 return ReadableStreamBYOBRequest;1001}());1002Object.defineProperties(ReadableStreamBYOBRequest.prototype, {1003 respond: { enumerable: true },1004 respondWithNewView: { enumerable: true },1005 view: { enumerable: true }1006});1007setFunctionName(ReadableStreamBYOBRequest.prototype.respond, 'respond');1008setFunctionName(ReadableStreamBYOBRequest.prototype.respondWithNewView, 'respondWithNewView');1009if (typeof SymbolPolyfill.toStringTag === 'symbol') {1010 Object.defineProperty(ReadableStreamBYOBRequest.prototype, SymbolPolyfill.toStringTag, {1011 value: 'ReadableStreamBYOBRequest',1012 configurable: true1013 });1014}1015/**1016 * Allows control of a {@link ReadableStream | readable byte stream}'s state and internal queue.1017 *1018 * @public1019 */1020var ReadableByteStreamController = /** @class */ (function () {1021 function ReadableByteStreamController() {1022 throw new TypeError('Illegal constructor');1023 }1024 Object.defineProperty(ReadableByteStreamController.prototype, "byobRequest", {1025 /**1026 * Returns the current BYOB pull request, or `null` if there isn't one.1027 */1028 get: function () {1029 if (!IsReadableByteStreamController(this)) {1030 throw byteStreamControllerBrandCheckException('byobRequest');1031 }1032 return ReadableByteStreamControllerGetBYOBRequest(this);1033 },1034 enumerable: false,1035 configurable: true1036 });1037 Object.defineProperty(ReadableByteStreamController.prototype, "desiredSize", {1038 /**1039 * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is1040 * over-full. An underlying byte source ought to use this information to determine when and how to apply backpressure.1041 */1042 get: function () {1043 if (!IsReadableByteStreamController(this)) {1044 throw byteStreamControllerBrandCheckException('desiredSize');1045 }1046 return ReadableByteStreamControllerGetDesiredSize(this);1047 },1048 enumerable: false,1049 configurable: true1050 });1051 /**1052 * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from1053 * the stream, but once those are read, the stream will become closed.1054 */1055 ReadableByteStreamController.prototype.close = function () {1056 if (!IsReadableByteStreamController(this)) {1057 throw byteStreamControllerBrandCheckException('close');1058 }1059 if (this._closeRequested) {1060 throw new TypeError('The stream has already been closed; do not close it again!');1061 }1062 var state = this._controlledReadableByteStream._state;1063 if (state !== 'readable') {1064 throw new TypeError("The stream (in ".concat(state, " state) is not in the readable state and cannot be closed"));1065 }1066 ReadableByteStreamControllerClose(this);1067 };1068 ReadableByteStreamController.prototype.enqueue = function (chunk) {1069 if (!IsReadableByteStreamController(this)) {1070 throw byteStreamControllerBrandCheckException('enqueue');1071 }1072 assertRequiredArgument(chunk, 1, 'enqueue');1073 if (!ArrayBuffer.isView(chunk)) {1074 throw new TypeError('chunk must be an array buffer view');1075 }1076 if (chunk.byteLength === 0) {1077 throw new TypeError('chunk must have non-zero byteLength');1078 }1079 if (chunk.buffer.byteLength === 0) {1080 throw new TypeError("chunk's buffer must have non-zero byteLength");1081 }1082 if (this._closeRequested) {1083 throw new TypeError('stream is closed or draining');1084 }1085 var state = this._controlledReadableByteStream._state;1086 if (state !== 'readable') {1087 throw new TypeError("The stream (in ".concat(state, " state) is not in the readable state and cannot be enqueued to"));1088 }1089 ReadableByteStreamControllerEnqueue(this, chunk);1090 };1091 /**1092 * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.1093 */1094 ReadableByteStreamController.prototype.error = function (e) {1095 if (e === void 0) { e = undefined; }1096 if (!IsReadableByteStreamController(this)) {1097 throw byteStreamControllerBrandCheckException('error');1098 }1099 ReadableByteStreamControllerError(this, e);1100 };1101 /** @internal */1102 ReadableByteStreamController.prototype[CancelSteps] = function (reason) {1103 ReadableByteStreamControllerClearPendingPullIntos(this);1104 ResetQueue(this);1105 var result = this._cancelAlgorithm(reason);1106 ReadableByteStreamControllerClearAlgorithms(this);1107 return result;1108 };1109 /** @internal */1110 ReadableByteStreamController.prototype[PullSteps] = function (readRequest) {1111 var stream = this._controlledReadableByteStream;1112 if (this._queueTotalSize > 0) {1113 ReadableByteStreamControllerFillReadRequestFromQueue(this, readRequest);1114 return;1115 }1116 var autoAllocateChunkSize = this._autoAllocateChunkSize;1117 if (autoAllocateChunkSize !== undefined) {1118 var buffer = void 0;1119 try {1120 buffer = new ArrayBuffer(autoAllocateChunkSize);1121 }1122 catch (bufferE) {1123 readRequest._errorSteps(bufferE);1124 return;1125 }1126 var pullIntoDescriptor = {1127 buffer: buffer,1128 bufferByteLength: autoAllocateChunkSize,1129 byteOffset: 0,1130 byteLength: autoAllocateChunkSize,1131 bytesFilled: 0,1132 minimumFill: 1,1133 elementSize: 1,1134 viewConstructor: Uint8Array,1135 readerType: 'default'1136 };1137 this._pendingPullIntos.push(pullIntoDescriptor);1138 }1139 ReadableStreamAddReadRequest(stream, readRequest);1140 ReadableByteStreamControllerCallPullIfNeeded(this);1141 };1142 /** @internal */1143 ReadableByteStreamController.prototype[ReleaseSteps] = function () {1144 if (this._pendingPullIntos.length > 0) {1145 var firstPullInto = this._pendingPullIntos.peek();1146 firstPullInto.readerType = 'none';1147 this._pendingPullIntos = new SimpleQueue();1148 this._pendingPullIntos.push(firstPullInto);1149 }1150 };1151 return ReadableByteStreamController;1152}());1153Object.defineProperties(ReadableByteStreamController.prototype, {1154 close: { enumerable: true },1155 enqueue: { enumerable: true },1156 error: { enumerable: true },1157 byobRequest: { enumerable: true },1158 desiredSize: { enumerable: true }1159});1160setFunctionName(ReadableByteStreamController.prototype.close, 'close');1161setFunctionName(ReadableByteStreamController.prototype.enqueue, 'enqueue');1162setFunctionName(ReadableByteStreamController.prototype.error, 'error');1163if (typeof SymbolPolyfill.toStringTag === 'symbol') {1164 Object.defineProperty(ReadableByteStreamController.prototype, SymbolPolyfill.toStringTag, {1165 value: 'ReadableByteStreamController',1166 configurable: true1167 });1168}1169// Abstract operations for the ReadableByteStreamController.1170function IsReadableByteStreamController(x) {1171 if (!typeIsObject(x)) {1172 return false;1173 }1174 if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableByteStream')) {1175 return false;1176 }1177 return x instanceof ReadableByteStreamController;1178}1179function IsReadableStreamBYOBRequest(x) {1180 if (!typeIsObject(x)) {1181 return false;1182 }1183 if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {1184 return false;1185 }1186 return x instanceof ReadableStreamBYOBRequest;1187}1188function ReadableByteStreamControllerCallPullIfNeeded(controller) {1189 var shouldPull = ReadableByteStreamControllerShouldCallPull(controller);1190 if (!shouldPull) {1191 return;1192 }1193 if (controller._pulling) {1194 controller._pullAgain = true;1195 return;1196 }1197 controller._pulling = true;1198 // TODO: Test controller argument1199 var pullPromise = controller._pullAlgorithm();1200 uponPromise(pullPromise, function () {