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