5965 lines
1.1 MiB
5965 lines
1.1 MiB
(function(define){var __define; typeof define === "function" && (__define=define,define=null);
|
|
// modules are defined as an array
|
|
// [ module function, map of requires ]
|
|
//
|
|
// map of requires is short require name -> numeric require
|
|
//
|
|
// anything defined in a previous bundle is accessed via the
|
|
// orig method which is the require for previous bundles
|
|
|
|
(function (modules, entry, mainEntry, parcelRequireName, globalName) {
|
|
/* eslint-disable no-undef */
|
|
var globalObject =
|
|
typeof globalThis !== 'undefined'
|
|
? globalThis
|
|
: typeof self !== 'undefined'
|
|
? self
|
|
: typeof window !== 'undefined'
|
|
? window
|
|
: typeof global !== 'undefined'
|
|
? global
|
|
: {};
|
|
/* eslint-enable no-undef */
|
|
|
|
// Save the require from previous bundle to this closure if any
|
|
var previousRequire =
|
|
typeof globalObject[parcelRequireName] === 'function' &&
|
|
globalObject[parcelRequireName];
|
|
|
|
var cache = previousRequire.cache || {};
|
|
// Do not use `require` to prevent Webpack from trying to bundle this call
|
|
var nodeRequire =
|
|
typeof module !== 'undefined' &&
|
|
typeof module.require === 'function' &&
|
|
module.require.bind(module);
|
|
|
|
function newRequire(name, jumped) {
|
|
if (!cache[name]) {
|
|
if (!modules[name]) {
|
|
// if we cannot find the module within our internal map or
|
|
// cache jump to the current global require ie. the last bundle
|
|
// that was added to the page.
|
|
var currentRequire =
|
|
typeof globalObject[parcelRequireName] === 'function' &&
|
|
globalObject[parcelRequireName];
|
|
if (!jumped && currentRequire) {
|
|
return currentRequire(name, true);
|
|
}
|
|
|
|
// If there are other bundles on this page the require from the
|
|
// previous one is saved to 'previousRequire'. Repeat this as
|
|
// many times as there are bundles until the module is found or
|
|
// we exhaust the require chain.
|
|
if (previousRequire) {
|
|
return previousRequire(name, true);
|
|
}
|
|
|
|
// Try the node require function if it exists.
|
|
if (nodeRequire && typeof name === 'string') {
|
|
return nodeRequire(name);
|
|
}
|
|
|
|
var err = new Error("Cannot find module '" + name + "'");
|
|
err.code = 'MODULE_NOT_FOUND';
|
|
throw err;
|
|
}
|
|
|
|
localRequire.resolve = resolve;
|
|
localRequire.cache = {};
|
|
|
|
var module = (cache[name] = new newRequire.Module(name));
|
|
|
|
modules[name][0].call(
|
|
module.exports,
|
|
localRequire,
|
|
module,
|
|
module.exports,
|
|
this
|
|
);
|
|
}
|
|
|
|
return cache[name].exports;
|
|
|
|
function localRequire(x) {
|
|
var res = localRequire.resolve(x);
|
|
return res === false ? {} : newRequire(res);
|
|
}
|
|
|
|
function resolve(x) {
|
|
var id = modules[name][1][x];
|
|
return id != null ? id : x;
|
|
}
|
|
}
|
|
|
|
function Module(moduleName) {
|
|
this.id = moduleName;
|
|
this.bundle = newRequire;
|
|
this.exports = {};
|
|
}
|
|
|
|
newRequire.isParcelRequire = true;
|
|
newRequire.Module = Module;
|
|
newRequire.modules = modules;
|
|
newRequire.cache = cache;
|
|
newRequire.parent = previousRequire;
|
|
newRequire.register = function (id, exports) {
|
|
modules[id] = [
|
|
function (require, module) {
|
|
module.exports = exports;
|
|
},
|
|
{},
|
|
];
|
|
};
|
|
|
|
Object.defineProperty(newRequire, 'root', {
|
|
get: function () {
|
|
return globalObject[parcelRequireName];
|
|
},
|
|
});
|
|
|
|
globalObject[parcelRequireName] = newRequire;
|
|
|
|
for (var i = 0; i < entry.length; i++) {
|
|
newRequire(entry[i]);
|
|
}
|
|
|
|
if (mainEntry) {
|
|
// Expose entry point to Node, AMD or browser globals
|
|
// Based on https://github.com/ForbesLindesay/umd/blob/master/template.js
|
|
var mainExports = newRequire(mainEntry);
|
|
|
|
// CommonJS
|
|
if (typeof exports === 'object' && typeof module !== 'undefined') {
|
|
module.exports = mainExports;
|
|
|
|
// RequireJS
|
|
} else if (typeof define === 'function' && define.amd) {
|
|
define(function () {
|
|
return mainExports;
|
|
});
|
|
|
|
// <script>
|
|
} else if (globalName) {
|
|
this[globalName] = mainExports;
|
|
}
|
|
}
|
|
})({"KxAZI":[function(require,module,exports) {
|
|
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
parcelHelpers.export(exports, "toFormData", ()=>toFormData);
|
|
var _fromJs = require("fetch-blob/from.js");
|
|
var _esmMinJs = require("formdata-polyfill/esm.min.js");
|
|
let s = 0;
|
|
const S = {
|
|
START_BOUNDARY: s++,
|
|
HEADER_FIELD_START: s++,
|
|
HEADER_FIELD: s++,
|
|
HEADER_VALUE_START: s++,
|
|
HEADER_VALUE: s++,
|
|
HEADER_VALUE_ALMOST_DONE: s++,
|
|
HEADERS_ALMOST_DONE: s++,
|
|
PART_DATA_START: s++,
|
|
PART_DATA: s++,
|
|
END: s++
|
|
};
|
|
let f = 1;
|
|
const F = {
|
|
PART_BOUNDARY: f,
|
|
LAST_BOUNDARY: f *= 2
|
|
};
|
|
const LF = 10;
|
|
const CR = 13;
|
|
const SPACE = 32;
|
|
const HYPHEN = 45;
|
|
const COLON = 58;
|
|
const A = 97;
|
|
const Z = 122;
|
|
const lower = (c)=>c | 0x20;
|
|
const noop = ()=>{};
|
|
class MultipartParser {
|
|
/**
|
|
* @param {string} boundary
|
|
*/ constructor(boundary){
|
|
this.index = 0;
|
|
this.flags = 0;
|
|
this.onHeaderEnd = noop;
|
|
this.onHeaderField = noop;
|
|
this.onHeadersEnd = noop;
|
|
this.onHeaderValue = noop;
|
|
this.onPartBegin = noop;
|
|
this.onPartData = noop;
|
|
this.onPartEnd = noop;
|
|
this.boundaryChars = {};
|
|
boundary = "\r\n--" + boundary;
|
|
const ui8a = new Uint8Array(boundary.length);
|
|
for(let i = 0; i < boundary.length; i++){
|
|
ui8a[i] = boundary.charCodeAt(i);
|
|
this.boundaryChars[ui8a[i]] = true;
|
|
}
|
|
this.boundary = ui8a;
|
|
this.lookbehind = new Uint8Array(this.boundary.length + 8);
|
|
this.state = S.START_BOUNDARY;
|
|
}
|
|
/**
|
|
* @param {Uint8Array} data
|
|
*/ write(data) {
|
|
let i = 0;
|
|
const length_ = data.length;
|
|
let previousIndex = this.index;
|
|
let { lookbehind, boundary, boundaryChars, index, state, flags } = this;
|
|
const boundaryLength = this.boundary.length;
|
|
const boundaryEnd = boundaryLength - 1;
|
|
const bufferLength = data.length;
|
|
let c;
|
|
let cl;
|
|
const mark = (name)=>{
|
|
this[name + "Mark"] = i;
|
|
};
|
|
const clear = (name)=>{
|
|
delete this[name + "Mark"];
|
|
};
|
|
const callback = (callbackSymbol, start, end, ui8a)=>{
|
|
if (start === undefined || start !== end) this[callbackSymbol](ui8a && ui8a.subarray(start, end));
|
|
};
|
|
const dataCallback = (name, clear)=>{
|
|
const markSymbol = name + "Mark";
|
|
if (!(markSymbol in this)) return;
|
|
if (clear) {
|
|
callback(name, this[markSymbol], i, data);
|
|
delete this[markSymbol];
|
|
} else {
|
|
callback(name, this[markSymbol], data.length, data);
|
|
this[markSymbol] = 0;
|
|
}
|
|
};
|
|
for(i = 0; i < length_; i++){
|
|
c = data[i];
|
|
switch(state){
|
|
case S.START_BOUNDARY:
|
|
if (index === boundary.length - 2) {
|
|
if (c === HYPHEN) flags |= F.LAST_BOUNDARY;
|
|
else if (c !== CR) return;
|
|
index++;
|
|
break;
|
|
} else if (index - 1 === boundary.length - 2) {
|
|
if (flags & F.LAST_BOUNDARY && c === HYPHEN) {
|
|
state = S.END;
|
|
flags = 0;
|
|
} else if (!(flags & F.LAST_BOUNDARY) && c === LF) {
|
|
index = 0;
|
|
callback("onPartBegin");
|
|
state = S.HEADER_FIELD_START;
|
|
} else return;
|
|
break;
|
|
}
|
|
if (c !== boundary[index + 2]) index = -2;
|
|
if (c === boundary[index + 2]) index++;
|
|
break;
|
|
case S.HEADER_FIELD_START:
|
|
state = S.HEADER_FIELD;
|
|
mark("onHeaderField");
|
|
index = 0;
|
|
// falls through
|
|
case S.HEADER_FIELD:
|
|
if (c === CR) {
|
|
clear("onHeaderField");
|
|
state = S.HEADERS_ALMOST_DONE;
|
|
break;
|
|
}
|
|
index++;
|
|
if (c === HYPHEN) break;
|
|
if (c === COLON) {
|
|
if (index === 1) // empty header field
|
|
return;
|
|
dataCallback("onHeaderField", true);
|
|
state = S.HEADER_VALUE_START;
|
|
break;
|
|
}
|
|
cl = lower(c);
|
|
if (cl < A || cl > Z) return;
|
|
break;
|
|
case S.HEADER_VALUE_START:
|
|
if (c === SPACE) break;
|
|
mark("onHeaderValue");
|
|
state = S.HEADER_VALUE;
|
|
// falls through
|
|
case S.HEADER_VALUE:
|
|
if (c === CR) {
|
|
dataCallback("onHeaderValue", true);
|
|
callback("onHeaderEnd");
|
|
state = S.HEADER_VALUE_ALMOST_DONE;
|
|
}
|
|
break;
|
|
case S.HEADER_VALUE_ALMOST_DONE:
|
|
if (c !== LF) return;
|
|
state = S.HEADER_FIELD_START;
|
|
break;
|
|
case S.HEADERS_ALMOST_DONE:
|
|
if (c !== LF) return;
|
|
callback("onHeadersEnd");
|
|
state = S.PART_DATA_START;
|
|
break;
|
|
case S.PART_DATA_START:
|
|
state = S.PART_DATA;
|
|
mark("onPartData");
|
|
// falls through
|
|
case S.PART_DATA:
|
|
previousIndex = index;
|
|
if (index === 0) {
|
|
// boyer-moore derrived algorithm to safely skip non-boundary data
|
|
i += boundaryEnd;
|
|
while(i < bufferLength && !(data[i] in boundaryChars))i += boundaryLength;
|
|
i -= boundaryEnd;
|
|
c = data[i];
|
|
}
|
|
if (index < boundary.length) {
|
|
if (boundary[index] === c) {
|
|
if (index === 0) dataCallback("onPartData", true);
|
|
index++;
|
|
} else index = 0;
|
|
} else if (index === boundary.length) {
|
|
index++;
|
|
if (c === CR) // CR = part boundary
|
|
flags |= F.PART_BOUNDARY;
|
|
else if (c === HYPHEN) // HYPHEN = end boundary
|
|
flags |= F.LAST_BOUNDARY;
|
|
else index = 0;
|
|
} else if (index - 1 === boundary.length) {
|
|
if (flags & F.PART_BOUNDARY) {
|
|
index = 0;
|
|
if (c === LF) {
|
|
// unset the PART_BOUNDARY flag
|
|
flags &= ~F.PART_BOUNDARY;
|
|
callback("onPartEnd");
|
|
callback("onPartBegin");
|
|
state = S.HEADER_FIELD_START;
|
|
break;
|
|
}
|
|
} else if (flags & F.LAST_BOUNDARY) {
|
|
if (c === HYPHEN) {
|
|
callback("onPartEnd");
|
|
state = S.END;
|
|
flags = 0;
|
|
} else index = 0;
|
|
} else index = 0;
|
|
}
|
|
if (index > 0) // when matching a possible boundary, keep a lookbehind reference
|
|
// in case it turns out to be a false lead
|
|
lookbehind[index - 1] = c;
|
|
else if (previousIndex > 0) {
|
|
// if our boundary turned out to be rubbish, the captured lookbehind
|
|
// belongs to partData
|
|
const _lookbehind = new Uint8Array(lookbehind.buffer, lookbehind.byteOffset, lookbehind.byteLength);
|
|
callback("onPartData", 0, previousIndex, _lookbehind);
|
|
previousIndex = 0;
|
|
mark("onPartData");
|
|
// reconsider the current character even so it interrupted the sequence
|
|
// it could be the beginning of a new sequence
|
|
i--;
|
|
}
|
|
break;
|
|
case S.END:
|
|
break;
|
|
default:
|
|
throw new Error(`Unexpected state entered: ${state}`);
|
|
}
|
|
}
|
|
dataCallback("onHeaderField");
|
|
dataCallback("onHeaderValue");
|
|
dataCallback("onPartData");
|
|
// Update properties for the next call
|
|
this.index = index;
|
|
this.state = state;
|
|
this.flags = flags;
|
|
}
|
|
end() {
|
|
if (this.state === S.HEADER_FIELD_START && this.index === 0 || this.state === S.PART_DATA && this.index === this.boundary.length) this.onPartEnd();
|
|
else if (this.state !== S.END) throw new Error("MultipartParser.end(): stream ended unexpectedly");
|
|
}
|
|
}
|
|
function _fileName(headerValue) {
|
|
// matches either a quoted-string or a token (RFC 2616 section 19.5.1)
|
|
const m = headerValue.match(/\bfilename=("(.*?)"|([^()<>@,;:\\"/[\]?={}\s\t]+))($|;\s)/i);
|
|
if (!m) return;
|
|
const match = m[2] || m[3] || "";
|
|
let filename = match.slice(match.lastIndexOf("\\") + 1);
|
|
filename = filename.replace(/%22/g, '"');
|
|
filename = filename.replace(/&#(\d{4});/g, (m, code)=>{
|
|
return String.fromCharCode(code);
|
|
});
|
|
return filename;
|
|
}
|
|
async function toFormData(Body, ct) {
|
|
if (!/multipart/i.test(ct)) throw new TypeError("Failed to fetch");
|
|
const m = ct.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
|
|
if (!m) throw new TypeError("no or bad content-type header, no multipart boundary");
|
|
const parser = new MultipartParser(m[1] || m[2]);
|
|
let headerField;
|
|
let headerValue;
|
|
let entryValue;
|
|
let entryName;
|
|
let contentType;
|
|
let filename;
|
|
const entryChunks = [];
|
|
const formData = new (0, _esmMinJs.FormData)();
|
|
const onPartData = (ui8a)=>{
|
|
entryValue += decoder.decode(ui8a, {
|
|
stream: true
|
|
});
|
|
};
|
|
const appendToFile = (ui8a)=>{
|
|
entryChunks.push(ui8a);
|
|
};
|
|
const appendFileToFormData = ()=>{
|
|
const file = new (0, _fromJs.File)(entryChunks, filename, {
|
|
type: contentType
|
|
});
|
|
formData.append(entryName, file);
|
|
};
|
|
const appendEntryToFormData = ()=>{
|
|
formData.append(entryName, entryValue);
|
|
};
|
|
const decoder = new TextDecoder("utf-8");
|
|
decoder.decode();
|
|
parser.onPartBegin = function() {
|
|
parser.onPartData = onPartData;
|
|
parser.onPartEnd = appendEntryToFormData;
|
|
headerField = "";
|
|
headerValue = "";
|
|
entryValue = "";
|
|
entryName = "";
|
|
contentType = "";
|
|
filename = null;
|
|
entryChunks.length = 0;
|
|
};
|
|
parser.onHeaderField = function(ui8a) {
|
|
headerField += decoder.decode(ui8a, {
|
|
stream: true
|
|
});
|
|
};
|
|
parser.onHeaderValue = function(ui8a) {
|
|
headerValue += decoder.decode(ui8a, {
|
|
stream: true
|
|
});
|
|
};
|
|
parser.onHeaderEnd = function() {
|
|
headerValue += decoder.decode();
|
|
headerField = headerField.toLowerCase();
|
|
if (headerField === "content-disposition") {
|
|
// matches either a quoted-string or a token (RFC 2616 section 19.5.1)
|
|
const m = headerValue.match(/\bname=("([^"]*)"|([^()<>@,;:\\"/[\]?={}\s\t]+))/i);
|
|
if (m) entryName = m[2] || m[3] || "";
|
|
filename = _fileName(headerValue);
|
|
if (filename) {
|
|
parser.onPartData = appendToFile;
|
|
parser.onPartEnd = appendFileToFormData;
|
|
}
|
|
} else if (headerField === "content-type") contentType = headerValue;
|
|
headerValue = "";
|
|
headerField = "";
|
|
};
|
|
for await (const chunk of Body)parser.write(chunk);
|
|
parser.end();
|
|
return formData;
|
|
}
|
|
|
|
},{"fetch-blob/from.js":"evJsm","formdata-polyfill/esm.min.js":"2Dd9W","@parcel/transformer-js/src/esmodule-helpers.js":"iIXqM"}],"evJsm":[function(require,module,exports) {
|
|
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
parcelHelpers.export(exports, "File", ()=>(0, _fileJsDefault.default));
|
|
parcelHelpers.export(exports, "Blob", ()=>(0, _indexJsDefault.default));
|
|
parcelHelpers.export(exports, "blobFrom", ()=>blobFrom);
|
|
parcelHelpers.export(exports, "blobFromSync", ()=>blobFromSync);
|
|
parcelHelpers.export(exports, "fileFrom", ()=>fileFrom);
|
|
parcelHelpers.export(exports, "fileFromSync", ()=>fileFromSync);
|
|
var _nodeFs = require("fs");
|
|
var _nodePath = require("path");
|
|
var _nodeDomexception = require("node-domexception");
|
|
var _nodeDomexceptionDefault = parcelHelpers.interopDefault(_nodeDomexception);
|
|
var _fileJs = require("./file.js");
|
|
var _fileJsDefault = parcelHelpers.interopDefault(_fileJs);
|
|
var _indexJs = require("./index.js");
|
|
var _indexJsDefault = parcelHelpers.interopDefault(_indexJs);
|
|
const { stat } = (0, _nodeFs.promises);
|
|
/**
|
|
* @param {string} path filepath on the disk
|
|
* @param {string} [type] mimetype to use
|
|
*/ const blobFromSync = (path, type)=>fromBlob((0, _nodeFs.statSync)(path), path, type);
|
|
/**
|
|
* @param {string} path filepath on the disk
|
|
* @param {string} [type] mimetype to use
|
|
* @returns {Promise<Blob>}
|
|
*/ const blobFrom = (path, type)=>stat(path).then((stat)=>fromBlob(stat, path, type));
|
|
/**
|
|
* @param {string} path filepath on the disk
|
|
* @param {string} [type] mimetype to use
|
|
* @returns {Promise<File>}
|
|
*/ const fileFrom = (path, type)=>stat(path).then((stat)=>fromFile(stat, path, type));
|
|
/**
|
|
* @param {string} path filepath on the disk
|
|
* @param {string} [type] mimetype to use
|
|
*/ const fileFromSync = (path, type)=>fromFile((0, _nodeFs.statSync)(path), path, type);
|
|
// @ts-ignore
|
|
const fromBlob = (stat, path, type = "")=>new (0, _indexJsDefault.default)([
|
|
new BlobDataItem({
|
|
path,
|
|
size: stat.size,
|
|
lastModified: stat.mtimeMs,
|
|
start: 0
|
|
})
|
|
], {
|
|
type
|
|
});
|
|
// @ts-ignore
|
|
const fromFile = (stat, path, type = "")=>new (0, _fileJsDefault.default)([
|
|
new BlobDataItem({
|
|
path,
|
|
size: stat.size,
|
|
lastModified: stat.mtimeMs,
|
|
start: 0
|
|
})
|
|
], (0, _nodePath.basename)(path), {
|
|
type,
|
|
lastModified: stat.mtimeMs
|
|
});
|
|
/**
|
|
* This is a blob backed up by a file on the disk
|
|
* with minium requirement. Its wrapped around a Blob as a blobPart
|
|
* so you have no direct access to this.
|
|
*
|
|
* @private
|
|
*/ class BlobDataItem {
|
|
#path;
|
|
#start;
|
|
constructor(options){
|
|
this.#path = options.path;
|
|
this.#start = options.start;
|
|
this.size = options.size;
|
|
this.lastModified = options.lastModified;
|
|
}
|
|
/**
|
|
* Slicing arguments is first validated and formatted
|
|
* to not be out of range by Blob.prototype.slice
|
|
*/ slice(start, end) {
|
|
return new BlobDataItem({
|
|
path: this.#path,
|
|
lastModified: this.lastModified,
|
|
size: end - start,
|
|
start: this.#start + start
|
|
});
|
|
}
|
|
async *stream() {
|
|
const { mtimeMs } = await stat(this.#path);
|
|
if (mtimeMs > this.lastModified) throw new (0, _nodeDomexceptionDefault.default)("The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.", "NotReadableError");
|
|
yield* (0, _nodeFs.createReadStream)(this.#path, {
|
|
start: this.#start,
|
|
end: this.#start + this.size - 1
|
|
});
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return "Blob";
|
|
}
|
|
}
|
|
exports.default = blobFromSync;
|
|
|
|
},{"node:fs":"786Ur","node:path":"iJSRK","node-domexception":"i0a38","./file.js":"akf6n","./index.js":"gejxf","@parcel/transformer-js/src/esmodule-helpers.js":"iIXqM"}],"786Ur":[function(require,module,exports) {
|
|
"use strict";
|
|
|
|
},{}],"iJSRK":[function(require,module,exports) {
|
|
// 'path' module extracted from Node.js v8.11.1 (only the posix part)
|
|
// transplited with Babel
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|
// following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
var process = require("c0743715070b1b8a");
|
|
"use strict";
|
|
function assertPath(path) {
|
|
if (typeof path !== "string") throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
|
|
}
|
|
// Resolves . and .. elements in a path with directory names
|
|
function normalizeStringPosix(path, allowAboveRoot) {
|
|
var res = "";
|
|
var lastSegmentLength = 0;
|
|
var lastSlash = -1;
|
|
var dots = 0;
|
|
var code;
|
|
for(var i = 0; i <= path.length; ++i){
|
|
if (i < path.length) code = path.charCodeAt(i);
|
|
else if (code === 47 /*/*/ ) break;
|
|
else code = 47 /*/*/ ;
|
|
if (code === 47 /*/*/ ) {
|
|
if (lastSlash === i - 1 || dots === 1) ;
|
|
else if (lastSlash !== i - 1 && dots === 2) {
|
|
if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/ ) {
|
|
if (res.length > 2) {
|
|
var lastSlashIndex = res.lastIndexOf("/");
|
|
if (lastSlashIndex !== res.length - 1) {
|
|
if (lastSlashIndex === -1) {
|
|
res = "";
|
|
lastSegmentLength = 0;
|
|
} else {
|
|
res = res.slice(0, lastSlashIndex);
|
|
lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
|
|
}
|
|
lastSlash = i;
|
|
dots = 0;
|
|
continue;
|
|
}
|
|
} else if (res.length === 2 || res.length === 1) {
|
|
res = "";
|
|
lastSegmentLength = 0;
|
|
lastSlash = i;
|
|
dots = 0;
|
|
continue;
|
|
}
|
|
}
|
|
if (allowAboveRoot) {
|
|
if (res.length > 0) res += "/..";
|
|
else res = "..";
|
|
lastSegmentLength = 2;
|
|
}
|
|
} else {
|
|
if (res.length > 0) res += "/" + path.slice(lastSlash + 1, i);
|
|
else res = path.slice(lastSlash + 1, i);
|
|
lastSegmentLength = i - lastSlash - 1;
|
|
}
|
|
lastSlash = i;
|
|
dots = 0;
|
|
} else if (code === 46 /*.*/ && dots !== -1) ++dots;
|
|
else dots = -1;
|
|
}
|
|
return res;
|
|
}
|
|
function _format(sep, pathObject) {
|
|
var dir = pathObject.dir || pathObject.root;
|
|
var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
|
|
if (!dir) return base;
|
|
if (dir === pathObject.root) return dir + base;
|
|
return dir + sep + base;
|
|
}
|
|
var posix = {
|
|
// path.resolve([from ...], to)
|
|
resolve: function resolve() {
|
|
var resolvedPath = "";
|
|
var resolvedAbsolute = false;
|
|
var cwd;
|
|
for(var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--){
|
|
var path;
|
|
if (i >= 0) path = arguments[i];
|
|
else {
|
|
if (cwd === undefined) cwd = process.cwd();
|
|
path = cwd;
|
|
}
|
|
assertPath(path);
|
|
// Skip empty entries
|
|
if (path.length === 0) continue;
|
|
resolvedPath = path + "/" + resolvedPath;
|
|
resolvedAbsolute = path.charCodeAt(0) === 47 /*/*/ ;
|
|
}
|
|
// At this point the path should be resolved to a full absolute path, but
|
|
// handle relative paths to be safe (might happen when process.cwd() fails)
|
|
// Normalize the path
|
|
resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
|
|
if (resolvedAbsolute) {
|
|
if (resolvedPath.length > 0) return "/" + resolvedPath;
|
|
else return "/";
|
|
} else if (resolvedPath.length > 0) return resolvedPath;
|
|
else return ".";
|
|
},
|
|
normalize: function normalize(path) {
|
|
assertPath(path);
|
|
if (path.length === 0) return ".";
|
|
var isAbsolute = path.charCodeAt(0) === 47 /*/*/ ;
|
|
var trailingSeparator = path.charCodeAt(path.length - 1) === 47 /*/*/ ;
|
|
// Normalize the path
|
|
path = normalizeStringPosix(path, !isAbsolute);
|
|
if (path.length === 0 && !isAbsolute) path = ".";
|
|
if (path.length > 0 && trailingSeparator) path += "/";
|
|
if (isAbsolute) return "/" + path;
|
|
return path;
|
|
},
|
|
isAbsolute: function isAbsolute(path) {
|
|
assertPath(path);
|
|
return path.length > 0 && path.charCodeAt(0) === 47 /*/*/ ;
|
|
},
|
|
join: function join() {
|
|
if (arguments.length === 0) return ".";
|
|
var joined;
|
|
for(var i = 0; i < arguments.length; ++i){
|
|
var arg = arguments[i];
|
|
assertPath(arg);
|
|
if (arg.length > 0) {
|
|
if (joined === undefined) joined = arg;
|
|
else joined += "/" + arg;
|
|
}
|
|
}
|
|
if (joined === undefined) return ".";
|
|
return posix.normalize(joined);
|
|
},
|
|
relative: function relative(from, to) {
|
|
assertPath(from);
|
|
assertPath(to);
|
|
if (from === to) return "";
|
|
from = posix.resolve(from);
|
|
to = posix.resolve(to);
|
|
if (from === to) return "";
|
|
// Trim any leading backslashes
|
|
var fromStart = 1;
|
|
for(; fromStart < from.length; ++fromStart){
|
|
if (from.charCodeAt(fromStart) !== 47 /*/*/ ) break;
|
|
}
|
|
var fromEnd = from.length;
|
|
var fromLen = fromEnd - fromStart;
|
|
// Trim any leading backslashes
|
|
var toStart = 1;
|
|
for(; toStart < to.length; ++toStart){
|
|
if (to.charCodeAt(toStart) !== 47 /*/*/ ) break;
|
|
}
|
|
var toEnd = to.length;
|
|
var toLen = toEnd - toStart;
|
|
// Compare paths to find the longest common path from root
|
|
var length = fromLen < toLen ? fromLen : toLen;
|
|
var lastCommonSep = -1;
|
|
var i = 0;
|
|
for(; i <= length; ++i){
|
|
if (i === length) {
|
|
if (toLen > length) {
|
|
if (to.charCodeAt(toStart + i) === 47 /*/*/ ) // We get here if `from` is the exact base path for `to`.
|
|
// For example: from='/foo/bar'; to='/foo/bar/baz'
|
|
return to.slice(toStart + i + 1);
|
|
else if (i === 0) // We get here if `from` is the root
|
|
// For example: from='/'; to='/foo'
|
|
return to.slice(toStart + i);
|
|
} else if (fromLen > length) {
|
|
if (from.charCodeAt(fromStart + i) === 47 /*/*/ ) // We get here if `to` is the exact base path for `from`.
|
|
// For example: from='/foo/bar/baz'; to='/foo/bar'
|
|
lastCommonSep = i;
|
|
else if (i === 0) // We get here if `to` is the root.
|
|
// For example: from='/foo'; to='/'
|
|
lastCommonSep = 0;
|
|
}
|
|
break;
|
|
}
|
|
var fromCode = from.charCodeAt(fromStart + i);
|
|
var toCode = to.charCodeAt(toStart + i);
|
|
if (fromCode !== toCode) break;
|
|
else if (fromCode === 47 /*/*/ ) lastCommonSep = i;
|
|
}
|
|
var out = "";
|
|
// Generate the relative path based on the path difference between `to`
|
|
// and `from`
|
|
for(i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i)if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/ ) {
|
|
if (out.length === 0) out += "..";
|
|
else out += "/..";
|
|
}
|
|
// Lastly, append the rest of the destination (`to`) path that comes after
|
|
// the common path parts
|
|
if (out.length > 0) return out + to.slice(toStart + lastCommonSep);
|
|
else {
|
|
toStart += lastCommonSep;
|
|
if (to.charCodeAt(toStart) === 47 /*/*/ ) ++toStart;
|
|
return to.slice(toStart);
|
|
}
|
|
},
|
|
_makeLong: function _makeLong(path) {
|
|
return path;
|
|
},
|
|
dirname: function dirname(path) {
|
|
assertPath(path);
|
|
if (path.length === 0) return ".";
|
|
var code = path.charCodeAt(0);
|
|
var hasRoot = code === 47 /*/*/ ;
|
|
var end = -1;
|
|
var matchedSlash = true;
|
|
for(var i = path.length - 1; i >= 1; --i){
|
|
code = path.charCodeAt(i);
|
|
if (code === 47 /*/*/ ) {
|
|
if (!matchedSlash) {
|
|
end = i;
|
|
break;
|
|
}
|
|
} else // We saw the first non-path separator
|
|
matchedSlash = false;
|
|
}
|
|
if (end === -1) return hasRoot ? "/" : ".";
|
|
if (hasRoot && end === 1) return "//";
|
|
return path.slice(0, end);
|
|
},
|
|
basename: function basename(path, ext) {
|
|
if (ext !== undefined && typeof ext !== "string") throw new TypeError('"ext" argument must be a string');
|
|
assertPath(path);
|
|
var start = 0;
|
|
var end = -1;
|
|
var matchedSlash = true;
|
|
var i;
|
|
if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
|
|
if (ext.length === path.length && ext === path) return "";
|
|
var extIdx = ext.length - 1;
|
|
var firstNonSlashEnd = -1;
|
|
for(i = path.length - 1; i >= 0; --i){
|
|
var code = path.charCodeAt(i);
|
|
if (code === 47 /*/*/ ) // If we reached a path separator that was not part of a set of path
|
|
// separators at the end of the string, stop now
|
|
{
|
|
if (!matchedSlash) {
|
|
start = i + 1;
|
|
break;
|
|
}
|
|
} else {
|
|
if (firstNonSlashEnd === -1) {
|
|
// We saw the first non-path separator, remember this index in case
|
|
// we need it if the extension ends up not matching
|
|
matchedSlash = false;
|
|
firstNonSlashEnd = i + 1;
|
|
}
|
|
if (extIdx >= 0) {
|
|
// Try to match the explicit extension
|
|
if (code === ext.charCodeAt(extIdx)) {
|
|
if (--extIdx === -1) // We matched the extension, so mark this as the end of our path
|
|
// component
|
|
end = i;
|
|
} else {
|
|
// Extension does not match, so our result is the entire path
|
|
// component
|
|
extIdx = -1;
|
|
end = firstNonSlashEnd;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (start === end) end = firstNonSlashEnd;
|
|
else if (end === -1) end = path.length;
|
|
return path.slice(start, end);
|
|
} else {
|
|
for(i = path.length - 1; i >= 0; --i){
|
|
if (path.charCodeAt(i) === 47 /*/*/ ) // If we reached a path separator that was not part of a set of path
|
|
// separators at the end of the string, stop now
|
|
{
|
|
if (!matchedSlash) {
|
|
start = i + 1;
|
|
break;
|
|
}
|
|
} else if (end === -1) {
|
|
// We saw the first non-path separator, mark this as the end of our
|
|
// path component
|
|
matchedSlash = false;
|
|
end = i + 1;
|
|
}
|
|
}
|
|
if (end === -1) return "";
|
|
return path.slice(start, end);
|
|
}
|
|
},
|
|
extname: function extname(path) {
|
|
assertPath(path);
|
|
var startDot = -1;
|
|
var startPart = 0;
|
|
var end = -1;
|
|
var matchedSlash = true;
|
|
// Track the state of characters (if any) we see before our first dot and
|
|
// after any path separator we find
|
|
var preDotState = 0;
|
|
for(var i = path.length - 1; i >= 0; --i){
|
|
var code = path.charCodeAt(i);
|
|
if (code === 47 /*/*/ ) {
|
|
// If we reached a path separator that was not part of a set of path
|
|
// separators at the end of the string, stop now
|
|
if (!matchedSlash) {
|
|
startPart = i + 1;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
if (end === -1) {
|
|
// We saw the first non-path separator, mark this as the end of our
|
|
// extension
|
|
matchedSlash = false;
|
|
end = i + 1;
|
|
}
|
|
if (code === 46 /*.*/ ) {
|
|
// If this is our first dot, mark it as the start of our extension
|
|
if (startDot === -1) startDot = i;
|
|
else if (preDotState !== 1) preDotState = 1;
|
|
} else if (startDot !== -1) // We saw a non-dot and non-path separator before our dot, so we should
|
|
// have a good chance at having a non-empty extension
|
|
preDotState = -1;
|
|
}
|
|
if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
|
|
preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
|
|
preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) return "";
|
|
return path.slice(startDot, end);
|
|
},
|
|
format: function format(pathObject) {
|
|
if (pathObject === null || typeof pathObject !== "object") throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
|
|
return _format("/", pathObject);
|
|
},
|
|
parse: function parse(path) {
|
|
assertPath(path);
|
|
var ret = {
|
|
root: "",
|
|
dir: "",
|
|
base: "",
|
|
ext: "",
|
|
name: ""
|
|
};
|
|
if (path.length === 0) return ret;
|
|
var code = path.charCodeAt(0);
|
|
var isAbsolute = code === 47 /*/*/ ;
|
|
var start;
|
|
if (isAbsolute) {
|
|
ret.root = "/";
|
|
start = 1;
|
|
} else start = 0;
|
|
var startDot = -1;
|
|
var startPart = 0;
|
|
var end = -1;
|
|
var matchedSlash = true;
|
|
var i = path.length - 1;
|
|
// Track the state of characters (if any) we see before our first dot and
|
|
// after any path separator we find
|
|
var preDotState = 0;
|
|
// Get non-dir info
|
|
for(; i >= start; --i){
|
|
code = path.charCodeAt(i);
|
|
if (code === 47 /*/*/ ) {
|
|
// If we reached a path separator that was not part of a set of path
|
|
// separators at the end of the string, stop now
|
|
if (!matchedSlash) {
|
|
startPart = i + 1;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
if (end === -1) {
|
|
// We saw the first non-path separator, mark this as the end of our
|
|
// extension
|
|
matchedSlash = false;
|
|
end = i + 1;
|
|
}
|
|
if (code === 46 /*.*/ ) {
|
|
// If this is our first dot, mark it as the start of our extension
|
|
if (startDot === -1) startDot = i;
|
|
else if (preDotState !== 1) preDotState = 1;
|
|
} else if (startDot !== -1) // We saw a non-dot and non-path separator before our dot, so we should
|
|
// have a good chance at having a non-empty extension
|
|
preDotState = -1;
|
|
}
|
|
if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
|
|
preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
|
|
preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
|
|
if (end !== -1) {
|
|
if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);
|
|
else ret.base = ret.name = path.slice(startPart, end);
|
|
}
|
|
} else {
|
|
if (startPart === 0 && isAbsolute) {
|
|
ret.name = path.slice(1, startDot);
|
|
ret.base = path.slice(1, end);
|
|
} else {
|
|
ret.name = path.slice(startPart, startDot);
|
|
ret.base = path.slice(startPart, end);
|
|
}
|
|
ret.ext = path.slice(startDot, end);
|
|
}
|
|
if (startPart > 0) ret.dir = path.slice(0, startPart - 1);
|
|
else if (isAbsolute) ret.dir = "/";
|
|
return ret;
|
|
},
|
|
sep: "/",
|
|
delimiter: ":",
|
|
win32: null,
|
|
posix: null
|
|
};
|
|
posix.posix = posix;
|
|
module.exports = posix;
|
|
|
|
},{"c0743715070b1b8a":"lhTbJ"}],"lhTbJ":[function(require,module,exports) {
|
|
var q = Object.create;
|
|
var p = Object.defineProperty;
|
|
var A = Object.getOwnPropertyDescriptor;
|
|
var I = Object.getOwnPropertyNames;
|
|
var Q = Object.getPrototypeOf, S = Object.prototype.hasOwnProperty;
|
|
var N = (e, t)=>()=>(t || e((t = {
|
|
exports: {}
|
|
}).exports, t), t.exports), O = (e, t)=>{
|
|
for(var n in t)p(e, n, {
|
|
get: t[n],
|
|
enumerable: !0
|
|
});
|
|
}, m = (e, t, n, w)=>{
|
|
if (t && typeof t == "object" || typeof t == "function") for (let f of I(t))!S.call(e, f) && f !== n && p(e, f, {
|
|
get: ()=>t[f],
|
|
enumerable: !(w = A(t, f)) || w.enumerable
|
|
});
|
|
return e;
|
|
}, h = (e, t, n)=>(m(e, t, "default"), n && m(n, t, "default")), y = (e, t, n)=>(n = e != null ? q(Q(e)) : {}, m(t || !e || !e.__esModule ? p(n, "default", {
|
|
value: e,
|
|
enumerable: !0
|
|
}) : n, e)), U = (e)=>m(p({}, "__esModule", {
|
|
value: !0
|
|
}), e);
|
|
var v = N((F, E)=>{
|
|
var r = E.exports = {}, i, u;
|
|
function T() {
|
|
throw new Error("setTimeout has not been defined");
|
|
}
|
|
function g() {
|
|
throw new Error("clearTimeout has not been defined");
|
|
}
|
|
(function() {
|
|
try {
|
|
typeof setTimeout == "function" ? i = setTimeout : i = T;
|
|
} catch (e) {
|
|
i = T;
|
|
}
|
|
try {
|
|
typeof clearTimeout == "function" ? u = clearTimeout : u = g;
|
|
} catch (e) {
|
|
u = g;
|
|
}
|
|
})();
|
|
function b(e) {
|
|
if (i === setTimeout) return setTimeout(e, 0);
|
|
if ((i === T || !i) && setTimeout) return i = setTimeout, setTimeout(e, 0);
|
|
try {
|
|
return i(e, 0);
|
|
} catch (t) {
|
|
try {
|
|
return i.call(null, e, 0);
|
|
} catch (n) {
|
|
return i.call(this, e, 0);
|
|
}
|
|
}
|
|
}
|
|
function j(e) {
|
|
if (u === clearTimeout) return clearTimeout(e);
|
|
if ((u === g || !u) && clearTimeout) return u = clearTimeout, clearTimeout(e);
|
|
try {
|
|
return u(e);
|
|
} catch (t) {
|
|
try {
|
|
return u.call(null, e);
|
|
} catch (n) {
|
|
return u.call(this, e);
|
|
}
|
|
}
|
|
}
|
|
var o = [], s = !1, a, d = -1;
|
|
function z() {
|
|
!s || !a || (s = !1, a.length ? o = a.concat(o) : d = -1, o.length && x());
|
|
}
|
|
function x() {
|
|
if (!s) {
|
|
var e = b(z);
|
|
s = !0;
|
|
for(var t = o.length; t;){
|
|
for(a = o, o = []; ++d < t;)a && a[d].run();
|
|
d = -1, t = o.length;
|
|
}
|
|
a = null, s = !1, j(e);
|
|
}
|
|
}
|
|
r.nextTick = function(e) {
|
|
var t = new Array(arguments.length - 1);
|
|
if (arguments.length > 1) for(var n = 1; n < arguments.length; n++)t[n - 1] = arguments[n];
|
|
o.push(new L(e, t)), o.length === 1 && !s && b(x);
|
|
};
|
|
function L(e, t) {
|
|
this.fun = e, this.array = t;
|
|
}
|
|
L.prototype.run = function() {
|
|
this.fun.apply(null, this.array);
|
|
};
|
|
r.title = "browser";
|
|
r.browser = !0;
|
|
r.env = {};
|
|
r.argv = [];
|
|
r.version = "";
|
|
r.versions = {};
|
|
function c() {}
|
|
r.on = c;
|
|
r.addListener = c;
|
|
r.once = c;
|
|
r.off = c;
|
|
r.removeListener = c;
|
|
r.removeAllListeners = c;
|
|
r.emit = c;
|
|
r.prependListener = c;
|
|
r.prependOnceListener = c;
|
|
r.listeners = function(e) {
|
|
return [];
|
|
};
|
|
r.binding = function(e) {
|
|
throw new Error("process.binding is not supported");
|
|
};
|
|
r.cwd = function() {
|
|
return "/";
|
|
};
|
|
r.chdir = function(e) {
|
|
throw new Error("process.chdir is not supported");
|
|
};
|
|
r.umask = function() {
|
|
return 0;
|
|
};
|
|
});
|
|
var l = {};
|
|
O(l, {
|
|
default: ()=>B
|
|
});
|
|
module.exports = U(l);
|
|
var C = y(v());
|
|
h(l, y(v()), module.exports);
|
|
var B = C.default;
|
|
|
|
},{}],"i0a38":[function(require,module,exports) {
|
|
/*! node-domexception. MIT License. Jimmy W\u00e4rting <https://jimmy.warting.se/opensource> */ if (!globalThis.DOMException) try {
|
|
const { MessageChannel } = require("2233cbddec3cc84d"), port = new MessageChannel().port1, ab = new ArrayBuffer();
|
|
port.postMessage(ab, [
|
|
ab,
|
|
ab
|
|
]);
|
|
} catch (err) {
|
|
err.constructor.name === "DOMException" && (globalThis.DOMException = err.constructor);
|
|
}
|
|
module.exports = globalThis.DOMException;
|
|
|
|
},{"2233cbddec3cc84d":"786Ur"}],"akf6n":[function(require,module,exports) {
|
|
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
parcelHelpers.export(exports, "File", ()=>File);
|
|
var _indexJs = require("./index.js");
|
|
var _indexJsDefault = parcelHelpers.interopDefault(_indexJs);
|
|
const _File = class File extends (0, _indexJsDefault.default) {
|
|
#lastModified = 0;
|
|
#name = "";
|
|
/**
|
|
* @param {*[]} fileBits
|
|
* @param {string} fileName
|
|
* @param {{lastModified?: number, type?: string}} options
|
|
*/ // @ts-ignore
|
|
constructor(fileBits, fileName, options = {}){
|
|
if (arguments.length < 2) throw new TypeError(`Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`);
|
|
super(fileBits, options);
|
|
if (options === null) options = {};
|
|
// Simulate WebIDL type casting for NaN value in lastModified option.
|
|
const lastModified = options.lastModified === undefined ? Date.now() : Number(options.lastModified);
|
|
if (!Number.isNaN(lastModified)) this.#lastModified = lastModified;
|
|
this.#name = String(fileName);
|
|
}
|
|
get name() {
|
|
return this.#name;
|
|
}
|
|
get lastModified() {
|
|
return this.#lastModified;
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return "File";
|
|
}
|
|
static [Symbol.hasInstance](object) {
|
|
return !!object && object instanceof (0, _indexJsDefault.default) && /^(File)$/.test(object[Symbol.toStringTag]);
|
|
}
|
|
};
|
|
const File = _File;
|
|
exports.default = File;
|
|
|
|
},{"./index.js":"gejxf","@parcel/transformer-js/src/esmodule-helpers.js":"iIXqM"}],"gejxf":[function(require,module,exports) {
|
|
/*! fetch-blob. MIT License. Jimmy W\u00e4rting <https://jimmy.warting.se/opensource> */ // TODO (jimmywarting): in the feature use conditional loading with top level await (requires 14.x)
|
|
// Node has recently added whatwg stream into core
|
|
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
parcelHelpers.export(exports, "Blob", ()=>Blob);
|
|
var _streamsCjs = require("./streams.cjs");
|
|
// 64 KiB (same size chrome slice theirs blob into Uint8array's)
|
|
const POOL_SIZE = 65536;
|
|
/** @param {(Blob | Uint8Array)[]} parts */ async function* toIterator(parts, clone = true) {
|
|
for (const part of parts){
|
|
if ("stream" in part) yield* /** @type {AsyncIterableIterator<Uint8Array>} */ part.stream();
|
|
else if (ArrayBuffer.isView(part)) {
|
|
if (clone) {
|
|
let position = part.byteOffset;
|
|
const end = part.byteOffset + part.byteLength;
|
|
while(position !== end){
|
|
const size = Math.min(end - position, POOL_SIZE);
|
|
const chunk = part.buffer.slice(position, position + size);
|
|
position += chunk.byteLength;
|
|
yield new Uint8Array(chunk);
|
|
}
|
|
} else yield part;
|
|
} else {
|
|
// For blobs that have arrayBuffer but no stream method (nodes buffer.Blob)
|
|
let position = 0, b = /** @type {Blob} */ part;
|
|
while(position !== b.size){
|
|
const chunk = b.slice(position, Math.min(b.size, position + POOL_SIZE));
|
|
const buffer = await chunk.arrayBuffer();
|
|
position += buffer.byteLength;
|
|
yield new Uint8Array(buffer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const _Blob = class Blob {
|
|
/** @type {Array.<(Blob|Uint8Array)>} */ #parts = [];
|
|
#type = "";
|
|
#size = 0;
|
|
#endings = "transparent";
|
|
/**
|
|
* The Blob() constructor returns a new Blob object. The content
|
|
* of the blob consists of the concatenation of the values given
|
|
* in the parameter array.
|
|
*
|
|
* @param {*} blobParts
|
|
* @param {{ type?: string, endings?: string }} [options]
|
|
*/ constructor(blobParts = [], options = {}){
|
|
if (typeof blobParts !== "object" || blobParts === null) throw new TypeError("Failed to construct 'Blob': The provided value cannot be converted to a sequence.");
|
|
if (typeof blobParts[Symbol.iterator] !== "function") throw new TypeError("Failed to construct 'Blob': The object must have a callable @@iterator property.");
|
|
if (typeof options !== "object" && typeof options !== "function") throw new TypeError("Failed to construct 'Blob': parameter 2 cannot convert to dictionary.");
|
|
if (options === null) options = {};
|
|
const encoder = new TextEncoder();
|
|
for (const element of blobParts){
|
|
let part;
|
|
if (ArrayBuffer.isView(element)) part = new Uint8Array(element.buffer.slice(element.byteOffset, element.byteOffset + element.byteLength));
|
|
else if (element instanceof ArrayBuffer) part = new Uint8Array(element.slice(0));
|
|
else if (element instanceof Blob) part = element;
|
|
else part = encoder.encode(`${element}`);
|
|
this.#size += ArrayBuffer.isView(part) ? part.byteLength : part.size;
|
|
this.#parts.push(part);
|
|
}
|
|
this.#endings = `${options.endings === undefined ? "transparent" : options.endings}`;
|
|
const type = options.type === undefined ? "" : String(options.type);
|
|
this.#type = /^[\x20-\x7E]*$/.test(type) ? type : "";
|
|
}
|
|
/**
|
|
* The Blob interface's size property returns the
|
|
* size of the Blob in bytes.
|
|
*/ get size() {
|
|
return this.#size;
|
|
}
|
|
/**
|
|
* The type property of a Blob object returns the MIME type of the file.
|
|
*/ get type() {
|
|
return this.#type;
|
|
}
|
|
/**
|
|
* The text() method in the Blob interface returns a Promise
|
|
* that resolves with a string containing the contents of
|
|
* the blob, interpreted as UTF-8.
|
|
*
|
|
* @return {Promise<string>}
|
|
*/ async text() {
|
|
// More optimized than using this.arrayBuffer()
|
|
// that requires twice as much ram
|
|
const decoder = new TextDecoder();
|
|
let str = "";
|
|
for await (const part of toIterator(this.#parts, false))str += decoder.decode(part, {
|
|
stream: true
|
|
});
|
|
// Remaining
|
|
str += decoder.decode();
|
|
return str;
|
|
}
|
|
/**
|
|
* The arrayBuffer() method in the Blob interface returns a
|
|
* Promise that resolves with the contents of the blob as
|
|
* binary data contained in an ArrayBuffer.
|
|
*
|
|
* @return {Promise<ArrayBuffer>}
|
|
*/ async arrayBuffer() {
|
|
// Easier way... Just a unnecessary overhead
|
|
// const view = new Uint8Array(this.size);
|
|
// await this.stream().getReader({mode: 'byob'}).read(view);
|
|
// return view.buffer;
|
|
const data = new Uint8Array(this.size);
|
|
let offset = 0;
|
|
for await (const chunk of toIterator(this.#parts, false)){
|
|
data.set(chunk, offset);
|
|
offset += chunk.length;
|
|
}
|
|
return data.buffer;
|
|
}
|
|
stream() {
|
|
const it = toIterator(this.#parts, true);
|
|
return new globalThis.ReadableStream({
|
|
// @ts-ignore
|
|
type: "bytes",
|
|
async pull (ctrl) {
|
|
const chunk = await it.next();
|
|
chunk.done ? ctrl.close() : ctrl.enqueue(chunk.value);
|
|
},
|
|
async cancel () {
|
|
await it.return();
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* The Blob interface's slice() method creates and returns a
|
|
* new Blob object which contains data from a subset of the
|
|
* blob on which it's called.
|
|
*
|
|
* @param {number} [start]
|
|
* @param {number} [end]
|
|
* @param {string} [type]
|
|
*/ slice(start = 0, end = this.size, type = "") {
|
|
const { size } = this;
|
|
let relativeStart = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
|
|
let relativeEnd = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
|
|
const span = Math.max(relativeEnd - relativeStart, 0);
|
|
const parts = this.#parts;
|
|
const blobParts = [];
|
|
let added = 0;
|
|
for (const part of parts){
|
|
// don't add the overflow to new blobParts
|
|
if (added >= span) break;
|
|
const size = ArrayBuffer.isView(part) ? part.byteLength : part.size;
|
|
if (relativeStart && size <= relativeStart) {
|
|
// Skip the beginning and change the relative
|
|
// start & end position as we skip the unwanted parts
|
|
relativeStart -= size;
|
|
relativeEnd -= size;
|
|
} else {
|
|
let chunk;
|
|
if (ArrayBuffer.isView(part)) {
|
|
chunk = part.subarray(relativeStart, Math.min(size, relativeEnd));
|
|
added += chunk.byteLength;
|
|
} else {
|
|
chunk = part.slice(relativeStart, Math.min(size, relativeEnd));
|
|
added += chunk.size;
|
|
}
|
|
relativeEnd -= size;
|
|
blobParts.push(chunk);
|
|
relativeStart = 0 // All next sequential parts should start at 0
|
|
;
|
|
}
|
|
}
|
|
const blob = new Blob([], {
|
|
type: String(type).toLowerCase()
|
|
});
|
|
blob.#size = span;
|
|
blob.#parts = blobParts;
|
|
return blob;
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return "Blob";
|
|
}
|
|
static [Symbol.hasInstance](object) {
|
|
return object && typeof object === "object" && typeof object.constructor === "function" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]);
|
|
}
|
|
};
|
|
Object.defineProperties(_Blob.prototype, {
|
|
size: {
|
|
enumerable: true
|
|
},
|
|
type: {
|
|
enumerable: true
|
|
},
|
|
slice: {
|
|
enumerable: true
|
|
}
|
|
});
|
|
const Blob = _Blob;
|
|
exports.default = Blob;
|
|
|
|
},{"./streams.cjs":"2cILO","@parcel/transformer-js/src/esmodule-helpers.js":"iIXqM"}],"2cILO":[function(require,module,exports) {
|
|
/* c8 ignore start */ // 64 KiB (same size chrome slice theirs blob into Uint8array's)
|
|
const POOL_SIZE = 65536;
|
|
if (!globalThis.ReadableStream) // `node:stream/web` got introduced in v16.5.0 as experimental
|
|
// and it's preferred over the polyfilled version. So we also
|
|
// suppress the warning that gets emitted by NodeJS for using it.
|
|
try {
|
|
const process = require("23c025be8d106b7e");
|
|
const { emitWarning } = process;
|
|
try {
|
|
process.emitWarning = ()=>{};
|
|
Object.assign(globalThis, require("e0657700649f8cd5"));
|
|
process.emitWarning = emitWarning;
|
|
} catch (error) {
|
|
process.emitWarning = emitWarning;
|
|
throw error;
|
|
}
|
|
} catch (error) {
|
|
// fallback to polyfill implementation
|
|
Object.assign(globalThis, require("20407509c94b6a2f"));
|
|
}
|
|
try {
|
|
// Don't use node: prefix for this, require+node: is not supported until node v14.14
|
|
// Only `import()` can use prefix in 12.20 and later
|
|
const { Blob } = require("ba6ffa4f2269a545");
|
|
if (Blob && !Blob.prototype.stream) Blob.prototype.stream = function name(params) {
|
|
let position = 0;
|
|
const blob = this;
|
|
return new ReadableStream({
|
|
type: "bytes",
|
|
async pull (ctrl) {
|
|
const chunk = blob.slice(position, Math.min(blob.size, position + POOL_SIZE));
|
|
const buffer = await chunk.arrayBuffer();
|
|
position += buffer.byteLength;
|
|
ctrl.enqueue(new Uint8Array(buffer));
|
|
if (position === blob.size) ctrl.close();
|
|
}
|
|
});
|
|
};
|
|
} catch (error) {} /* c8 ignore end */
|
|
|
|
},{"23c025be8d106b7e":"node:process","e0657700649f8cd5":"node:stream/web","20407509c94b6a2f":"d0vFL","ba6ffa4f2269a545":"j1qyA"}],"d0vFL":[function(require,module,exports) {
|
|
var global = arguments[3];
|
|
/**
|
|
* web-streams-polyfill v3.2.1
|
|
*/ (function(global, factory) {
|
|
factory(exports);
|
|
})(this, function(exports1) {
|
|
"use strict";
|
|
/// <reference lib="es2015.symbol" />
|
|
const SymbolPolyfill = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol : (description)=>`Symbol(${description})`;
|
|
/// <reference lib="dom" />
|
|
function noop() {
|
|
return undefined;
|
|
}
|
|
function getGlobals() {
|
|
if (typeof self !== "undefined") return self;
|
|
else if (typeof window !== "undefined") return window;
|
|
else if (typeof global !== "undefined") return global;
|
|
return undefined;
|
|
}
|
|
const globals = getGlobals();
|
|
function typeIsObject(x) {
|
|
return typeof x === "object" && x !== null || typeof x === "function";
|
|
}
|
|
const rethrowAssertionErrorRejection = noop;
|
|
const originalPromise = Promise;
|
|
const originalPromiseThen = Promise.prototype.then;
|
|
const originalPromiseResolve = Promise.resolve.bind(originalPromise);
|
|
const originalPromiseReject = Promise.reject.bind(originalPromise);
|
|
function newPromise(executor) {
|
|
return new originalPromise(executor);
|
|
}
|
|
function promiseResolvedWith(value) {
|
|
return originalPromiseResolve(value);
|
|
}
|
|
function promiseRejectedWith(reason) {
|
|
return originalPromiseReject(reason);
|
|
}
|
|
function PerformPromiseThen(promise, onFulfilled, onRejected) {
|
|
// There doesn't appear to be any way to correctly emulate the behaviour from JavaScript, so this is just an
|
|
// approximation.
|
|
return originalPromiseThen.call(promise, onFulfilled, onRejected);
|
|
}
|
|
function uponPromise(promise, onFulfilled, onRejected) {
|
|
PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), undefined, rethrowAssertionErrorRejection);
|
|
}
|
|
function uponFulfillment(promise, onFulfilled) {
|
|
uponPromise(promise, onFulfilled);
|
|
}
|
|
function uponRejection(promise, onRejected) {
|
|
uponPromise(promise, undefined, onRejected);
|
|
}
|
|
function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) {
|
|
return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler);
|
|
}
|
|
function setPromiseIsHandledToTrue(promise) {
|
|
PerformPromiseThen(promise, undefined, rethrowAssertionErrorRejection);
|
|
}
|
|
const queueMicrotask = (()=>{
|
|
const globalQueueMicrotask = globals && globals.queueMicrotask;
|
|
if (typeof globalQueueMicrotask === "function") return globalQueueMicrotask;
|
|
const resolvedPromise = promiseResolvedWith(undefined);
|
|
return (fn)=>PerformPromiseThen(resolvedPromise, fn);
|
|
})();
|
|
function reflectCall(F, V, args) {
|
|
if (typeof F !== "function") throw new TypeError("Argument is not a function");
|
|
return Function.prototype.apply.call(F, V, args);
|
|
}
|
|
function promiseCall(F, V, args) {
|
|
try {
|
|
return promiseResolvedWith(reflectCall(F, V, args));
|
|
} catch (value) {
|
|
return promiseRejectedWith(value);
|
|
}
|
|
}
|
|
// Original from Chromium
|
|
// https://chromium.googlesource.com/chromium/src/+/0aee4434a4dba42a42abaea9bfbc0cd196a63bc1/third_party/blink/renderer/core/streams/SimpleQueue.js
|
|
const QUEUE_MAX_ARRAY_SIZE = 16384;
|
|
/**
|
|
* Simple queue structure.
|
|
*
|
|
* Avoids scalability issues with using a packed array directly by using
|
|
* multiple arrays in a linked list and keeping the array size bounded.
|
|
*/ class SimpleQueue {
|
|
constructor(){
|
|
this._cursor = 0;
|
|
this._size = 0;
|
|
// _front and _back are always defined.
|
|
this._front = {
|
|
_elements: [],
|
|
_next: undefined
|
|
};
|
|
this._back = this._front;
|
|
// The cursor is used to avoid calling Array.shift().
|
|
// It contains the index of the front element of the array inside the
|
|
// front-most node. It is always in the range [0, QUEUE_MAX_ARRAY_SIZE).
|
|
this._cursor = 0;
|
|
// When there is only one node, size === elements.length - cursor.
|
|
this._size = 0;
|
|
}
|
|
get length() {
|
|
return this._size;
|
|
}
|
|
// For exception safety, this method is structured in order:
|
|
// 1. Read state
|
|
// 2. Calculate required state mutations
|
|
// 3. Perform state mutations
|
|
push(element) {
|
|
const oldBack = this._back;
|
|
let newBack = oldBack;
|
|
if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) newBack = {
|
|
_elements: [],
|
|
_next: undefined
|
|
};
|
|
// push() is the mutation most likely to throw an exception, so it
|
|
// goes first.
|
|
oldBack._elements.push(element);
|
|
if (newBack !== oldBack) {
|
|
this._back = newBack;
|
|
oldBack._next = newBack;
|
|
}
|
|
++this._size;
|
|
}
|
|
// Like push(), shift() follows the read -> calculate -> mutate pattern for
|
|
// exception safety.
|
|
shift() {
|
|
const oldFront = this._front;
|
|
let newFront = oldFront;
|
|
const oldCursor = this._cursor;
|
|
let newCursor = oldCursor + 1;
|
|
const elements = oldFront._elements;
|
|
const element = elements[oldCursor];
|
|
if (newCursor === QUEUE_MAX_ARRAY_SIZE) {
|
|
newFront = oldFront._next;
|
|
newCursor = 0;
|
|
}
|
|
// No mutations before this point.
|
|
--this._size;
|
|
this._cursor = newCursor;
|
|
if (oldFront !== newFront) this._front = newFront;
|
|
// Permit shifted element to be garbage collected.
|
|
elements[oldCursor] = undefined;
|
|
return element;
|
|
}
|
|
// The tricky thing about forEach() is that it can be called
|
|
// re-entrantly. The queue may be mutated inside the callback. It is easy to
|
|
// see that push() within the callback has no negative effects since the end
|
|
// of the queue is checked for on every iteration. If shift() is called
|
|
// repeatedly within the callback then the next iteration may return an
|
|
// element that has been removed. In this case the callback will be called
|
|
// with undefined values until we either "catch up" with elements that still
|
|
// exist or reach the back of the queue.
|
|
forEach(callback) {
|
|
let i = this._cursor;
|
|
let node = this._front;
|
|
let elements = node._elements;
|
|
while(i !== elements.length || node._next !== undefined){
|
|
if (i === elements.length) {
|
|
node = node._next;
|
|
elements = node._elements;
|
|
i = 0;
|
|
if (elements.length === 0) break;
|
|
}
|
|
callback(elements[i]);
|
|
++i;
|
|
}
|
|
}
|
|
// Return the element that would be returned if shift() was called now,
|
|
// without modifying the queue.
|
|
peek() {
|
|
const front = this._front;
|
|
const cursor = this._cursor;
|
|
return front._elements[cursor];
|
|
}
|
|
}
|
|
function ReadableStreamReaderGenericInitialize(reader, stream) {
|
|
reader._ownerReadableStream = stream;
|
|
stream._reader = reader;
|
|
if (stream._state === "readable") defaultReaderClosedPromiseInitialize(reader);
|
|
else if (stream._state === "closed") defaultReaderClosedPromiseInitializeAsResolved(reader);
|
|
else defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
|
|
}
|
|
// A client of ReadableStreamDefaultReader and ReadableStreamBYOBReader may use these functions directly to bypass state
|
|
// check.
|
|
function ReadableStreamReaderGenericCancel(reader, reason) {
|
|
const stream = reader._ownerReadableStream;
|
|
return ReadableStreamCancel(stream, reason);
|
|
}
|
|
function ReadableStreamReaderGenericRelease(reader) {
|
|
if (reader._ownerReadableStream._state === "readable") defaultReaderClosedPromiseReject(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
|
|
else defaultReaderClosedPromiseResetToRejected(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
|
|
reader._ownerReadableStream._reader = undefined;
|
|
reader._ownerReadableStream = undefined;
|
|
}
|
|
// Helper functions for the readers.
|
|
function readerLockException(name) {
|
|
return new TypeError("Cannot " + name + " a stream using a released reader");
|
|
}
|
|
// Helper functions for the ReadableStreamDefaultReader.
|
|
function defaultReaderClosedPromiseInitialize(reader) {
|
|
reader._closedPromise = newPromise((resolve, reject)=>{
|
|
reader._closedPromise_resolve = resolve;
|
|
reader._closedPromise_reject = reject;
|
|
});
|
|
}
|
|
function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
|
|
defaultReaderClosedPromiseInitialize(reader);
|
|
defaultReaderClosedPromiseReject(reader, reason);
|
|
}
|
|
function defaultReaderClosedPromiseInitializeAsResolved(reader) {
|
|
defaultReaderClosedPromiseInitialize(reader);
|
|
defaultReaderClosedPromiseResolve(reader);
|
|
}
|
|
function defaultReaderClosedPromiseReject(reader, reason) {
|
|
if (reader._closedPromise_reject === undefined) return;
|
|
setPromiseIsHandledToTrue(reader._closedPromise);
|
|
reader._closedPromise_reject(reason);
|
|
reader._closedPromise_resolve = undefined;
|
|
reader._closedPromise_reject = undefined;
|
|
}
|
|
function defaultReaderClosedPromiseResetToRejected(reader, reason) {
|
|
defaultReaderClosedPromiseInitializeAsRejected(reader, reason);
|
|
}
|
|
function defaultReaderClosedPromiseResolve(reader) {
|
|
if (reader._closedPromise_resolve === undefined) return;
|
|
reader._closedPromise_resolve(undefined);
|
|
reader._closedPromise_resolve = undefined;
|
|
reader._closedPromise_reject = undefined;
|
|
}
|
|
const AbortSteps = SymbolPolyfill("[[AbortSteps]]");
|
|
const ErrorSteps = SymbolPolyfill("[[ErrorSteps]]");
|
|
const CancelSteps = SymbolPolyfill("[[CancelSteps]]");
|
|
const PullSteps = SymbolPolyfill("[[PullSteps]]");
|
|
/// <reference lib="es2015.core" />
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite#Polyfill
|
|
const NumberIsFinite = Number.isFinite || function(x) {
|
|
return typeof x === "number" && isFinite(x);
|
|
};
|
|
/// <reference lib="es2015.core" />
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc#Polyfill
|
|
const MathTrunc = Math.trunc || function(v) {
|
|
return v < 0 ? Math.ceil(v) : Math.floor(v);
|
|
};
|
|
// https://heycam.github.io/webidl/#idl-dictionaries
|
|
function isDictionary(x) {
|
|
return typeof x === "object" || typeof x === "function";
|
|
}
|
|
function assertDictionary(obj, context) {
|
|
if (obj !== undefined && !isDictionary(obj)) throw new TypeError(`${context} is not an object.`);
|
|
}
|
|
// https://heycam.github.io/webidl/#idl-callback-functions
|
|
function assertFunction(x, context) {
|
|
if (typeof x !== "function") throw new TypeError(`${context} is not a function.`);
|
|
}
|
|
// https://heycam.github.io/webidl/#idl-object
|
|
function isObject(x) {
|
|
return typeof x === "object" && x !== null || typeof x === "function";
|
|
}
|
|
function assertObject(x, context) {
|
|
if (!isObject(x)) throw new TypeError(`${context} is not an object.`);
|
|
}
|
|
function assertRequiredArgument(x, position, context) {
|
|
if (x === undefined) throw new TypeError(`Parameter ${position} is required in '${context}'.`);
|
|
}
|
|
function assertRequiredField(x, field, context) {
|
|
if (x === undefined) throw new TypeError(`${field} is required in '${context}'.`);
|
|
}
|
|
// https://heycam.github.io/webidl/#idl-unrestricted-double
|
|
function convertUnrestrictedDouble(value) {
|
|
return Number(value);
|
|
}
|
|
function censorNegativeZero(x) {
|
|
return x === 0 ? 0 : x;
|
|
}
|
|
function integerPart(x) {
|
|
return censorNegativeZero(MathTrunc(x));
|
|
}
|
|
// https://heycam.github.io/webidl/#idl-unsigned-long-long
|
|
function convertUnsignedLongLongWithEnforceRange(value, context) {
|
|
const lowerBound = 0;
|
|
const upperBound = Number.MAX_SAFE_INTEGER;
|
|
let x = Number(value);
|
|
x = censorNegativeZero(x);
|
|
if (!NumberIsFinite(x)) throw new TypeError(`${context} is not a finite number`);
|
|
x = integerPart(x);
|
|
if (x < lowerBound || x > upperBound) throw new TypeError(`${context} is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`);
|
|
if (!NumberIsFinite(x) || x === 0) return 0;
|
|
// TODO Use BigInt if supported?
|
|
// let xBigInt = BigInt(integerPart(x));
|
|
// xBigInt = BigInt.asUintN(64, xBigInt);
|
|
// return Number(xBigInt);
|
|
return x;
|
|
}
|
|
function assertReadableStream(x, context) {
|
|
if (!IsReadableStream(x)) throw new TypeError(`${context} is not a ReadableStream.`);
|
|
}
|
|
// Abstract operations for the ReadableStream.
|
|
function AcquireReadableStreamDefaultReader(stream) {
|
|
return new ReadableStreamDefaultReader(stream);
|
|
}
|
|
// ReadableStream API exposed for controllers.
|
|
function ReadableStreamAddReadRequest(stream, readRequest) {
|
|
stream._reader._readRequests.push(readRequest);
|
|
}
|
|
function ReadableStreamFulfillReadRequest(stream, chunk, done) {
|
|
const reader = stream._reader;
|
|
const readRequest = reader._readRequests.shift();
|
|
if (done) readRequest._closeSteps();
|
|
else readRequest._chunkSteps(chunk);
|
|
}
|
|
function ReadableStreamGetNumReadRequests(stream) {
|
|
return stream._reader._readRequests.length;
|
|
}
|
|
function ReadableStreamHasDefaultReader(stream) {
|
|
const reader = stream._reader;
|
|
if (reader === undefined) return false;
|
|
if (!IsReadableStreamDefaultReader(reader)) return false;
|
|
return true;
|
|
}
|
|
/**
|
|
* A default reader vended by a {@link ReadableStream}.
|
|
*
|
|
* @public
|
|
*/ class ReadableStreamDefaultReader {
|
|
constructor(stream){
|
|
assertRequiredArgument(stream, 1, "ReadableStreamDefaultReader");
|
|
assertReadableStream(stream, "First parameter");
|
|
if (IsReadableStreamLocked(stream)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
|
|
ReadableStreamReaderGenericInitialize(this, stream);
|
|
this._readRequests = new SimpleQueue();
|
|
}
|
|
/**
|
|
* Returns a promise that will be fulfilled when the stream becomes closed,
|
|
* or rejected if the stream ever errors or the reader's lock is released before the stream finishes closing.
|
|
*/ get closed() {
|
|
if (!IsReadableStreamDefaultReader(this)) return promiseRejectedWith(defaultReaderBrandCheckException("closed"));
|
|
return this._closedPromise;
|
|
}
|
|
/**
|
|
* If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
|
|
*/ cancel(reason) {
|
|
if (!IsReadableStreamDefaultReader(this)) return promiseRejectedWith(defaultReaderBrandCheckException("cancel"));
|
|
if (this._ownerReadableStream === undefined) return promiseRejectedWith(readerLockException("cancel"));
|
|
return ReadableStreamReaderGenericCancel(this, reason);
|
|
}
|
|
/**
|
|
* Returns a promise that allows access to the next chunk from the stream's internal queue, if available.
|
|
*
|
|
* If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
|
|
*/ read() {
|
|
if (!IsReadableStreamDefaultReader(this)) return promiseRejectedWith(defaultReaderBrandCheckException("read"));
|
|
if (this._ownerReadableStream === undefined) return promiseRejectedWith(readerLockException("read from"));
|
|
let resolvePromise;
|
|
let rejectPromise;
|
|
const promise = newPromise((resolve, reject)=>{
|
|
resolvePromise = resolve;
|
|
rejectPromise = reject;
|
|
});
|
|
const readRequest = {
|
|
_chunkSteps: (chunk)=>resolvePromise({
|
|
value: chunk,
|
|
done: false
|
|
}),
|
|
_closeSteps: ()=>resolvePromise({
|
|
value: undefined,
|
|
done: true
|
|
}),
|
|
_errorSteps: (e)=>rejectPromise(e)
|
|
};
|
|
ReadableStreamDefaultReaderRead(this, readRequest);
|
|
return promise;
|
|
}
|
|
/**
|
|
* Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
|
|
* If the associated stream is errored when the lock is released, the reader will appear errored in the same way
|
|
* from now on; otherwise, the reader will appear closed.
|
|
*
|
|
* A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
|
|
* the reader's {@link ReadableStreamDefaultReader.read | read()} method has not yet been settled. Attempting to
|
|
* do so will throw a `TypeError` and leave the reader locked to the stream.
|
|
*/ releaseLock() {
|
|
if (!IsReadableStreamDefaultReader(this)) throw defaultReaderBrandCheckException("releaseLock");
|
|
if (this._ownerReadableStream === undefined) return;
|
|
if (this._readRequests.length > 0) throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled");
|
|
ReadableStreamReaderGenericRelease(this);
|
|
}
|
|
}
|
|
Object.defineProperties(ReadableStreamDefaultReader.prototype, {
|
|
cancel: {
|
|
enumerable: true
|
|
},
|
|
read: {
|
|
enumerable: true
|
|
},
|
|
releaseLock: {
|
|
enumerable: true
|
|
},
|
|
closed: {
|
|
enumerable: true
|
|
}
|
|
});
|
|
if (typeof SymbolPolyfill.toStringTag === "symbol") Object.defineProperty(ReadableStreamDefaultReader.prototype, SymbolPolyfill.toStringTag, {
|
|
value: "ReadableStreamDefaultReader",
|
|
configurable: true
|
|
});
|
|
// Abstract operations for the readers.
|
|
function IsReadableStreamDefaultReader(x) {
|
|
if (!typeIsObject(x)) return false;
|
|
if (!Object.prototype.hasOwnProperty.call(x, "_readRequests")) return false;
|
|
return x instanceof ReadableStreamDefaultReader;
|
|
}
|
|
function ReadableStreamDefaultReaderRead(reader, readRequest) {
|
|
const stream = reader._ownerReadableStream;
|
|
stream._disturbed = true;
|
|
if (stream._state === "closed") readRequest._closeSteps();
|
|
else if (stream._state === "errored") readRequest._errorSteps(stream._storedError);
|
|
else stream._readableStreamController[PullSteps](readRequest);
|
|
}
|
|
// Helper functions for the ReadableStreamDefaultReader.
|
|
function defaultReaderBrandCheckException(name) {
|
|
return new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);
|
|
}
|
|
/// <reference lib="es2018.asynciterable" />
|
|
/* eslint-disable @typescript-eslint/no-empty-function */ const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function*() {}).prototype);
|
|
/// <reference lib="es2018.asynciterable" />
|
|
class ReadableStreamAsyncIteratorImpl {
|
|
constructor(reader, preventCancel){
|
|
this._ongoingPromise = undefined;
|
|
this._isFinished = false;
|
|
this._reader = reader;
|
|
this._preventCancel = preventCancel;
|
|
}
|
|
next() {
|
|
const nextSteps = ()=>this._nextSteps();
|
|
this._ongoingPromise = this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) : nextSteps();
|
|
return this._ongoingPromise;
|
|
}
|
|
return(value) {
|
|
const returnSteps = ()=>this._returnSteps(value);
|
|
return this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) : returnSteps();
|
|
}
|
|
_nextSteps() {
|
|
if (this._isFinished) return Promise.resolve({
|
|
value: undefined,
|
|
done: true
|
|
});
|
|
const reader = this._reader;
|
|
if (reader._ownerReadableStream === undefined) return promiseRejectedWith(readerLockException("iterate"));
|
|
let resolvePromise;
|
|
let rejectPromise;
|
|
const promise = newPromise((resolve, reject)=>{
|
|
resolvePromise = resolve;
|
|
rejectPromise = reject;
|
|
});
|
|
const readRequest = {
|
|
_chunkSteps: (chunk)=>{
|
|
this._ongoingPromise = undefined;
|
|
// This needs to be delayed by one microtask, otherwise we stop pulling too early which breaks a test.
|
|
// FIXME Is this a bug in the specification, or in the test?
|
|
queueMicrotask(()=>resolvePromise({
|
|
value: chunk,
|
|
done: false
|
|
}));
|
|
},
|
|
_closeSteps: ()=>{
|
|
this._ongoingPromise = undefined;
|
|
this._isFinished = true;
|
|
ReadableStreamReaderGenericRelease(reader);
|
|
resolvePromise({
|
|
value: undefined,
|
|
done: true
|
|
});
|
|
},
|
|
_errorSteps: (reason)=>{
|
|
this._ongoingPromise = undefined;
|
|
this._isFinished = true;
|
|
ReadableStreamReaderGenericRelease(reader);
|
|
rejectPromise(reason);
|
|
}
|
|
};
|
|
ReadableStreamDefaultReaderRead(reader, readRequest);
|
|
return promise;
|
|
}
|
|
_returnSteps(value) {
|
|
if (this._isFinished) return Promise.resolve({
|
|
value,
|
|
done: true
|
|
});
|
|
this._isFinished = true;
|
|
const reader = this._reader;
|
|
if (reader._ownerReadableStream === undefined) return promiseRejectedWith(readerLockException("finish iterating"));
|
|
if (!this._preventCancel) {
|
|
const result = ReadableStreamReaderGenericCancel(reader, value);
|
|
ReadableStreamReaderGenericRelease(reader);
|
|
return transformPromiseWith(result, ()=>({
|
|
value,
|
|
done: true
|
|
}));
|
|
}
|
|
ReadableStreamReaderGenericRelease(reader);
|
|
return promiseResolvedWith({
|
|
value,
|
|
done: true
|
|
});
|
|
}
|
|
}
|
|
const ReadableStreamAsyncIteratorPrototype = {
|
|
next () {
|
|
if (!IsReadableStreamAsyncIterator(this)) return promiseRejectedWith(streamAsyncIteratorBrandCheckException("next"));
|
|
return this._asyncIteratorImpl.next();
|
|
},
|
|
return (value) {
|
|
if (!IsReadableStreamAsyncIterator(this)) return promiseRejectedWith(streamAsyncIteratorBrandCheckException("return"));
|
|
return this._asyncIteratorImpl.return(value);
|
|
}
|
|
};
|
|
if (AsyncIteratorPrototype !== undefined) Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
|
|
// Abstract operations for the ReadableStream.
|
|
function AcquireReadableStreamAsyncIterator(stream, preventCancel) {
|
|
const reader = AcquireReadableStreamDefaultReader(stream);
|
|
const impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel);
|
|
const iterator = Object.create(ReadableStreamAsyncIteratorPrototype);
|
|
iterator._asyncIteratorImpl = impl;
|
|
return iterator;
|
|
}
|
|
function IsReadableStreamAsyncIterator(x) {
|
|
if (!typeIsObject(x)) return false;
|
|
if (!Object.prototype.hasOwnProperty.call(x, "_asyncIteratorImpl")) return false;
|
|
try {
|
|
// noinspection SuspiciousTypeOfGuard
|
|
return x._asyncIteratorImpl instanceof ReadableStreamAsyncIteratorImpl;
|
|
} catch (_a) {
|
|
return false;
|
|
}
|
|
}
|
|
// Helper functions for the ReadableStream.
|
|
function streamAsyncIteratorBrandCheckException(name) {
|
|
return new TypeError(`ReadableStreamAsyncIterator.${name} can only be used on a ReadableSteamAsyncIterator`);
|
|
}
|
|
/// <reference lib="es2015.core" />
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN#Polyfill
|
|
const NumberIsNaN = Number.isNaN || function(x) {
|
|
// eslint-disable-next-line no-self-compare
|
|
return x !== x;
|
|
};
|
|
function CreateArrayFromList(elements) {
|
|
// We use arrays to represent lists, so this is basically a no-op.
|
|
// Do a slice though just in case we happen to depend on the unique-ness.
|
|
return elements.slice();
|
|
}
|
|
function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) {
|
|
new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
|
|
}
|
|
// Not implemented correctly
|
|
function TransferArrayBuffer(O) {
|
|
return O;
|
|
}
|
|
// Not implemented correctly
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
function IsDetachedBuffer(O) {
|
|
return false;
|
|
}
|
|
function ArrayBufferSlice(buffer, begin, end) {
|
|
// ArrayBuffer.prototype.slice is not available on IE10
|
|
// https://www.caniuse.com/mdn-javascript_builtins_arraybuffer_slice
|
|
if (buffer.slice) return buffer.slice(begin, end);
|
|
const length = end - begin;
|
|
const slice = new ArrayBuffer(length);
|
|
CopyDataBlockBytes(slice, 0, buffer, begin, length);
|
|
return slice;
|
|
}
|
|
function IsNonNegativeNumber(v) {
|
|
if (typeof v !== "number") return false;
|
|
if (NumberIsNaN(v)) return false;
|
|
if (v < 0) return false;
|
|
return true;
|
|
}
|
|
function CloneAsUint8Array(O) {
|
|
const buffer = ArrayBufferSlice(O.buffer, O.byteOffset, O.byteOffset + O.byteLength);
|
|
return new Uint8Array(buffer);
|
|
}
|
|
function DequeueValue(container) {
|
|
const pair = container._queue.shift();
|
|
container._queueTotalSize -= pair.size;
|
|
if (container._queueTotalSize < 0) container._queueTotalSize = 0;
|
|
return pair.value;
|
|
}
|
|
function EnqueueValueWithSize(container, value, size) {
|
|
if (!IsNonNegativeNumber(size) || size === Infinity) throw new RangeError("Size must be a finite, non-NaN, non-negative number.");
|
|
container._queue.push({
|
|
value,
|
|
size
|
|
});
|
|
container._queueTotalSize += size;
|
|
}
|
|
function PeekQueueValue(container) {
|
|
const pair = container._queue.peek();
|
|
return pair.value;
|
|
}
|
|
function ResetQueue(container) {
|
|
container._queue = new SimpleQueue();
|
|
container._queueTotalSize = 0;
|
|
}
|
|
/**
|
|
* A pull-into request in a {@link ReadableByteStreamController}.
|
|
*
|
|
* @public
|
|
*/ class ReadableStreamBYOBRequest {
|
|
constructor(){
|
|
throw new TypeError("Illegal constructor");
|
|
}
|
|
/**
|
|
* Returns the view for writing in to, or `null` if the BYOB request has already been responded to.
|
|
*/ get view() {
|
|
if (!IsReadableStreamBYOBRequest(this)) throw byobRequestBrandCheckException("view");
|
|
return this._view;
|
|
}
|
|
respond(bytesWritten) {
|
|
if (!IsReadableStreamBYOBRequest(this)) throw byobRequestBrandCheckException("respond");
|
|
assertRequiredArgument(bytesWritten, 1, "respond");
|
|
bytesWritten = convertUnsignedLongLongWithEnforceRange(bytesWritten, "First parameter");
|
|
if (this._associatedReadableByteStreamController === undefined) throw new TypeError("This BYOB request has been invalidated");
|
|
IsDetachedBuffer(this._view.buffer);
|
|
ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);
|
|
}
|
|
respondWithNewView(view) {
|
|
if (!IsReadableStreamBYOBRequest(this)) throw byobRequestBrandCheckException("respondWithNewView");
|
|
assertRequiredArgument(view, 1, "respondWithNewView");
|
|
if (!ArrayBuffer.isView(view)) throw new TypeError("You can only respond with array buffer views");
|
|
if (this._associatedReadableByteStreamController === undefined) throw new TypeError("This BYOB request has been invalidated");
|
|
IsDetachedBuffer(view.buffer);
|
|
ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
|
|
}
|
|
}
|
|
Object.defineProperties(ReadableStreamBYOBRequest.prototype, {
|
|
respond: {
|
|
enumerable: true
|
|
},
|
|
respondWithNewView: {
|
|
enumerable: true
|
|
},
|
|
view: {
|
|
enumerable: true
|
|
}
|
|
});
|
|
if (typeof SymbolPolyfill.toStringTag === "symbol") Object.defineProperty(ReadableStreamBYOBRequest.prototype, SymbolPolyfill.toStringTag, {
|
|
value: "ReadableStreamBYOBRequest",
|
|
configurable: true
|
|
});
|
|
/**
|
|
* Allows control of a {@link ReadableStream | readable byte stream}'s state and internal queue.
|
|
*
|
|
* @public
|
|
*/ class ReadableByteStreamController {
|
|
constructor(){
|
|
throw new TypeError("Illegal constructor");
|
|
}
|
|
/**
|
|
* Returns the current BYOB pull request, or `null` if there isn't one.
|
|
*/ get byobRequest() {
|
|
if (!IsReadableByteStreamController(this)) throw byteStreamControllerBrandCheckException("byobRequest");
|
|
return ReadableByteStreamControllerGetBYOBRequest(this);
|
|
}
|
|
/**
|
|
* Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
|
|
* over-full. An underlying byte source ought to use this information to determine when and how to apply backpressure.
|
|
*/ get desiredSize() {
|
|
if (!IsReadableByteStreamController(this)) throw byteStreamControllerBrandCheckException("desiredSize");
|
|
return ReadableByteStreamControllerGetDesiredSize(this);
|
|
}
|
|
/**
|
|
* Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from
|
|
* the stream, but once those are read, the stream will become closed.
|
|
*/ close() {
|
|
if (!IsReadableByteStreamController(this)) throw byteStreamControllerBrandCheckException("close");
|
|
if (this._closeRequested) throw new TypeError("The stream has already been closed; do not close it again!");
|
|
const state = this._controlledReadableByteStream._state;
|
|
if (state !== "readable") throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be closed`);
|
|
ReadableByteStreamControllerClose(this);
|
|
}
|
|
enqueue(chunk) {
|
|
if (!IsReadableByteStreamController(this)) throw byteStreamControllerBrandCheckException("enqueue");
|
|
assertRequiredArgument(chunk, 1, "enqueue");
|
|
if (!ArrayBuffer.isView(chunk)) throw new TypeError("chunk must be an array buffer view");
|
|
if (chunk.byteLength === 0) throw new TypeError("chunk must have non-zero byteLength");
|
|
if (chunk.buffer.byteLength === 0) throw new TypeError(`chunk's buffer must have non-zero byteLength`);
|
|
if (this._closeRequested) throw new TypeError("stream is closed or draining");
|
|
const state = this._controlledReadableByteStream._state;
|
|
if (state !== "readable") throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be enqueued to`);
|
|
ReadableByteStreamControllerEnqueue(this, chunk);
|
|
}
|
|
/**
|
|
* Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
|
|
*/ error(e) {
|
|
if (!IsReadableByteStreamController(this)) throw byteStreamControllerBrandCheckException("error");
|
|
ReadableByteStreamControllerError(this, e);
|
|
}
|
|
/** @internal */ [CancelSteps](reason) {
|
|
ReadableByteStreamControllerClearPendingPullIntos(this);
|
|
ResetQueue(this);
|
|
const result = this._cancelAlgorithm(reason);
|
|
ReadableByteStreamControllerClearAlgorithms(this);
|
|
return result;
|
|
}
|
|
/** @internal */ [PullSteps](readRequest) {
|
|
const stream = this._controlledReadableByteStream;
|
|
if (this._queueTotalSize > 0) {
|
|
const entry = this._queue.shift();
|
|
this._queueTotalSize -= entry.byteLength;
|
|
ReadableByteStreamControllerHandleQueueDrain(this);
|
|
const view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
|
|
readRequest._chunkSteps(view);
|
|
return;
|
|
}
|
|
const autoAllocateChunkSize = this._autoAllocateChunkSize;
|
|
if (autoAllocateChunkSize !== undefined) {
|
|
let buffer;
|
|
try {
|
|
buffer = new ArrayBuffer(autoAllocateChunkSize);
|
|
} catch (bufferE) {
|
|
readRequest._errorSteps(bufferE);
|
|
return;
|
|
}
|
|
const pullIntoDescriptor = {
|
|
buffer,
|
|
bufferByteLength: autoAllocateChunkSize,
|
|
byteOffset: 0,
|
|
byteLength: autoAllocateChunkSize,
|
|
bytesFilled: 0,
|
|
elementSize: 1,
|
|
viewConstructor: Uint8Array,
|
|
readerType: "default"
|
|
};
|
|
this._pendingPullIntos.push(pullIntoDescriptor);
|
|
}
|
|
ReadableStreamAddReadRequest(stream, readRequest);
|
|
ReadableByteStreamControllerCallPullIfNeeded(this);
|
|
}
|
|
}
|
|
Object.defineProperties(ReadableByteStreamController.prototype, {
|
|
close: {
|
|
enumerable: true
|
|
},
|
|
enqueue: {
|
|
enumerable: true
|
|
},
|
|
error: {
|
|
enumerable: true
|
|
},
|
|
byobRequest: {
|
|
enumerable: true
|
|
},
|
|
desiredSize: {
|
|
enumerable: true
|
|
}
|
|
});
|
|
if (typeof SymbolPolyfill.toStringTag === "symbol") Object.defineProperty(ReadableByteStreamController.prototype, SymbolPolyfill.toStringTag, {
|
|
value: "ReadableByteStreamController",
|
|
configurable: true
|
|
});
|
|
// Abstract operations for the ReadableByteStreamController.
|
|
function IsReadableByteStreamController(x) {
|
|
if (!typeIsObject(x)) return false;
|
|
if (!Object.prototype.hasOwnProperty.call(x, "_controlledReadableByteStream")) return false;
|
|
return x instanceof ReadableByteStreamController;
|
|
}
|
|
function IsReadableStreamBYOBRequest(x) {
|
|
if (!typeIsObject(x)) return false;
|
|
if (!Object.prototype.hasOwnProperty.call(x, "_associatedReadableByteStreamController")) return false;
|
|
return x instanceof ReadableStreamBYOBRequest;
|
|
}
|
|
function ReadableByteStreamControllerCallPullIfNeeded(controller) {
|
|
const shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
|
|
if (!shouldPull) return;
|
|
if (controller._pulling) {
|
|
controller._pullAgain = true;
|
|
return;
|
|
}
|
|
controller._pulling = true;
|
|
// TODO: Test controller argument
|
|
const pullPromise = controller._pullAlgorithm();
|
|
uponPromise(pullPromise, ()=>{
|
|
controller._pulling = false;
|
|
if (controller._pullAgain) {
|
|
controller._pullAgain = false;
|
|
ReadableByteStreamControllerCallPullIfNeeded(controller);
|
|
}
|
|
}, (e)=>{
|
|
ReadableByteStreamControllerError(controller, e);
|
|
});
|
|
}
|
|
function ReadableByteStreamControllerClearPendingPullIntos(controller) {
|
|
ReadableByteStreamControllerInvalidateBYOBRequest(controller);
|
|
controller._pendingPullIntos = new SimpleQueue();
|
|
}
|
|
function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {
|
|
let done = false;
|
|
if (stream._state === "closed") done = true;
|
|
const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
|
|
if (pullIntoDescriptor.readerType === "default") ReadableStreamFulfillReadRequest(stream, filledView, done);
|
|
else ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
|
|
}
|
|
function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {
|
|
const bytesFilled = pullIntoDescriptor.bytesFilled;
|
|
const elementSize = pullIntoDescriptor.elementSize;
|
|
return new pullIntoDescriptor.viewConstructor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize);
|
|
}
|
|
function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) {
|
|
controller._queue.push({
|
|
buffer,
|
|
byteOffset,
|
|
byteLength
|
|
});
|
|
controller._queueTotalSize += byteLength;
|
|
}
|
|
function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {
|
|
const elementSize = pullIntoDescriptor.elementSize;
|
|
const currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize;
|
|
const maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
|
|
const maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
|
|
const maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize;
|
|
let totalBytesToCopyRemaining = maxBytesToCopy;
|
|
let ready = false;
|
|
if (maxAlignedBytes > currentAlignedBytes) {
|
|
totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
|
|
ready = true;
|
|
}
|
|
const queue = controller._queue;
|
|
while(totalBytesToCopyRemaining > 0){
|
|
const headOfQueue = queue.peek();
|
|
const bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength);
|
|
const destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
|
|
CopyDataBlockBytes(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy);
|
|
if (headOfQueue.byteLength === bytesToCopy) queue.shift();
|
|
else {
|
|
headOfQueue.byteOffset += bytesToCopy;
|
|
headOfQueue.byteLength -= bytesToCopy;
|
|
}
|
|
controller._queueTotalSize -= bytesToCopy;
|
|
ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor);
|
|
totalBytesToCopyRemaining -= bytesToCopy;
|
|
}
|
|
return ready;
|
|
}
|
|
function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
|
|
pullIntoDescriptor.bytesFilled += size;
|
|
}
|
|
function ReadableByteStreamControllerHandleQueueDrain(controller) {
|
|
if (controller._queueTotalSize === 0 && controller._closeRequested) {
|
|
ReadableByteStreamControllerClearAlgorithms(controller);
|
|
ReadableStreamClose(controller._controlledReadableByteStream);
|
|
} else ReadableByteStreamControllerCallPullIfNeeded(controller);
|
|
}
|
|
function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {
|
|
if (controller._byobRequest === null) return;
|
|
controller._byobRequest._associatedReadableByteStreamController = undefined;
|
|
controller._byobRequest._view = null;
|
|
controller._byobRequest = null;
|
|
}
|
|
function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {
|
|
while(controller._pendingPullIntos.length > 0){
|
|
if (controller._queueTotalSize === 0) return;
|
|
const pullIntoDescriptor = controller._pendingPullIntos.peek();
|
|
if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {
|
|
ReadableByteStreamControllerShiftPendingPullInto(controller);
|
|
ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
|
|
}
|
|
}
|
|
}
|
|
function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest) {
|
|
const stream = controller._controlledReadableByteStream;
|
|
let elementSize = 1;
|
|
if (view.constructor !== DataView) elementSize = view.constructor.BYTES_PER_ELEMENT;
|
|
const ctor = view.constructor;
|
|
// try {
|
|
const buffer = TransferArrayBuffer(view.buffer);
|
|
// } catch (e) {
|
|
// readIntoRequest._errorSteps(e);
|
|
// return;
|
|
// }
|
|
const pullIntoDescriptor = {
|
|
buffer,
|
|
bufferByteLength: buffer.byteLength,
|
|
byteOffset: view.byteOffset,
|
|
byteLength: view.byteLength,
|
|
bytesFilled: 0,
|
|
elementSize,
|
|
viewConstructor: ctor,
|
|
readerType: "byob"
|
|
};
|
|
if (controller._pendingPullIntos.length > 0) {
|
|
controller._pendingPullIntos.push(pullIntoDescriptor);
|
|
// No ReadableByteStreamControllerCallPullIfNeeded() call since:
|
|
// - No change happens on desiredSize
|
|
// - The source has already been notified of that there's at least 1 pending read(view)
|
|
ReadableStreamAddReadIntoRequest(stream, readIntoRequest);
|
|
return;
|
|
}
|
|
if (stream._state === "closed") {
|
|
const emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);
|
|
readIntoRequest._closeSteps(emptyView);
|
|
return;
|
|
}
|
|
if (controller._queueTotalSize > 0) {
|
|
if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {
|
|
const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
|
|
ReadableByteStreamControllerHandleQueueDrain(controller);
|
|
readIntoRequest._chunkSteps(filledView);
|
|
return;
|
|
}
|
|
if (controller._closeRequested) {
|
|
const e = new TypeError("Insufficient bytes to fill elements in the given buffer");
|
|
ReadableByteStreamControllerError(controller, e);
|
|
readIntoRequest._errorSteps(e);
|
|
return;
|
|
}
|
|
}
|
|
controller._pendingPullIntos.push(pullIntoDescriptor);
|
|
ReadableStreamAddReadIntoRequest(stream, readIntoRequest);
|
|
ReadableByteStreamControllerCallPullIfNeeded(controller);
|
|
}
|
|
function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
|
|
const stream = controller._controlledReadableByteStream;
|
|
if (ReadableStreamHasBYOBReader(stream)) while(ReadableStreamGetNumReadIntoRequests(stream) > 0){
|
|
const pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);
|
|
ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);
|
|
}
|
|
}
|
|
function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
|
|
ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
|
|
if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) return;
|
|
ReadableByteStreamControllerShiftPendingPullInto(controller);
|
|
const remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
|
|
if (remainderSize > 0) {
|
|
const end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
|
|
const remainder = ArrayBufferSlice(pullIntoDescriptor.buffer, end - remainderSize, end);
|
|
ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);
|
|
}
|
|
pullIntoDescriptor.bytesFilled -= remainderSize;
|
|
ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
|
|
ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
|
|
}
|
|
function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
|
|
const firstDescriptor = controller._pendingPullIntos.peek();
|
|
ReadableByteStreamControllerInvalidateBYOBRequest(controller);
|
|
const state = controller._controlledReadableByteStream._state;
|
|
if (state === "closed") ReadableByteStreamControllerRespondInClosedState(controller);
|
|
else ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
|
|
ReadableByteStreamControllerCallPullIfNeeded(controller);
|
|
}
|
|
function ReadableByteStreamControllerShiftPendingPullInto(controller) {
|
|
const descriptor = controller._pendingPullIntos.shift();
|
|
return descriptor;
|
|
}
|
|
function ReadableByteStreamControllerShouldCallPull(controller) {
|
|
const stream = controller._controlledReadableByteStream;
|
|
if (stream._state !== "readable") return false;
|
|
if (controller._closeRequested) return false;
|
|
if (!controller._started) return false;
|
|
if (ReadableStreamHasDefaultReader(stream) && ReadableStreamGetNumReadRequests(stream) > 0) return true;
|
|
if (ReadableStreamHasBYOBReader(stream) && ReadableStreamGetNumReadIntoRequests(stream) > 0) return true;
|
|
const desiredSize = ReadableByteStreamControllerGetDesiredSize(controller);
|
|
if (desiredSize > 0) return true;
|
|
return false;
|
|
}
|
|
function ReadableByteStreamControllerClearAlgorithms(controller) {
|
|
controller._pullAlgorithm = undefined;
|
|
controller._cancelAlgorithm = undefined;
|
|
}
|
|
// A client of ReadableByteStreamController may use these functions directly to bypass state check.
|
|
function ReadableByteStreamControllerClose(controller) {
|
|
const stream = controller._controlledReadableByteStream;
|
|
if (controller._closeRequested || stream._state !== "readable") return;
|
|
if (controller._queueTotalSize > 0) {
|
|
controller._closeRequested = true;
|
|
return;
|
|
}
|
|
if (controller._pendingPullIntos.length > 0) {
|
|
const firstPendingPullInto = controller._pendingPullIntos.peek();
|
|
if (firstPendingPullInto.bytesFilled > 0) {
|
|
const e = new TypeError("Insufficient bytes to fill elements in the given buffer");
|
|
ReadableByteStreamControllerError(controller, e);
|
|
throw e;
|
|
}
|
|
}
|
|
ReadableByteStreamControllerClearAlgorithms(controller);
|
|
ReadableStreamClose(stream);
|
|
}
|
|
function ReadableByteStreamControllerEnqueue(controller, chunk) {
|
|
const stream = controller._controlledReadableByteStream;
|
|
if (controller._closeRequested || stream._state !== "readable") return;
|
|
const buffer = chunk.buffer;
|
|
const byteOffset = chunk.byteOffset;
|
|
const byteLength = chunk.byteLength;
|
|
const transferredBuffer = TransferArrayBuffer(buffer);
|
|
if (controller._pendingPullIntos.length > 0) {
|
|
const firstPendingPullInto = controller._pendingPullIntos.peek();
|
|
IsDetachedBuffer(firstPendingPullInto.buffer);
|
|
firstPendingPullInto.buffer = TransferArrayBuffer(firstPendingPullInto.buffer);
|
|
}
|
|
ReadableByteStreamControllerInvalidateBYOBRequest(controller);
|
|
if (ReadableStreamHasDefaultReader(stream)) {
|
|
if (ReadableStreamGetNumReadRequests(stream) === 0) ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
|
|
else {
|
|
if (controller._pendingPullIntos.length > 0) ReadableByteStreamControllerShiftPendingPullInto(controller);
|
|
const transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);
|
|
ReadableStreamFulfillReadRequest(stream, transferredView, false);
|
|
}
|
|
} else if (ReadableStreamHasBYOBReader(stream)) {
|
|
// TODO: Ideally in this branch detaching should happen only if the buffer is not consumed fully.
|
|
ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
|
|
ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
|
|
} else ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
|
|
ReadableByteStreamControllerCallPullIfNeeded(controller);
|
|
}
|
|
function ReadableByteStreamControllerError(controller, e) {
|
|
const stream = controller._controlledReadableByteStream;
|
|
if (stream._state !== "readable") return;
|
|
ReadableByteStreamControllerClearPendingPullIntos(controller);
|
|
ResetQueue(controller);
|
|
ReadableByteStreamControllerClearAlgorithms(controller);
|
|
ReadableStreamError(stream, e);
|
|
}
|
|
function ReadableByteStreamControllerGetBYOBRequest(controller) {
|
|
if (controller._byobRequest === null && controller._pendingPullIntos.length > 0) {
|
|
const firstDescriptor = controller._pendingPullIntos.peek();
|
|
const view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
|
|
const byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);
|
|
SetUpReadableStreamBYOBRequest(byobRequest, controller, view);
|
|
controller._byobRequest = byobRequest;
|
|
}
|
|
return controller._byobRequest;
|
|
}
|
|
function ReadableByteStreamControllerGetDesiredSize(controller) {
|
|
const state = controller._controlledReadableByteStream._state;
|
|
if (state === "errored") return null;
|
|
if (state === "closed") return 0;
|
|
return controller._strategyHWM - controller._queueTotalSize;
|
|
}
|
|
function ReadableByteStreamControllerRespond(controller, bytesWritten) {
|
|
const firstDescriptor = controller._pendingPullIntos.peek();
|
|
const state = controller._controlledReadableByteStream._state;
|
|
if (state === "closed") {
|
|
if (bytesWritten !== 0) throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream");
|
|
} else {
|
|
if (bytesWritten === 0) throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");
|
|
if (firstDescriptor.bytesFilled + bytesWritten > firstDescriptor.byteLength) throw new RangeError("bytesWritten out of range");
|
|
}
|
|
firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
|
|
ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
|
|
}
|
|
function ReadableByteStreamControllerRespondWithNewView(controller, view) {
|
|
const firstDescriptor = controller._pendingPullIntos.peek();
|
|
const state = controller._controlledReadableByteStream._state;
|
|
if (state === "closed") {
|
|
if (view.byteLength !== 0) throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream");
|
|
} else {
|
|
if (view.byteLength === 0) throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");
|
|
}
|
|
if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) throw new RangeError("The region specified by view does not match byobRequest");
|
|
if (firstDescriptor.bufferByteLength !== view.buffer.byteLength) throw new RangeError("The buffer of view has different capacity than byobRequest");
|
|
if (firstDescriptor.bytesFilled + view.byteLength > firstDescriptor.byteLength) throw new RangeError("The region specified by view is larger than byobRequest");
|
|
const viewByteLength = view.byteLength;
|
|
firstDescriptor.buffer = TransferArrayBuffer(view.buffer);
|
|
ReadableByteStreamControllerRespondInternal(controller, viewByteLength);
|
|
}
|
|
function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) {
|
|
controller._controlledReadableByteStream = stream;
|
|
controller._pullAgain = false;
|
|
controller._pulling = false;
|
|
controller._byobRequest = null;
|
|
// Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly.
|
|
controller._queue = controller._queueTotalSize = undefined;
|
|
ResetQueue(controller);
|
|
controller._closeRequested = false;
|
|
controller._started = false;
|
|
controller._strategyHWM = highWaterMark;
|
|
controller._pullAlgorithm = pullAlgorithm;
|
|
controller._cancelAlgorithm = cancelAlgorithm;
|
|
controller._autoAllocateChunkSize = autoAllocateChunkSize;
|
|
controller._pendingPullIntos = new SimpleQueue();
|
|
stream._readableStreamController = controller;
|
|
const startResult = startAlgorithm();
|
|
uponPromise(promiseResolvedWith(startResult), ()=>{
|
|
controller._started = true;
|
|
ReadableByteStreamControllerCallPullIfNeeded(controller);
|
|
}, (r)=>{
|
|
ReadableByteStreamControllerError(controller, r);
|
|
});
|
|
}
|
|
function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) {
|
|
const controller = Object.create(ReadableByteStreamController.prototype);
|
|
let startAlgorithm = ()=>undefined;
|
|
let pullAlgorithm = ()=>promiseResolvedWith(undefined);
|
|
let cancelAlgorithm = ()=>promiseResolvedWith(undefined);
|
|
if (underlyingByteSource.start !== undefined) startAlgorithm = ()=>underlyingByteSource.start(controller);
|
|
if (underlyingByteSource.pull !== undefined) pullAlgorithm = ()=>underlyingByteSource.pull(controller);
|
|
if (underlyingByteSource.cancel !== undefined) cancelAlgorithm = (reason)=>underlyingByteSource.cancel(reason);
|
|
const autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
|
|
if (autoAllocateChunkSize === 0) throw new TypeError("autoAllocateChunkSize must be greater than 0");
|
|
SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize);
|
|
}
|
|
function SetUpReadableStreamBYOBRequest(request, controller, view) {
|
|
request._associatedReadableByteStreamController = controller;
|
|
request._view = view;
|
|
}
|
|
// Helper functions for the ReadableStreamBYOBRequest.
|
|
function byobRequestBrandCheckException(name) {
|
|
return new TypeError(`ReadableStreamBYOBRequest.prototype.${name} can only be used on a ReadableStreamBYOBRequest`);
|
|
}
|
|
// Helper functions for the ReadableByteStreamController.
|
|
function byteStreamControllerBrandCheckException(name) {
|
|
return new TypeError(`ReadableByteStreamController.prototype.${name} can only be used on a ReadableByteStreamController`);
|
|
}
|
|
// Abstract operations for the ReadableStream.
|
|
function AcquireReadableStreamBYOBReader(stream) {
|
|
return new ReadableStreamBYOBReader(stream);
|
|
}
|
|
// ReadableStream API exposed for controllers.
|
|
function ReadableStreamAddReadIntoRequest(stream, readIntoRequest) {
|
|
stream._reader._readIntoRequests.push(readIntoRequest);
|
|
}
|
|
function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {
|
|
const reader = stream._reader;
|
|
const readIntoRequest = reader._readIntoRequests.shift();
|
|
if (done) readIntoRequest._closeSteps(chunk);
|
|
else readIntoRequest._chunkSteps(chunk);
|
|
}
|
|
function ReadableStreamGetNumReadIntoRequests(stream) {
|
|
return stream._reader._readIntoRequests.length;
|
|
}
|
|
function ReadableStreamHasBYOBReader(stream) {
|
|
const reader = stream._reader;
|
|
if (reader === undefined) return false;
|
|
if (!IsReadableStreamBYOBReader(reader)) return false;
|
|
return true;
|
|
}
|
|
/**
|
|
* A BYOB reader vended by a {@link ReadableStream}.
|
|
*
|
|
* @public
|
|
*/ class ReadableStreamBYOBReader {
|
|
constructor(stream){
|
|
assertRequiredArgument(stream, 1, "ReadableStreamBYOBReader");
|
|
assertReadableStream(stream, "First parameter");
|
|
if (IsReadableStreamLocked(stream)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
|
|
if (!IsReadableByteStreamController(stream._readableStreamController)) throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");
|
|
ReadableStreamReaderGenericInitialize(this, stream);
|
|
this._readIntoRequests = new SimpleQueue();
|
|
}
|
|
/**
|
|
* Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
|
|
* the reader's lock is released before the stream finishes closing.
|
|
*/ get closed() {
|
|
if (!IsReadableStreamBYOBReader(this)) return promiseRejectedWith(byobReaderBrandCheckException("closed"));
|
|
return this._closedPromise;
|
|
}
|
|
/**
|
|
* If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
|
|
*/ cancel(reason) {
|
|
if (!IsReadableStreamBYOBReader(this)) return promiseRejectedWith(byobReaderBrandCheckException("cancel"));
|
|
if (this._ownerReadableStream === undefined) return promiseRejectedWith(readerLockException("cancel"));
|
|
return ReadableStreamReaderGenericCancel(this, reason);
|
|
}
|
|
/**
|
|
* Attempts to reads bytes into view, and returns a promise resolved with the result.
|
|
*
|
|
* If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
|
|
*/ read(view) {
|
|
if (!IsReadableStreamBYOBReader(this)) return promiseRejectedWith(byobReaderBrandCheckException("read"));
|
|
if (!ArrayBuffer.isView(view)) return promiseRejectedWith(new TypeError("view must be an array buffer view"));
|
|
if (view.byteLength === 0) return promiseRejectedWith(new TypeError("view must have non-zero byteLength"));
|
|
if (view.buffer.byteLength === 0) return promiseRejectedWith(new TypeError(`view's buffer must have non-zero byteLength`));
|
|
IsDetachedBuffer(view.buffer);
|
|
if (this._ownerReadableStream === undefined) return promiseRejectedWith(readerLockException("read from"));
|
|
let resolvePromise;
|
|
let rejectPromise;
|
|
const promise = newPromise((resolve, reject)=>{
|
|
resolvePromise = resolve;
|
|
rejectPromise = reject;
|
|
});
|
|
const readIntoRequest = {
|
|
_chunkSteps: (chunk)=>resolvePromise({
|
|
value: chunk,
|
|
done: false
|
|
}),
|
|
_closeSteps: (chunk)=>resolvePromise({
|
|
value: chunk,
|
|
done: true
|
|
}),
|
|
_errorSteps: (e)=>rejectPromise(e)
|
|
};
|
|
ReadableStreamBYOBReaderRead(this, view, readIntoRequest);
|
|
return promise;
|
|
}
|
|
/**
|
|
* Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
|
|
* If the associated stream is errored when the lock is released, the reader will appear errored in the same way
|
|
* from now on; otherwise, the reader will appear closed.
|
|
*
|
|
* A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
|
|
* the reader's {@link ReadableStreamBYOBReader.read | read()} method has not yet been settled. Attempting to
|
|
* do so will throw a `TypeError` and leave the reader locked to the stream.
|
|
*/ releaseLock() {
|
|
if (!IsReadableStreamBYOBReader(this)) throw byobReaderBrandCheckException("releaseLock");
|
|
if (this._ownerReadableStream === undefined) return;
|
|
if (this._readIntoRequests.length > 0) throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled");
|
|
ReadableStreamReaderGenericRelease(this);
|
|
}
|
|
}
|
|
Object.defineProperties(ReadableStreamBYOBReader.prototype, {
|
|
cancel: {
|
|
enumerable: true
|
|
},
|
|
read: {
|
|
enumerable: true
|
|
},
|
|
releaseLock: {
|
|
enumerable: true
|
|
},
|
|
closed: {
|
|
enumerable: true
|
|
}
|
|
});
|
|
if (typeof SymbolPolyfill.toStringTag === "symbol") Object.defineProperty(ReadableStreamBYOBReader.prototype, SymbolPolyfill.toStringTag, {
|
|
value: "ReadableStreamBYOBReader",
|
|
configurable: true
|
|
});
|
|
// Abstract operations for the readers.
|
|
function IsReadableStreamBYOBReader(x) {
|
|
if (!typeIsObject(x)) return false;
|
|
if (!Object.prototype.hasOwnProperty.call(x, "_readIntoRequests")) return false;
|
|
return x instanceof ReadableStreamBYOBReader;
|
|
}
|
|
function ReadableStreamBYOBReaderRead(reader, view, readIntoRequest) {
|
|
const stream = reader._ownerReadableStream;
|
|
stream._disturbed = true;
|
|
if (stream._state === "errored") readIntoRequest._errorSteps(stream._storedError);
|
|
else ReadableByteStreamControllerPullInto(stream._readableStreamController, view, readIntoRequest);
|
|
}
|
|
// Helper functions for the ReadableStreamBYOBReader.
|
|
function byobReaderBrandCheckException(name) {
|
|
return new TypeError(`ReadableStreamBYOBReader.prototype.${name} can only be used on a ReadableStreamBYOBReader`);
|
|
}
|
|
function ExtractHighWaterMark(strategy, defaultHWM) {
|
|
const { highWaterMark } = strategy;
|
|
if (highWaterMark === undefined) return defaultHWM;
|
|
if (NumberIsNaN(highWaterMark) || highWaterMark < 0) throw new RangeError("Invalid highWaterMark");
|
|
return highWaterMark;
|
|
}
|
|
function ExtractSizeAlgorithm(strategy) {
|
|
const { size } = strategy;
|
|
if (!size) return ()=>1;
|
|
return size;
|
|
}
|
|
function convertQueuingStrategy(init, context) {
|
|
assertDictionary(init, context);
|
|
const highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;
|
|
const size = init === null || init === void 0 ? void 0 : init.size;
|
|
return {
|
|
highWaterMark: highWaterMark === undefined ? undefined : convertUnrestrictedDouble(highWaterMark),
|
|
size: size === undefined ? undefined : convertQueuingStrategySize(size, `${context} has member 'size' that`)
|
|
};
|
|
}
|
|
function convertQueuingStrategySize(fn, context) {
|
|
assertFunction(fn, context);
|
|
return (chunk)=>convertUnrestrictedDouble(fn(chunk));
|
|
}
|
|
function convertUnderlyingSink(original, context) {
|
|
assertDictionary(original, context);
|
|
const abort = original === null || original === void 0 ? void 0 : original.abort;
|
|
const close = original === null || original === void 0 ? void 0 : original.close;
|
|
const start = original === null || original === void 0 ? void 0 : original.start;
|
|
const type = original === null || original === void 0 ? void 0 : original.type;
|
|
const write = original === null || original === void 0 ? void 0 : original.write;
|
|
return {
|
|
abort: abort === undefined ? undefined : convertUnderlyingSinkAbortCallback(abort, original, `${context} has member 'abort' that`),
|
|
close: close === undefined ? undefined : convertUnderlyingSinkCloseCallback(close, original, `${context} has member 'close' that`),
|
|
start: start === undefined ? undefined : convertUnderlyingSinkStartCallback(start, original, `${context} has member 'start' that`),
|
|
write: write === undefined ? undefined : convertUnderlyingSinkWriteCallback(write, original, `${context} has member 'write' that`),
|
|
type
|
|
};
|
|
}
|
|
function convertUnderlyingSinkAbortCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (reason)=>promiseCall(fn, original, [
|
|
reason
|
|
]);
|
|
}
|
|
function convertUnderlyingSinkCloseCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return ()=>promiseCall(fn, original, []);
|
|
}
|
|
function convertUnderlyingSinkStartCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (controller)=>reflectCall(fn, original, [
|
|
controller
|
|
]);
|
|
}
|
|
function convertUnderlyingSinkWriteCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (chunk, controller)=>promiseCall(fn, original, [
|
|
chunk,
|
|
controller
|
|
]);
|
|
}
|
|
function assertWritableStream(x, context) {
|
|
if (!IsWritableStream(x)) throw new TypeError(`${context} is not a WritableStream.`);
|
|
}
|
|
function isAbortSignal(value) {
|
|
if (typeof value !== "object" || value === null) return false;
|
|
try {
|
|
return typeof value.aborted === "boolean";
|
|
} catch (_a) {
|
|
// AbortSignal.prototype.aborted throws if its brand check fails
|
|
return false;
|
|
}
|
|
}
|
|
const supportsAbortController = typeof AbortController === "function";
|
|
/**
|
|
* Construct a new AbortController, if supported by the platform.
|
|
*
|
|
* @internal
|
|
*/ function createAbortController() {
|
|
if (supportsAbortController) return new AbortController();
|
|
return undefined;
|
|
}
|
|
/**
|
|
* A writable stream represents a destination for data, into which you can write.
|
|
*
|
|
* @public
|
|
*/ class WritableStream {
|
|
constructor(rawUnderlyingSink = {}, rawStrategy = {}){
|
|
if (rawUnderlyingSink === undefined) rawUnderlyingSink = null;
|
|
else assertObject(rawUnderlyingSink, "First parameter");
|
|
const strategy = convertQueuingStrategy(rawStrategy, "Second parameter");
|
|
const underlyingSink = convertUnderlyingSink(rawUnderlyingSink, "First parameter");
|
|
InitializeWritableStream(this);
|
|
const type = underlyingSink.type;
|
|
if (type !== undefined) throw new RangeError("Invalid type is specified");
|
|
const sizeAlgorithm = ExtractSizeAlgorithm(strategy);
|
|
const highWaterMark = ExtractHighWaterMark(strategy, 1);
|
|
SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm);
|
|
}
|
|
/**
|
|
* Returns whether or not the writable stream is locked to a writer.
|
|
*/ get locked() {
|
|
if (!IsWritableStream(this)) throw streamBrandCheckException$2("locked");
|
|
return IsWritableStreamLocked(this);
|
|
}
|
|
/**
|
|
* Aborts the stream, signaling that the producer can no longer successfully write to the stream and it is to be
|
|
* immediately moved to an errored state, with any queued-up writes discarded. This will also execute any abort
|
|
* mechanism of the underlying sink.
|
|
*
|
|
* The returned promise will fulfill if the stream shuts down successfully, or reject if the underlying sink signaled
|
|
* that there was an error doing so. Additionally, it will reject with a `TypeError` (without attempting to cancel
|
|
* the stream) if the stream is currently locked.
|
|
*/ abort(reason) {
|
|
if (!IsWritableStream(this)) return promiseRejectedWith(streamBrandCheckException$2("abort"));
|
|
if (IsWritableStreamLocked(this)) return promiseRejectedWith(new TypeError("Cannot abort a stream that already has a writer"));
|
|
return WritableStreamAbort(this, reason);
|
|
}
|
|
/**
|
|
* Closes the stream. The underlying sink will finish processing any previously-written chunks, before invoking its
|
|
* close behavior. During this time any further attempts to write will fail (without erroring the stream).
|
|
*
|
|
* The method returns a promise that will fulfill if all remaining chunks are successfully written and the stream
|
|
* successfully closes, or rejects if an error is encountered during this process. Additionally, it will reject with
|
|
* a `TypeError` (without attempting to cancel the stream) if the stream is currently locked.
|
|
*/ close() {
|
|
if (!IsWritableStream(this)) return promiseRejectedWith(streamBrandCheckException$2("close"));
|
|
if (IsWritableStreamLocked(this)) return promiseRejectedWith(new TypeError("Cannot close a stream that already has a writer"));
|
|
if (WritableStreamCloseQueuedOrInFlight(this)) return promiseRejectedWith(new TypeError("Cannot close an already-closing stream"));
|
|
return WritableStreamClose(this);
|
|
}
|
|
/**
|
|
* Creates a {@link WritableStreamDefaultWriter | writer} and locks the stream to the new writer. While the stream
|
|
* is locked, no other writer can be acquired until this one is released.
|
|
*
|
|
* This functionality is especially useful for creating abstractions that desire the ability to write to a stream
|
|
* without interruption or interleaving. By getting a writer for the stream, you can ensure nobody else can write at
|
|
* the same time, which would cause the resulting written data to be unpredictable and probably useless.
|
|
*/ getWriter() {
|
|
if (!IsWritableStream(this)) throw streamBrandCheckException$2("getWriter");
|
|
return AcquireWritableStreamDefaultWriter(this);
|
|
}
|
|
}
|
|
Object.defineProperties(WritableStream.prototype, {
|
|
abort: {
|
|
enumerable: true
|
|
},
|
|
close: {
|
|
enumerable: true
|
|
},
|
|
getWriter: {
|
|
enumerable: true
|
|
},
|
|
locked: {
|
|
enumerable: true
|
|
}
|
|
});
|
|
if (typeof SymbolPolyfill.toStringTag === "symbol") Object.defineProperty(WritableStream.prototype, SymbolPolyfill.toStringTag, {
|
|
value: "WritableStream",
|
|
configurable: true
|
|
});
|
|
// Abstract operations for the WritableStream.
|
|
function AcquireWritableStreamDefaultWriter(stream) {
|
|
return new WritableStreamDefaultWriter(stream);
|
|
}
|
|
// Throws if and only if startAlgorithm throws.
|
|
function CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark = 1, sizeAlgorithm = ()=>1) {
|
|
const stream = Object.create(WritableStream.prototype);
|
|
InitializeWritableStream(stream);
|
|
const controller = Object.create(WritableStreamDefaultController.prototype);
|
|
SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
|
|
return stream;
|
|
}
|
|
function InitializeWritableStream(stream) {
|
|
stream._state = "writable";
|
|
// The error that will be reported by new method calls once the state becomes errored. Only set when [[state]] is
|
|
// 'erroring' or 'errored'. May be set to an undefined value.
|
|
stream._storedError = undefined;
|
|
stream._writer = undefined;
|
|
// Initialize to undefined first because the constructor of the controller checks this
|
|
// variable to validate the caller.
|
|
stream._writableStreamController = undefined;
|
|
// This queue is placed here instead of the writer class in order to allow for passing a writer to the next data
|
|
// producer without waiting for the queued writes to finish.
|
|
stream._writeRequests = new SimpleQueue();
|
|
// Write requests are removed from _writeRequests when write() is called on the underlying sink. This prevents
|
|
// them from being erroneously rejected on error. If a write() call is in-flight, the request is stored here.
|
|
stream._inFlightWriteRequest = undefined;
|
|
// The promise that was returned from writer.close(). Stored here because it may be fulfilled after the writer
|
|
// has been detached.
|
|
stream._closeRequest = undefined;
|
|
// Close request is removed from _closeRequest when close() is called on the underlying sink. This prevents it
|
|
// from being erroneously rejected on error. If a close() call is in-flight, the request is stored here.
|
|
stream._inFlightCloseRequest = undefined;
|
|
// The promise that was returned from writer.abort(). This may also be fulfilled after the writer has detached.
|
|
stream._pendingAbortRequest = undefined;
|
|
// The backpressure signal set by the controller.
|
|
stream._backpressure = false;
|
|
}
|
|
function IsWritableStream(x) {
|
|
if (!typeIsObject(x)) return false;
|
|
if (!Object.prototype.hasOwnProperty.call(x, "_writableStreamController")) return false;
|
|
return x instanceof WritableStream;
|
|
}
|
|
function IsWritableStreamLocked(stream) {
|
|
if (stream._writer === undefined) return false;
|
|
return true;
|
|
}
|
|
function WritableStreamAbort(stream, reason) {
|
|
var _a;
|
|
if (stream._state === "closed" || stream._state === "errored") return promiseResolvedWith(undefined);
|
|
stream._writableStreamController._abortReason = reason;
|
|
(_a = stream._writableStreamController._abortController) === null || _a === void 0 || _a.abort();
|
|
// TypeScript narrows the type of `stream._state` down to 'writable' | 'erroring',
|
|
// but it doesn't know that signaling abort runs author code that might have changed the state.
|
|
// Widen the type again by casting to WritableStreamState.
|
|
const state = stream._state;
|
|
if (state === "closed" || state === "errored") return promiseResolvedWith(undefined);
|
|
if (stream._pendingAbortRequest !== undefined) return stream._pendingAbortRequest._promise;
|
|
let wasAlreadyErroring = false;
|
|
if (state === "erroring") {
|
|
wasAlreadyErroring = true;
|
|
// reason will not be used, so don't keep a reference to it.
|
|
reason = undefined;
|
|
}
|
|
const promise = newPromise((resolve, reject)=>{
|
|
stream._pendingAbortRequest = {
|
|
_promise: undefined,
|
|
_resolve: resolve,
|
|
_reject: reject,
|
|
_reason: reason,
|
|
_wasAlreadyErroring: wasAlreadyErroring
|
|
};
|
|
});
|
|
stream._pendingAbortRequest._promise = promise;
|
|
if (!wasAlreadyErroring) WritableStreamStartErroring(stream, reason);
|
|
return promise;
|
|
}
|
|
function WritableStreamClose(stream) {
|
|
const state = stream._state;
|
|
if (state === "closed" || state === "errored") return promiseRejectedWith(new TypeError(`The stream (in ${state} state) is not in the writable state and cannot be closed`));
|
|
const promise = newPromise((resolve, reject)=>{
|
|
const closeRequest = {
|
|
_resolve: resolve,
|
|
_reject: reject
|
|
};
|
|
stream._closeRequest = closeRequest;
|
|
});
|
|
const writer = stream._writer;
|
|
if (writer !== undefined && stream._backpressure && state === "writable") defaultWriterReadyPromiseResolve(writer);
|
|
WritableStreamDefaultControllerClose(stream._writableStreamController);
|
|
return promise;
|
|
}
|
|
// WritableStream API exposed for controllers.
|
|
function WritableStreamAddWriteRequest(stream) {
|
|
const promise = newPromise((resolve, reject)=>{
|
|
const writeRequest = {
|
|
_resolve: resolve,
|
|
_reject: reject
|
|
};
|
|
stream._writeRequests.push(writeRequest);
|
|
});
|
|
return promise;
|
|
}
|
|
function WritableStreamDealWithRejection(stream, error) {
|
|
const state = stream._state;
|
|
if (state === "writable") {
|
|
WritableStreamStartErroring(stream, error);
|
|
return;
|
|
}
|
|
WritableStreamFinishErroring(stream);
|
|
}
|
|
function WritableStreamStartErroring(stream, reason) {
|
|
const controller = stream._writableStreamController;
|
|
stream._state = "erroring";
|
|
stream._storedError = reason;
|
|
const writer = stream._writer;
|
|
if (writer !== undefined) WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);
|
|
if (!WritableStreamHasOperationMarkedInFlight(stream) && controller._started) WritableStreamFinishErroring(stream);
|
|
}
|
|
function WritableStreamFinishErroring(stream) {
|
|
stream._state = "errored";
|
|
stream._writableStreamController[ErrorSteps]();
|
|
const storedError = stream._storedError;
|
|
stream._writeRequests.forEach((writeRequest)=>{
|
|
writeRequest._reject(storedError);
|
|
});
|
|
stream._writeRequests = new SimpleQueue();
|
|
if (stream._pendingAbortRequest === undefined) {
|
|
WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
|
|
return;
|
|
}
|
|
const abortRequest = stream._pendingAbortRequest;
|
|
stream._pendingAbortRequest = undefined;
|
|
if (abortRequest._wasAlreadyErroring) {
|
|
abortRequest._reject(storedError);
|
|
WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
|
|
return;
|
|
}
|
|
const promise = stream._writableStreamController[AbortSteps](abortRequest._reason);
|
|
uponPromise(promise, ()=>{
|
|
abortRequest._resolve();
|
|
WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
|
|
}, (reason)=>{
|
|
abortRequest._reject(reason);
|
|
WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
|
|
});
|
|
}
|
|
function WritableStreamFinishInFlightWrite(stream) {
|
|
stream._inFlightWriteRequest._resolve(undefined);
|
|
stream._inFlightWriteRequest = undefined;
|
|
}
|
|
function WritableStreamFinishInFlightWriteWithError(stream, error) {
|
|
stream._inFlightWriteRequest._reject(error);
|
|
stream._inFlightWriteRequest = undefined;
|
|
WritableStreamDealWithRejection(stream, error);
|
|
}
|
|
function WritableStreamFinishInFlightClose(stream) {
|
|
stream._inFlightCloseRequest._resolve(undefined);
|
|
stream._inFlightCloseRequest = undefined;
|
|
const state = stream._state;
|
|
if (state === "erroring") {
|
|
// The error was too late to do anything, so it is ignored.
|
|
stream._storedError = undefined;
|
|
if (stream._pendingAbortRequest !== undefined) {
|
|
stream._pendingAbortRequest._resolve();
|
|
stream._pendingAbortRequest = undefined;
|
|
}
|
|
}
|
|
stream._state = "closed";
|
|
const writer = stream._writer;
|
|
if (writer !== undefined) defaultWriterClosedPromiseResolve(writer);
|
|
}
|
|
function WritableStreamFinishInFlightCloseWithError(stream, error) {
|
|
stream._inFlightCloseRequest._reject(error);
|
|
stream._inFlightCloseRequest = undefined;
|
|
// Never execute sink abort() after sink close().
|
|
if (stream._pendingAbortRequest !== undefined) {
|
|
stream._pendingAbortRequest._reject(error);
|
|
stream._pendingAbortRequest = undefined;
|
|
}
|
|
WritableStreamDealWithRejection(stream, error);
|
|
}
|
|
// TODO(ricea): Fix alphabetical order.
|
|
function WritableStreamCloseQueuedOrInFlight(stream) {
|
|
if (stream._closeRequest === undefined && stream._inFlightCloseRequest === undefined) return false;
|
|
return true;
|
|
}
|
|
function WritableStreamHasOperationMarkedInFlight(stream) {
|
|
if (stream._inFlightWriteRequest === undefined && stream._inFlightCloseRequest === undefined) return false;
|
|
return true;
|
|
}
|
|
function WritableStreamMarkCloseRequestInFlight(stream) {
|
|
stream._inFlightCloseRequest = stream._closeRequest;
|
|
stream._closeRequest = undefined;
|
|
}
|
|
function WritableStreamMarkFirstWriteRequestInFlight(stream) {
|
|
stream._inFlightWriteRequest = stream._writeRequests.shift();
|
|
}
|
|
function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
|
|
if (stream._closeRequest !== undefined) {
|
|
stream._closeRequest._reject(stream._storedError);
|
|
stream._closeRequest = undefined;
|
|
}
|
|
const writer = stream._writer;
|
|
if (writer !== undefined) defaultWriterClosedPromiseReject(writer, stream._storedError);
|
|
}
|
|
function WritableStreamUpdateBackpressure(stream, backpressure) {
|
|
const writer = stream._writer;
|
|
if (writer !== undefined && backpressure !== stream._backpressure) {
|
|
if (backpressure) defaultWriterReadyPromiseReset(writer);
|
|
else defaultWriterReadyPromiseResolve(writer);
|
|
}
|
|
stream._backpressure = backpressure;
|
|
}
|
|
/**
|
|
* A default writer vended by a {@link WritableStream}.
|
|
*
|
|
* @public
|
|
*/ class WritableStreamDefaultWriter {
|
|
constructor(stream){
|
|
assertRequiredArgument(stream, 1, "WritableStreamDefaultWriter");
|
|
assertWritableStream(stream, "First parameter");
|
|
if (IsWritableStreamLocked(stream)) throw new TypeError("This stream has already been locked for exclusive writing by another writer");
|
|
this._ownerWritableStream = stream;
|
|
stream._writer = this;
|
|
const state = stream._state;
|
|
if (state === "writable") {
|
|
if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._backpressure) defaultWriterReadyPromiseInitialize(this);
|
|
else defaultWriterReadyPromiseInitializeAsResolved(this);
|
|
defaultWriterClosedPromiseInitialize(this);
|
|
} else if (state === "erroring") {
|
|
defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError);
|
|
defaultWriterClosedPromiseInitialize(this);
|
|
} else if (state === "closed") {
|
|
defaultWriterReadyPromiseInitializeAsResolved(this);
|
|
defaultWriterClosedPromiseInitializeAsResolved(this);
|
|
} else {
|
|
const storedError = stream._storedError;
|
|
defaultWriterReadyPromiseInitializeAsRejected(this, storedError);
|
|
defaultWriterClosedPromiseInitializeAsRejected(this, storedError);
|
|
}
|
|
}
|
|
/**
|
|
* Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
|
|
* the writer\u2019s lock is released before the stream finishes closing.
|
|
*/ get closed() {
|
|
if (!IsWritableStreamDefaultWriter(this)) return promiseRejectedWith(defaultWriterBrandCheckException("closed"));
|
|
return this._closedPromise;
|
|
}
|
|
/**
|
|
* Returns the desired size to fill the stream\u2019s internal queue. It can be negative, if the queue is over-full.
|
|
* A producer can use this information to determine the right amount of data to write.
|
|
*
|
|
* It will be `null` if the stream cannot be successfully written to (due to either being errored, or having an abort
|
|
* queued up). It will return zero if the stream is closed. And the getter will throw an exception if invoked when
|
|
* the writer\u2019s lock is released.
|
|
*/ get desiredSize() {
|
|
if (!IsWritableStreamDefaultWriter(this)) throw defaultWriterBrandCheckException("desiredSize");
|
|
if (this._ownerWritableStream === undefined) throw defaultWriterLockException("desiredSize");
|
|
return WritableStreamDefaultWriterGetDesiredSize(this);
|
|
}
|
|
/**
|
|
* Returns a promise that will be fulfilled when the desired size to fill the stream\u2019s internal queue transitions
|
|
* from non-positive to positive, signaling that it is no longer applying backpressure. Once the desired size dips
|
|
* back to zero or below, the getter will return a new promise that stays pending until the next transition.
|
|
*
|
|
* If the stream becomes errored or aborted, or the writer\u2019s lock is released, the returned promise will become
|
|
* rejected.
|
|
*/ get ready() {
|
|
if (!IsWritableStreamDefaultWriter(this)) return promiseRejectedWith(defaultWriterBrandCheckException("ready"));
|
|
return this._readyPromise;
|
|
}
|
|
/**
|
|
* If the reader is active, behaves the same as {@link WritableStream.abort | stream.abort(reason)}.
|
|
*/ abort(reason) {
|
|
if (!IsWritableStreamDefaultWriter(this)) return promiseRejectedWith(defaultWriterBrandCheckException("abort"));
|
|
if (this._ownerWritableStream === undefined) return promiseRejectedWith(defaultWriterLockException("abort"));
|
|
return WritableStreamDefaultWriterAbort(this, reason);
|
|
}
|
|
/**
|
|
* If the reader is active, behaves the same as {@link WritableStream.close | stream.close()}.
|
|
*/ close() {
|
|
if (!IsWritableStreamDefaultWriter(this)) return promiseRejectedWith(defaultWriterBrandCheckException("close"));
|
|
const stream = this._ownerWritableStream;
|
|
if (stream === undefined) return promiseRejectedWith(defaultWriterLockException("close"));
|
|
if (WritableStreamCloseQueuedOrInFlight(stream)) return promiseRejectedWith(new TypeError("Cannot close an already-closing stream"));
|
|
return WritableStreamDefaultWriterClose(this);
|
|
}
|
|
/**
|
|
* Releases the writer\u2019s lock on the corresponding stream. After the lock is released, the writer is no longer active.
|
|
* If the associated stream is errored when the lock is released, the writer will appear errored in the same way from
|
|
* now on; otherwise, the writer will appear closed.
|
|
*
|
|
* Note that the lock can still be released even if some ongoing writes have not yet finished (i.e. even if the
|
|
* promises returned from previous calls to {@link WritableStreamDefaultWriter.write | write()} have not yet settled).
|
|
* It\u2019s not necessary to hold the lock on the writer for the duration of the write; the lock instead simply prevents
|
|
* other producers from writing in an interleaved manner.
|
|
*/ releaseLock() {
|
|
if (!IsWritableStreamDefaultWriter(this)) throw defaultWriterBrandCheckException("releaseLock");
|
|
const stream = this._ownerWritableStream;
|
|
if (stream === undefined) return;
|
|
WritableStreamDefaultWriterRelease(this);
|
|
}
|
|
write(chunk) {
|
|
if (!IsWritableStreamDefaultWriter(this)) return promiseRejectedWith(defaultWriterBrandCheckException("write"));
|
|
if (this._ownerWritableStream === undefined) return promiseRejectedWith(defaultWriterLockException("write to"));
|
|
return WritableStreamDefaultWriterWrite(this, chunk);
|
|
}
|
|
}
|
|
Object.defineProperties(WritableStreamDefaultWriter.prototype, {
|
|
abort: {
|
|
enumerable: true
|
|
},
|
|
close: {
|
|
enumerable: true
|
|
},
|
|
releaseLock: {
|
|
enumerable: true
|
|
},
|
|
write: {
|
|
enumerable: true
|
|
},
|
|
closed: {
|
|
enumerable: true
|
|
},
|
|
desiredSize: {
|
|
enumerable: true
|
|
},
|
|
ready: {
|
|
enumerable: true
|
|
}
|
|
});
|
|
if (typeof SymbolPolyfill.toStringTag === "symbol") Object.defineProperty(WritableStreamDefaultWriter.prototype, SymbolPolyfill.toStringTag, {
|
|
value: "WritableStreamDefaultWriter",
|
|
configurable: true
|
|
});
|
|
// Abstract operations for the WritableStreamDefaultWriter.
|
|
function IsWritableStreamDefaultWriter(x) {
|
|
if (!typeIsObject(x)) return false;
|
|
if (!Object.prototype.hasOwnProperty.call(x, "_ownerWritableStream")) return false;
|
|
return x instanceof WritableStreamDefaultWriter;
|
|
}
|
|
// A client of WritableStreamDefaultWriter may use these functions directly to bypass state check.
|
|
function WritableStreamDefaultWriterAbort(writer, reason) {
|
|
const stream = writer._ownerWritableStream;
|
|
return WritableStreamAbort(stream, reason);
|
|
}
|
|
function WritableStreamDefaultWriterClose(writer) {
|
|
const stream = writer._ownerWritableStream;
|
|
return WritableStreamClose(stream);
|
|
}
|
|
function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {
|
|
const stream = writer._ownerWritableStream;
|
|
const state = stream._state;
|
|
if (WritableStreamCloseQueuedOrInFlight(stream) || state === "closed") return promiseResolvedWith(undefined);
|
|
if (state === "errored") return promiseRejectedWith(stream._storedError);
|
|
return WritableStreamDefaultWriterClose(writer);
|
|
}
|
|
function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {
|
|
if (writer._closedPromiseState === "pending") defaultWriterClosedPromiseReject(writer, error);
|
|
else defaultWriterClosedPromiseResetToRejected(writer, error);
|
|
}
|
|
function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {
|
|
if (writer._readyPromiseState === "pending") defaultWriterReadyPromiseReject(writer, error);
|
|
else defaultWriterReadyPromiseResetToRejected(writer, error);
|
|
}
|
|
function WritableStreamDefaultWriterGetDesiredSize(writer) {
|
|
const stream = writer._ownerWritableStream;
|
|
const state = stream._state;
|
|
if (state === "errored" || state === "erroring") return null;
|
|
if (state === "closed") return 0;
|
|
return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);
|
|
}
|
|
function WritableStreamDefaultWriterRelease(writer) {
|
|
const stream = writer._ownerWritableStream;
|
|
const releasedError = new TypeError(`Writer was released and can no longer be used to monitor the stream's closedness`);
|
|
WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);
|
|
// The state transitions to "errored" before the sink abort() method runs, but the writer.closed promise is not
|
|
// rejected until afterwards. This means that simply testing state will not work.
|
|
WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);
|
|
stream._writer = undefined;
|
|
writer._ownerWritableStream = undefined;
|
|
}
|
|
function WritableStreamDefaultWriterWrite(writer, chunk) {
|
|
const stream = writer._ownerWritableStream;
|
|
const controller = stream._writableStreamController;
|
|
const chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);
|
|
if (stream !== writer._ownerWritableStream) return promiseRejectedWith(defaultWriterLockException("write to"));
|
|
const state = stream._state;
|
|
if (state === "errored") return promiseRejectedWith(stream._storedError);
|
|
if (WritableStreamCloseQueuedOrInFlight(stream) || state === "closed") return promiseRejectedWith(new TypeError("The stream is closing or closed and cannot be written to"));
|
|
if (state === "erroring") return promiseRejectedWith(stream._storedError);
|
|
const promise = WritableStreamAddWriteRequest(stream);
|
|
WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);
|
|
return promise;
|
|
}
|
|
const closeSentinel = {};
|
|
/**
|
|
* Allows control of a {@link WritableStream | writable stream}'s state and internal queue.
|
|
*
|
|
* @public
|
|
*/ class WritableStreamDefaultController {
|
|
constructor(){
|
|
throw new TypeError("Illegal constructor");
|
|
}
|
|
/**
|
|
* The reason which was passed to `WritableStream.abort(reason)` when the stream was aborted.
|
|
*
|
|
* @deprecated
|
|
* This property has been removed from the specification, see https://github.com/whatwg/streams/pull/1177.
|
|
* Use {@link WritableStreamDefaultController.signal}'s `reason` instead.
|
|
*/ get abortReason() {
|
|
if (!IsWritableStreamDefaultController(this)) throw defaultControllerBrandCheckException$2("abortReason");
|
|
return this._abortReason;
|
|
}
|
|
/**
|
|
* An `AbortSignal` that can be used to abort the pending write or close operation when the stream is aborted.
|
|
*/ get signal() {
|
|
if (!IsWritableStreamDefaultController(this)) throw defaultControllerBrandCheckException$2("signal");
|
|
if (this._abortController === undefined) // Older browsers or older Node versions may not support `AbortController` or `AbortSignal`.
|
|
// We don't want to bundle and ship an `AbortController` polyfill together with our polyfill,
|
|
// so instead we only implement support for `signal` if we find a global `AbortController` constructor.
|
|
throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");
|
|
return this._abortController.signal;
|
|
}
|
|
/**
|
|
* Closes the controlled writable stream, making all future interactions with it fail with the given error `e`.
|
|
*
|
|
* This method is rarely used, since usually it suffices to return a rejected promise from one of the underlying
|
|
* sink's methods. However, it can be useful for suddenly shutting down a stream in response to an event outside the
|
|
* normal lifecycle of interactions with the underlying sink.
|
|
*/ error(e) {
|
|
if (!IsWritableStreamDefaultController(this)) throw defaultControllerBrandCheckException$2("error");
|
|
const state = this._controlledWritableStream._state;
|
|
if (state !== "writable") // The stream is closed, errored or will be soon. The sink can't do anything useful if it gets an error here, so
|
|
// just treat it as a no-op.
|
|
return;
|
|
WritableStreamDefaultControllerError(this, e);
|
|
}
|
|
/** @internal */ [AbortSteps](reason) {
|
|
const result = this._abortAlgorithm(reason);
|
|
WritableStreamDefaultControllerClearAlgorithms(this);
|
|
return result;
|
|
}
|
|
/** @internal */ [ErrorSteps]() {
|
|
ResetQueue(this);
|
|
}
|
|
}
|
|
Object.defineProperties(WritableStreamDefaultController.prototype, {
|
|
abortReason: {
|
|
enumerable: true
|
|
},
|
|
signal: {
|
|
enumerable: true
|
|
},
|
|
error: {
|
|
enumerable: true
|
|
}
|
|
});
|
|
if (typeof SymbolPolyfill.toStringTag === "symbol") Object.defineProperty(WritableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {
|
|
value: "WritableStreamDefaultController",
|
|
configurable: true
|
|
});
|
|
// Abstract operations implementing interface required by the WritableStream.
|
|
function IsWritableStreamDefaultController(x) {
|
|
if (!typeIsObject(x)) return false;
|
|
if (!Object.prototype.hasOwnProperty.call(x, "_controlledWritableStream")) return false;
|
|
return x instanceof WritableStreamDefaultController;
|
|
}
|
|
function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {
|
|
controller._controlledWritableStream = stream;
|
|
stream._writableStreamController = controller;
|
|
// Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly.
|
|
controller._queue = undefined;
|
|
controller._queueTotalSize = undefined;
|
|
ResetQueue(controller);
|
|
controller._abortReason = undefined;
|
|
controller._abortController = createAbortController();
|
|
controller._started = false;
|
|
controller._strategySizeAlgorithm = sizeAlgorithm;
|
|
controller._strategyHWM = highWaterMark;
|
|
controller._writeAlgorithm = writeAlgorithm;
|
|
controller._closeAlgorithm = closeAlgorithm;
|
|
controller._abortAlgorithm = abortAlgorithm;
|
|
const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
|
|
WritableStreamUpdateBackpressure(stream, backpressure);
|
|
const startResult = startAlgorithm();
|
|
const startPromise = promiseResolvedWith(startResult);
|
|
uponPromise(startPromise, ()=>{
|
|
controller._started = true;
|
|
WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
|
|
}, (r)=>{
|
|
controller._started = true;
|
|
WritableStreamDealWithRejection(stream, r);
|
|
});
|
|
}
|
|
function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, highWaterMark, sizeAlgorithm) {
|
|
const controller = Object.create(WritableStreamDefaultController.prototype);
|
|
let startAlgorithm = ()=>undefined;
|
|
let writeAlgorithm = ()=>promiseResolvedWith(undefined);
|
|
let closeAlgorithm = ()=>promiseResolvedWith(undefined);
|
|
let abortAlgorithm = ()=>promiseResolvedWith(undefined);
|
|
if (underlyingSink.start !== undefined) startAlgorithm = ()=>underlyingSink.start(controller);
|
|
if (underlyingSink.write !== undefined) writeAlgorithm = (chunk)=>underlyingSink.write(chunk, controller);
|
|
if (underlyingSink.close !== undefined) closeAlgorithm = ()=>underlyingSink.close();
|
|
if (underlyingSink.abort !== undefined) abortAlgorithm = (reason)=>underlyingSink.abort(reason);
|
|
SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
|
|
}
|
|
// ClearAlgorithms may be called twice. Erroring the same stream in multiple ways will often result in redundant calls.
|
|
function WritableStreamDefaultControllerClearAlgorithms(controller) {
|
|
controller._writeAlgorithm = undefined;
|
|
controller._closeAlgorithm = undefined;
|
|
controller._abortAlgorithm = undefined;
|
|
controller._strategySizeAlgorithm = undefined;
|
|
}
|
|
function WritableStreamDefaultControllerClose(controller) {
|
|
EnqueueValueWithSize(controller, closeSentinel, 0);
|
|
WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
|
|
}
|
|
function WritableStreamDefaultControllerGetChunkSize(controller, chunk) {
|
|
try {
|
|
return controller._strategySizeAlgorithm(chunk);
|
|
} catch (chunkSizeE) {
|
|
WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
|
|
return 1;
|
|
}
|
|
}
|
|
function WritableStreamDefaultControllerGetDesiredSize(controller) {
|
|
return controller._strategyHWM - controller._queueTotalSize;
|
|
}
|
|
function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) {
|
|
try {
|
|
EnqueueValueWithSize(controller, chunk, chunkSize);
|
|
} catch (enqueueE) {
|
|
WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
|
|
return;
|
|
}
|
|
const stream = controller._controlledWritableStream;
|
|
if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._state === "writable") {
|
|
const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
|
|
WritableStreamUpdateBackpressure(stream, backpressure);
|
|
}
|
|
WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
|
|
}
|
|
// Abstract operations for the WritableStreamDefaultController.
|
|
function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
|
|
const stream = controller._controlledWritableStream;
|
|
if (!controller._started) return;
|
|
if (stream._inFlightWriteRequest !== undefined) return;
|
|
const state = stream._state;
|
|
if (state === "erroring") {
|
|
WritableStreamFinishErroring(stream);
|
|
return;
|
|
}
|
|
if (controller._queue.length === 0) return;
|
|
const value = PeekQueueValue(controller);
|
|
if (value === closeSentinel) WritableStreamDefaultControllerProcessClose(controller);
|
|
else WritableStreamDefaultControllerProcessWrite(controller, value);
|
|
}
|
|
function WritableStreamDefaultControllerErrorIfNeeded(controller, error) {
|
|
if (controller._controlledWritableStream._state === "writable") WritableStreamDefaultControllerError(controller, error);
|
|
}
|
|
function WritableStreamDefaultControllerProcessClose(controller) {
|
|
const stream = controller._controlledWritableStream;
|
|
WritableStreamMarkCloseRequestInFlight(stream);
|
|
DequeueValue(controller);
|
|
const sinkClosePromise = controller._closeAlgorithm();
|
|
WritableStreamDefaultControllerClearAlgorithms(controller);
|
|
uponPromise(sinkClosePromise, ()=>{
|
|
WritableStreamFinishInFlightClose(stream);
|
|
}, (reason)=>{
|
|
WritableStreamFinishInFlightCloseWithError(stream, reason);
|
|
});
|
|
}
|
|
function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
|
|
const stream = controller._controlledWritableStream;
|
|
WritableStreamMarkFirstWriteRequestInFlight(stream);
|
|
const sinkWritePromise = controller._writeAlgorithm(chunk);
|
|
uponPromise(sinkWritePromise, ()=>{
|
|
WritableStreamFinishInFlightWrite(stream);
|
|
const state = stream._state;
|
|
DequeueValue(controller);
|
|
if (!WritableStreamCloseQueuedOrInFlight(stream) && state === "writable") {
|
|
const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
|
|
WritableStreamUpdateBackpressure(stream, backpressure);
|
|
}
|
|
WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
|
|
}, (reason)=>{
|
|
if (stream._state === "writable") WritableStreamDefaultControllerClearAlgorithms(controller);
|
|
WritableStreamFinishInFlightWriteWithError(stream, reason);
|
|
});
|
|
}
|
|
function WritableStreamDefaultControllerGetBackpressure(controller) {
|
|
const desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);
|
|
return desiredSize <= 0;
|
|
}
|
|
// A client of WritableStreamDefaultController may use these functions directly to bypass state check.
|
|
function WritableStreamDefaultControllerError(controller, error) {
|
|
const stream = controller._controlledWritableStream;
|
|
WritableStreamDefaultControllerClearAlgorithms(controller);
|
|
WritableStreamStartErroring(stream, error);
|
|
}
|
|
// Helper functions for the WritableStream.
|
|
function streamBrandCheckException$2(name) {
|
|
return new TypeError(`WritableStream.prototype.${name} can only be used on a WritableStream`);
|
|
}
|
|
// Helper functions for the WritableStreamDefaultController.
|
|
function defaultControllerBrandCheckException$2(name) {
|
|
return new TypeError(`WritableStreamDefaultController.prototype.${name} can only be used on a WritableStreamDefaultController`);
|
|
}
|
|
// Helper functions for the WritableStreamDefaultWriter.
|
|
function defaultWriterBrandCheckException(name) {
|
|
return new TypeError(`WritableStreamDefaultWriter.prototype.${name} can only be used on a WritableStreamDefaultWriter`);
|
|
}
|
|
function defaultWriterLockException(name) {
|
|
return new TypeError("Cannot " + name + " a stream using a released writer");
|
|
}
|
|
function defaultWriterClosedPromiseInitialize(writer) {
|
|
writer._closedPromise = newPromise((resolve, reject)=>{
|
|
writer._closedPromise_resolve = resolve;
|
|
writer._closedPromise_reject = reject;
|
|
writer._closedPromiseState = "pending";
|
|
});
|
|
}
|
|
function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) {
|
|
defaultWriterClosedPromiseInitialize(writer);
|
|
defaultWriterClosedPromiseReject(writer, reason);
|
|
}
|
|
function defaultWriterClosedPromiseInitializeAsResolved(writer) {
|
|
defaultWriterClosedPromiseInitialize(writer);
|
|
defaultWriterClosedPromiseResolve(writer);
|
|
}
|
|
function defaultWriterClosedPromiseReject(writer, reason) {
|
|
if (writer._closedPromise_reject === undefined) return;
|
|
setPromiseIsHandledToTrue(writer._closedPromise);
|
|
writer._closedPromise_reject(reason);
|
|
writer._closedPromise_resolve = undefined;
|
|
writer._closedPromise_reject = undefined;
|
|
writer._closedPromiseState = "rejected";
|
|
}
|
|
function defaultWriterClosedPromiseResetToRejected(writer, reason) {
|
|
defaultWriterClosedPromiseInitializeAsRejected(writer, reason);
|
|
}
|
|
function defaultWriterClosedPromiseResolve(writer) {
|
|
if (writer._closedPromise_resolve === undefined) return;
|
|
writer._closedPromise_resolve(undefined);
|
|
writer._closedPromise_resolve = undefined;
|
|
writer._closedPromise_reject = undefined;
|
|
writer._closedPromiseState = "resolved";
|
|
}
|
|
function defaultWriterReadyPromiseInitialize(writer) {
|
|
writer._readyPromise = newPromise((resolve, reject)=>{
|
|
writer._readyPromise_resolve = resolve;
|
|
writer._readyPromise_reject = reject;
|
|
});
|
|
writer._readyPromiseState = "pending";
|
|
}
|
|
function defaultWriterReadyPromiseInitializeAsRejected(writer, reason) {
|
|
defaultWriterReadyPromiseInitialize(writer);
|
|
defaultWriterReadyPromiseReject(writer, reason);
|
|
}
|
|
function defaultWriterReadyPromiseInitializeAsResolved(writer) {
|
|
defaultWriterReadyPromiseInitialize(writer);
|
|
defaultWriterReadyPromiseResolve(writer);
|
|
}
|
|
function defaultWriterReadyPromiseReject(writer, reason) {
|
|
if (writer._readyPromise_reject === undefined) return;
|
|
setPromiseIsHandledToTrue(writer._readyPromise);
|
|
writer._readyPromise_reject(reason);
|
|
writer._readyPromise_resolve = undefined;
|
|
writer._readyPromise_reject = undefined;
|
|
writer._readyPromiseState = "rejected";
|
|
}
|
|
function defaultWriterReadyPromiseReset(writer) {
|
|
defaultWriterReadyPromiseInitialize(writer);
|
|
}
|
|
function defaultWriterReadyPromiseResetToRejected(writer, reason) {
|
|
defaultWriterReadyPromiseInitializeAsRejected(writer, reason);
|
|
}
|
|
function defaultWriterReadyPromiseResolve(writer) {
|
|
if (writer._readyPromise_resolve === undefined) return;
|
|
writer._readyPromise_resolve(undefined);
|
|
writer._readyPromise_resolve = undefined;
|
|
writer._readyPromise_reject = undefined;
|
|
writer._readyPromiseState = "fulfilled";
|
|
}
|
|
/// <reference lib="dom" />
|
|
const NativeDOMException = typeof DOMException !== "undefined" ? DOMException : undefined;
|
|
/// <reference types="node" />
|
|
function isDOMExceptionConstructor(ctor) {
|
|
if (!(typeof ctor === "function" || typeof ctor === "object")) return false;
|
|
try {
|
|
new ctor();
|
|
return true;
|
|
} catch (_a) {
|
|
return false;
|
|
}
|
|
}
|
|
function createDOMExceptionPolyfill() {
|
|
// eslint-disable-next-line no-shadow
|
|
const ctor = function DOMException1(message, name) {
|
|
this.message = message || "";
|
|
this.name = name || "Error";
|
|
if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
|
|
};
|
|
ctor.prototype = Object.create(Error.prototype);
|
|
Object.defineProperty(ctor.prototype, "constructor", {
|
|
value: ctor,
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
return ctor;
|
|
}
|
|
// eslint-disable-next-line no-redeclare
|
|
const DOMException$1 = isDOMExceptionConstructor(NativeDOMException) ? NativeDOMException : createDOMExceptionPolyfill();
|
|
function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
|
|
const reader = AcquireReadableStreamDefaultReader(source);
|
|
const writer = AcquireWritableStreamDefaultWriter(dest);
|
|
source._disturbed = true;
|
|
let shuttingDown = false;
|
|
// This is used to keep track of the spec's requirement that we wait for ongoing writes during shutdown.
|
|
let currentWrite = promiseResolvedWith(undefined);
|
|
return newPromise((resolve, reject)=>{
|
|
let abortAlgorithm;
|
|
if (signal !== undefined) {
|
|
abortAlgorithm = ()=>{
|
|
const error = new DOMException$1("Aborted", "AbortError");
|
|
const actions = [];
|
|
if (!preventAbort) actions.push(()=>{
|
|
if (dest._state === "writable") return WritableStreamAbort(dest, error);
|
|
return promiseResolvedWith(undefined);
|
|
});
|
|
if (!preventCancel) actions.push(()=>{
|
|
if (source._state === "readable") return ReadableStreamCancel(source, error);
|
|
return promiseResolvedWith(undefined);
|
|
});
|
|
shutdownWithAction(()=>Promise.all(actions.map((action)=>action())), true, error);
|
|
};
|
|
if (signal.aborted) {
|
|
abortAlgorithm();
|
|
return;
|
|
}
|
|
signal.addEventListener("abort", abortAlgorithm);
|
|
}
|
|
// Using reader and writer, read all chunks from this and write them to dest
|
|
// - Backpressure must be enforced
|
|
// - Shutdown must stop all activity
|
|
function pipeLoop() {
|
|
return newPromise((resolveLoop, rejectLoop)=>{
|
|
function next(done) {
|
|
if (done) resolveLoop();
|
|
else // Use `PerformPromiseThen` instead of `uponPromise` to avoid
|
|
// adding unnecessary `.catch(rethrowAssertionErrorRejection)` handlers
|
|
PerformPromiseThen(pipeStep(), next, rejectLoop);
|
|
}
|
|
next(false);
|
|
});
|
|
}
|
|
function pipeStep() {
|
|
if (shuttingDown) return promiseResolvedWith(true);
|
|
return PerformPromiseThen(writer._readyPromise, ()=>{
|
|
return newPromise((resolveRead, rejectRead)=>{
|
|
ReadableStreamDefaultReaderRead(reader, {
|
|
_chunkSteps: (chunk)=>{
|
|
currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, chunk), undefined, noop);
|
|
resolveRead(false);
|
|
},
|
|
_closeSteps: ()=>resolveRead(true),
|
|
_errorSteps: rejectRead
|
|
});
|
|
});
|
|
});
|
|
}
|
|
// Errors must be propagated forward
|
|
isOrBecomesErrored(source, reader._closedPromise, (storedError)=>{
|
|
if (!preventAbort) shutdownWithAction(()=>WritableStreamAbort(dest, storedError), true, storedError);
|
|
else shutdown(true, storedError);
|
|
});
|
|
// Errors must be propagated backward
|
|
isOrBecomesErrored(dest, writer._closedPromise, (storedError)=>{
|
|
if (!preventCancel) shutdownWithAction(()=>ReadableStreamCancel(source, storedError), true, storedError);
|
|
else shutdown(true, storedError);
|
|
});
|
|
// Closing must be propagated forward
|
|
isOrBecomesClosed(source, reader._closedPromise, ()=>{
|
|
if (!preventClose) shutdownWithAction(()=>WritableStreamDefaultWriterCloseWithErrorPropagation(writer));
|
|
else shutdown();
|
|
});
|
|
// Closing must be propagated backward
|
|
if (WritableStreamCloseQueuedOrInFlight(dest) || dest._state === "closed") {
|
|
const destClosed = new TypeError("the destination writable stream closed before all data could be piped to it");
|
|
if (!preventCancel) shutdownWithAction(()=>ReadableStreamCancel(source, destClosed), true, destClosed);
|
|
else shutdown(true, destClosed);
|
|
}
|
|
setPromiseIsHandledToTrue(pipeLoop());
|
|
function waitForWritesToFinish() {
|
|
// Another write may have started while we were waiting on this currentWrite, so we have to be sure to wait
|
|
// for that too.
|
|
const oldCurrentWrite = currentWrite;
|
|
return PerformPromiseThen(currentWrite, ()=>oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : undefined);
|
|
}
|
|
function isOrBecomesErrored(stream, promise, action) {
|
|
if (stream._state === "errored") action(stream._storedError);
|
|
else uponRejection(promise, action);
|
|
}
|
|
function isOrBecomesClosed(stream, promise, action) {
|
|
if (stream._state === "closed") action();
|
|
else uponFulfillment(promise, action);
|
|
}
|
|
function shutdownWithAction(action, originalIsError, originalError) {
|
|
if (shuttingDown) return;
|
|
shuttingDown = true;
|
|
if (dest._state === "writable" && !WritableStreamCloseQueuedOrInFlight(dest)) uponFulfillment(waitForWritesToFinish(), doTheRest);
|
|
else doTheRest();
|
|
function doTheRest() {
|
|
uponPromise(action(), ()=>finalize(originalIsError, originalError), (newError)=>finalize(true, newError));
|
|
}
|
|
}
|
|
function shutdown(isError, error) {
|
|
if (shuttingDown) return;
|
|
shuttingDown = true;
|
|
if (dest._state === "writable" && !WritableStreamCloseQueuedOrInFlight(dest)) uponFulfillment(waitForWritesToFinish(), ()=>finalize(isError, error));
|
|
else finalize(isError, error);
|
|
}
|
|
function finalize(isError, error) {
|
|
WritableStreamDefaultWriterRelease(writer);
|
|
ReadableStreamReaderGenericRelease(reader);
|
|
if (signal !== undefined) signal.removeEventListener("abort", abortAlgorithm);
|
|
if (isError) reject(error);
|
|
else resolve(undefined);
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* Allows control of a {@link ReadableStream | readable stream}'s state and internal queue.
|
|
*
|
|
* @public
|
|
*/ class ReadableStreamDefaultController {
|
|
constructor(){
|
|
throw new TypeError("Illegal constructor");
|
|
}
|
|
/**
|
|
* Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
|
|
* over-full. An underlying source ought to use this information to determine when and how to apply backpressure.
|
|
*/ get desiredSize() {
|
|
if (!IsReadableStreamDefaultController(this)) throw defaultControllerBrandCheckException$1("desiredSize");
|
|
return ReadableStreamDefaultControllerGetDesiredSize(this);
|
|
}
|
|
/**
|
|
* Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from
|
|
* the stream, but once those are read, the stream will become closed.
|
|
*/ close() {
|
|
if (!IsReadableStreamDefaultController(this)) throw defaultControllerBrandCheckException$1("close");
|
|
if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) throw new TypeError("The stream is not in a state that permits close");
|
|
ReadableStreamDefaultControllerClose(this);
|
|
}
|
|
enqueue(chunk) {
|
|
if (!IsReadableStreamDefaultController(this)) throw defaultControllerBrandCheckException$1("enqueue");
|
|
if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) throw new TypeError("The stream is not in a state that permits enqueue");
|
|
return ReadableStreamDefaultControllerEnqueue(this, chunk);
|
|
}
|
|
/**
|
|
* Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
|
|
*/ error(e) {
|
|
if (!IsReadableStreamDefaultController(this)) throw defaultControllerBrandCheckException$1("error");
|
|
ReadableStreamDefaultControllerError(this, e);
|
|
}
|
|
/** @internal */ [CancelSteps](reason) {
|
|
ResetQueue(this);
|
|
const result = this._cancelAlgorithm(reason);
|
|
ReadableStreamDefaultControllerClearAlgorithms(this);
|
|
return result;
|
|
}
|
|
/** @internal */ [PullSteps](readRequest) {
|
|
const stream = this._controlledReadableStream;
|
|
if (this._queue.length > 0) {
|
|
const chunk = DequeueValue(this);
|
|
if (this._closeRequested && this._queue.length === 0) {
|
|
ReadableStreamDefaultControllerClearAlgorithms(this);
|
|
ReadableStreamClose(stream);
|
|
} else ReadableStreamDefaultControllerCallPullIfNeeded(this);
|
|
readRequest._chunkSteps(chunk);
|
|
} else {
|
|
ReadableStreamAddReadRequest(stream, readRequest);
|
|
ReadableStreamDefaultControllerCallPullIfNeeded(this);
|
|
}
|
|
}
|
|
}
|
|
Object.defineProperties(ReadableStreamDefaultController.prototype, {
|
|
close: {
|
|
enumerable: true
|
|
},
|
|
enqueue: {
|
|
enumerable: true
|
|
},
|
|
error: {
|
|
enumerable: true
|
|
},
|
|
desiredSize: {
|
|
enumerable: true
|
|
}
|
|
});
|
|
if (typeof SymbolPolyfill.toStringTag === "symbol") Object.defineProperty(ReadableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {
|
|
value: "ReadableStreamDefaultController",
|
|
configurable: true
|
|
});
|
|
// Abstract operations for the ReadableStreamDefaultController.
|
|
function IsReadableStreamDefaultController(x) {
|
|
if (!typeIsObject(x)) return false;
|
|
if (!Object.prototype.hasOwnProperty.call(x, "_controlledReadableStream")) return false;
|
|
return x instanceof ReadableStreamDefaultController;
|
|
}
|
|
function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
|
|
const shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
|
|
if (!shouldPull) return;
|
|
if (controller._pulling) {
|
|
controller._pullAgain = true;
|
|
return;
|
|
}
|
|
controller._pulling = true;
|
|
const pullPromise = controller._pullAlgorithm();
|
|
uponPromise(pullPromise, ()=>{
|
|
controller._pulling = false;
|
|
if (controller._pullAgain) {
|
|
controller._pullAgain = false;
|
|
ReadableStreamDefaultControllerCallPullIfNeeded(controller);
|
|
}
|
|
}, (e)=>{
|
|
ReadableStreamDefaultControllerError(controller, e);
|
|
});
|
|
}
|
|
function ReadableStreamDefaultControllerShouldCallPull(controller) {
|
|
const stream = controller._controlledReadableStream;
|
|
if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) return false;
|
|
if (!controller._started) return false;
|
|
if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) return true;
|
|
const desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
|
|
if (desiredSize > 0) return true;
|
|
return false;
|
|
}
|
|
function ReadableStreamDefaultControllerClearAlgorithms(controller) {
|
|
controller._pullAlgorithm = undefined;
|
|
controller._cancelAlgorithm = undefined;
|
|
controller._strategySizeAlgorithm = undefined;
|
|
}
|
|
// A client of ReadableStreamDefaultController may use these functions directly to bypass state check.
|
|
function ReadableStreamDefaultControllerClose(controller) {
|
|
if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) return;
|
|
const stream = controller._controlledReadableStream;
|
|
controller._closeRequested = true;
|
|
if (controller._queue.length === 0) {
|
|
ReadableStreamDefaultControllerClearAlgorithms(controller);
|
|
ReadableStreamClose(stream);
|
|
}
|
|
}
|
|
function ReadableStreamDefaultControllerEnqueue(controller, chunk) {
|
|
if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) return;
|
|
const stream = controller._controlledReadableStream;
|
|
if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) ReadableStreamFulfillReadRequest(stream, chunk, false);
|
|
else {
|
|
let chunkSize;
|
|
try {
|
|
chunkSize = controller._strategySizeAlgorithm(chunk);
|
|
} catch (chunkSizeE) {
|
|
ReadableStreamDefaultControllerError(controller, chunkSizeE);
|
|
throw chunkSizeE;
|
|
}
|
|
try {
|
|
EnqueueValueWithSize(controller, chunk, chunkSize);
|
|
} catch (enqueueE) {
|
|
ReadableStreamDefaultControllerError(controller, enqueueE);
|
|
throw enqueueE;
|
|
}
|
|
}
|
|
ReadableStreamDefaultControllerCallPullIfNeeded(controller);
|
|
}
|
|
function ReadableStreamDefaultControllerError(controller, e) {
|
|
const stream = controller._controlledReadableStream;
|
|
if (stream._state !== "readable") return;
|
|
ResetQueue(controller);
|
|
ReadableStreamDefaultControllerClearAlgorithms(controller);
|
|
ReadableStreamError(stream, e);
|
|
}
|
|
function ReadableStreamDefaultControllerGetDesiredSize(controller) {
|
|
const state = controller._controlledReadableStream._state;
|
|
if (state === "errored") return null;
|
|
if (state === "closed") return 0;
|
|
return controller._strategyHWM - controller._queueTotalSize;
|
|
}
|
|
// This is used in the implementation of TransformStream.
|
|
function ReadableStreamDefaultControllerHasBackpressure(controller) {
|
|
if (ReadableStreamDefaultControllerShouldCallPull(controller)) return false;
|
|
return true;
|
|
}
|
|
function ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) {
|
|
const state = controller._controlledReadableStream._state;
|
|
if (!controller._closeRequested && state === "readable") return true;
|
|
return false;
|
|
}
|
|
function SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) {
|
|
controller._controlledReadableStream = stream;
|
|
controller._queue = undefined;
|
|
controller._queueTotalSize = undefined;
|
|
ResetQueue(controller);
|
|
controller._started = false;
|
|
controller._closeRequested = false;
|
|
controller._pullAgain = false;
|
|
controller._pulling = false;
|
|
controller._strategySizeAlgorithm = sizeAlgorithm;
|
|
controller._strategyHWM = highWaterMark;
|
|
controller._pullAlgorithm = pullAlgorithm;
|
|
controller._cancelAlgorithm = cancelAlgorithm;
|
|
stream._readableStreamController = controller;
|
|
const startResult = startAlgorithm();
|
|
uponPromise(promiseResolvedWith(startResult), ()=>{
|
|
controller._started = true;
|
|
ReadableStreamDefaultControllerCallPullIfNeeded(controller);
|
|
}, (r)=>{
|
|
ReadableStreamDefaultControllerError(controller, r);
|
|
});
|
|
}
|
|
function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) {
|
|
const controller = Object.create(ReadableStreamDefaultController.prototype);
|
|
let startAlgorithm = ()=>undefined;
|
|
let pullAlgorithm = ()=>promiseResolvedWith(undefined);
|
|
let cancelAlgorithm = ()=>promiseResolvedWith(undefined);
|
|
if (underlyingSource.start !== undefined) startAlgorithm = ()=>underlyingSource.start(controller);
|
|
if (underlyingSource.pull !== undefined) pullAlgorithm = ()=>underlyingSource.pull(controller);
|
|
if (underlyingSource.cancel !== undefined) cancelAlgorithm = (reason)=>underlyingSource.cancel(reason);
|
|
SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
|
|
}
|
|
// Helper functions for the ReadableStreamDefaultController.
|
|
function defaultControllerBrandCheckException$1(name) {
|
|
return new TypeError(`ReadableStreamDefaultController.prototype.${name} can only be used on a ReadableStreamDefaultController`);
|
|
}
|
|
function ReadableStreamTee(stream, cloneForBranch2) {
|
|
if (IsReadableByteStreamController(stream._readableStreamController)) return ReadableByteStreamTee(stream);
|
|
return ReadableStreamDefaultTee(stream);
|
|
}
|
|
function ReadableStreamDefaultTee(stream, cloneForBranch2) {
|
|
const reader = AcquireReadableStreamDefaultReader(stream);
|
|
let reading = false;
|
|
let readAgain = false;
|
|
let canceled1 = false;
|
|
let canceled2 = false;
|
|
let reason1;
|
|
let reason2;
|
|
let branch1;
|
|
let branch2;
|
|
let resolveCancelPromise;
|
|
const cancelPromise = newPromise((resolve)=>{
|
|
resolveCancelPromise = resolve;
|
|
});
|
|
function pullAlgorithm() {
|
|
if (reading) {
|
|
readAgain = true;
|
|
return promiseResolvedWith(undefined);
|
|
}
|
|
reading = true;
|
|
const readRequest = {
|
|
_chunkSteps: (chunk)=>{
|
|
// This needs to be delayed a microtask because it takes at least a microtask to detect errors (using
|
|
// reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let
|
|
// successful synchronously-available reads get ahead of asynchronously-available errors.
|
|
queueMicrotask(()=>{
|
|
readAgain = false;
|
|
const chunk1 = chunk;
|
|
const chunk2 = chunk;
|
|
// There is no way to access the cloning code right now in the reference implementation.
|
|
// If we add one then we'll need an implementation for serializable objects.
|
|
// if (!canceled2 && cloneForBranch2) {
|
|
// chunk2 = StructuredDeserialize(StructuredSerialize(chunk2));
|
|
// }
|
|
if (!canceled1) ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, chunk1);
|
|
if (!canceled2) ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, chunk2);
|
|
reading = false;
|
|
if (readAgain) pullAlgorithm();
|
|
});
|
|
},
|
|
_closeSteps: ()=>{
|
|
reading = false;
|
|
if (!canceled1) ReadableStreamDefaultControllerClose(branch1._readableStreamController);
|
|
if (!canceled2) ReadableStreamDefaultControllerClose(branch2._readableStreamController);
|
|
if (!canceled1 || !canceled2) resolveCancelPromise(undefined);
|
|
},
|
|
_errorSteps: ()=>{
|
|
reading = false;
|
|
}
|
|
};
|
|
ReadableStreamDefaultReaderRead(reader, readRequest);
|
|
return promiseResolvedWith(undefined);
|
|
}
|
|
function cancel1Algorithm(reason) {
|
|
canceled1 = true;
|
|
reason1 = reason;
|
|
if (canceled2) {
|
|
const compositeReason = CreateArrayFromList([
|
|
reason1,
|
|
reason2
|
|
]);
|
|
const cancelResult = ReadableStreamCancel(stream, compositeReason);
|
|
resolveCancelPromise(cancelResult);
|
|
}
|
|
return cancelPromise;
|
|
}
|
|
function cancel2Algorithm(reason) {
|
|
canceled2 = true;
|
|
reason2 = reason;
|
|
if (canceled1) {
|
|
const compositeReason = CreateArrayFromList([
|
|
reason1,
|
|
reason2
|
|
]);
|
|
const cancelResult = ReadableStreamCancel(stream, compositeReason);
|
|
resolveCancelPromise(cancelResult);
|
|
}
|
|
return cancelPromise;
|
|
}
|
|
function startAlgorithm() {
|
|
// do nothing
|
|
}
|
|
branch1 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm);
|
|
branch2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm);
|
|
uponRejection(reader._closedPromise, (r)=>{
|
|
ReadableStreamDefaultControllerError(branch1._readableStreamController, r);
|
|
ReadableStreamDefaultControllerError(branch2._readableStreamController, r);
|
|
if (!canceled1 || !canceled2) resolveCancelPromise(undefined);
|
|
});
|
|
return [
|
|
branch1,
|
|
branch2
|
|
];
|
|
}
|
|
function ReadableByteStreamTee(stream) {
|
|
let reader = AcquireReadableStreamDefaultReader(stream);
|
|
let reading = false;
|
|
let readAgainForBranch1 = false;
|
|
let readAgainForBranch2 = false;
|
|
let canceled1 = false;
|
|
let canceled2 = false;
|
|
let reason1;
|
|
let reason2;
|
|
let branch1;
|
|
let branch2;
|
|
let resolveCancelPromise;
|
|
const cancelPromise = newPromise((resolve)=>{
|
|
resolveCancelPromise = resolve;
|
|
});
|
|
function forwardReaderError(thisReader) {
|
|
uponRejection(thisReader._closedPromise, (r)=>{
|
|
if (thisReader !== reader) return;
|
|
ReadableByteStreamControllerError(branch1._readableStreamController, r);
|
|
ReadableByteStreamControllerError(branch2._readableStreamController, r);
|
|
if (!canceled1 || !canceled2) resolveCancelPromise(undefined);
|
|
});
|
|
}
|
|
function pullWithDefaultReader() {
|
|
if (IsReadableStreamBYOBReader(reader)) {
|
|
ReadableStreamReaderGenericRelease(reader);
|
|
reader = AcquireReadableStreamDefaultReader(stream);
|
|
forwardReaderError(reader);
|
|
}
|
|
const readRequest = {
|
|
_chunkSteps: (chunk)=>{
|
|
// This needs to be delayed a microtask because it takes at least a microtask to detect errors (using
|
|
// reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let
|
|
// successful synchronously-available reads get ahead of asynchronously-available errors.
|
|
queueMicrotask(()=>{
|
|
readAgainForBranch1 = false;
|
|
readAgainForBranch2 = false;
|
|
const chunk1 = chunk;
|
|
let chunk2 = chunk;
|
|
if (!canceled1 && !canceled2) try {
|
|
chunk2 = CloneAsUint8Array(chunk);
|
|
} catch (cloneE) {
|
|
ReadableByteStreamControllerError(branch1._readableStreamController, cloneE);
|
|
ReadableByteStreamControllerError(branch2._readableStreamController, cloneE);
|
|
resolveCancelPromise(ReadableStreamCancel(stream, cloneE));
|
|
return;
|
|
}
|
|
if (!canceled1) ReadableByteStreamControllerEnqueue(branch1._readableStreamController, chunk1);
|
|
if (!canceled2) ReadableByteStreamControllerEnqueue(branch2._readableStreamController, chunk2);
|
|
reading = false;
|
|
if (readAgainForBranch1) pull1Algorithm();
|
|
else if (readAgainForBranch2) pull2Algorithm();
|
|
});
|
|
},
|
|
_closeSteps: ()=>{
|
|
reading = false;
|
|
if (!canceled1) ReadableByteStreamControllerClose(branch1._readableStreamController);
|
|
if (!canceled2) ReadableByteStreamControllerClose(branch2._readableStreamController);
|
|
if (branch1._readableStreamController._pendingPullIntos.length > 0) ReadableByteStreamControllerRespond(branch1._readableStreamController, 0);
|
|
if (branch2._readableStreamController._pendingPullIntos.length > 0) ReadableByteStreamControllerRespond(branch2._readableStreamController, 0);
|
|
if (!canceled1 || !canceled2) resolveCancelPromise(undefined);
|
|
},
|
|
_errorSteps: ()=>{
|
|
reading = false;
|
|
}
|
|
};
|
|
ReadableStreamDefaultReaderRead(reader, readRequest);
|
|
}
|
|
function pullWithBYOBReader(view, forBranch2) {
|
|
if (IsReadableStreamDefaultReader(reader)) {
|
|
ReadableStreamReaderGenericRelease(reader);
|
|
reader = AcquireReadableStreamBYOBReader(stream);
|
|
forwardReaderError(reader);
|
|
}
|
|
const byobBranch = forBranch2 ? branch2 : branch1;
|
|
const otherBranch = forBranch2 ? branch1 : branch2;
|
|
const readIntoRequest = {
|
|
_chunkSteps: (chunk)=>{
|
|
// This needs to be delayed a microtask because it takes at least a microtask to detect errors (using
|
|
// reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let
|
|
// successful synchronously-available reads get ahead of asynchronously-available errors.
|
|
queueMicrotask(()=>{
|
|
readAgainForBranch1 = false;
|
|
readAgainForBranch2 = false;
|
|
const byobCanceled = forBranch2 ? canceled2 : canceled1;
|
|
const otherCanceled = forBranch2 ? canceled1 : canceled2;
|
|
if (!otherCanceled) {
|
|
let clonedChunk;
|
|
try {
|
|
clonedChunk = CloneAsUint8Array(chunk);
|
|
} catch (cloneE) {
|
|
ReadableByteStreamControllerError(byobBranch._readableStreamController, cloneE);
|
|
ReadableByteStreamControllerError(otherBranch._readableStreamController, cloneE);
|
|
resolveCancelPromise(ReadableStreamCancel(stream, cloneE));
|
|
return;
|
|
}
|
|
if (!byobCanceled) ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
|
|
ReadableByteStreamControllerEnqueue(otherBranch._readableStreamController, clonedChunk);
|
|
} else if (!byobCanceled) ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
|
|
reading = false;
|
|
if (readAgainForBranch1) pull1Algorithm();
|
|
else if (readAgainForBranch2) pull2Algorithm();
|
|
});
|
|
},
|
|
_closeSteps: (chunk)=>{
|
|
reading = false;
|
|
const byobCanceled = forBranch2 ? canceled2 : canceled1;
|
|
const otherCanceled = forBranch2 ? canceled1 : canceled2;
|
|
if (!byobCanceled) ReadableByteStreamControllerClose(byobBranch._readableStreamController);
|
|
if (!otherCanceled) ReadableByteStreamControllerClose(otherBranch._readableStreamController);
|
|
if (chunk !== undefined) {
|
|
if (!byobCanceled) ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
|
|
if (!otherCanceled && otherBranch._readableStreamController._pendingPullIntos.length > 0) ReadableByteStreamControllerRespond(otherBranch._readableStreamController, 0);
|
|
}
|
|
if (!byobCanceled || !otherCanceled) resolveCancelPromise(undefined);
|
|
},
|
|
_errorSteps: ()=>{
|
|
reading = false;
|
|
}
|
|
};
|
|
ReadableStreamBYOBReaderRead(reader, view, readIntoRequest);
|
|
}
|
|
function pull1Algorithm() {
|
|
if (reading) {
|
|
readAgainForBranch1 = true;
|
|
return promiseResolvedWith(undefined);
|
|
}
|
|
reading = true;
|
|
const byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch1._readableStreamController);
|
|
if (byobRequest === null) pullWithDefaultReader();
|
|
else pullWithBYOBReader(byobRequest._view, false);
|
|
return promiseResolvedWith(undefined);
|
|
}
|
|
function pull2Algorithm() {
|
|
if (reading) {
|
|
readAgainForBranch2 = true;
|
|
return promiseResolvedWith(undefined);
|
|
}
|
|
reading = true;
|
|
const byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch2._readableStreamController);
|
|
if (byobRequest === null) pullWithDefaultReader();
|
|
else pullWithBYOBReader(byobRequest._view, true);
|
|
return promiseResolvedWith(undefined);
|
|
}
|
|
function cancel1Algorithm(reason) {
|
|
canceled1 = true;
|
|
reason1 = reason;
|
|
if (canceled2) {
|
|
const compositeReason = CreateArrayFromList([
|
|
reason1,
|
|
reason2
|
|
]);
|
|
const cancelResult = ReadableStreamCancel(stream, compositeReason);
|
|
resolveCancelPromise(cancelResult);
|
|
}
|
|
return cancelPromise;
|
|
}
|
|
function cancel2Algorithm(reason) {
|
|
canceled2 = true;
|
|
reason2 = reason;
|
|
if (canceled1) {
|
|
const compositeReason = CreateArrayFromList([
|
|
reason1,
|
|
reason2
|
|
]);
|
|
const cancelResult = ReadableStreamCancel(stream, compositeReason);
|
|
resolveCancelPromise(cancelResult);
|
|
}
|
|
return cancelPromise;
|
|
}
|
|
function startAlgorithm() {
|
|
return;
|
|
}
|
|
branch1 = CreateReadableByteStream(startAlgorithm, pull1Algorithm, cancel1Algorithm);
|
|
branch2 = CreateReadableByteStream(startAlgorithm, pull2Algorithm, cancel2Algorithm);
|
|
forwardReaderError(reader);
|
|
return [
|
|
branch1,
|
|
branch2
|
|
];
|
|
}
|
|
function convertUnderlyingDefaultOrByteSource(source, context) {
|
|
assertDictionary(source, context);
|
|
const original = source;
|
|
const autoAllocateChunkSize = original === null || original === void 0 ? void 0 : original.autoAllocateChunkSize;
|
|
const cancel = original === null || original === void 0 ? void 0 : original.cancel;
|
|
const pull = original === null || original === void 0 ? void 0 : original.pull;
|
|
const start = original === null || original === void 0 ? void 0 : original.start;
|
|
const type = original === null || original === void 0 ? void 0 : original.type;
|
|
return {
|
|
autoAllocateChunkSize: autoAllocateChunkSize === undefined ? undefined : convertUnsignedLongLongWithEnforceRange(autoAllocateChunkSize, `${context} has member 'autoAllocateChunkSize' that`),
|
|
cancel: cancel === undefined ? undefined : convertUnderlyingSourceCancelCallback(cancel, original, `${context} has member 'cancel' that`),
|
|
pull: pull === undefined ? undefined : convertUnderlyingSourcePullCallback(pull, original, `${context} has member 'pull' that`),
|
|
start: start === undefined ? undefined : convertUnderlyingSourceStartCallback(start, original, `${context} has member 'start' that`),
|
|
type: type === undefined ? undefined : convertReadableStreamType(type, `${context} has member 'type' that`)
|
|
};
|
|
}
|
|
function convertUnderlyingSourceCancelCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (reason)=>promiseCall(fn, original, [
|
|
reason
|
|
]);
|
|
}
|
|
function convertUnderlyingSourcePullCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (controller)=>promiseCall(fn, original, [
|
|
controller
|
|
]);
|
|
}
|
|
function convertUnderlyingSourceStartCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (controller)=>reflectCall(fn, original, [
|
|
controller
|
|
]);
|
|
}
|
|
function convertReadableStreamType(type, context) {
|
|
type = `${type}`;
|
|
if (type !== "bytes") throw new TypeError(`${context} '${type}' is not a valid enumeration value for ReadableStreamType`);
|
|
return type;
|
|
}
|
|
function convertReaderOptions(options, context) {
|
|
assertDictionary(options, context);
|
|
const mode = options === null || options === void 0 ? void 0 : options.mode;
|
|
return {
|
|
mode: mode === undefined ? undefined : convertReadableStreamReaderMode(mode, `${context} has member 'mode' that`)
|
|
};
|
|
}
|
|
function convertReadableStreamReaderMode(mode, context) {
|
|
mode = `${mode}`;
|
|
if (mode !== "byob") throw new TypeError(`${context} '${mode}' is not a valid enumeration value for ReadableStreamReaderMode`);
|
|
return mode;
|
|
}
|
|
function convertIteratorOptions(options, context) {
|
|
assertDictionary(options, context);
|
|
const preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;
|
|
return {
|
|
preventCancel: Boolean(preventCancel)
|
|
};
|
|
}
|
|
function convertPipeOptions(options, context) {
|
|
assertDictionary(options, context);
|
|
const preventAbort = options === null || options === void 0 ? void 0 : options.preventAbort;
|
|
const preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;
|
|
const preventClose = options === null || options === void 0 ? void 0 : options.preventClose;
|
|
const signal = options === null || options === void 0 ? void 0 : options.signal;
|
|
if (signal !== undefined) assertAbortSignal(signal, `${context} has member 'signal' that`);
|
|
return {
|
|
preventAbort: Boolean(preventAbort),
|
|
preventCancel: Boolean(preventCancel),
|
|
preventClose: Boolean(preventClose),
|
|
signal
|
|
};
|
|
}
|
|
function assertAbortSignal(signal, context) {
|
|
if (!isAbortSignal(signal)) throw new TypeError(`${context} is not an AbortSignal.`);
|
|
}
|
|
function convertReadableWritablePair(pair, context) {
|
|
assertDictionary(pair, context);
|
|
const readable = pair === null || pair === void 0 ? void 0 : pair.readable;
|
|
assertRequiredField(readable, "readable", "ReadableWritablePair");
|
|
assertReadableStream(readable, `${context} has member 'readable' that`);
|
|
const writable = pair === null || pair === void 0 ? void 0 : pair.writable;
|
|
assertRequiredField(writable, "writable", "ReadableWritablePair");
|
|
assertWritableStream(writable, `${context} has member 'writable' that`);
|
|
return {
|
|
readable,
|
|
writable
|
|
};
|
|
}
|
|
/**
|
|
* A readable stream represents a source of data, from which you can read.
|
|
*
|
|
* @public
|
|
*/ class ReadableStream {
|
|
constructor(rawUnderlyingSource = {}, rawStrategy = {}){
|
|
if (rawUnderlyingSource === undefined) rawUnderlyingSource = null;
|
|
else assertObject(rawUnderlyingSource, "First parameter");
|
|
const strategy = convertQueuingStrategy(rawStrategy, "Second parameter");
|
|
const underlyingSource = convertUnderlyingDefaultOrByteSource(rawUnderlyingSource, "First parameter");
|
|
InitializeReadableStream(this);
|
|
if (underlyingSource.type === "bytes") {
|
|
if (strategy.size !== undefined) throw new RangeError("The strategy for a byte stream cannot have a size function");
|
|
const highWaterMark = ExtractHighWaterMark(strategy, 0);
|
|
SetUpReadableByteStreamControllerFromUnderlyingSource(this, underlyingSource, highWaterMark);
|
|
} else {
|
|
const sizeAlgorithm = ExtractSizeAlgorithm(strategy);
|
|
const highWaterMark = ExtractHighWaterMark(strategy, 1);
|
|
SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, highWaterMark, sizeAlgorithm);
|
|
}
|
|
}
|
|
/**
|
|
* Whether or not the readable stream is locked to a {@link ReadableStreamDefaultReader | reader}.
|
|
*/ get locked() {
|
|
if (!IsReadableStream(this)) throw streamBrandCheckException$1("locked");
|
|
return IsReadableStreamLocked(this);
|
|
}
|
|
/**
|
|
* Cancels the stream, signaling a loss of interest in the stream by a consumer.
|
|
*
|
|
* The supplied `reason` argument will be given to the underlying source's {@link UnderlyingSource.cancel | cancel()}
|
|
* method, which might or might not use it.
|
|
*/ cancel(reason) {
|
|
if (!IsReadableStream(this)) return promiseRejectedWith(streamBrandCheckException$1("cancel"));
|
|
if (IsReadableStreamLocked(this)) return promiseRejectedWith(new TypeError("Cannot cancel a stream that already has a reader"));
|
|
return ReadableStreamCancel(this, reason);
|
|
}
|
|
getReader(rawOptions) {
|
|
if (!IsReadableStream(this)) throw streamBrandCheckException$1("getReader");
|
|
const options = convertReaderOptions(rawOptions, "First parameter");
|
|
if (options.mode === undefined) return AcquireReadableStreamDefaultReader(this);
|
|
return AcquireReadableStreamBYOBReader(this);
|
|
}
|
|
pipeThrough(rawTransform, rawOptions = {}) {
|
|
if (!IsReadableStream(this)) throw streamBrandCheckException$1("pipeThrough");
|
|
assertRequiredArgument(rawTransform, 1, "pipeThrough");
|
|
const transform = convertReadableWritablePair(rawTransform, "First parameter");
|
|
const options = convertPipeOptions(rawOptions, "Second parameter");
|
|
if (IsReadableStreamLocked(this)) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");
|
|
if (IsWritableStreamLocked(transform.writable)) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");
|
|
const promise = ReadableStreamPipeTo(this, transform.writable, options.preventClose, options.preventAbort, options.preventCancel, options.signal);
|
|
setPromiseIsHandledToTrue(promise);
|
|
return transform.readable;
|
|
}
|
|
pipeTo(destination, rawOptions = {}) {
|
|
if (!IsReadableStream(this)) return promiseRejectedWith(streamBrandCheckException$1("pipeTo"));
|
|
if (destination === undefined) return promiseRejectedWith(`Parameter 1 is required in 'pipeTo'.`);
|
|
if (!IsWritableStream(destination)) return promiseRejectedWith(new TypeError(`ReadableStream.prototype.pipeTo's first argument must be a WritableStream`));
|
|
let options;
|
|
try {
|
|
options = convertPipeOptions(rawOptions, "Second parameter");
|
|
} catch (e) {
|
|
return promiseRejectedWith(e);
|
|
}
|
|
if (IsReadableStreamLocked(this)) return promiseRejectedWith(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream"));
|
|
if (IsWritableStreamLocked(destination)) return promiseRejectedWith(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream"));
|
|
return ReadableStreamPipeTo(this, destination, options.preventClose, options.preventAbort, options.preventCancel, options.signal);
|
|
}
|
|
/**
|
|
* Tees this readable stream, returning a two-element array containing the two resulting branches as
|
|
* new {@link ReadableStream} instances.
|
|
*
|
|
* Teeing a stream will lock it, preventing any other consumer from acquiring a reader.
|
|
* To cancel the stream, cancel both of the resulting branches; a composite cancellation reason will then be
|
|
* propagated to the stream's underlying source.
|
|
*
|
|
* Note that the chunks seen in each branch will be the same object. If the chunks are not immutable,
|
|
* this could allow interference between the two branches.
|
|
*/ tee() {
|
|
if (!IsReadableStream(this)) throw streamBrandCheckException$1("tee");
|
|
const branches = ReadableStreamTee(this);
|
|
return CreateArrayFromList(branches);
|
|
}
|
|
values(rawOptions) {
|
|
if (!IsReadableStream(this)) throw streamBrandCheckException$1("values");
|
|
const options = convertIteratorOptions(rawOptions, "First parameter");
|
|
return AcquireReadableStreamAsyncIterator(this, options.preventCancel);
|
|
}
|
|
}
|
|
Object.defineProperties(ReadableStream.prototype, {
|
|
cancel: {
|
|
enumerable: true
|
|
},
|
|
getReader: {
|
|
enumerable: true
|
|
},
|
|
pipeThrough: {
|
|
enumerable: true
|
|
},
|
|
pipeTo: {
|
|
enumerable: true
|
|
},
|
|
tee: {
|
|
enumerable: true
|
|
},
|
|
values: {
|
|
enumerable: true
|
|
},
|
|
locked: {
|
|
enumerable: true
|
|
}
|
|
});
|
|
if (typeof SymbolPolyfill.toStringTag === "symbol") Object.defineProperty(ReadableStream.prototype, SymbolPolyfill.toStringTag, {
|
|
value: "ReadableStream",
|
|
configurable: true
|
|
});
|
|
if (typeof SymbolPolyfill.asyncIterator === "symbol") Object.defineProperty(ReadableStream.prototype, SymbolPolyfill.asyncIterator, {
|
|
value: ReadableStream.prototype.values,
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
// Abstract operations for the ReadableStream.
|
|
// Throws if and only if startAlgorithm throws.
|
|
function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark = 1, sizeAlgorithm = ()=>1) {
|
|
const stream = Object.create(ReadableStream.prototype);
|
|
InitializeReadableStream(stream);
|
|
const controller = Object.create(ReadableStreamDefaultController.prototype);
|
|
SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
|
|
return stream;
|
|
}
|
|
// Throws if and only if startAlgorithm throws.
|
|
function CreateReadableByteStream(startAlgorithm, pullAlgorithm, cancelAlgorithm) {
|
|
const stream = Object.create(ReadableStream.prototype);
|
|
InitializeReadableStream(stream);
|
|
const controller = Object.create(ReadableByteStreamController.prototype);
|
|
SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, 0, undefined);
|
|
return stream;
|
|
}
|
|
function InitializeReadableStream(stream) {
|
|
stream._state = "readable";
|
|
stream._reader = undefined;
|
|
stream._storedError = undefined;
|
|
stream._disturbed = false;
|
|
}
|
|
function IsReadableStream(x) {
|
|
if (!typeIsObject(x)) return false;
|
|
if (!Object.prototype.hasOwnProperty.call(x, "_readableStreamController")) return false;
|
|
return x instanceof ReadableStream;
|
|
}
|
|
function IsReadableStreamLocked(stream) {
|
|
if (stream._reader === undefined) return false;
|
|
return true;
|
|
}
|
|
// ReadableStream API exposed for controllers.
|
|
function ReadableStreamCancel(stream, reason) {
|
|
stream._disturbed = true;
|
|
if (stream._state === "closed") return promiseResolvedWith(undefined);
|
|
if (stream._state === "errored") return promiseRejectedWith(stream._storedError);
|
|
ReadableStreamClose(stream);
|
|
const reader = stream._reader;
|
|
if (reader !== undefined && IsReadableStreamBYOBReader(reader)) {
|
|
reader._readIntoRequests.forEach((readIntoRequest)=>{
|
|
readIntoRequest._closeSteps(undefined);
|
|
});
|
|
reader._readIntoRequests = new SimpleQueue();
|
|
}
|
|
const sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
|
|
return transformPromiseWith(sourceCancelPromise, noop);
|
|
}
|
|
function ReadableStreamClose(stream) {
|
|
stream._state = "closed";
|
|
const reader = stream._reader;
|
|
if (reader === undefined) return;
|
|
defaultReaderClosedPromiseResolve(reader);
|
|
if (IsReadableStreamDefaultReader(reader)) {
|
|
reader._readRequests.forEach((readRequest)=>{
|
|
readRequest._closeSteps();
|
|
});
|
|
reader._readRequests = new SimpleQueue();
|
|
}
|
|
}
|
|
function ReadableStreamError(stream, e) {
|
|
stream._state = "errored";
|
|
stream._storedError = e;
|
|
const reader = stream._reader;
|
|
if (reader === undefined) return;
|
|
defaultReaderClosedPromiseReject(reader, e);
|
|
if (IsReadableStreamDefaultReader(reader)) {
|
|
reader._readRequests.forEach((readRequest)=>{
|
|
readRequest._errorSteps(e);
|
|
});
|
|
reader._readRequests = new SimpleQueue();
|
|
} else {
|
|
reader._readIntoRequests.forEach((readIntoRequest)=>{
|
|
readIntoRequest._errorSteps(e);
|
|
});
|
|
reader._readIntoRequests = new SimpleQueue();
|
|
}
|
|
}
|
|
// Helper functions for the ReadableStream.
|
|
function streamBrandCheckException$1(name) {
|
|
return new TypeError(`ReadableStream.prototype.${name} can only be used on a ReadableStream`);
|
|
}
|
|
function convertQueuingStrategyInit(init, context) {
|
|
assertDictionary(init, context);
|
|
const highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;
|
|
assertRequiredField(highWaterMark, "highWaterMark", "QueuingStrategyInit");
|
|
return {
|
|
highWaterMark: convertUnrestrictedDouble(highWaterMark)
|
|
};
|
|
}
|
|
// The size function must not have a prototype property nor be a constructor
|
|
const byteLengthSizeFunction = (chunk)=>{
|
|
return chunk.byteLength;
|
|
};
|
|
try {
|
|
Object.defineProperty(byteLengthSizeFunction, "name", {
|
|
value: "size",
|
|
configurable: true
|
|
});
|
|
} catch (_a) {
|
|
// This property is non-configurable in older browsers, so ignore if this throws.
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#browser_compatibility
|
|
}
|
|
/**
|
|
* A queuing strategy that counts the number of bytes in each chunk.
|
|
*
|
|
* @public
|
|
*/ class ByteLengthQueuingStrategy {
|
|
constructor(options){
|
|
assertRequiredArgument(options, 1, "ByteLengthQueuingStrategy");
|
|
options = convertQueuingStrategyInit(options, "First parameter");
|
|
this._byteLengthQueuingStrategyHighWaterMark = options.highWaterMark;
|
|
}
|
|
/**
|
|
* Returns the high water mark provided to the constructor.
|
|
*/ get highWaterMark() {
|
|
if (!IsByteLengthQueuingStrategy(this)) throw byteLengthBrandCheckException("highWaterMark");
|
|
return this._byteLengthQueuingStrategyHighWaterMark;
|
|
}
|
|
/**
|
|
* Measures the size of `chunk` by returning the value of its `byteLength` property.
|
|
*/ get size() {
|
|
if (!IsByteLengthQueuingStrategy(this)) throw byteLengthBrandCheckException("size");
|
|
return byteLengthSizeFunction;
|
|
}
|
|
}
|
|
Object.defineProperties(ByteLengthQueuingStrategy.prototype, {
|
|
highWaterMark: {
|
|
enumerable: true
|
|
},
|
|
size: {
|
|
enumerable: true
|
|
}
|
|
});
|
|
if (typeof SymbolPolyfill.toStringTag === "symbol") Object.defineProperty(ByteLengthQueuingStrategy.prototype, SymbolPolyfill.toStringTag, {
|
|
value: "ByteLengthQueuingStrategy",
|
|
configurable: true
|
|
});
|
|
// Helper functions for the ByteLengthQueuingStrategy.
|
|
function byteLengthBrandCheckException(name) {
|
|
return new TypeError(`ByteLengthQueuingStrategy.prototype.${name} can only be used on a ByteLengthQueuingStrategy`);
|
|
}
|
|
function IsByteLengthQueuingStrategy(x) {
|
|
if (!typeIsObject(x)) return false;
|
|
if (!Object.prototype.hasOwnProperty.call(x, "_byteLengthQueuingStrategyHighWaterMark")) return false;
|
|
return x instanceof ByteLengthQueuingStrategy;
|
|
}
|
|
// The size function must not have a prototype property nor be a constructor
|
|
const countSizeFunction = ()=>{
|
|
return 1;
|
|
};
|
|
try {
|
|
Object.defineProperty(countSizeFunction, "name", {
|
|
value: "size",
|
|
configurable: true
|
|
});
|
|
} catch (_a) {
|
|
// This property is non-configurable in older browsers, so ignore if this throws.
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#browser_compatibility
|
|
}
|
|
/**
|
|
* A queuing strategy that counts the number of chunks.
|
|
*
|
|
* @public
|
|
*/ class CountQueuingStrategy {
|
|
constructor(options){
|
|
assertRequiredArgument(options, 1, "CountQueuingStrategy");
|
|
options = convertQueuingStrategyInit(options, "First parameter");
|
|
this._countQueuingStrategyHighWaterMark = options.highWaterMark;
|
|
}
|
|
/**
|
|
* Returns the high water mark provided to the constructor.
|
|
*/ get highWaterMark() {
|
|
if (!IsCountQueuingStrategy(this)) throw countBrandCheckException("highWaterMark");
|
|
return this._countQueuingStrategyHighWaterMark;
|
|
}
|
|
/**
|
|
* Measures the size of `chunk` by always returning 1.
|
|
* This ensures that the total queue size is a count of the number of chunks in the queue.
|
|
*/ get size() {
|
|
if (!IsCountQueuingStrategy(this)) throw countBrandCheckException("size");
|
|
return countSizeFunction;
|
|
}
|
|
}
|
|
Object.defineProperties(CountQueuingStrategy.prototype, {
|
|
highWaterMark: {
|
|
enumerable: true
|
|
},
|
|
size: {
|
|
enumerable: true
|
|
}
|
|
});
|
|
if (typeof SymbolPolyfill.toStringTag === "symbol") Object.defineProperty(CountQueuingStrategy.prototype, SymbolPolyfill.toStringTag, {
|
|
value: "CountQueuingStrategy",
|
|
configurable: true
|
|
});
|
|
// Helper functions for the CountQueuingStrategy.
|
|
function countBrandCheckException(name) {
|
|
return new TypeError(`CountQueuingStrategy.prototype.${name} can only be used on a CountQueuingStrategy`);
|
|
}
|
|
function IsCountQueuingStrategy(x) {
|
|
if (!typeIsObject(x)) return false;
|
|
if (!Object.prototype.hasOwnProperty.call(x, "_countQueuingStrategyHighWaterMark")) return false;
|
|
return x instanceof CountQueuingStrategy;
|
|
}
|
|
function convertTransformer(original, context) {
|
|
assertDictionary(original, context);
|
|
const flush = original === null || original === void 0 ? void 0 : original.flush;
|
|
const readableType = original === null || original === void 0 ? void 0 : original.readableType;
|
|
const start = original === null || original === void 0 ? void 0 : original.start;
|
|
const transform = original === null || original === void 0 ? void 0 : original.transform;
|
|
const writableType = original === null || original === void 0 ? void 0 : original.writableType;
|
|
return {
|
|
flush: flush === undefined ? undefined : convertTransformerFlushCallback(flush, original, `${context} has member 'flush' that`),
|
|
readableType,
|
|
start: start === undefined ? undefined : convertTransformerStartCallback(start, original, `${context} has member 'start' that`),
|
|
transform: transform === undefined ? undefined : convertTransformerTransformCallback(transform, original, `${context} has member 'transform' that`),
|
|
writableType
|
|
};
|
|
}
|
|
function convertTransformerFlushCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (controller)=>promiseCall(fn, original, [
|
|
controller
|
|
]);
|
|
}
|
|
function convertTransformerStartCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (controller)=>reflectCall(fn, original, [
|
|
controller
|
|
]);
|
|
}
|
|
function convertTransformerTransformCallback(fn, original, context) {
|
|
assertFunction(fn, context);
|
|
return (chunk, controller)=>promiseCall(fn, original, [
|
|
chunk,
|
|
controller
|
|
]);
|
|
}
|
|
// Class TransformStream
|
|
/**
|
|
* A transform stream consists of a pair of streams: a {@link WritableStream | writable stream},
|
|
* known as its writable side, and a {@link ReadableStream | readable stream}, known as its readable side.
|
|
* In a manner specific to the transform stream in question, writes to the writable side result in new data being
|
|
* made available for reading from the readable side.
|
|
*
|
|
* @public
|
|
*/ class TransformStream {
|
|
constructor(rawTransformer = {}, rawWritableStrategy = {}, rawReadableStrategy = {}){
|
|
if (rawTransformer === undefined) rawTransformer = null;
|
|
const writableStrategy = convertQueuingStrategy(rawWritableStrategy, "Second parameter");
|
|
const readableStrategy = convertQueuingStrategy(rawReadableStrategy, "Third parameter");
|
|
const transformer = convertTransformer(rawTransformer, "First parameter");
|
|
if (transformer.readableType !== undefined) throw new RangeError("Invalid readableType specified");
|
|
if (transformer.writableType !== undefined) throw new RangeError("Invalid writableType specified");
|
|
const readableHighWaterMark = ExtractHighWaterMark(readableStrategy, 0);
|
|
const readableSizeAlgorithm = ExtractSizeAlgorithm(readableStrategy);
|
|
const writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1);
|
|
const writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy);
|
|
let startPromise_resolve;
|
|
const startPromise = newPromise((resolve)=>{
|
|
startPromise_resolve = resolve;
|
|
});
|
|
InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
|
|
SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);
|
|
if (transformer.start !== undefined) startPromise_resolve(transformer.start(this._transformStreamController));
|
|
else startPromise_resolve(undefined);
|
|
}
|
|
/**
|
|
* The readable side of the transform stream.
|
|
*/ get readable() {
|
|
if (!IsTransformStream(this)) throw streamBrandCheckException("readable");
|
|
return this._readable;
|
|
}
|
|
/**
|
|
* The writable side of the transform stream.
|
|
*/ get writable() {
|
|
if (!IsTransformStream(this)) throw streamBrandCheckException("writable");
|
|
return this._writable;
|
|
}
|
|
}
|
|
Object.defineProperties(TransformStream.prototype, {
|
|
readable: {
|
|
enumerable: true
|
|
},
|
|
writable: {
|
|
enumerable: true
|
|
}
|
|
});
|
|
if (typeof SymbolPolyfill.toStringTag === "symbol") Object.defineProperty(TransformStream.prototype, SymbolPolyfill.toStringTag, {
|
|
value: "TransformStream",
|
|
configurable: true
|
|
});
|
|
function InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) {
|
|
function startAlgorithm() {
|
|
return startPromise;
|
|
}
|
|
function writeAlgorithm(chunk) {
|
|
return TransformStreamDefaultSinkWriteAlgorithm(stream, chunk);
|
|
}
|
|
function abortAlgorithm(reason) {
|
|
return TransformStreamDefaultSinkAbortAlgorithm(stream, reason);
|
|
}
|
|
function closeAlgorithm() {
|
|
return TransformStreamDefaultSinkCloseAlgorithm(stream);
|
|
}
|
|
stream._writable = CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, writableHighWaterMark, writableSizeAlgorithm);
|
|
function pullAlgorithm() {
|
|
return TransformStreamDefaultSourcePullAlgorithm(stream);
|
|
}
|
|
function cancelAlgorithm(reason) {
|
|
TransformStreamErrorWritableAndUnblockWrite(stream, reason);
|
|
return promiseResolvedWith(undefined);
|
|
}
|
|
stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
|
|
// The [[backpressure]] slot is set to undefined so that it can be initialised by TransformStreamSetBackpressure.
|
|
stream._backpressure = undefined;
|
|
stream._backpressureChangePromise = undefined;
|
|
stream._backpressureChangePromise_resolve = undefined;
|
|
TransformStreamSetBackpressure(stream, true);
|
|
stream._transformStreamController = undefined;
|
|
}
|
|
function IsTransformStream(x) {
|
|
if (!typeIsObject(x)) return false;
|
|
if (!Object.prototype.hasOwnProperty.call(x, "_transformStreamController")) return false;
|
|
return x instanceof TransformStream;
|
|
}
|
|
// This is a no-op if both sides are already errored.
|
|
function TransformStreamError(stream, e) {
|
|
ReadableStreamDefaultControllerError(stream._readable._readableStreamController, e);
|
|
TransformStreamErrorWritableAndUnblockWrite(stream, e);
|
|
}
|
|
function TransformStreamErrorWritableAndUnblockWrite(stream, e) {
|
|
TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController);
|
|
WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e);
|
|
if (stream._backpressure) // Pretend that pull() was called to permit any pending write() calls to complete. TransformStreamSetBackpressure()
|
|
// cannot be called from enqueue() or pull() once the ReadableStream is errored, so this will will be the final time
|
|
// _backpressure is set.
|
|
TransformStreamSetBackpressure(stream, false);
|
|
}
|
|
function TransformStreamSetBackpressure(stream, backpressure) {
|
|
// Passes also when called during construction.
|
|
if (stream._backpressureChangePromise !== undefined) stream._backpressureChangePromise_resolve();
|
|
stream._backpressureChangePromise = newPromise((resolve)=>{
|
|
stream._backpressureChangePromise_resolve = resolve;
|
|
});
|
|
stream._backpressure = backpressure;
|
|
}
|
|
// Class TransformStreamDefaultController
|
|
/**
|
|
* Allows control of the {@link ReadableStream} and {@link WritableStream} of the associated {@link TransformStream}.
|
|
*
|
|
* @public
|
|
*/ class TransformStreamDefaultController {
|
|
constructor(){
|
|
throw new TypeError("Illegal constructor");
|
|
}
|
|
/**
|
|
* Returns the desired size to fill the readable side\u2019s internal queue. It can be negative, if the queue is over-full.
|
|
*/ get desiredSize() {
|
|
if (!IsTransformStreamDefaultController(this)) throw defaultControllerBrandCheckException("desiredSize");
|
|
const readableController = this._controlledTransformStream._readable._readableStreamController;
|
|
return ReadableStreamDefaultControllerGetDesiredSize(readableController);
|
|
}
|
|
enqueue(chunk) {
|
|
if (!IsTransformStreamDefaultController(this)) throw defaultControllerBrandCheckException("enqueue");
|
|
TransformStreamDefaultControllerEnqueue(this, chunk);
|
|
}
|
|
/**
|
|
* Errors both the readable side and the writable side of the controlled transform stream, making all future
|
|
* interactions with it fail with the given error `e`. Any chunks queued for transformation will be discarded.
|
|
*/ error(reason) {
|
|
if (!IsTransformStreamDefaultController(this)) throw defaultControllerBrandCheckException("error");
|
|
TransformStreamDefaultControllerError(this, reason);
|
|
}
|
|
/**
|
|
* Closes the readable side and errors the writable side of the controlled transform stream. This is useful when the
|
|
* transformer only needs to consume a portion of the chunks written to the writable side.
|
|
*/ terminate() {
|
|
if (!IsTransformStreamDefaultController(this)) throw defaultControllerBrandCheckException("terminate");
|
|
TransformStreamDefaultControllerTerminate(this);
|
|
}
|
|
}
|
|
Object.defineProperties(TransformStreamDefaultController.prototype, {
|
|
enqueue: {
|
|
enumerable: true
|
|
},
|
|
error: {
|
|
enumerable: true
|
|
},
|
|
terminate: {
|
|
enumerable: true
|
|
},
|
|
desiredSize: {
|
|
enumerable: true
|
|
}
|
|
});
|
|
if (typeof SymbolPolyfill.toStringTag === "symbol") Object.defineProperty(TransformStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {
|
|
value: "TransformStreamDefaultController",
|
|
configurable: true
|
|
});
|
|
// Transform Stream Default Controller Abstract Operations
|
|
function IsTransformStreamDefaultController(x) {
|
|
if (!typeIsObject(x)) return false;
|
|
if (!Object.prototype.hasOwnProperty.call(x, "_controlledTransformStream")) return false;
|
|
return x instanceof TransformStreamDefaultController;
|
|
}
|
|
function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm) {
|
|
controller._controlledTransformStream = stream;
|
|
stream._transformStreamController = controller;
|
|
controller._transformAlgorithm = transformAlgorithm;
|
|
controller._flushAlgorithm = flushAlgorithm;
|
|
}
|
|
function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) {
|
|
const controller = Object.create(TransformStreamDefaultController.prototype);
|
|
let transformAlgorithm = (chunk)=>{
|
|
try {
|
|
TransformStreamDefaultControllerEnqueue(controller, chunk);
|
|
return promiseResolvedWith(undefined);
|
|
} catch (transformResultE) {
|
|
return promiseRejectedWith(transformResultE);
|
|
}
|
|
};
|
|
let flushAlgorithm = ()=>promiseResolvedWith(undefined);
|
|
if (transformer.transform !== undefined) transformAlgorithm = (chunk)=>transformer.transform(chunk, controller);
|
|
if (transformer.flush !== undefined) flushAlgorithm = ()=>transformer.flush(controller);
|
|
SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm);
|
|
}
|
|
function TransformStreamDefaultControllerClearAlgorithms(controller) {
|
|
controller._transformAlgorithm = undefined;
|
|
controller._flushAlgorithm = undefined;
|
|
}
|
|
function TransformStreamDefaultControllerEnqueue(controller, chunk) {
|
|
const stream = controller._controlledTransformStream;
|
|
const readableController = stream._readable._readableStreamController;
|
|
if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController)) throw new TypeError("Readable side is not in a state that permits enqueue");
|
|
// We throttle transform invocations based on the backpressure of the ReadableStream, but we still
|
|
// accept TransformStreamDefaultControllerEnqueue() calls.
|
|
try {
|
|
ReadableStreamDefaultControllerEnqueue(readableController, chunk);
|
|
} catch (e) {
|
|
// This happens when readableStrategy.size() throws.
|
|
TransformStreamErrorWritableAndUnblockWrite(stream, e);
|
|
throw stream._readable._storedError;
|
|
}
|
|
const backpressure = ReadableStreamDefaultControllerHasBackpressure(readableController);
|
|
if (backpressure !== stream._backpressure) TransformStreamSetBackpressure(stream, true);
|
|
}
|
|
function TransformStreamDefaultControllerError(controller, e) {
|
|
TransformStreamError(controller._controlledTransformStream, e);
|
|
}
|
|
function TransformStreamDefaultControllerPerformTransform(controller, chunk) {
|
|
const transformPromise = controller._transformAlgorithm(chunk);
|
|
return transformPromiseWith(transformPromise, undefined, (r)=>{
|
|
TransformStreamError(controller._controlledTransformStream, r);
|
|
throw r;
|
|
});
|
|
}
|
|
function TransformStreamDefaultControllerTerminate(controller) {
|
|
const stream = controller._controlledTransformStream;
|
|
const readableController = stream._readable._readableStreamController;
|
|
ReadableStreamDefaultControllerClose(readableController);
|
|
const error = new TypeError("TransformStream terminated");
|
|
TransformStreamErrorWritableAndUnblockWrite(stream, error);
|
|
}
|
|
// TransformStreamDefaultSink Algorithms
|
|
function TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) {
|
|
const controller = stream._transformStreamController;
|
|
if (stream._backpressure) {
|
|
const backpressureChangePromise = stream._backpressureChangePromise;
|
|
return transformPromiseWith(backpressureChangePromise, ()=>{
|
|
const writable = stream._writable;
|
|
const state = writable._state;
|
|
if (state === "erroring") throw writable._storedError;
|
|
return TransformStreamDefaultControllerPerformTransform(controller, chunk);
|
|
});
|
|
}
|
|
return TransformStreamDefaultControllerPerformTransform(controller, chunk);
|
|
}
|
|
function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) {
|
|
// abort() is not called synchronously, so it is possible for abort() to be called when the stream is already
|
|
// errored.
|
|
TransformStreamError(stream, reason);
|
|
return promiseResolvedWith(undefined);
|
|
}
|
|
function TransformStreamDefaultSinkCloseAlgorithm(stream) {
|
|
// stream._readable cannot change after construction, so caching it across a call to user code is safe.
|
|
const readable = stream._readable;
|
|
const controller = stream._transformStreamController;
|
|
const flushPromise = controller._flushAlgorithm();
|
|
TransformStreamDefaultControllerClearAlgorithms(controller);
|
|
// Return a promise that is fulfilled with undefined on success.
|
|
return transformPromiseWith(flushPromise, ()=>{
|
|
if (readable._state === "errored") throw readable._storedError;
|
|
ReadableStreamDefaultControllerClose(readable._readableStreamController);
|
|
}, (r)=>{
|
|
TransformStreamError(stream, r);
|
|
throw readable._storedError;
|
|
});
|
|
}
|
|
// TransformStreamDefaultSource Algorithms
|
|
function TransformStreamDefaultSourcePullAlgorithm(stream) {
|
|
// Invariant. Enforced by the promises returned by start() and pull().
|
|
TransformStreamSetBackpressure(stream, false);
|
|
// Prevent the next pull() call until there is backpressure.
|
|
return stream._backpressureChangePromise;
|
|
}
|
|
// Helper functions for the TransformStreamDefaultController.
|
|
function defaultControllerBrandCheckException(name) {
|
|
return new TypeError(`TransformStreamDefaultController.prototype.${name} can only be used on a TransformStreamDefaultController`);
|
|
}
|
|
// Helper functions for the TransformStream.
|
|
function streamBrandCheckException(name) {
|
|
return new TypeError(`TransformStream.prototype.${name} can only be used on a TransformStream`);
|
|
}
|
|
exports1.ByteLengthQueuingStrategy = ByteLengthQueuingStrategy;
|
|
exports1.CountQueuingStrategy = CountQueuingStrategy;
|
|
exports1.ReadableByteStreamController = ReadableByteStreamController;
|
|
exports1.ReadableStream = ReadableStream;
|
|
exports1.ReadableStreamBYOBReader = ReadableStreamBYOBReader;
|
|
exports1.ReadableStreamBYOBRequest = ReadableStreamBYOBRequest;
|
|
exports1.ReadableStreamDefaultController = ReadableStreamDefaultController;
|
|
exports1.ReadableStreamDefaultReader = ReadableStreamDefaultReader;
|
|
exports1.TransformStream = TransformStream;
|
|
exports1.TransformStreamDefaultController = TransformStreamDefaultController;
|
|
exports1.WritableStream = WritableStream;
|
|
exports1.WritableStreamDefaultController = WritableStreamDefaultController;
|
|
exports1.WritableStreamDefaultWriter = WritableStreamDefaultWriter;
|
|
Object.defineProperty(exports1, "__esModule", {
|
|
value: true
|
|
});
|
|
});
|
|
|
|
},{}],"j1qyA":[function(require,module,exports) {
|
|
var Er = Object.create;
|
|
var N = Object.defineProperty;
|
|
var dr = Object.getOwnPropertyDescriptor;
|
|
var gr = Object.getOwnPropertyNames;
|
|
var mr = Object.getPrototypeOf, Ir = Object.prototype.hasOwnProperty;
|
|
var $ = (i, r)=>()=>(r || i((r = {
|
|
exports: {}
|
|
}).exports, r), r.exports), Fr = (i, r)=>{
|
|
for(var t in r)N(i, t, {
|
|
get: r[t],
|
|
enumerable: !0
|
|
});
|
|
}, L = (i, r, t, n)=>{
|
|
if (r && typeof r == "object" || typeof r == "function") for (let e of gr(r))!Ir.call(i, e) && e !== t && N(i, e, {
|
|
get: ()=>r[e],
|
|
enumerable: !(n = dr(r, e)) || n.enumerable
|
|
});
|
|
return i;
|
|
}, S = (i, r, t)=>(L(i, r, "default"), t && L(t, r, "default")), J = (i, r, t)=>(t = i != null ? Er(mr(i)) : {}, L(r || !i || !i.__esModule ? N(t, "default", {
|
|
value: i,
|
|
enumerable: !0
|
|
}) : t, i)), Ar = (i)=>L(N({}, "__esModule", {
|
|
value: !0
|
|
}), i);
|
|
var Q = $((M)=>{
|
|
"use strict";
|
|
M.byteLength = Rr;
|
|
M.toByteArray = Cr;
|
|
M.fromByteArray = Lr;
|
|
var B = [], w = [], Ur = typeof Uint8Array < "u" ? Uint8Array : Array, P = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
for(m = 0, K = P.length; m < K; ++m)B[m] = P[m], w[P.charCodeAt(m)] = m;
|
|
var m, K;
|
|
w["-".charCodeAt(0)] = 62;
|
|
w["_".charCodeAt(0)] = 63;
|
|
function Z(i) {
|
|
var r = i.length;
|
|
if (r % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
|
|
var t = i.indexOf("=");
|
|
t === -1 && (t = r);
|
|
var n = t === r ? 0 : 4 - t % 4;
|
|
return [
|
|
t,
|
|
n
|
|
];
|
|
}
|
|
function Rr(i) {
|
|
var r = Z(i), t = r[0], n = r[1];
|
|
return (t + n) * 3 / 4 - n;
|
|
}
|
|
function Tr(i, r, t) {
|
|
return (r + t) * 3 / 4 - t;
|
|
}
|
|
function Cr(i) {
|
|
var r, t = Z(i), n = t[0], e = t[1], o = new Ur(Tr(i, n, e)), u = 0, f = e > 0 ? n - 4 : n, c;
|
|
for(c = 0; c < f; c += 4)r = w[i.charCodeAt(c)] << 18 | w[i.charCodeAt(c + 1)] << 12 | w[i.charCodeAt(c + 2)] << 6 | w[i.charCodeAt(c + 3)], o[u++] = r >> 16 & 255, o[u++] = r >> 8 & 255, o[u++] = r & 255;
|
|
return e === 2 && (r = w[i.charCodeAt(c)] << 2 | w[i.charCodeAt(c + 1)] >> 4, o[u++] = r & 255), e === 1 && (r = w[i.charCodeAt(c)] << 10 | w[i.charCodeAt(c + 1)] << 4 | w[i.charCodeAt(c + 2)] >> 2, o[u++] = r >> 8 & 255, o[u++] = r & 255), o;
|
|
}
|
|
function Sr(i) {
|
|
return B[i >> 18 & 63] + B[i >> 12 & 63] + B[i >> 6 & 63] + B[i & 63];
|
|
}
|
|
function _r(i, r, t) {
|
|
for(var n, e = [], o = r; o < t; o += 3)n = (i[o] << 16 & 16711680) + (i[o + 1] << 8 & 65280) + (i[o + 2] & 255), e.push(Sr(n));
|
|
return e.join("");
|
|
}
|
|
function Lr(i) {
|
|
for(var r, t = i.length, n = t % 3, e = [], o = 16383, u = 0, f = t - n; u < f; u += o)e.push(_r(i, u, u + o > f ? f : u + o));
|
|
return n === 1 ? (r = i[t - 1], e.push(B[r >> 2] + B[r << 4 & 63] + "==")) : n === 2 && (r = (i[t - 2] << 8) + i[t - 1], e.push(B[r >> 10] + B[r >> 4 & 63] + B[r << 2 & 63] + "=")), e.join("");
|
|
}
|
|
});
|
|
var v = $((O)=>{
|
|
O.read = function(i, r, t, n, e) {
|
|
var o, u, f = e * 8 - n - 1, c = (1 << f) - 1, l = c >> 1, s = -7, p = t ? e - 1 : 0, F = t ? -1 : 1, x = i[r + p];
|
|
for(p += F, o = x & (1 << -s) - 1, x >>= -s, s += f; s > 0; o = o * 256 + i[r + p], p += F, s -= 8);
|
|
for(u = o & (1 << -s) - 1, o >>= -s, s += n; s > 0; u = u * 256 + i[r + p], p += F, s -= 8);
|
|
if (o === 0) o = 1 - l;
|
|
else {
|
|
if (o === c) return u ? NaN : (x ? -1 : 1) * (1 / 0);
|
|
u = u + Math.pow(2, n), o = o - l;
|
|
}
|
|
return (x ? -1 : 1) * u * Math.pow(2, o - n);
|
|
};
|
|
O.write = function(i, r, t, n, e, o) {
|
|
var u, f, c, l = o * 8 - e - 1, s = (1 << l) - 1, p = s >> 1, F = e === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, x = n ? 0 : o - 1, b = n ? 1 : -1, Br = r < 0 || r === 0 && 1 / r < 0 ? 1 : 0;
|
|
for(r = Math.abs(r), isNaN(r) || r === 1 / 0 ? (f = isNaN(r) ? 1 : 0, u = s) : (u = Math.floor(Math.log(r) / Math.LN2), r * (c = Math.pow(2, -u)) < 1 && (u--, c *= 2), u + p >= 1 ? r += F / c : r += F * Math.pow(2, 1 - p), r * c >= 2 && (u++, c /= 2), u + p >= s ? (f = 0, u = s) : u + p >= 1 ? (f = (r * c - 1) * Math.pow(2, e), u = u + p) : (f = r * Math.pow(2, p - 1) * Math.pow(2, e), u = 0)); e >= 8; i[t + x] = f & 255, x += b, f /= 256, e -= 8);
|
|
for(u = u << e | f, l += e; l > 0; i[t + x] = u & 255, x += b, u /= 256, l -= 8);
|
|
i[t + x - b] |= Br * 128;
|
|
};
|
|
});
|
|
var z = $((T)=>{
|
|
"use strict";
|
|
var G = Q(), U = v(), rr = typeof Symbol == "function" && typeof Symbol.for == "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
|
|
T.Buffer = h;
|
|
T.SlowBuffer = $r;
|
|
T.INSPECT_MAX_BYTES = 50;
|
|
var k = 2147483647;
|
|
T.kMaxLength = k;
|
|
h.TYPED_ARRAY_SUPPORT = Nr();
|
|
!h.TYPED_ARRAY_SUPPORT && typeof console < "u" && typeof console.error == "function" && console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
|
|
function Nr() {
|
|
try {
|
|
let i = new Uint8Array(1), r = {
|
|
foo: function() {
|
|
return 42;
|
|
}
|
|
};
|
|
return Object.setPrototypeOf(r, Uint8Array.prototype), Object.setPrototypeOf(i, r), i.foo() === 42;
|
|
} catch (i) {
|
|
return !1;
|
|
}
|
|
}
|
|
Object.defineProperty(h.prototype, "parent", {
|
|
enumerable: !0,
|
|
get: function() {
|
|
if (h.isBuffer(this)) return this.buffer;
|
|
}
|
|
});
|
|
Object.defineProperty(h.prototype, "offset", {
|
|
enumerable: !0,
|
|
get: function() {
|
|
if (h.isBuffer(this)) return this.byteOffset;
|
|
}
|
|
});
|
|
function d(i) {
|
|
if (i > k) throw new RangeError('The value "' + i + '" is invalid for option "size"');
|
|
let r = new Uint8Array(i);
|
|
return Object.setPrototypeOf(r, h.prototype), r;
|
|
}
|
|
function h(i, r, t) {
|
|
if (typeof i == "number") {
|
|
if (typeof r == "string") throw new TypeError('The "string" argument must be of type string. Received type number');
|
|
return j(i);
|
|
}
|
|
return er(i, r, t);
|
|
}
|
|
h.poolSize = 8192;
|
|
function er(i, r, t) {
|
|
if (typeof i == "string") return kr(i, r);
|
|
if (ArrayBuffer.isView(i)) return Dr(i);
|
|
if (i == null) throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof i);
|
|
if (E(i, ArrayBuffer) || i && E(i.buffer, ArrayBuffer) || typeof SharedArrayBuffer < "u" && (E(i, SharedArrayBuffer) || i && E(i.buffer, SharedArrayBuffer))) return q(i, r, t);
|
|
if (typeof i == "number") throw new TypeError('The "value" argument must not be of type number. Received type number');
|
|
let n = i.valueOf && i.valueOf();
|
|
if (n != null && n !== i) return h.from(n, r, t);
|
|
let e = br(i);
|
|
if (e) return e;
|
|
if (typeof Symbol < "u" && Symbol.toPrimitive != null && typeof i[Symbol.toPrimitive] == "function") return h.from(i[Symbol.toPrimitive]("string"), r, t);
|
|
throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof i);
|
|
}
|
|
h.from = function(i, r, t) {
|
|
return er(i, r, t);
|
|
};
|
|
Object.setPrototypeOf(h.prototype, Uint8Array.prototype);
|
|
Object.setPrototypeOf(h, Uint8Array);
|
|
function or(i) {
|
|
if (typeof i != "number") throw new TypeError('"size" argument must be of type number');
|
|
if (i < 0) throw new RangeError('The value "' + i + '" is invalid for option "size"');
|
|
}
|
|
function Mr(i, r, t) {
|
|
return or(i), i <= 0 ? d(i) : r !== void 0 ? typeof t == "string" ? d(i).fill(r, t) : d(i).fill(r) : d(i);
|
|
}
|
|
h.alloc = function(i, r, t) {
|
|
return Mr(i, r, t);
|
|
};
|
|
function j(i) {
|
|
return or(i), d(i < 0 ? 0 : H(i) | 0);
|
|
}
|
|
h.allocUnsafe = function(i) {
|
|
return j(i);
|
|
};
|
|
h.allocUnsafeSlow = function(i) {
|
|
return j(i);
|
|
};
|
|
function kr(i, r) {
|
|
if ((typeof r != "string" || r === "") && (r = "utf8"), !h.isEncoding(r)) throw new TypeError("Unknown encoding: " + r);
|
|
let t = ur(i, r) | 0, n = d(t), e = n.write(i, r);
|
|
return e !== t && (n = n.slice(0, e)), n;
|
|
}
|
|
function Y(i) {
|
|
let r = i.length < 0 ? 0 : H(i.length) | 0, t = d(r);
|
|
for(let n = 0; n < r; n += 1)t[n] = i[n] & 255;
|
|
return t;
|
|
}
|
|
function Dr(i) {
|
|
if (E(i, Uint8Array)) {
|
|
let r = new Uint8Array(i);
|
|
return q(r.buffer, r.byteOffset, r.byteLength);
|
|
}
|
|
return Y(i);
|
|
}
|
|
function q(i, r, t) {
|
|
if (r < 0 || i.byteLength < r) throw new RangeError('"offset" is outside of buffer bounds');
|
|
if (i.byteLength < r + (t || 0)) throw new RangeError('"length" is outside of buffer bounds');
|
|
let n;
|
|
return r === void 0 && t === void 0 ? n = new Uint8Array(i) : t === void 0 ? n = new Uint8Array(i, r) : n = new Uint8Array(i, r, t), Object.setPrototypeOf(n, h.prototype), n;
|
|
}
|
|
function br(i) {
|
|
if (h.isBuffer(i)) {
|
|
let r = H(i.length) | 0, t = d(r);
|
|
return t.length === 0 || i.copy(t, 0, 0, r), t;
|
|
}
|
|
if (i.length !== void 0) return typeof i.length != "number" || X(i.length) ? d(0) : Y(i);
|
|
if (i.type === "Buffer" && Array.isArray(i.data)) return Y(i.data);
|
|
}
|
|
function H(i) {
|
|
if (i >= k) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + k.toString(16) + " bytes");
|
|
return i | 0;
|
|
}
|
|
function $r(i) {
|
|
return +i != i && (i = 0), h.alloc(+i);
|
|
}
|
|
h.isBuffer = function(r) {
|
|
return r != null && r._isBuffer === !0 && r !== h.prototype;
|
|
};
|
|
h.compare = function(r, t) {
|
|
if (E(r, Uint8Array) && (r = h.from(r, r.offset, r.byteLength)), E(t, Uint8Array) && (t = h.from(t, t.offset, t.byteLength)), !h.isBuffer(r) || !h.isBuffer(t)) throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
|
|
if (r === t) return 0;
|
|
let n = r.length, e = t.length;
|
|
for(let o = 0, u = Math.min(n, e); o < u; ++o)if (r[o] !== t[o]) {
|
|
n = r[o], e = t[o];
|
|
break;
|
|
}
|
|
return n < e ? -1 : e < n ? 1 : 0;
|
|
};
|
|
h.isEncoding = function(r) {
|
|
switch(String(r).toLowerCase()){
|
|
case "hex":
|
|
case "utf8":
|
|
case "utf-8":
|
|
case "ascii":
|
|
case "latin1":
|
|
case "binary":
|
|
case "base64":
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return !0;
|
|
default:
|
|
return !1;
|
|
}
|
|
};
|
|
h.concat = function(r, t) {
|
|
if (!Array.isArray(r)) throw new TypeError('"list" argument must be an Array of Buffers');
|
|
if (r.length === 0) return h.alloc(0);
|
|
let n;
|
|
if (t === void 0) for(t = 0, n = 0; n < r.length; ++n)t += r[n].length;
|
|
let e = h.allocUnsafe(t), o = 0;
|
|
for(n = 0; n < r.length; ++n){
|
|
let u = r[n];
|
|
if (E(u, Uint8Array)) o + u.length > e.length ? (h.isBuffer(u) || (u = h.from(u)), u.copy(e, o)) : Uint8Array.prototype.set.call(e, u, o);
|
|
else if (h.isBuffer(u)) u.copy(e, o);
|
|
else throw new TypeError('"list" argument must be an Array of Buffers');
|
|
o += u.length;
|
|
}
|
|
return e;
|
|
};
|
|
function ur(i, r) {
|
|
if (h.isBuffer(i)) return i.length;
|
|
if (ArrayBuffer.isView(i) || E(i, ArrayBuffer)) return i.byteLength;
|
|
if (typeof i != "string") throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof i);
|
|
let t = i.length, n = arguments.length > 2 && arguments[2] === !0;
|
|
if (!n && t === 0) return 0;
|
|
let e = !1;
|
|
for(;;)switch(r){
|
|
case "ascii":
|
|
case "latin1":
|
|
case "binary":
|
|
return t;
|
|
case "utf8":
|
|
case "utf-8":
|
|
return W(i).length;
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return t * 2;
|
|
case "hex":
|
|
return t >>> 1;
|
|
case "base64":
|
|
return wr(i).length;
|
|
default:
|
|
if (e) return n ? -1 : W(i).length;
|
|
r = ("" + r).toLowerCase(), e = !0;
|
|
}
|
|
}
|
|
h.byteLength = ur;
|
|
function Pr(i, r, t) {
|
|
let n = !1;
|
|
if ((r === void 0 || r < 0) && (r = 0), r > this.length || ((t === void 0 || t > this.length) && (t = this.length), t <= 0) || (t >>>= 0, r >>>= 0, t <= r)) return "";
|
|
for(i || (i = "utf8");;)switch(i){
|
|
case "hex":
|
|
return zr(this, r, t);
|
|
case "utf8":
|
|
case "utf-8":
|
|
return fr(this, r, t);
|
|
case "ascii":
|
|
return Vr(this, r, t);
|
|
case "latin1":
|
|
case "binary":
|
|
return Xr(this, r, t);
|
|
case "base64":
|
|
return jr(this, r, t);
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return Jr(this, r, t);
|
|
default:
|
|
if (n) throw new TypeError("Unknown encoding: " + i);
|
|
i = (i + "").toLowerCase(), n = !0;
|
|
}
|
|
}
|
|
h.prototype._isBuffer = !0;
|
|
function I(i, r, t) {
|
|
let n = i[r];
|
|
i[r] = i[t], i[t] = n;
|
|
}
|
|
h.prototype.swap16 = function() {
|
|
let r = this.length;
|
|
if (r % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
|
|
for(let t = 0; t < r; t += 2)I(this, t, t + 1);
|
|
return this;
|
|
};
|
|
h.prototype.swap32 = function() {
|
|
let r = this.length;
|
|
if (r % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
|
|
for(let t = 0; t < r; t += 4)I(this, t, t + 3), I(this, t + 1, t + 2);
|
|
return this;
|
|
};
|
|
h.prototype.swap64 = function() {
|
|
let r = this.length;
|
|
if (r % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
|
|
for(let t = 0; t < r; t += 8)I(this, t, t + 7), I(this, t + 1, t + 6), I(this, t + 2, t + 5), I(this, t + 3, t + 4);
|
|
return this;
|
|
};
|
|
h.prototype.toString = function() {
|
|
let r = this.length;
|
|
return r === 0 ? "" : arguments.length === 0 ? fr(this, 0, r) : Pr.apply(this, arguments);
|
|
};
|
|
h.prototype.toLocaleString = h.prototype.toString;
|
|
h.prototype.equals = function(r) {
|
|
if (!h.isBuffer(r)) throw new TypeError("Argument must be a Buffer");
|
|
return this === r ? !0 : h.compare(this, r) === 0;
|
|
};
|
|
h.prototype.inspect = function() {
|
|
let r = "", t = T.INSPECT_MAX_BYTES;
|
|
return r = this.toString("hex", 0, t).replace(/(.{2})/g, "$1 ").trim(), this.length > t && (r += " ... "), "<Buffer " + r + ">";
|
|
};
|
|
rr && (h.prototype[rr] = h.prototype.inspect);
|
|
h.prototype.compare = function(r, t, n, e, o) {
|
|
if (E(r, Uint8Array) && (r = h.from(r, r.offset, r.byteLength)), !h.isBuffer(r)) throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof r);
|
|
if (t === void 0 && (t = 0), n === void 0 && (n = r ? r.length : 0), e === void 0 && (e = 0), o === void 0 && (o = this.length), t < 0 || n > r.length || e < 0 || o > this.length) throw new RangeError("out of range index");
|
|
if (e >= o && t >= n) return 0;
|
|
if (e >= o) return -1;
|
|
if (t >= n) return 1;
|
|
if (t >>>= 0, n >>>= 0, e >>>= 0, o >>>= 0, this === r) return 0;
|
|
let u = o - e, f = n - t, c = Math.min(u, f), l = this.slice(e, o), s = r.slice(t, n);
|
|
for(let p = 0; p < c; ++p)if (l[p] !== s[p]) {
|
|
u = l[p], f = s[p];
|
|
break;
|
|
}
|
|
return u < f ? -1 : f < u ? 1 : 0;
|
|
};
|
|
function hr(i, r, t, n, e) {
|
|
if (i.length === 0) return -1;
|
|
if (typeof t == "string" ? (n = t, t = 0) : t > 2147483647 ? t = 2147483647 : t < -2147483648 && (t = -2147483648), t = +t, X(t) && (t = e ? 0 : i.length - 1), t < 0 && (t = i.length + t), t >= i.length) {
|
|
if (e) return -1;
|
|
t = i.length - 1;
|
|
} else if (t < 0) {
|
|
if (e) t = 0;
|
|
else return -1;
|
|
}
|
|
if (typeof r == "string" && (r = h.from(r, n)), h.isBuffer(r)) return r.length === 0 ? -1 : tr(i, r, t, n, e);
|
|
if (typeof r == "number") return r = r & 255, typeof Uint8Array.prototype.indexOf == "function" ? e ? Uint8Array.prototype.indexOf.call(i, r, t) : Uint8Array.prototype.lastIndexOf.call(i, r, t) : tr(i, [
|
|
r
|
|
], t, n, e);
|
|
throw new TypeError("val must be string, number or Buffer");
|
|
}
|
|
function tr(i, r, t, n, e) {
|
|
let o = 1, u = i.length, f = r.length;
|
|
if (n !== void 0 && (n = String(n).toLowerCase(), n === "ucs2" || n === "ucs-2" || n === "utf16le" || n === "utf-16le")) {
|
|
if (i.length < 2 || r.length < 2) return -1;
|
|
o = 2, u /= 2, f /= 2, t /= 2;
|
|
}
|
|
function c(s, p) {
|
|
return o === 1 ? s[p] : s.readUInt16BE(p * o);
|
|
}
|
|
let l;
|
|
if (e) {
|
|
let s = -1;
|
|
for(l = t; l < u; l++)if (c(i, l) === c(r, s === -1 ? 0 : l - s)) {
|
|
if (s === -1 && (s = l), l - s + 1 === f) return s * o;
|
|
} else s !== -1 && (l -= l - s), s = -1;
|
|
} else for(t + f > u && (t = u - f), l = t; l >= 0; l--){
|
|
let s = !0;
|
|
for(let p = 0; p < f; p++)if (c(i, l + p) !== c(r, p)) {
|
|
s = !1;
|
|
break;
|
|
}
|
|
if (s) return l;
|
|
}
|
|
return -1;
|
|
}
|
|
h.prototype.includes = function(r, t, n) {
|
|
return this.indexOf(r, t, n) !== -1;
|
|
};
|
|
h.prototype.indexOf = function(r, t, n) {
|
|
return hr(this, r, t, n, !0);
|
|
};
|
|
h.prototype.lastIndexOf = function(r, t, n) {
|
|
return hr(this, r, t, n, !1);
|
|
};
|
|
function Or(i, r, t, n) {
|
|
t = Number(t) || 0;
|
|
let e = i.length - t;
|
|
n ? (n = Number(n), n > e && (n = e)) : n = e;
|
|
let o = r.length;
|
|
n > o / 2 && (n = o / 2);
|
|
let u;
|
|
for(u = 0; u < n; ++u){
|
|
let f = parseInt(r.substr(u * 2, 2), 16);
|
|
if (X(f)) return u;
|
|
i[t + u] = f;
|
|
}
|
|
return u;
|
|
}
|
|
function Gr(i, r, t, n) {
|
|
return D(W(r, i.length - t), i, t, n);
|
|
}
|
|
function Yr(i, r, t, n) {
|
|
return D(vr(r), i, t, n);
|
|
}
|
|
function qr(i, r, t, n) {
|
|
return D(wr(r), i, t, n);
|
|
}
|
|
function Wr(i, r, t, n) {
|
|
return D(rt(r, i.length - t), i, t, n);
|
|
}
|
|
h.prototype.write = function(r, t, n, e) {
|
|
if (t === void 0) e = "utf8", n = this.length, t = 0;
|
|
else if (n === void 0 && typeof t == "string") e = t, n = this.length, t = 0;
|
|
else if (isFinite(t)) t = t >>> 0, isFinite(n) ? (n = n >>> 0, e === void 0 && (e = "utf8")) : (e = n, n = void 0);
|
|
else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
|
|
let o = this.length - t;
|
|
if ((n === void 0 || n > o) && (n = o), r.length > 0 && (n < 0 || t < 0) || t > this.length) throw new RangeError("Attempt to write outside buffer bounds");
|
|
e || (e = "utf8");
|
|
let u = !1;
|
|
for(;;)switch(e){
|
|
case "hex":
|
|
return Or(this, r, t, n);
|
|
case "utf8":
|
|
case "utf-8":
|
|
return Gr(this, r, t, n);
|
|
case "ascii":
|
|
case "latin1":
|
|
case "binary":
|
|
return Yr(this, r, t, n);
|
|
case "base64":
|
|
return qr(this, r, t, n);
|
|
case "ucs2":
|
|
case "ucs-2":
|
|
case "utf16le":
|
|
case "utf-16le":
|
|
return Wr(this, r, t, n);
|
|
default:
|
|
if (u) throw new TypeError("Unknown encoding: " + e);
|
|
e = ("" + e).toLowerCase(), u = !0;
|
|
}
|
|
};
|
|
h.prototype.toJSON = function() {
|
|
return {
|
|
type: "Buffer",
|
|
data: Array.prototype.slice.call(this._arr || this, 0)
|
|
};
|
|
};
|
|
function jr(i, r, t) {
|
|
return r === 0 && t === i.length ? G.fromByteArray(i) : G.fromByteArray(i.slice(r, t));
|
|
}
|
|
function fr(i, r, t) {
|
|
t = Math.min(i.length, t);
|
|
let n = [], e = r;
|
|
for(; e < t;){
|
|
let o = i[e], u = null, f = o > 239 ? 4 : o > 223 ? 3 : o > 191 ? 2 : 1;
|
|
if (e + f <= t) {
|
|
let c, l, s, p;
|
|
switch(f){
|
|
case 1:
|
|
o < 128 && (u = o);
|
|
break;
|
|
case 2:
|
|
c = i[e + 1], (c & 192) === 128 && (p = (o & 31) << 6 | c & 63, p > 127 && (u = p));
|
|
break;
|
|
case 3:
|
|
c = i[e + 1], l = i[e + 2], (c & 192) === 128 && (l & 192) === 128 && (p = (o & 15) << 12 | (c & 63) << 6 | l & 63, p > 2047 && (p < 55296 || p > 57343) && (u = p));
|
|
break;
|
|
case 4:
|
|
c = i[e + 1], l = i[e + 2], s = i[e + 3], (c & 192) === 128 && (l & 192) === 128 && (s & 192) === 128 && (p = (o & 15) << 18 | (c & 63) << 12 | (l & 63) << 6 | s & 63, p > 65535 && p < 1114112 && (u = p));
|
|
}
|
|
}
|
|
u === null ? (u = 65533, f = 1) : u > 65535 && (u -= 65536, n.push(u >>> 10 & 1023 | 55296), u = 56320 | u & 1023), n.push(u), e += f;
|
|
}
|
|
return Hr(n);
|
|
}
|
|
var ir = 4096;
|
|
function Hr(i) {
|
|
let r = i.length;
|
|
if (r <= ir) return String.fromCharCode.apply(String, i);
|
|
let t = "", n = 0;
|
|
for(; n < r;)t += String.fromCharCode.apply(String, i.slice(n, n += ir));
|
|
return t;
|
|
}
|
|
function Vr(i, r, t) {
|
|
let n = "";
|
|
t = Math.min(i.length, t);
|
|
for(let e = r; e < t; ++e)n += String.fromCharCode(i[e] & 127);
|
|
return n;
|
|
}
|
|
function Xr(i, r, t) {
|
|
let n = "";
|
|
t = Math.min(i.length, t);
|
|
for(let e = r; e < t; ++e)n += String.fromCharCode(i[e]);
|
|
return n;
|
|
}
|
|
function zr(i, r, t) {
|
|
let n = i.length;
|
|
(!r || r < 0) && (r = 0), (!t || t < 0 || t > n) && (t = n);
|
|
let e = "";
|
|
for(let o = r; o < t; ++o)e += tt[i[o]];
|
|
return e;
|
|
}
|
|
function Jr(i, r, t) {
|
|
let n = i.slice(r, t), e = "";
|
|
for(let o = 0; o < n.length - 1; o += 2)e += String.fromCharCode(n[o] + n[o + 1] * 256);
|
|
return e;
|
|
}
|
|
h.prototype.slice = function(r, t) {
|
|
let n = this.length;
|
|
r = ~~r, t = t === void 0 ? n : ~~t, r < 0 ? (r += n, r < 0 && (r = 0)) : r > n && (r = n), t < 0 ? (t += n, t < 0 && (t = 0)) : t > n && (t = n), t < r && (t = r);
|
|
let e = this.subarray(r, t);
|
|
return Object.setPrototypeOf(e, h.prototype), e;
|
|
};
|
|
function a(i, r, t) {
|
|
if (i % 1 !== 0 || i < 0) throw new RangeError("offset is not uint");
|
|
if (i + r > t) throw new RangeError("Trying to access beyond buffer length");
|
|
}
|
|
h.prototype.readUintLE = h.prototype.readUIntLE = function(r, t, n) {
|
|
r = r >>> 0, t = t >>> 0, n || a(r, t, this.length);
|
|
let e = this[r], o = 1, u = 0;
|
|
for(; ++u < t && (o *= 256);)e += this[r + u] * o;
|
|
return e;
|
|
};
|
|
h.prototype.readUintBE = h.prototype.readUIntBE = function(r, t, n) {
|
|
r = r >>> 0, t = t >>> 0, n || a(r, t, this.length);
|
|
let e = this[r + --t], o = 1;
|
|
for(; t > 0 && (o *= 256);)e += this[r + --t] * o;
|
|
return e;
|
|
};
|
|
h.prototype.readUint8 = h.prototype.readUInt8 = function(r, t) {
|
|
return r = r >>> 0, t || a(r, 1, this.length), this[r];
|
|
};
|
|
h.prototype.readUint16LE = h.prototype.readUInt16LE = function(r, t) {
|
|
return r = r >>> 0, t || a(r, 2, this.length), this[r] | this[r + 1] << 8;
|
|
};
|
|
h.prototype.readUint16BE = h.prototype.readUInt16BE = function(r, t) {
|
|
return r = r >>> 0, t || a(r, 2, this.length), this[r] << 8 | this[r + 1];
|
|
};
|
|
h.prototype.readUint32LE = h.prototype.readUInt32LE = function(r, t) {
|
|
return r = r >>> 0, t || a(r, 4, this.length), (this[r] | this[r + 1] << 8 | this[r + 2] << 16) + this[r + 3] * 16777216;
|
|
};
|
|
h.prototype.readUint32BE = h.prototype.readUInt32BE = function(r, t) {
|
|
return r = r >>> 0, t || a(r, 4, this.length), this[r] * 16777216 + (this[r + 1] << 16 | this[r + 2] << 8 | this[r + 3]);
|
|
};
|
|
h.prototype.readBigUInt64LE = g(function(r) {
|
|
r = r >>> 0, R(r, "offset");
|
|
let t = this[r], n = this[r + 7];
|
|
(t === void 0 || n === void 0) && _(r, this.length - 8);
|
|
let e = t + this[++r] * 256 + this[++r] * 2 ** 16 + this[++r] * 2 ** 24, o = this[++r] + this[++r] * 256 + this[++r] * 2 ** 16 + n * 2 ** 24;
|
|
return BigInt(e) + (BigInt(o) << BigInt(32));
|
|
});
|
|
h.prototype.readBigUInt64BE = g(function(r) {
|
|
r = r >>> 0, R(r, "offset");
|
|
let t = this[r], n = this[r + 7];
|
|
(t === void 0 || n === void 0) && _(r, this.length - 8);
|
|
let e = t * 2 ** 24 + this[++r] * 2 ** 16 + this[++r] * 256 + this[++r], o = this[++r] * 2 ** 24 + this[++r] * 2 ** 16 + this[++r] * 256 + n;
|
|
return (BigInt(e) << BigInt(32)) + BigInt(o);
|
|
});
|
|
h.prototype.readIntLE = function(r, t, n) {
|
|
r = r >>> 0, t = t >>> 0, n || a(r, t, this.length);
|
|
let e = this[r], o = 1, u = 0;
|
|
for(; ++u < t && (o *= 256);)e += this[r + u] * o;
|
|
return o *= 128, e >= o && (e -= Math.pow(2, 8 * t)), e;
|
|
};
|
|
h.prototype.readIntBE = function(r, t, n) {
|
|
r = r >>> 0, t = t >>> 0, n || a(r, t, this.length);
|
|
let e = t, o = 1, u = this[r + --e];
|
|
for(; e > 0 && (o *= 256);)u += this[r + --e] * o;
|
|
return o *= 128, u >= o && (u -= Math.pow(2, 8 * t)), u;
|
|
};
|
|
h.prototype.readInt8 = function(r, t) {
|
|
return r = r >>> 0, t || a(r, 1, this.length), this[r] & 128 ? (255 - this[r] + 1) * -1 : this[r];
|
|
};
|
|
h.prototype.readInt16LE = function(r, t) {
|
|
r = r >>> 0, t || a(r, 2, this.length);
|
|
let n = this[r] | this[r + 1] << 8;
|
|
return n & 32768 ? n | 4294901760 : n;
|
|
};
|
|
h.prototype.readInt16BE = function(r, t) {
|
|
r = r >>> 0, t || a(r, 2, this.length);
|
|
let n = this[r + 1] | this[r] << 8;
|
|
return n & 32768 ? n | 4294901760 : n;
|
|
};
|
|
h.prototype.readInt32LE = function(r, t) {
|
|
return r = r >>> 0, t || a(r, 4, this.length), this[r] | this[r + 1] << 8 | this[r + 2] << 16 | this[r + 3] << 24;
|
|
};
|
|
h.prototype.readInt32BE = function(r, t) {
|
|
return r = r >>> 0, t || a(r, 4, this.length), this[r] << 24 | this[r + 1] << 16 | this[r + 2] << 8 | this[r + 3];
|
|
};
|
|
h.prototype.readBigInt64LE = g(function(r) {
|
|
r = r >>> 0, R(r, "offset");
|
|
let t = this[r], n = this[r + 7];
|
|
(t === void 0 || n === void 0) && _(r, this.length - 8);
|
|
let e = this[r + 4] + this[r + 5] * 256 + this[r + 6] * 2 ** 16 + (n << 24);
|
|
return (BigInt(e) << BigInt(32)) + BigInt(t + this[++r] * 256 + this[++r] * 2 ** 16 + this[++r] * 2 ** 24);
|
|
});
|
|
h.prototype.readBigInt64BE = g(function(r) {
|
|
r = r >>> 0, R(r, "offset");
|
|
let t = this[r], n = this[r + 7];
|
|
(t === void 0 || n === void 0) && _(r, this.length - 8);
|
|
let e = (t << 24) + this[++r] * 2 ** 16 + this[++r] * 256 + this[++r];
|
|
return (BigInt(e) << BigInt(32)) + BigInt(this[++r] * 2 ** 24 + this[++r] * 2 ** 16 + this[++r] * 256 + n);
|
|
});
|
|
h.prototype.readFloatLE = function(r, t) {
|
|
return r = r >>> 0, t || a(r, 4, this.length), U.read(this, r, !0, 23, 4);
|
|
};
|
|
h.prototype.readFloatBE = function(r, t) {
|
|
return r = r >>> 0, t || a(r, 4, this.length), U.read(this, r, !1, 23, 4);
|
|
};
|
|
h.prototype.readDoubleLE = function(r, t) {
|
|
return r = r >>> 0, t || a(r, 8, this.length), U.read(this, r, !0, 52, 8);
|
|
};
|
|
h.prototype.readDoubleBE = function(r, t) {
|
|
return r = r >>> 0, t || a(r, 8, this.length), U.read(this, r, !1, 52, 8);
|
|
};
|
|
function y(i, r, t, n, e, o) {
|
|
if (!h.isBuffer(i)) throw new TypeError('"buffer" argument must be a Buffer instance');
|
|
if (r > e || r < o) throw new RangeError('"value" argument is out of bounds');
|
|
if (t + n > i.length) throw new RangeError("Index out of range");
|
|
}
|
|
h.prototype.writeUintLE = h.prototype.writeUIntLE = function(r, t, n, e) {
|
|
if (r = +r, t = t >>> 0, n = n >>> 0, !e) {
|
|
let f = Math.pow(2, 8 * n) - 1;
|
|
y(this, r, t, n, f, 0);
|
|
}
|
|
let o = 1, u = 0;
|
|
for(this[t] = r & 255; ++u < n && (o *= 256);)this[t + u] = r / o & 255;
|
|
return t + n;
|
|
};
|
|
h.prototype.writeUintBE = h.prototype.writeUIntBE = function(r, t, n, e) {
|
|
if (r = +r, t = t >>> 0, n = n >>> 0, !e) {
|
|
let f = Math.pow(2, 8 * n) - 1;
|
|
y(this, r, t, n, f, 0);
|
|
}
|
|
let o = n - 1, u = 1;
|
|
for(this[t + o] = r & 255; --o >= 0 && (u *= 256);)this[t + o] = r / u & 255;
|
|
return t + n;
|
|
};
|
|
h.prototype.writeUint8 = h.prototype.writeUInt8 = function(r, t, n) {
|
|
return r = +r, t = t >>> 0, n || y(this, r, t, 1, 255, 0), this[t] = r & 255, t + 1;
|
|
};
|
|
h.prototype.writeUint16LE = h.prototype.writeUInt16LE = function(r, t, n) {
|
|
return r = +r, t = t >>> 0, n || y(this, r, t, 2, 65535, 0), this[t] = r & 255, this[t + 1] = r >>> 8, t + 2;
|
|
};
|
|
h.prototype.writeUint16BE = h.prototype.writeUInt16BE = function(r, t, n) {
|
|
return r = +r, t = t >>> 0, n || y(this, r, t, 2, 65535, 0), this[t] = r >>> 8, this[t + 1] = r & 255, t + 2;
|
|
};
|
|
h.prototype.writeUint32LE = h.prototype.writeUInt32LE = function(r, t, n) {
|
|
return r = +r, t = t >>> 0, n || y(this, r, t, 4, 4294967295, 0), this[t + 3] = r >>> 24, this[t + 2] = r >>> 16, this[t + 1] = r >>> 8, this[t] = r & 255, t + 4;
|
|
};
|
|
h.prototype.writeUint32BE = h.prototype.writeUInt32BE = function(r, t, n) {
|
|
return r = +r, t = t >>> 0, n || y(this, r, t, 4, 4294967295, 0), this[t] = r >>> 24, this[t + 1] = r >>> 16, this[t + 2] = r >>> 8, this[t + 3] = r & 255, t + 4;
|
|
};
|
|
function cr(i, r, t, n, e) {
|
|
yr(r, n, e, i, t, 7);
|
|
let o = Number(r & BigInt(4294967295));
|
|
i[t++] = o, o = o >> 8, i[t++] = o, o = o >> 8, i[t++] = o, o = o >> 8, i[t++] = o;
|
|
let u = Number(r >> BigInt(32) & BigInt(4294967295));
|
|
return i[t++] = u, u = u >> 8, i[t++] = u, u = u >> 8, i[t++] = u, u = u >> 8, i[t++] = u, t;
|
|
}
|
|
function pr(i, r, t, n, e) {
|
|
yr(r, n, e, i, t, 7);
|
|
let o = Number(r & BigInt(4294967295));
|
|
i[t + 7] = o, o = o >> 8, i[t + 6] = o, o = o >> 8, i[t + 5] = o, o = o >> 8, i[t + 4] = o;
|
|
let u = Number(r >> BigInt(32) & BigInt(4294967295));
|
|
return i[t + 3] = u, u = u >> 8, i[t + 2] = u, u = u >> 8, i[t + 1] = u, u = u >> 8, i[t] = u, t + 8;
|
|
}
|
|
h.prototype.writeBigUInt64LE = g(function(r, t = 0) {
|
|
return cr(this, r, t, BigInt(0), BigInt("0xffffffffffffffff"));
|
|
});
|
|
h.prototype.writeBigUInt64BE = g(function(r, t = 0) {
|
|
return pr(this, r, t, BigInt(0), BigInt("0xffffffffffffffff"));
|
|
});
|
|
h.prototype.writeIntLE = function(r, t, n, e) {
|
|
if (r = +r, t = t >>> 0, !e) {
|
|
let c = Math.pow(2, 8 * n - 1);
|
|
y(this, r, t, n, c - 1, -c);
|
|
}
|
|
let o = 0, u = 1, f = 0;
|
|
for(this[t] = r & 255; ++o < n && (u *= 256);)r < 0 && f === 0 && this[t + o - 1] !== 0 && (f = 1), this[t + o] = (r / u >> 0) - f & 255;
|
|
return t + n;
|
|
};
|
|
h.prototype.writeIntBE = function(r, t, n, e) {
|
|
if (r = +r, t = t >>> 0, !e) {
|
|
let c = Math.pow(2, 8 * n - 1);
|
|
y(this, r, t, n, c - 1, -c);
|
|
}
|
|
let o = n - 1, u = 1, f = 0;
|
|
for(this[t + o] = r & 255; --o >= 0 && (u *= 256);)r < 0 && f === 0 && this[t + o + 1] !== 0 && (f = 1), this[t + o] = (r / u >> 0) - f & 255;
|
|
return t + n;
|
|
};
|
|
h.prototype.writeInt8 = function(r, t, n) {
|
|
return r = +r, t = t >>> 0, n || y(this, r, t, 1, 127, -128), r < 0 && (r = 255 + r + 1), this[t] = r & 255, t + 1;
|
|
};
|
|
h.prototype.writeInt16LE = function(r, t, n) {
|
|
return r = +r, t = t >>> 0, n || y(this, r, t, 2, 32767, -32768), this[t] = r & 255, this[t + 1] = r >>> 8, t + 2;
|
|
};
|
|
h.prototype.writeInt16BE = function(r, t, n) {
|
|
return r = +r, t = t >>> 0, n || y(this, r, t, 2, 32767, -32768), this[t] = r >>> 8, this[t + 1] = r & 255, t + 2;
|
|
};
|
|
h.prototype.writeInt32LE = function(r, t, n) {
|
|
return r = +r, t = t >>> 0, n || y(this, r, t, 4, 2147483647, -2147483648), this[t] = r & 255, this[t + 1] = r >>> 8, this[t + 2] = r >>> 16, this[t + 3] = r >>> 24, t + 4;
|
|
};
|
|
h.prototype.writeInt32BE = function(r, t, n) {
|
|
return r = +r, t = t >>> 0, n || y(this, r, t, 4, 2147483647, -2147483648), r < 0 && (r = 4294967295 + r + 1), this[t] = r >>> 24, this[t + 1] = r >>> 16, this[t + 2] = r >>> 8, this[t + 3] = r & 255, t + 4;
|
|
};
|
|
h.prototype.writeBigInt64LE = g(function(r, t = 0) {
|
|
return cr(this, r, t, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
|
|
});
|
|
h.prototype.writeBigInt64BE = g(function(r, t = 0) {
|
|
return pr(this, r, t, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
|
|
});
|
|
function sr(i, r, t, n, e, o) {
|
|
if (t + n > i.length) throw new RangeError("Index out of range");
|
|
if (t < 0) throw new RangeError("Index out of range");
|
|
}
|
|
function lr(i, r, t, n, e) {
|
|
return r = +r, t = t >>> 0, e || sr(i, r, t, 4, 34028234663852886e22, -340282346638528860000000000000000000000), U.write(i, r, t, n, 23, 4), t + 4;
|
|
}
|
|
h.prototype.writeFloatLE = function(r, t, n) {
|
|
return lr(this, r, t, !0, n);
|
|
};
|
|
h.prototype.writeFloatBE = function(r, t, n) {
|
|
return lr(this, r, t, !1, n);
|
|
};
|
|
function ar(i, r, t, n, e) {
|
|
return r = +r, t = t >>> 0, e || sr(i, r, t, 8, 17976931348623157e292, -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000), U.write(i, r, t, n, 52, 8), t + 8;
|
|
}
|
|
h.prototype.writeDoubleLE = function(r, t, n) {
|
|
return ar(this, r, t, !0, n);
|
|
};
|
|
h.prototype.writeDoubleBE = function(r, t, n) {
|
|
return ar(this, r, t, !1, n);
|
|
};
|
|
h.prototype.copy = function(r, t, n, e) {
|
|
if (!h.isBuffer(r)) throw new TypeError("argument should be a Buffer");
|
|
if (n || (n = 0), !e && e !== 0 && (e = this.length), t >= r.length && (t = r.length), t || (t = 0), e > 0 && e < n && (e = n), e === n || r.length === 0 || this.length === 0) return 0;
|
|
if (t < 0) throw new RangeError("targetStart out of bounds");
|
|
if (n < 0 || n >= this.length) throw new RangeError("Index out of range");
|
|
if (e < 0) throw new RangeError("sourceEnd out of bounds");
|
|
e > this.length && (e = this.length), r.length - t < e - n && (e = r.length - t + n);
|
|
let o = e - n;
|
|
return this === r && typeof Uint8Array.prototype.copyWithin == "function" ? this.copyWithin(t, n, e) : Uint8Array.prototype.set.call(r, this.subarray(n, e), t), o;
|
|
};
|
|
h.prototype.fill = function(r, t, n, e) {
|
|
if (typeof r == "string") {
|
|
if (typeof t == "string" ? (e = t, t = 0, n = this.length) : typeof n == "string" && (e = n, n = this.length), e !== void 0 && typeof e != "string") throw new TypeError("encoding must be a string");
|
|
if (typeof e == "string" && !h.isEncoding(e)) throw new TypeError("Unknown encoding: " + e);
|
|
if (r.length === 1) {
|
|
let u = r.charCodeAt(0);
|
|
(e === "utf8" && u < 128 || e === "latin1") && (r = u);
|
|
}
|
|
} else typeof r == "number" ? r = r & 255 : typeof r == "boolean" && (r = Number(r));
|
|
if (t < 0 || this.length < t || this.length < n) throw new RangeError("Out of range index");
|
|
if (n <= t) return this;
|
|
t = t >>> 0, n = n === void 0 ? this.length : n >>> 0, r || (r = 0);
|
|
let o;
|
|
if (typeof r == "number") for(o = t; o < n; ++o)this[o] = r;
|
|
else {
|
|
let u = h.isBuffer(r) ? r : h.from(r, e), f = u.length;
|
|
if (f === 0) throw new TypeError('The value "' + r + '" is invalid for argument "value"');
|
|
for(o = 0; o < n - t; ++o)this[o + t] = u[o % f];
|
|
}
|
|
return this;
|
|
};
|
|
var A = {};
|
|
function V(i, r, t) {
|
|
A[i] = class extends t {
|
|
constructor(){
|
|
super(), Object.defineProperty(this, "message", {
|
|
value: r.apply(this, arguments),
|
|
writable: !0,
|
|
configurable: !0
|
|
}), this.name = `${this.name} [${i}]`, this.stack, delete this.name;
|
|
}
|
|
get code() {
|
|
return i;
|
|
}
|
|
set code(e) {
|
|
Object.defineProperty(this, "code", {
|
|
configurable: !0,
|
|
enumerable: !0,
|
|
value: e,
|
|
writable: !0
|
|
});
|
|
}
|
|
toString() {
|
|
return `${this.name} [${i}]: ${this.message}`;
|
|
}
|
|
};
|
|
}
|
|
V("ERR_BUFFER_OUT_OF_BOUNDS", function(i) {
|
|
return i ? `${i} is outside of buffer bounds` : "Attempt to access memory outside buffer bounds";
|
|
}, RangeError);
|
|
V("ERR_INVALID_ARG_TYPE", function(i, r) {
|
|
return `The "${i}" argument must be of type number. Received type ${typeof r}`;
|
|
}, TypeError);
|
|
V("ERR_OUT_OF_RANGE", function(i, r, t) {
|
|
let n = `The value of "${i}" is out of range.`, e = t;
|
|
return Number.isInteger(t) && Math.abs(t) > 2 ** 32 ? e = nr(String(t)) : typeof t == "bigint" && (e = String(t), (t > BigInt(2) ** BigInt(32) || t < -(BigInt(2) ** BigInt(32))) && (e = nr(e)), e += "n"), n += ` It must be ${r}. Received ${e}`, n;
|
|
}, RangeError);
|
|
function nr(i) {
|
|
let r = "", t = i.length, n = i[0] === "-" ? 1 : 0;
|
|
for(; t >= n + 4; t -= 3)r = `_${i.slice(t - 3, t)}${r}`;
|
|
return `${i.slice(0, t)}${r}`;
|
|
}
|
|
function Kr(i, r, t) {
|
|
R(r, "offset"), (i[r] === void 0 || i[r + t] === void 0) && _(r, i.length - (t + 1));
|
|
}
|
|
function yr(i, r, t, n, e, o) {
|
|
if (i > t || i < r) {
|
|
let u = typeof r == "bigint" ? "n" : "", f;
|
|
throw o > 3 ? r === 0 || r === BigInt(0) ? f = `>= 0${u} and < 2${u} ** ${(o + 1) * 8}${u}` : f = `>= -(2${u} ** ${(o + 1) * 8 - 1}${u}) and < 2 ** ${(o + 1) * 8 - 1}${u}` : f = `>= ${r}${u} and <= ${t}${u}`, new A.ERR_OUT_OF_RANGE("value", f, i);
|
|
}
|
|
Kr(n, e, o);
|
|
}
|
|
function R(i, r) {
|
|
if (typeof i != "number") throw new A.ERR_INVALID_ARG_TYPE(r, "number", i);
|
|
}
|
|
function _(i, r, t) {
|
|
throw Math.floor(i) !== i ? (R(i, t), new A.ERR_OUT_OF_RANGE(t || "offset", "an integer", i)) : r < 0 ? new A.ERR_BUFFER_OUT_OF_BOUNDS : new A.ERR_OUT_OF_RANGE(t || "offset", `>= ${t ? 1 : 0} and <= ${r}`, i);
|
|
}
|
|
var Zr = /[^+/0-9A-Za-z-_]/g;
|
|
function Qr(i) {
|
|
if (i = i.split("=")[0], i = i.trim().replace(Zr, ""), i.length < 2) return "";
|
|
for(; i.length % 4 !== 0;)i = i + "=";
|
|
return i;
|
|
}
|
|
function W(i, r) {
|
|
r = r || 1 / 0;
|
|
let t, n = i.length, e = null, o = [];
|
|
for(let u = 0; u < n; ++u){
|
|
if (t = i.charCodeAt(u), t > 55295 && t < 57344) {
|
|
if (!e) {
|
|
if (t > 56319) {
|
|
(r -= 3) > -1 && o.push(239, 191, 189);
|
|
continue;
|
|
} else if (u + 1 === n) {
|
|
(r -= 3) > -1 && o.push(239, 191, 189);
|
|
continue;
|
|
}
|
|
e = t;
|
|
continue;
|
|
}
|
|
if (t < 56320) {
|
|
(r -= 3) > -1 && o.push(239, 191, 189), e = t;
|
|
continue;
|
|
}
|
|
t = (e - 55296 << 10 | t - 56320) + 65536;
|
|
} else e && (r -= 3) > -1 && o.push(239, 191, 189);
|
|
if (e = null, t < 128) {
|
|
if ((r -= 1) < 0) break;
|
|
o.push(t);
|
|
} else if (t < 2048) {
|
|
if ((r -= 2) < 0) break;
|
|
o.push(t >> 6 | 192, t & 63 | 128);
|
|
} else if (t < 65536) {
|
|
if ((r -= 3) < 0) break;
|
|
o.push(t >> 12 | 224, t >> 6 & 63 | 128, t & 63 | 128);
|
|
} else if (t < 1114112) {
|
|
if ((r -= 4) < 0) break;
|
|
o.push(t >> 18 | 240, t >> 12 & 63 | 128, t >> 6 & 63 | 128, t & 63 | 128);
|
|
} else throw new Error("Invalid code point");
|
|
}
|
|
return o;
|
|
}
|
|
function vr(i) {
|
|
let r = [];
|
|
for(let t = 0; t < i.length; ++t)r.push(i.charCodeAt(t) & 255);
|
|
return r;
|
|
}
|
|
function rt(i, r) {
|
|
let t, n, e, o = [];
|
|
for(let u = 0; u < i.length && !((r -= 2) < 0); ++u)t = i.charCodeAt(u), n = t >> 8, e = t % 256, o.push(e), o.push(n);
|
|
return o;
|
|
}
|
|
function wr(i) {
|
|
return G.toByteArray(Qr(i));
|
|
}
|
|
function D(i, r, t, n) {
|
|
let e;
|
|
for(e = 0; e < n && !(e + t >= r.length || e >= i.length); ++e)r[e + t] = i[e];
|
|
return e;
|
|
}
|
|
function E(i, r) {
|
|
return i instanceof r || i != null && i.constructor != null && i.constructor.name != null && i.constructor.name === r.name;
|
|
}
|
|
function X(i) {
|
|
return i !== i;
|
|
}
|
|
var tt = function() {
|
|
let i = "0123456789abcdef", r = new Array(256);
|
|
for(let t = 0; t < 16; ++t){
|
|
let n = t * 16;
|
|
for(let e = 0; e < 16; ++e)r[n + e] = i[t] + i[e];
|
|
}
|
|
return r;
|
|
}();
|
|
function g(i) {
|
|
return typeof BigInt > "u" ? it : i;
|
|
}
|
|
function it() {
|
|
throw new Error("BigInt not supported");
|
|
}
|
|
});
|
|
var C = {};
|
|
Fr(C, {
|
|
default: ()=>nt
|
|
});
|
|
module.exports = Ar(C);
|
|
var xr = J(z());
|
|
S(C, J(z()), module.exports);
|
|
var nt = xr.default; /*! Bundled license information:
|
|
|
|
ieee754/index.js:
|
|
(*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)
|
|
|
|
buffer/index.js:
|
|
(*!
|
|
* The buffer module from node.js, for the browser.
|
|
*
|
|
* @author Feross Aboukhadijeh <https://feross.org>
|
|
* @license MIT
|
|
*)
|
|
*/
|
|
|
|
},{}],"iIXqM":[function(require,module,exports) {
|
|
exports.interopDefault = function(a) {
|
|
return a && a.__esModule ? a : {
|
|
default: a
|
|
};
|
|
};
|
|
exports.defineInteropFlag = function(a) {
|
|
Object.defineProperty(a, "__esModule", {
|
|
value: true
|
|
});
|
|
};
|
|
exports.exportAll = function(source, dest) {
|
|
Object.keys(source).forEach(function(key) {
|
|
if (key === "default" || key === "__esModule" || dest.hasOwnProperty(key)) return;
|
|
Object.defineProperty(dest, key, {
|
|
enumerable: true,
|
|
get: function() {
|
|
return source[key];
|
|
}
|
|
});
|
|
});
|
|
return dest;
|
|
};
|
|
exports.export = function(dest, destName, get) {
|
|
Object.defineProperty(dest, destName, {
|
|
enumerable: true,
|
|
get: get
|
|
});
|
|
};
|
|
|
|
},{}],"2Dd9W":[function(require,module,exports) {
|
|
/*! formdata-polyfill. MIT License. Jimmy W\u00e4rting <https://jimmy.warting.se/opensource> */ var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
parcelHelpers.export(exports, "File", ()=>File);
|
|
parcelHelpers.export(exports, "FormData", ()=>FormData);
|
|
/** @param {FormData} F */ parcelHelpers.export(exports, "formDataToBlob", ()=>formDataToBlob);
|
|
var _fetchBlob = require("fetch-blob");
|
|
var _fetchBlobDefault = parcelHelpers.interopDefault(_fetchBlob);
|
|
var _fileJs = require("fetch-blob/file.js");
|
|
var _fileJsDefault = parcelHelpers.interopDefault(_fileJs);
|
|
var { toStringTag: t, iterator: i, hasInstance: h } = Symbol, r = Math.random, m = "append,set,get,getAll,delete,keys,values,entries,forEach,constructor".split(","), f = (a, b, c)=>(a += "", /^(Blob|File)$/.test(b && b[t]) ? [
|
|
(c = c !== void 0 ? c + "" : b[t] == "File" ? b.name : "blob", a),
|
|
b.name !== c || b[t] == "blob" ? new (0, _fileJsDefault.default)([
|
|
b
|
|
], c, b) : b
|
|
] : [
|
|
a,
|
|
b + ""
|
|
]), e = (c, f)=>(f ? c : c.replace(/\r?\n|\r/g, "\r\n")).replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"), x = (n, a, e)=>{
|
|
if (a.length < e) throw new TypeError(`Failed to execute '${n}' on 'FormData': ${e} arguments required, but only ${a.length} present.`);
|
|
};
|
|
const File = (0, _fileJsDefault.default);
|
|
const FormData = class FormData {
|
|
#d = [];
|
|
constructor(...a){
|
|
if (a.length) throw new TypeError(`Failed to construct 'FormData': parameter 1 is not of type 'HTMLFormElement'.`);
|
|
}
|
|
get [t]() {
|
|
return "FormData";
|
|
}
|
|
[i]() {
|
|
return this.entries();
|
|
}
|
|
static [h](o) {
|
|
return o && typeof o === "object" && o[t] === "FormData" && !m.some((m)=>typeof o[m] != "function");
|
|
}
|
|
append(...a) {
|
|
x("append", arguments, 2);
|
|
this.#d.push(f(...a));
|
|
}
|
|
delete(a) {
|
|
x("delete", arguments, 1);
|
|
a += "";
|
|
this.#d = this.#d.filter(([b])=>b !== a);
|
|
}
|
|
get(a) {
|
|
x("get", arguments, 1);
|
|
a += "";
|
|
for(var b = this.#d, l = b.length, c = 0; c < l; c++)if (b[c][0] === a) return b[c][1];
|
|
return null;
|
|
}
|
|
getAll(a, b) {
|
|
x("getAll", arguments, 1);
|
|
b = [];
|
|
a += "";
|
|
this.#d.forEach((c)=>c[0] === a && b.push(c[1]));
|
|
return b;
|
|
}
|
|
has(a) {
|
|
x("has", arguments, 1);
|
|
a += "";
|
|
return this.#d.some((b)=>b[0] === a);
|
|
}
|
|
forEach(a, b) {
|
|
x("forEach", arguments, 1);
|
|
for (var [c, d] of this)a.call(b, d, c, this);
|
|
}
|
|
set(...a) {
|
|
x("set", arguments, 2);
|
|
var b = [], c = !0;
|
|
a = f(...a);
|
|
this.#d.forEach((d)=>{
|
|
d[0] === a[0] ? c && (c = !b.push(a)) : b.push(d);
|
|
});
|
|
c && b.push(a);
|
|
this.#d = b;
|
|
}
|
|
*entries() {
|
|
yield* this.#d;
|
|
}
|
|
*keys() {
|
|
for (var [a] of this)yield a;
|
|
}
|
|
*values() {
|
|
for (var [, a] of this)yield a;
|
|
}
|
|
};
|
|
function formDataToBlob(F, B = (0, _fetchBlobDefault.default)) {
|
|
var b = `${r()}${r()}`.replace(/\./g, "").slice(-28).padStart(32, "-"), c = [], p = `--${b}\r\nContent-Disposition: form-data; name="`;
|
|
F.forEach((v, n)=>typeof v == "string" ? c.push(p + e(n) + `"\r\n\r\n${v.replace(/\r(?!\n)|(?<!\r)\n/g, "\r\n")}\r\n`) : c.push(p + e(n) + `"; filename="${e(v.name, 1)}"\r\nContent-Type: ${v.type || "application/octet-stream"}\r\n\r\n`, v, "\r\n"));
|
|
c.push(`--${b}--`);
|
|
return new B(c, {
|
|
type: "multipart/form-data; boundary=" + b
|
|
});
|
|
}
|
|
|
|
},{"fetch-blob":"gejxf","fetch-blob/file.js":"akf6n","@parcel/transformer-js/src/esmodule-helpers.js":"iIXqM"}]},["KxAZI"], "KxAZI", "parcelRequireae38")
|
|
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"mappings":"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","sources":["node_modules/node-fetch/src/utils/multipart-parser.js","node_modules/fetch-blob/from.js","node_modules/@parcel/node-resolver-core/lib/_empty.js","node_modules/path-browserify/index.js","node_modules/@plasmohq/parcel-resolver/dist/polyfills/process.js","node_modules/node-domexception/index.js","node_modules/fetch-blob/file.js","node_modules/fetch-blob/index.js","node_modules/fetch-blob/streams.cjs","node_modules/web-streams-polyfill/dist/ponyfill.es2018.js","node_modules/web-streams-polyfill/src/stub/symbol.ts","node_modules/web-streams-polyfill/src/utils.ts","node_modules/web-streams-polyfill/src/lib/helpers/miscellaneous.ts","node_modules/web-streams-polyfill/src/lib/helpers/webidl.ts","node_modules/web-streams-polyfill/src/lib/simple-queue.ts","node_modules/web-streams-polyfill/src/lib/readable-stream/generic-reader.ts","node_modules/web-streams-polyfill/src/lib/abstract-ops/internal-methods.ts","node_modules/web-streams-polyfill/src/stub/number-isfinite.ts","node_modules/web-streams-polyfill/src/stub/math-trunc.ts","node_modules/web-streams-polyfill/src/lib/validators/basic.ts","node_modules/web-streams-polyfill/src/lib/validators/readable-stream.ts","node_modules/web-streams-polyfill/src/lib/readable-stream/default-reader.ts","node_modules/web-streams-polyfill/src/target/es2018/stub/async-iterator-prototype.ts","node_modules/web-streams-polyfill/src/lib/readable-stream/async-iterator.ts","node_modules/web-streams-polyfill/src/stub/number-isnan.ts","node_modules/web-streams-polyfill/src/lib/abstract-ops/ecmascript.ts","node_modules/web-streams-polyfill/src/lib/abstract-ops/miscellaneous.ts","node_modules/web-streams-polyfill/src/lib/abstract-ops/queue-with-sizes.ts","node_modules/web-streams-polyfill/src/lib/readable-stream/byte-stream-controller.ts","node_modules/web-streams-polyfill/src/lib/readable-stream/byob-reader.ts","node_modules/web-streams-polyfill/src/lib/abstract-ops/queuing-strategy.ts","node_modules/web-streams-polyfill/src/lib/validators/queuing-strategy.ts","node_modules/web-streams-polyfill/src/lib/validators/underlying-sink.ts","node_modules/web-streams-polyfill/src/lib/validators/writable-stream.ts","node_modules/web-streams-polyfill/src/lib/abort-signal.ts","node_modules/web-streams-polyfill/src/lib/writable-stream.ts","node_modules/web-streams-polyfill/src/stub/native.ts","node_modules/web-streams-polyfill/src/stub/dom-exception.ts","node_modules/web-streams-polyfill/src/lib/readable-stream/pipe.ts","node_modules/web-streams-polyfill/src/lib/readable-stream/default-controller.ts","node_modules/web-streams-polyfill/src/lib/readable-stream/tee.ts","node_modules/web-streams-polyfill/src/lib/validators/underlying-source.ts","node_modules/web-streams-polyfill/src/lib/validators/reader-options.ts","node_modules/web-streams-polyfill/src/lib/validators/iterator-options.ts","node_modules/web-streams-polyfill/src/lib/validators/pipe-options.ts","node_modules/web-streams-polyfill/src/lib/validators/readable-writable-pair.ts","node_modules/web-streams-polyfill/src/lib/readable-stream.ts","node_modules/web-streams-polyfill/src/lib/validators/queuing-strategy-init.ts","node_modules/web-streams-polyfill/src/lib/byte-length-queuing-strategy.ts","node_modules/web-streams-polyfill/src/lib/count-queuing-strategy.ts","node_modules/web-streams-polyfill/src/lib/validators/transformer.ts","node_modules/web-streams-polyfill/src/lib/transform-stream.ts","node_modules/@plasmohq/parcel-resolver/dist/polyfills/buffer.js","node_modules/@parcel/transformer-js/src/esmodule-helpers.js","node_modules/formdata-polyfill/esm.min.js"],"sourcesContent":["import {File} from 'fetch-blob/from.js';\nimport {FormData} from 'formdata-polyfill/esm.min.js';\n\nlet s = 0;\nconst S = {\n\tSTART_BOUNDARY: s++,\n\tHEADER_FIELD_START: s++,\n\tHEADER_FIELD: s++,\n\tHEADER_VALUE_START: s++,\n\tHEADER_VALUE: s++,\n\tHEADER_VALUE_ALMOST_DONE: s++,\n\tHEADERS_ALMOST_DONE: s++,\n\tPART_DATA_START: s++,\n\tPART_DATA: s++,\n\tEND: s++\n};\n\nlet f = 1;\nconst F = {\n\tPART_BOUNDARY: f,\n\tLAST_BOUNDARY: f *= 2\n};\n\nconst LF = 10;\nconst CR = 13;\nconst SPACE = 32;\nconst HYPHEN = 45;\nconst COLON = 58;\nconst A = 97;\nconst Z = 122;\n\nconst lower = c => c | 0x20;\n\nconst noop = () => {};\n\nclass MultipartParser {\n\t/**\n\t * @param {string} boundary\n\t */\n\tconstructor(boundary) {\n\t\tthis.index = 0;\n\t\tthis.flags = 0;\n\n\t\tthis.onHeaderEnd = noop;\n\t\tthis.onHeaderField = noop;\n\t\tthis.onHeadersEnd = noop;\n\t\tthis.onHeaderValue = noop;\n\t\tthis.onPartBegin = noop;\n\t\tthis.onPartData = noop;\n\t\tthis.onPartEnd = noop;\n\n\t\tthis.boundaryChars = {};\n\n\t\tboundary = '\\r\\n--' + boundary;\n\t\tconst ui8a = new Uint8Array(boundary.length);\n\t\tfor (let i = 0; i < boundary.length; i++) {\n\t\t\tui8a[i] = boundary.charCodeAt(i);\n\t\t\tthis.boundaryChars[ui8a[i]] = true;\n\t\t}\n\n\t\tthis.boundary = ui8a;\n\t\tthis.lookbehind = new Uint8Array(this.boundary.length + 8);\n\t\tthis.state = S.START_BOUNDARY;\n\t}\n\n\t/**\n\t * @param {Uint8Array} data\n\t */\n\twrite(data) {\n\t\tlet i = 0;\n\t\tconst length_ = data.length;\n\t\tlet previousIndex = this.index;\n\t\tlet {lookbehind, boundary, boundaryChars, index, state, flags} = this;\n\t\tconst boundaryLength = this.boundary.length;\n\t\tconst boundaryEnd = boundaryLength - 1;\n\t\tconst bufferLength = data.length;\n\t\tlet c;\n\t\tlet cl;\n\n\t\tconst mark = name => {\n\t\t\tthis[name + 'Mark'] = i;\n\t\t};\n\n\t\tconst clear = name => {\n\t\t\tdelete this[name + 'Mark'];\n\t\t};\n\n\t\tconst callback = (callbackSymbol, start, end, ui8a) => {\n\t\t\tif (start === undefined || start !== end) {\n\t\t\t\tthis[callbackSymbol](ui8a && ui8a.subarray(start, end));\n\t\t\t}\n\t\t};\n\n\t\tconst dataCallback = (name, clear) => {\n\t\t\tconst markSymbol = name + 'Mark';\n\t\t\tif (!(markSymbol in this)) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif (clear) {\n\t\t\t\tcallback(name, this[markSymbol], i, data);\n\t\t\t\tdelete this[markSymbol];\n\t\t\t} else {\n\t\t\t\tcallback(name, this[markSymbol], data.length, data);\n\t\t\t\tthis[markSymbol] = 0;\n\t\t\t}\n\t\t};\n\n\t\tfor (i = 0; i < length_; i++) {\n\t\t\tc = data[i];\n\n\t\t\tswitch (state) {\n\t\t\t\tcase S.START_BOUNDARY:\n\t\t\t\t\tif (index === boundary.length - 2) {\n\t\t\t\t\t\tif (c === HYPHEN) {\n\t\t\t\t\t\t\tflags |= F.LAST_BOUNDARY;\n\t\t\t\t\t\t} else if (c !== CR) {\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tindex++;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t} else if (index - 1 === boundary.length - 2) {\n\t\t\t\t\t\tif (flags & F.LAST_BOUNDARY && c === HYPHEN) {\n\t\t\t\t\t\t\tstate = S.END;\n\t\t\t\t\t\t\tflags = 0;\n\t\t\t\t\t\t} else if (!(flags & F.LAST_BOUNDARY) && c === LF) {\n\t\t\t\t\t\t\tindex = 0;\n\t\t\t\t\t\t\tcallback('onPartBegin');\n\t\t\t\t\t\t\tstate = S.HEADER_FIELD_START;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (c !== boundary[index + 2]) {\n\t\t\t\t\t\tindex = -2;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (c === boundary[index + 2]) {\n\t\t\t\t\t\tindex++;\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\tcase S.HEADER_FIELD_START:\n\t\t\t\t\tstate = S.HEADER_FIELD;\n\t\t\t\t\tmark('onHeaderField');\n\t\t\t\t\tindex = 0;\n\t\t\t\t\t// falls through\n\t\t\t\tcase S.HEADER_FIELD:\n\t\t\t\t\tif (c === CR) {\n\t\t\t\t\t\tclear('onHeaderField');\n\t\t\t\t\t\tstate = S.HEADERS_ALMOST_DONE;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\tindex++;\n\t\t\t\t\tif (c === HYPHEN) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (c === COLON) {\n\t\t\t\t\t\tif (index === 1) {\n\t\t\t\t\t\t\t// empty header field\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tdataCallback('onHeaderField', true);\n\t\t\t\t\t\tstate = S.HEADER_VALUE_START;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\tcl = lower(c);\n\t\t\t\t\tif (cl < A || cl > Z) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\tcase S.HEADER_VALUE_START:\n\t\t\t\t\tif (c === SPACE) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\tmark('onHeaderValue');\n\t\t\t\t\tstate = S.HEADER_VALUE;\n\t\t\t\t\t// falls through\n\t\t\t\tcase S.HEADER_VALUE:\n\t\t\t\t\tif (c === CR) {\n\t\t\t\t\t\tdataCallback('onHeaderValue', true);\n\t\t\t\t\t\tcallback('onHeaderEnd');\n\t\t\t\t\t\tstate = S.HEADER_VALUE_ALMOST_DONE;\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\tcase S.HEADER_VALUE_ALMOST_DONE:\n\t\t\t\t\tif (c !== LF) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\n\t\t\t\t\tstate = S.HEADER_FIELD_START;\n\t\t\t\t\tbreak;\n\t\t\t\tcase S.HEADERS_ALMOST_DONE:\n\t\t\t\t\tif (c !== LF) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\n\t\t\t\t\tcallback('onHeadersEnd');\n\t\t\t\t\tstate = S.PART_DATA_START;\n\t\t\t\t\tbreak;\n\t\t\t\tcase S.PART_DATA_START:\n\t\t\t\t\tstate = S.PART_DATA;\n\t\t\t\t\tmark('onPartData');\n\t\t\t\t\t// falls through\n\t\t\t\tcase S.PART_DATA:\n\t\t\t\t\tpreviousIndex = index;\n\n\t\t\t\t\tif (index === 0) {\n\t\t\t\t\t\t// boyer-moore derrived algorithm to safely skip non-boundary data\n\t\t\t\t\t\ti += boundaryEnd;\n\t\t\t\t\t\twhile (i < bufferLength && !(data[i] in boundaryChars)) {\n\t\t\t\t\t\t\ti += boundaryLength;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\ti -= boundaryEnd;\n\t\t\t\t\t\tc = data[i];\n\t\t\t\t\t}\n\n\t\t\t\t\tif (index < boundary.length) {\n\t\t\t\t\t\tif (boundary[index] === c) {\n\t\t\t\t\t\t\tif (index === 0) {\n\t\t\t\t\t\t\t\tdataCallback('onPartData', true);\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tindex++;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tindex = 0;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if (index === boundary.length) {\n\t\t\t\t\t\tindex++;\n\t\t\t\t\t\tif (c === CR) {\n\t\t\t\t\t\t\t// CR = part boundary\n\t\t\t\t\t\t\tflags |= F.PART_BOUNDARY;\n\t\t\t\t\t\t} else if (c === HYPHEN) {\n\t\t\t\t\t\t\t// HYPHEN = end boundary\n\t\t\t\t\t\t\tflags |= F.LAST_BOUNDARY;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tindex = 0;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if (index - 1 === boundary.length) {\n\t\t\t\t\t\tif (flags & F.PART_BOUNDARY) {\n\t\t\t\t\t\t\tindex = 0;\n\t\t\t\t\t\t\tif (c === LF) {\n\t\t\t\t\t\t\t\t// unset the PART_BOUNDARY flag\n\t\t\t\t\t\t\t\tflags &= ~F.PART_BOUNDARY;\n\t\t\t\t\t\t\t\tcallback('onPartEnd');\n\t\t\t\t\t\t\t\tcallback('onPartBegin');\n\t\t\t\t\t\t\t\tstate = S.HEADER_FIELD_START;\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else if (flags & F.LAST_BOUNDARY) {\n\t\t\t\t\t\t\tif (c === HYPHEN) {\n\t\t\t\t\t\t\t\tcallback('onPartEnd');\n\t\t\t\t\t\t\t\tstate = S.END;\n\t\t\t\t\t\t\t\tflags = 0;\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tindex = 0;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tindex = 0;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tif (index > 0) {\n\t\t\t\t\t\t// when matching a possible boundary, keep a lookbehind reference\n\t\t\t\t\t\t// in case it turns out to be a false lead\n\t\t\t\t\t\tlookbehind[index - 1] = c;\n\t\t\t\t\t} else if (previousIndex > 0) {\n\t\t\t\t\t\t// if our boundary turned out to be rubbish, the captured lookbehind\n\t\t\t\t\t\t// belongs to partData\n\t\t\t\t\t\tconst _lookbehind = new Uint8Array(lookbehind.buffer, lookbehind.byteOffset, lookbehind.byteLength);\n\t\t\t\t\t\tcallback('onPartData', 0, previousIndex, _lookbehind);\n\t\t\t\t\t\tpreviousIndex = 0;\n\t\t\t\t\t\tmark('onPartData');\n\n\t\t\t\t\t\t// reconsider the current character even so it interrupted the sequence\n\t\t\t\t\t\t// it could be the beginning of a new sequence\n\t\t\t\t\t\ti--;\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\tcase S.END:\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tthrow new Error(`Unexpected state entered: ${state}`);\n\t\t\t}\n\t\t}\n\n\t\tdataCallback('onHeaderField');\n\t\tdataCallback('onHeaderValue');\n\t\tdataCallback('onPartData');\n\n\t\t// Update properties for the next call\n\t\tthis.index = index;\n\t\tthis.state = state;\n\t\tthis.flags = flags;\n\t}\n\n\tend() {\n\t\tif ((this.state === S.HEADER_FIELD_START && this.index === 0) ||\n\t\t\t(this.state === S.PART_DATA && this.index === this.boundary.length)) {\n\t\t\tthis.onPartEnd();\n\t\t} else if (this.state !== S.END) {\n\t\t\tthrow new Error('MultipartParser.end(): stream ended unexpectedly');\n\t\t}\n\t}\n}\n\nfunction _fileName(headerValue) {\n\t// matches either a quoted-string or a token (RFC 2616 section 19.5.1)\n\tconst m = headerValue.match(/\\bfilename=(\"(.*?)\"|([^()<>@,;:\\\\\"/[\\]?={}\\s\\t]+))($|;\\s)/i);\n\tif (!m) {\n\t\treturn;\n\t}\n\n\tconst match = m[2] || m[3] || '';\n\tlet filename = match.slice(match.lastIndexOf('\\\\') + 1);\n\tfilename = filename.replace(/%22/g, '\"');\n\tfilename = filename.replace(/&#(\\d{4});/g, (m, code) => {\n\t\treturn String.fromCharCode(code);\n\t});\n\treturn filename;\n}\n\nexport async function toFormData(Body, ct) {\n\tif (!/multipart/i.test(ct)) {\n\t\tthrow new TypeError('Failed to fetch');\n\t}\n\n\tconst m = ct.match(/boundary=(?:\"([^\"]+)\"|([^;]+))/i);\n\n\tif (!m) {\n\t\tthrow new TypeError('no or bad content-type header, no multipart boundary');\n\t}\n\n\tconst parser = new MultipartParser(m[1] || m[2]);\n\n\tlet headerField;\n\tlet headerValue;\n\tlet entryValue;\n\tlet entryName;\n\tlet contentType;\n\tlet filename;\n\tconst entryChunks = [];\n\tconst formData = new FormData();\n\n\tconst onPartData = ui8a => {\n\t\tentryValue += decoder.decode(ui8a, {stream: true});\n\t};\n\n\tconst appendToFile = ui8a => {\n\t\tentryChunks.push(ui8a);\n\t};\n\n\tconst appendFileToFormData = () => {\n\t\tconst file = new File(entryChunks, filename, {type: contentType});\n\t\tformData.append(entryName, file);\n\t};\n\n\tconst appendEntryToFormData = () => {\n\t\tformData.append(entryName, entryValue);\n\t};\n\n\tconst decoder = new TextDecoder('utf-8');\n\tdecoder.decode();\n\n\tparser.onPartBegin = function () {\n\t\tparser.onPartData = onPartData;\n\t\tparser.onPartEnd = appendEntryToFormData;\n\n\t\theaderField = '';\n\t\theaderValue = '';\n\t\tentryValue = '';\n\t\tentryName = '';\n\t\tcontentType = '';\n\t\tfilename = null;\n\t\tentryChunks.length = 0;\n\t};\n\n\tparser.onHeaderField = function (ui8a) {\n\t\theaderField += decoder.decode(ui8a, {stream: true});\n\t};\n\n\tparser.onHeaderValue = function (ui8a) {\n\t\theaderValue += decoder.decode(ui8a, {stream: true});\n\t};\n\n\tparser.onHeaderEnd = function () {\n\t\theaderValue += decoder.decode();\n\t\theaderField = headerField.toLowerCase();\n\n\t\tif (headerField === 'content-disposition') {\n\t\t\t// matches either a quoted-string or a token (RFC 2616 section 19.5.1)\n\t\t\tconst m = headerValue.match(/\\bname=(\"([^\"]*)\"|([^()<>@,;:\\\\\"/[\\]?={}\\s\\t]+))/i);\n\n\t\t\tif (m) {\n\t\t\t\tentryName = m[2] || m[3] || '';\n\t\t\t}\n\n\t\t\tfilename = _fileName(headerValue);\n\n\t\t\tif (filename) {\n\t\t\t\tparser.onPartData = appendToFile;\n\t\t\t\tparser.onPartEnd = appendFileToFormData;\n\t\t\t}\n\t\t} else if (headerField === 'content-type') {\n\t\t\tcontentType = headerValue;\n\t\t}\n\n\t\theaderValue = '';\n\t\theaderField = '';\n\t};\n\n\tfor await (const chunk of Body) {\n\t\tparser.write(chunk);\n\t}\n\n\tparser.end();\n\n\treturn formData;\n}\n","import { statSync, createReadStream, promises as fs } from 'node:fs'\nimport { basename } from 'node:path'\nimport DOMException from 'node-domexception'\n\nimport File from './file.js'\nimport Blob from './index.js'\n\nconst { stat } = fs\n\n/**\n * @param {string} path filepath on the disk\n * @param {string} [type] mimetype to use\n */\nconst blobFromSync = (path, type) => fromBlob(statSync(path), path, type)\n\n/**\n * @param {string} path filepath on the disk\n * @param {string} [type] mimetype to use\n * @returns {Promise<Blob>}\n */\nconst blobFrom = (path, type) => stat(path).then(stat => fromBlob(stat, path, type))\n\n/**\n * @param {string} path filepath on the disk\n * @param {string} [type] mimetype to use\n * @returns {Promise<File>}\n */\nconst fileFrom = (path, type) => stat(path).then(stat => fromFile(stat, path, type))\n\n/**\n * @param {string} path filepath on the disk\n * @param {string} [type] mimetype to use\n */\nconst fileFromSync = (path, type) => fromFile(statSync(path), path, type)\n\n// @ts-ignore\nconst fromBlob = (stat, path, type = '') => new Blob([new BlobDataItem({\n  path,\n  size: stat.size,\n  lastModified: stat.mtimeMs,\n  start: 0\n})], { type })\n\n// @ts-ignore\nconst fromFile = (stat, path, type = '') => new File([new BlobDataItem({\n  path,\n  size: stat.size,\n  lastModified: stat.mtimeMs,\n  start: 0\n})], basename(path), { type, lastModified: stat.mtimeMs })\n\n/**\n * This is a blob backed up by a file on the disk\n * with minium requirement. Its wrapped around a Blob as a blobPart\n * so you have no direct access to this.\n *\n * @private\n */\nclass BlobDataItem {\n  #path\n  #start\n\n  constructor (options) {\n    this.#path = options.path\n    this.#start = options.start\n    this.size = options.size\n    this.lastModified = options.lastModified\n  }\n\n  /**\n   * Slicing arguments is first validated and formatted\n   * to not be out of range by Blob.prototype.slice\n   */\n  slice (start, end) {\n    return new BlobDataItem({\n      path: this.#path,\n      lastModified: this.lastModified,\n      size: end - start,\n      start: this.#start + start\n    })\n  }\n\n  async * stream () {\n    const { mtimeMs } = await stat(this.#path)\n    if (mtimeMs > this.lastModified) {\n      throw new DOMException('The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.', 'NotReadableError')\n    }\n    yield * createReadStream(this.#path, {\n      start: this.#start,\n      end: this.#start + this.size - 1\n    })\n  }\n\n  get [Symbol.toStringTag] () {\n    return 'Blob'\n  }\n}\n\nexport default blobFromSync\nexport { File, Blob, blobFrom, blobFromSync, fileFrom, fileFromSync }\n","\"use strict\";","// 'path' module extracted from Node.js v8.11.1 (only the posix part)\n// transplited with Babel\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));\n  }\n}\n\n// Resolves . and .. elements in a path with directory names\nfunction normalizeStringPosix(path, allowAboveRoot) {\n  var res = '';\n  var lastSegmentLength = 0;\n  var lastSlash = -1;\n  var dots = 0;\n  var code;\n  for (var i = 0; i <= path.length; ++i) {\n    if (i < path.length)\n      code = path.charCodeAt(i);\n    else if (code === 47 /*/*/)\n      break;\n    else\n      code = 47 /*/*/;\n    if (code === 47 /*/*/) {\n      if (lastSlash === i - 1 || dots === 1) {\n        // NOOP\n      } else if (lastSlash !== i - 1 && dots === 2) {\n        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {\n          if (res.length > 2) {\n            var lastSlashIndex = res.lastIndexOf('/');\n            if (lastSlashIndex !== res.length - 1) {\n              if (lastSlashIndex === -1) {\n                res = '';\n                lastSegmentLength = 0;\n              } else {\n                res = res.slice(0, lastSlashIndex);\n                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');\n              }\n              lastSlash = i;\n              dots = 0;\n              continue;\n            }\n          } else if (res.length === 2 || res.length === 1) {\n            res = '';\n            lastSegmentLength = 0;\n            lastSlash = i;\n            dots = 0;\n            continue;\n          }\n        }\n        if (allowAboveRoot) {\n          if (res.length > 0)\n            res += '/..';\n          else\n            res = '..';\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (res.length > 0)\n          res += '/' + path.slice(lastSlash + 1, i);\n        else\n          res = path.slice(lastSlash + 1, i);\n        lastSegmentLength = i - lastSlash - 1;\n      }\n      lastSlash = i;\n      dots = 0;\n    } else if (code === 46 /*.*/ && dots !== -1) {\n      ++dots;\n    } else {\n      dots = -1;\n    }\n  }\n  return res;\n}\n\nfunction _format(sep, pathObject) {\n  var dir = pathObject.dir || pathObject.root;\n  var base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '');\n  if (!dir) {\n    return base;\n  }\n  if (dir === pathObject.root) {\n    return dir + base;\n  }\n  return dir + sep + base;\n}\n\nvar posix = {\n  // path.resolve([from ...], to)\n  resolve: function resolve() {\n    var resolvedPath = '';\n    var resolvedAbsolute = false;\n    var cwd;\n\n    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n      var path;\n      if (i >= 0)\n        path = arguments[i];\n      else {\n        if (cwd === undefined)\n          cwd = process.cwd();\n        path = cwd;\n      }\n\n      assertPath(path);\n\n      // Skip empty entries\n      if (path.length === 0) {\n        continue;\n      }\n\n      resolvedPath = path + '/' + resolvedPath;\n      resolvedAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    }\n\n    // At this point the path should be resolved to a full absolute path, but\n    // handle relative paths to be safe (might happen when process.cwd() fails)\n\n    // Normalize the path\n    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);\n\n    if (resolvedAbsolute) {\n      if (resolvedPath.length > 0)\n        return '/' + resolvedPath;\n      else\n        return '/';\n    } else if (resolvedPath.length > 0) {\n      return resolvedPath;\n    } else {\n      return '.';\n    }\n  },\n\n  normalize: function normalize(path) {\n    assertPath(path);\n\n    if (path.length === 0) return '.';\n\n    var isAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    var trailingSeparator = path.charCodeAt(path.length - 1) === 47 /*/*/;\n\n    // Normalize the path\n    path = normalizeStringPosix(path, !isAbsolute);\n\n    if (path.length === 0 && !isAbsolute) path = '.';\n    if (path.length > 0 && trailingSeparator) path += '/';\n\n    if (isAbsolute) return '/' + path;\n    return path;\n  },\n\n  isAbsolute: function isAbsolute(path) {\n    assertPath(path);\n    return path.length > 0 && path.charCodeAt(0) === 47 /*/*/;\n  },\n\n  join: function join() {\n    if (arguments.length === 0)\n      return '.';\n    var joined;\n    for (var i = 0; i < arguments.length; ++i) {\n      var arg = arguments[i];\n      assertPath(arg);\n      if (arg.length > 0) {\n        if (joined === undefined)\n          joined = arg;\n        else\n          joined += '/' + arg;\n      }\n    }\n    if (joined === undefined)\n      return '.';\n    return posix.normalize(joined);\n  },\n\n  relative: function relative(from, to) {\n    assertPath(from);\n    assertPath(to);\n\n    if (from === to) return '';\n\n    from = posix.resolve(from);\n    to = posix.resolve(to);\n\n    if (from === to) return '';\n\n    // Trim any leading backslashes\n    var fromStart = 1;\n    for (; fromStart < from.length; ++fromStart) {\n      if (from.charCodeAt(fromStart) !== 47 /*/*/)\n        break;\n    }\n    var fromEnd = from.length;\n    var fromLen = fromEnd - fromStart;\n\n    // Trim any leading backslashes\n    var toStart = 1;\n    for (; toStart < to.length; ++toStart) {\n      if (to.charCodeAt(toStart) !== 47 /*/*/)\n        break;\n    }\n    var toEnd = to.length;\n    var toLen = toEnd - toStart;\n\n    // Compare paths to find the longest common path from root\n    var length = fromLen < toLen ? fromLen : toLen;\n    var lastCommonSep = -1;\n    var i = 0;\n    for (; i <= length; ++i) {\n      if (i === length) {\n        if (toLen > length) {\n          if (to.charCodeAt(toStart + i) === 47 /*/*/) {\n            // We get here if `from` is the exact base path for `to`.\n            // For example: from='/foo/bar'; to='/foo/bar/baz'\n            return to.slice(toStart + i + 1);\n          } else if (i === 0) {\n            // We get here if `from` is the root\n            // For example: from='/'; to='/foo'\n            return to.slice(toStart + i);\n          }\n        } else if (fromLen > length) {\n          if (from.charCodeAt(fromStart + i) === 47 /*/*/) {\n            // We get here if `to` is the exact base path for `from`.\n            // For example: from='/foo/bar/baz'; to='/foo/bar'\n            lastCommonSep = i;\n          } else if (i === 0) {\n            // We get here if `to` is the root.\n            // For example: from='/foo'; to='/'\n            lastCommonSep = 0;\n          }\n        }\n        break;\n      }\n      var fromCode = from.charCodeAt(fromStart + i);\n      var toCode = to.charCodeAt(toStart + i);\n      if (fromCode !== toCode)\n        break;\n      else if (fromCode === 47 /*/*/)\n        lastCommonSep = i;\n    }\n\n    var out = '';\n    // Generate the relative path based on the path difference between `to`\n    // and `from`\n    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n      if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {\n        if (out.length === 0)\n          out += '..';\n        else\n          out += '/..';\n      }\n    }\n\n    // Lastly, append the rest of the destination (`to`) path that comes after\n    // the common path parts\n    if (out.length > 0)\n      return out + to.slice(toStart + lastCommonSep);\n    else {\n      toStart += lastCommonSep;\n      if (to.charCodeAt(toStart) === 47 /*/*/)\n        ++toStart;\n      return to.slice(toStart);\n    }\n  },\n\n  _makeLong: function _makeLong(path) {\n    return path;\n  },\n\n  dirname: function dirname(path) {\n    assertPath(path);\n    if (path.length === 0) return '.';\n    var code = path.charCodeAt(0);\n    var hasRoot = code === 47 /*/*/;\n    var end = -1;\n    var matchedSlash = true;\n    for (var i = path.length - 1; i >= 1; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          if (!matchedSlash) {\n            end = i;\n            break;\n          }\n        } else {\n        // We saw the first non-path separator\n        matchedSlash = false;\n      }\n    }\n\n    if (end === -1) return hasRoot ? '/' : '.';\n    if (hasRoot && end === 1) return '//';\n    return path.slice(0, end);\n  },\n\n  basename: function basename(path, ext) {\n    if (ext !== undefined && typeof ext !== 'string') throw new TypeError('\"ext\" argument must be a string');\n    assertPath(path);\n\n    var start = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i;\n\n    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n      if (ext.length === path.length && ext === path) return '';\n      var extIdx = ext.length - 1;\n      var firstNonSlashEnd = -1;\n      for (i = path.length - 1; i >= 0; --i) {\n        var code = path.charCodeAt(i);\n        if (code === 47 /*/*/) {\n            // If we reached a path separator that was not part of a set of path\n            // separators at the end of the string, stop now\n            if (!matchedSlash) {\n              start = i + 1;\n              break;\n            }\n          } else {\n          if (firstNonSlashEnd === -1) {\n            // We saw the first non-path separator, remember this index in case\n            // we need it if the extension ends up not matching\n            matchedSlash = false;\n            firstNonSlashEnd = i + 1;\n          }\n          if (extIdx >= 0) {\n            // Try to match the explicit extension\n            if (code === ext.charCodeAt(extIdx)) {\n              if (--extIdx === -1) {\n                // We matched the extension, so mark this as the end of our path\n                // component\n                end = i;\n              }\n            } else {\n              // Extension does not match, so our result is the entire path\n              // component\n              extIdx = -1;\n              end = firstNonSlashEnd;\n            }\n          }\n        }\n      }\n\n      if (start === end) end = firstNonSlashEnd;else if (end === -1) end = path.length;\n      return path.slice(start, end);\n    } else {\n      for (i = path.length - 1; i >= 0; --i) {\n        if (path.charCodeAt(i) === 47 /*/*/) {\n            // If we reached a path separator that was not part of a set of path\n            // separators at the end of the string, stop now\n            if (!matchedSlash) {\n              start = i + 1;\n              break;\n            }\n          } else if (end === -1) {\n          // We saw the first non-path separator, mark this as the end of our\n          // path component\n          matchedSlash = false;\n          end = i + 1;\n        }\n      }\n\n      if (end === -1) return '';\n      return path.slice(start, end);\n    }\n  },\n\n  extname: function extname(path) {\n    assertPath(path);\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n    for (var i = path.length - 1; i >= 0; --i) {\n      var code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            startPart = i + 1;\n            break;\n          }\n          continue;\n        }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n          // If this is our first dot, mark it as the start of our extension\n          if (startDot === -1)\n            startDot = i;\n          else if (preDotState !== 1)\n            preDotState = 1;\n      } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n\n    if (startDot === -1 || end === -1 ||\n        // We saw a non-dot character immediately before the dot\n        preDotState === 0 ||\n        // The (right-most) trimmed path component is exactly '..'\n        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      return '';\n    }\n    return path.slice(startDot, end);\n  },\n\n  format: function format(pathObject) {\n    if (pathObject === null || typeof pathObject !== 'object') {\n      throw new TypeError('The \"pathObject\" argument must be of type Object. Received type ' + typeof pathObject);\n    }\n    return _format('/', pathObject);\n  },\n\n  parse: function parse(path) {\n    assertPath(path);\n\n    var ret = { root: '', dir: '', base: '', ext: '', name: '' };\n    if (path.length === 0) return ret;\n    var code = path.charCodeAt(0);\n    var isAbsolute = code === 47 /*/*/;\n    var start;\n    if (isAbsolute) {\n      ret.root = '/';\n      start = 1;\n    } else {\n      start = 0;\n    }\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i = path.length - 1;\n\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n\n    // Get non-dir info\n    for (; i >= start; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            startPart = i + 1;\n            break;\n          }\n          continue;\n        }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n          // If this is our first dot, mark it as the start of our extension\n          if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;\n        } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n\n    if (startDot === -1 || end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      if (end !== -1) {\n        if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);else ret.base = ret.name = path.slice(startPart, end);\n      }\n    } else {\n      if (startPart === 0 && isAbsolute) {\n        ret.name = path.slice(1, startDot);\n        ret.base = path.slice(1, end);\n      } else {\n        ret.name = path.slice(startPart, startDot);\n        ret.base = path.slice(startPart, end);\n      }\n      ret.ext = path.slice(startDot, end);\n    }\n\n    if (startPart > 0) ret.dir = path.slice(0, startPart - 1);else if (isAbsolute) ret.dir = '/';\n\n    return ret;\n  },\n\n  sep: '/',\n  delimiter: ':',\n  win32: null,\n  posix: null\n};\n\nposix.posix = posix;\n\nmodule.exports = posix;\n","var q=Object.create;var p=Object.defineProperty;var A=Object.getOwnPropertyDescriptor;var I=Object.getOwnPropertyNames;var Q=Object.getPrototypeOf,S=Object.prototype.hasOwnProperty;var N=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),O=(e,t)=>{for(var n in t)p(e,n,{get:t[n],enumerable:!0})},m=(e,t,n,w)=>{if(t&&typeof t==\"object\"||typeof t==\"function\")for(let f of I(t))!S.call(e,f)&&f!==n&&p(e,f,{get:()=>t[f],enumerable:!(w=A(t,f))||w.enumerable});return e},h=(e,t,n)=>(m(e,t,\"default\"),n&&m(n,t,\"default\")),y=(e,t,n)=>(n=e!=null?q(Q(e)):{},m(t||!e||!e.__esModule?p(n,\"default\",{value:e,enumerable:!0}):n,e)),U=e=>m(p({},\"__esModule\",{value:!0}),e);var v=N((F,E)=>{var r=E.exports={},i,u;function T(){throw new Error(\"setTimeout has not been defined\")}function g(){throw new Error(\"clearTimeout has not been defined\")}(function(){try{typeof setTimeout==\"function\"?i=setTimeout:i=T}catch(e){i=T}try{typeof clearTimeout==\"function\"?u=clearTimeout:u=g}catch(e){u=g}})();function b(e){if(i===setTimeout)return setTimeout(e,0);if((i===T||!i)&&setTimeout)return i=setTimeout,setTimeout(e,0);try{return i(e,0)}catch(t){try{return i.call(null,e,0)}catch(n){return i.call(this,e,0)}}}function j(e){if(u===clearTimeout)return clearTimeout(e);if((u===g||!u)&&clearTimeout)return u=clearTimeout,clearTimeout(e);try{return u(e)}catch(t){try{return u.call(null,e)}catch(n){return u.call(this,e)}}}var o=[],s=!1,a,d=-1;function z(){!s||!a||(s=!1,a.length?o=a.concat(o):d=-1,o.length&&x())}function x(){if(!s){var e=b(z);s=!0;for(var t=o.length;t;){for(a=o,o=[];++d<t;)a&&a[d].run();d=-1,t=o.length}a=null,s=!1,j(e)}}r.nextTick=function(e){var t=new Array(arguments.length-1);if(arguments.length>1)for(var n=1;n<arguments.length;n++)t[n-1]=arguments[n];o.push(new L(e,t)),o.length===1&&!s&&b(x)};function L(e,t){this.fun=e,this.array=t}L.prototype.run=function(){this.fun.apply(null,this.array)};r.title=\"browser\";r.browser=!0;r.env={};r.argv=[];r.version=\"\";r.versions={};function c(){}r.on=c;r.addListener=c;r.once=c;r.off=c;r.removeListener=c;r.removeAllListeners=c;r.emit=c;r.prependListener=c;r.prependOnceListener=c;r.listeners=function(e){return[]};r.binding=function(e){throw new Error(\"process.binding is not supported\")};r.cwd=function(){return\"/\"};r.chdir=function(e){throw new Error(\"process.chdir is not supported\")};r.umask=function(){return 0}});var l={};O(l,{default:()=>B});module.exports=U(l);var C=y(v());h(l,y(v()),module.exports);var B=C.default;\n","/*! node-domexception. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */\n\nif (!globalThis.DOMException) {\n  try {\n    const { MessageChannel } = require('worker_threads'),\n    port = new MessageChannel().port1,\n    ab = new ArrayBuffer()\n    port.postMessage(ab, [ab, ab])\n  } catch (err) {\n    err.constructor.name === 'DOMException' && (\n      globalThis.DOMException = err.constructor\n    )\n  }\n}\n\nmodule.exports = globalThis.DOMException\n","import Blob from './index.js'\n\nconst _File = class File extends Blob {\n  #lastModified = 0\n  #name = ''\n\n  /**\n   * @param {*[]} fileBits\n   * @param {string} fileName\n   * @param {{lastModified?: number, type?: string}} options\n   */// @ts-ignore\n  constructor (fileBits, fileName, options = {}) {\n    if (arguments.length < 2) {\n      throw new TypeError(`Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`)\n    }\n    super(fileBits, options)\n\n    if (options === null) options = {}\n\n    // Simulate WebIDL type casting for NaN value in lastModified option.\n    const lastModified = options.lastModified === undefined ? Date.now() : Number(options.lastModified)\n    if (!Number.isNaN(lastModified)) {\n      this.#lastModified = lastModified\n    }\n\n    this.#name = String(fileName)\n  }\n\n  get name () {\n    return this.#name\n  }\n\n  get lastModified () {\n    return this.#lastModified\n  }\n\n  get [Symbol.toStringTag] () {\n    return 'File'\n  }\n\n  static [Symbol.hasInstance] (object) {\n    return !!object && object instanceof Blob &&\n      /^(File)$/.test(object[Symbol.toStringTag])\n  }\n}\n\n/** @type {typeof globalThis.File} */// @ts-ignore\nexport const File = _File\nexport default File\n","/*! fetch-blob. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */\n\n// TODO (jimmywarting): in the feature use conditional loading with top level await (requires 14.x)\n// Node has recently added whatwg stream into core\n\nimport './streams.cjs'\n\n// 64 KiB (same size chrome slice theirs blob into Uint8array's)\nconst POOL_SIZE = 65536\n\n/** @param {(Blob | Uint8Array)[]} parts */\nasync function * toIterator (parts, clone = true) {\n  for (const part of parts) {\n    if ('stream' in part) {\n      yield * (/** @type {AsyncIterableIterator<Uint8Array>} */ (part.stream()))\n    } else if (ArrayBuffer.isView(part)) {\n      if (clone) {\n        let position = part.byteOffset\n        const end = part.byteOffset + part.byteLength\n        while (position !== end) {\n          const size = Math.min(end - position, POOL_SIZE)\n          const chunk = part.buffer.slice(position, position + size)\n          position += chunk.byteLength\n          yield new Uint8Array(chunk)\n        }\n      } else {\n        yield part\n      }\n    /* c8 ignore next 10 */\n    } else {\n      // For blobs that have arrayBuffer but no stream method (nodes buffer.Blob)\n      let position = 0, b = (/** @type {Blob} */ (part))\n      while (position !== b.size) {\n        const chunk = b.slice(position, Math.min(b.size, position + POOL_SIZE))\n        const buffer = await chunk.arrayBuffer()\n        position += buffer.byteLength\n        yield new Uint8Array(buffer)\n      }\n    }\n  }\n}\n\nconst _Blob = class Blob {\n  /** @type {Array.<(Blob|Uint8Array)>} */\n  #parts = []\n  #type = ''\n  #size = 0\n  #endings = 'transparent'\n\n  /**\n   * The Blob() constructor returns a new Blob object. The content\n   * of the blob consists of the concatenation of the values given\n   * in the parameter array.\n   *\n   * @param {*} blobParts\n   * @param {{ type?: string, endings?: string }} [options]\n   */\n  constructor (blobParts = [], options = {}) {\n    if (typeof blobParts !== 'object' || blobParts === null) {\n      throw new TypeError('Failed to construct \\'Blob\\': The provided value cannot be converted to a sequence.')\n    }\n\n    if (typeof blobParts[Symbol.iterator] !== 'function') {\n      throw new TypeError('Failed to construct \\'Blob\\': The object must have a callable @@iterator property.')\n    }\n\n    if (typeof options !== 'object' && typeof options !== 'function') {\n      throw new TypeError('Failed to construct \\'Blob\\': parameter 2 cannot convert to dictionary.')\n    }\n\n    if (options === null) options = {}\n\n    const encoder = new TextEncoder()\n    for (const element of blobParts) {\n      let part\n      if (ArrayBuffer.isView(element)) {\n        part = new Uint8Array(element.buffer.slice(element.byteOffset, element.byteOffset + element.byteLength))\n      } else if (element instanceof ArrayBuffer) {\n        part = new Uint8Array(element.slice(0))\n      } else if (element instanceof Blob) {\n        part = element\n      } else {\n        part = encoder.encode(`${element}`)\n      }\n\n      this.#size += ArrayBuffer.isView(part) ? part.byteLength : part.size\n      this.#parts.push(part)\n    }\n\n    this.#endings = `${options.endings === undefined ? 'transparent' : options.endings}`\n    const type = options.type === undefined ? '' : String(options.type)\n    this.#type = /^[\\x20-\\x7E]*$/.test(type) ? type : ''\n  }\n\n  /**\n   * The Blob interface's size property returns the\n   * size of the Blob in bytes.\n   */\n  get size () {\n    return this.#size\n  }\n\n  /**\n   * The type property of a Blob object returns the MIME type of the file.\n   */\n  get type () {\n    return this.#type\n  }\n\n  /**\n   * The text() method in the Blob interface returns a Promise\n   * that resolves with a string containing the contents of\n   * the blob, interpreted as UTF-8.\n   *\n   * @return {Promise<string>}\n   */\n  async text () {\n    // More optimized than using this.arrayBuffer()\n    // that requires twice as much ram\n    const decoder = new TextDecoder()\n    let str = ''\n    for await (const part of toIterator(this.#parts, false)) {\n      str += decoder.decode(part, { stream: true })\n    }\n    // Remaining\n    str += decoder.decode()\n    return str\n  }\n\n  /**\n   * The arrayBuffer() method in the Blob interface returns a\n   * Promise that resolves with the contents of the blob as\n   * binary data contained in an ArrayBuffer.\n   *\n   * @return {Promise<ArrayBuffer>}\n   */\n  async arrayBuffer () {\n    // Easier way... Just a unnecessary overhead\n    // const view = new Uint8Array(this.size);\n    // await this.stream().getReader({mode: 'byob'}).read(view);\n    // return view.buffer;\n\n    const data = new Uint8Array(this.size)\n    let offset = 0\n    for await (const chunk of toIterator(this.#parts, false)) {\n      data.set(chunk, offset)\n      offset += chunk.length\n    }\n\n    return data.buffer\n  }\n\n  stream () {\n    const it = toIterator(this.#parts, true)\n\n    return new globalThis.ReadableStream({\n      // @ts-ignore\n      type: 'bytes',\n      async pull (ctrl) {\n        const chunk = await it.next()\n        chunk.done ? ctrl.close() : ctrl.enqueue(chunk.value)\n      },\n\n      async cancel () {\n        await it.return()\n      }\n    })\n  }\n\n  /**\n   * The Blob interface's slice() method creates and returns a\n   * new Blob object which contains data from a subset of the\n   * blob on which it's called.\n   *\n   * @param {number} [start]\n   * @param {number} [end]\n   * @param {string} [type]\n   */\n  slice (start = 0, end = this.size, type = '') {\n    const { size } = this\n\n    let relativeStart = start < 0 ? Math.max(size + start, 0) : Math.min(start, size)\n    let relativeEnd = end < 0 ? Math.max(size + end, 0) : Math.min(end, size)\n\n    const span = Math.max(relativeEnd - relativeStart, 0)\n    const parts = this.#parts\n    const blobParts = []\n    let added = 0\n\n    for (const part of parts) {\n      // don't add the overflow to new blobParts\n      if (added >= span) {\n        break\n      }\n\n      const size = ArrayBuffer.isView(part) ? part.byteLength : part.size\n      if (relativeStart && size <= relativeStart) {\n        // Skip the beginning and change the relative\n        // start & end position as we skip the unwanted parts\n        relativeStart -= size\n        relativeEnd -= size\n      } else {\n        let chunk\n        if (ArrayBuffer.isView(part)) {\n          chunk = part.subarray(relativeStart, Math.min(size, relativeEnd))\n          added += chunk.byteLength\n        } else {\n          chunk = part.slice(relativeStart, Math.min(size, relativeEnd))\n          added += chunk.size\n        }\n        relativeEnd -= size\n        blobParts.push(chunk)\n        relativeStart = 0 // All next sequential parts should start at 0\n      }\n    }\n\n    const blob = new Blob([], { type: String(type).toLowerCase() })\n    blob.#size = span\n    blob.#parts = blobParts\n\n    return blob\n  }\n\n  get [Symbol.toStringTag] () {\n    return 'Blob'\n  }\n\n  static [Symbol.hasInstance] (object) {\n    return (\n      object &&\n      typeof object === 'object' &&\n      typeof object.constructor === 'function' &&\n      (\n        typeof object.stream === 'function' ||\n        typeof object.arrayBuffer === 'function'\n      ) &&\n      /^(Blob|File)$/.test(object[Symbol.toStringTag])\n    )\n  }\n}\n\nObject.defineProperties(_Blob.prototype, {\n  size: { enumerable: true },\n  type: { enumerable: true },\n  slice: { enumerable: true }\n})\n\n/** @type {typeof globalThis.Blob} */\nexport const Blob = _Blob\nexport default Blob\n","/* c8 ignore start */\n// 64 KiB (same size chrome slice theirs blob into Uint8array's)\nconst POOL_SIZE = 65536\n\nif (!globalThis.ReadableStream) {\n  // `node:stream/web` got introduced in v16.5.0 as experimental\n  // and it's preferred over the polyfilled version. So we also\n  // suppress the warning that gets emitted by NodeJS for using it.\n  try {\n    const process = require('node:process')\n    const { emitWarning } = process\n    try {\n      process.emitWarning = () => {}\n      Object.assign(globalThis, require('node:stream/web'))\n      process.emitWarning = emitWarning\n    } catch (error) {\n      process.emitWarning = emitWarning\n      throw error\n    }\n  } catch (error) {\n    // fallback to polyfill implementation\n    Object.assign(globalThis, require('web-streams-polyfill/dist/ponyfill.es2018.js'))\n  }\n}\n\ntry {\n  // Don't use node: prefix for this, require+node: is not supported until node v14.14\n  // Only `import()` can use prefix in 12.20 and later\n  const { Blob } = require('buffer')\n  if (Blob && !Blob.prototype.stream) {\n    Blob.prototype.stream = function name (params) {\n      let position = 0\n      const blob = this\n\n      return new ReadableStream({\n        type: 'bytes',\n        async pull (ctrl) {\n          const chunk = blob.slice(position, Math.min(blob.size, position + POOL_SIZE))\n          const buffer = await chunk.arrayBuffer()\n          position += buffer.byteLength\n          ctrl.enqueue(new Uint8Array(buffer))\n\n          if (position === blob.size) {\n            ctrl.close()\n          }\n        }\n      })\n    }\n  }\n} catch (error) {}\n/* c8 ignore end */\n","/**\n * web-streams-polyfill v3.2.1\n */\n(function (global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n    typeof define === 'function' && define.amd ? define(['exports'], factory) :\n    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.WebStreamsPolyfill = {}));\n}(this, (function (exports) { 'use strict';\n\n    /// <reference lib=\"es2015.symbol\" />\n    const SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ?\n        Symbol :\n        description => `Symbol(${description})`;\n\n    /// <reference lib=\"dom\" />\n    function noop() {\n        return undefined;\n    }\n    function getGlobals() {\n        if (typeof self !== 'undefined') {\n            return self;\n        }\n        else if (typeof window !== 'undefined') {\n            return window;\n        }\n        else if (typeof global !== 'undefined') {\n            return global;\n        }\n        return undefined;\n    }\n    const globals = getGlobals();\n\n    function typeIsObject(x) {\n        return (typeof x === 'object' && x !== null) || typeof x === 'function';\n    }\n    const rethrowAssertionErrorRejection = noop;\n\n    const originalPromise = Promise;\n    const originalPromiseThen = Promise.prototype.then;\n    const originalPromiseResolve = Promise.resolve.bind(originalPromise);\n    const originalPromiseReject = Promise.reject.bind(originalPromise);\n    function newPromise(executor) {\n        return new originalPromise(executor);\n    }\n    function promiseResolvedWith(value) {\n        return originalPromiseResolve(value);\n    }\n    function promiseRejectedWith(reason) {\n        return originalPromiseReject(reason);\n    }\n    function PerformPromiseThen(promise, onFulfilled, onRejected) {\n        // There doesn't appear to be any way to correctly emulate the behaviour from JavaScript, so this is just an\n        // approximation.\n        return originalPromiseThen.call(promise, onFulfilled, onRejected);\n    }\n    function uponPromise(promise, onFulfilled, onRejected) {\n        PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), undefined, rethrowAssertionErrorRejection);\n    }\n    function uponFulfillment(promise, onFulfilled) {\n        uponPromise(promise, onFulfilled);\n    }\n    function uponRejection(promise, onRejected) {\n        uponPromise(promise, undefined, onRejected);\n    }\n    function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) {\n        return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler);\n    }\n    function setPromiseIsHandledToTrue(promise) {\n        PerformPromiseThen(promise, undefined, rethrowAssertionErrorRejection);\n    }\n    const queueMicrotask = (() => {\n        const globalQueueMicrotask = globals && globals.queueMicrotask;\n        if (typeof globalQueueMicrotask === 'function') {\n            return globalQueueMicrotask;\n        }\n        const resolvedPromise = promiseResolvedWith(undefined);\n        return (fn) => PerformPromiseThen(resolvedPromise, fn);\n    })();\n    function reflectCall(F, V, args) {\n        if (typeof F !== 'function') {\n            throw new TypeError('Argument is not a function');\n        }\n        return Function.prototype.apply.call(F, V, args);\n    }\n    function promiseCall(F, V, args) {\n        try {\n            return promiseResolvedWith(reflectCall(F, V, args));\n        }\n        catch (value) {\n            return promiseRejectedWith(value);\n        }\n    }\n\n    // Original from Chromium\n    // https://chromium.googlesource.com/chromium/src/+/0aee4434a4dba42a42abaea9bfbc0cd196a63bc1/third_party/blink/renderer/core/streams/SimpleQueue.js\n    const QUEUE_MAX_ARRAY_SIZE = 16384;\n    /**\n     * Simple queue structure.\n     *\n     * Avoids scalability issues with using a packed array directly by using\n     * multiple arrays in a linked list and keeping the array size bounded.\n     */\n    class SimpleQueue {\n        constructor() {\n            this._cursor = 0;\n            this._size = 0;\n            // _front and _back are always defined.\n            this._front = {\n                _elements: [],\n                _next: undefined\n            };\n            this._back = this._front;\n            // The cursor is used to avoid calling Array.shift().\n            // It contains the index of the front element of the array inside the\n            // front-most node. It is always in the range [0, QUEUE_MAX_ARRAY_SIZE).\n            this._cursor = 0;\n            // When there is only one node, size === elements.length - cursor.\n            this._size = 0;\n        }\n        get length() {\n            return this._size;\n        }\n        // For exception safety, this method is structured in order:\n        // 1. Read state\n        // 2. Calculate required state mutations\n        // 3. Perform state mutations\n        push(element) {\n            const oldBack = this._back;\n            let newBack = oldBack;\n            if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) {\n                newBack = {\n                    _elements: [],\n                    _next: undefined\n                };\n            }\n            // push() is the mutation most likely to throw an exception, so it\n            // goes first.\n            oldBack._elements.push(element);\n            if (newBack !== oldBack) {\n                this._back = newBack;\n                oldBack._next = newBack;\n            }\n            ++this._size;\n        }\n        // Like push(), shift() follows the read -> calculate -> mutate pattern for\n        // exception safety.\n        shift() { // must not be called on an empty queue\n            const oldFront = this._front;\n            let newFront = oldFront;\n            const oldCursor = this._cursor;\n            let newCursor = oldCursor + 1;\n            const elements = oldFront._elements;\n            const element = elements[oldCursor];\n            if (newCursor === QUEUE_MAX_ARRAY_SIZE) {\n                newFront = oldFront._next;\n                newCursor = 0;\n            }\n            // No mutations before this point.\n            --this._size;\n            this._cursor = newCursor;\n            if (oldFront !== newFront) {\n                this._front = newFront;\n            }\n            // Permit shifted element to be garbage collected.\n            elements[oldCursor] = undefined;\n            return element;\n        }\n        // The tricky thing about forEach() is that it can be called\n        // re-entrantly. The queue may be mutated inside the callback. It is easy to\n        // see that push() within the callback has no negative effects since the end\n        // of the queue is checked for on every iteration. If shift() is called\n        // repeatedly within the callback then the next iteration may return an\n        // element that has been removed. In this case the callback will be called\n        // with undefined values until we either \"catch up\" with elements that still\n        // exist or reach the back of the queue.\n        forEach(callback) {\n            let i = this._cursor;\n            let node = this._front;\n            let elements = node._elements;\n            while (i !== elements.length || node._next !== undefined) {\n                if (i === elements.length) {\n                    node = node._next;\n                    elements = node._elements;\n                    i = 0;\n                    if (elements.length === 0) {\n                        break;\n                    }\n                }\n                callback(elements[i]);\n                ++i;\n            }\n        }\n        // Return the element that would be returned if shift() was called now,\n        // without modifying the queue.\n        peek() { // must not be called on an empty queue\n            const front = this._front;\n            const cursor = this._cursor;\n            return front._elements[cursor];\n        }\n    }\n\n    function ReadableStreamReaderGenericInitialize(reader, stream) {\n        reader._ownerReadableStream = stream;\n        stream._reader = reader;\n        if (stream._state === 'readable') {\n            defaultReaderClosedPromiseInitialize(reader);\n        }\n        else if (stream._state === 'closed') {\n            defaultReaderClosedPromiseInitializeAsResolved(reader);\n        }\n        else {\n            defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);\n        }\n    }\n    // A client of ReadableStreamDefaultReader and ReadableStreamBYOBReader may use these functions directly to bypass state\n    // check.\n    function ReadableStreamReaderGenericCancel(reader, reason) {\n        const stream = reader._ownerReadableStream;\n        return ReadableStreamCancel(stream, reason);\n    }\n    function ReadableStreamReaderGenericRelease(reader) {\n        if (reader._ownerReadableStream._state === 'readable') {\n            defaultReaderClosedPromiseReject(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));\n        }\n        else {\n            defaultReaderClosedPromiseResetToRejected(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));\n        }\n        reader._ownerReadableStream._reader = undefined;\n        reader._ownerReadableStream = undefined;\n    }\n    // Helper functions for the readers.\n    function readerLockException(name) {\n        return new TypeError('Cannot ' + name + ' a stream using a released reader');\n    }\n    // Helper functions for the ReadableStreamDefaultReader.\n    function defaultReaderClosedPromiseInitialize(reader) {\n        reader._closedPromise = newPromise((resolve, reject) => {\n            reader._closedPromise_resolve = resolve;\n            reader._closedPromise_reject = reject;\n        });\n    }\n    function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {\n        defaultReaderClosedPromiseInitialize(reader);\n        defaultReaderClosedPromiseReject(reader, reason);\n    }\n    function defaultReaderClosedPromiseInitializeAsResolved(reader) {\n        defaultReaderClosedPromiseInitialize(reader);\n        defaultReaderClosedPromiseResolve(reader);\n    }\n    function defaultReaderClosedPromiseReject(reader, reason) {\n        if (reader._closedPromise_reject === undefined) {\n            return;\n        }\n        setPromiseIsHandledToTrue(reader._closedPromise);\n        reader._closedPromise_reject(reason);\n        reader._closedPromise_resolve = undefined;\n        reader._closedPromise_reject = undefined;\n    }\n    function defaultReaderClosedPromiseResetToRejected(reader, reason) {\n        defaultReaderClosedPromiseInitializeAsRejected(reader, reason);\n    }\n    function defaultReaderClosedPromiseResolve(reader) {\n        if (reader._closedPromise_resolve === undefined) {\n            return;\n        }\n        reader._closedPromise_resolve(undefined);\n        reader._closedPromise_resolve = undefined;\n        reader._closedPromise_reject = undefined;\n    }\n\n    const AbortSteps = SymbolPolyfill('[[AbortSteps]]');\n    const ErrorSteps = SymbolPolyfill('[[ErrorSteps]]');\n    const CancelSteps = SymbolPolyfill('[[CancelSteps]]');\n    const PullSteps = SymbolPolyfill('[[PullSteps]]');\n\n    /// <reference lib=\"es2015.core\" />\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite#Polyfill\n    const NumberIsFinite = Number.isFinite || function (x) {\n        return typeof x === 'number' && isFinite(x);\n    };\n\n    /// <reference lib=\"es2015.core\" />\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc#Polyfill\n    const MathTrunc = Math.trunc || function (v) {\n        return v < 0 ? Math.ceil(v) : Math.floor(v);\n    };\n\n    // https://heycam.github.io/webidl/#idl-dictionaries\n    function isDictionary(x) {\n        return typeof x === 'object' || typeof x === 'function';\n    }\n    function assertDictionary(obj, context) {\n        if (obj !== undefined && !isDictionary(obj)) {\n            throw new TypeError(`${context} is not an object.`);\n        }\n    }\n    // https://heycam.github.io/webidl/#idl-callback-functions\n    function assertFunction(x, context) {\n        if (typeof x !== 'function') {\n            throw new TypeError(`${context} is not a function.`);\n        }\n    }\n    // https://heycam.github.io/webidl/#idl-object\n    function isObject(x) {\n        return (typeof x === 'object' && x !== null) || typeof x === 'function';\n    }\n    function assertObject(x, context) {\n        if (!isObject(x)) {\n            throw new TypeError(`${context} is not an object.`);\n        }\n    }\n    function assertRequiredArgument(x, position, context) {\n        if (x === undefined) {\n            throw new TypeError(`Parameter ${position} is required in '${context}'.`);\n        }\n    }\n    function assertRequiredField(x, field, context) {\n        if (x === undefined) {\n            throw new TypeError(`${field} is required in '${context}'.`);\n        }\n    }\n    // https://heycam.github.io/webidl/#idl-unrestricted-double\n    function convertUnrestrictedDouble(value) {\n        return Number(value);\n    }\n    function censorNegativeZero(x) {\n        return x === 0 ? 0 : x;\n    }\n    function integerPart(x) {\n        return censorNegativeZero(MathTrunc(x));\n    }\n    // https://heycam.github.io/webidl/#idl-unsigned-long-long\n    function convertUnsignedLongLongWithEnforceRange(value, context) {\n        const lowerBound = 0;\n        const upperBound = Number.MAX_SAFE_INTEGER;\n        let x = Number(value);\n        x = censorNegativeZero(x);\n        if (!NumberIsFinite(x)) {\n            throw new TypeError(`${context} is not a finite number`);\n        }\n        x = integerPart(x);\n        if (x < lowerBound || x > upperBound) {\n            throw new TypeError(`${context} is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`);\n        }\n        if (!NumberIsFinite(x) || x === 0) {\n            return 0;\n        }\n        // TODO Use BigInt if supported?\n        // let xBigInt = BigInt(integerPart(x));\n        // xBigInt = BigInt.asUintN(64, xBigInt);\n        // return Number(xBigInt);\n        return x;\n    }\n\n    function assertReadableStream(x, context) {\n        if (!IsReadableStream(x)) {\n            throw new TypeError(`${context} is not a ReadableStream.`);\n        }\n    }\n\n    // Abstract operations for the ReadableStream.\n    function AcquireReadableStreamDefaultReader(stream) {\n        return new ReadableStreamDefaultReader(stream);\n    }\n    // ReadableStream API exposed for controllers.\n    function ReadableStreamAddReadRequest(stream, readRequest) {\n        stream._reader._readRequests.push(readRequest);\n    }\n    function ReadableStreamFulfillReadRequest(stream, chunk, done) {\n        const reader = stream._reader;\n        const readRequest = reader._readRequests.shift();\n        if (done) {\n            readRequest._closeSteps();\n        }\n        else {\n            readRequest._chunkSteps(chunk);\n        }\n    }\n    function ReadableStreamGetNumReadRequests(stream) {\n        return stream._reader._readRequests.length;\n    }\n    function ReadableStreamHasDefaultReader(stream) {\n        const reader = stream._reader;\n        if (reader === undefined) {\n            return false;\n        }\n        if (!IsReadableStreamDefaultReader(reader)) {\n            return false;\n        }\n        return true;\n    }\n    /**\n     * A default reader vended by a {@link ReadableStream}.\n     *\n     * @public\n     */\n    class ReadableStreamDefaultReader {\n        constructor(stream) {\n            assertRequiredArgument(stream, 1, 'ReadableStreamDefaultReader');\n            assertReadableStream(stream, 'First parameter');\n            if (IsReadableStreamLocked(stream)) {\n                throw new TypeError('This stream has already been locked for exclusive reading by another reader');\n            }\n            ReadableStreamReaderGenericInitialize(this, stream);\n            this._readRequests = new SimpleQueue();\n        }\n        /**\n         * Returns a promise that will be fulfilled when the stream becomes closed,\n         * or rejected if the stream ever errors or the reader's lock is released before the stream finishes closing.\n         */\n        get closed() {\n            if (!IsReadableStreamDefaultReader(this)) {\n                return promiseRejectedWith(defaultReaderBrandCheckException('closed'));\n            }\n            return this._closedPromise;\n        }\n        /**\n         * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.\n         */\n        cancel(reason = undefined) {\n            if (!IsReadableStreamDefaultReader(this)) {\n                return promiseRejectedWith(defaultReaderBrandCheckException('cancel'));\n            }\n            if (this._ownerReadableStream === undefined) {\n                return promiseRejectedWith(readerLockException('cancel'));\n            }\n            return ReadableStreamReaderGenericCancel(this, reason);\n        }\n        /**\n         * Returns a promise that allows access to the next chunk from the stream's internal queue, if available.\n         *\n         * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.\n         */\n        read() {\n            if (!IsReadableStreamDefaultReader(this)) {\n                return promiseRejectedWith(defaultReaderBrandCheckException('read'));\n            }\n            if (this._ownerReadableStream === undefined) {\n                return promiseRejectedWith(readerLockException('read from'));\n            }\n            let resolvePromise;\n            let rejectPromise;\n            const promise = newPromise((resolve, reject) => {\n                resolvePromise = resolve;\n                rejectPromise = reject;\n            });\n            const readRequest = {\n                _chunkSteps: chunk => resolvePromise({ value: chunk, done: false }),\n                _closeSteps: () => resolvePromise({ value: undefined, done: true }),\n                _errorSteps: e => rejectPromise(e)\n            };\n            ReadableStreamDefaultReaderRead(this, readRequest);\n            return promise;\n        }\n        /**\n         * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.\n         * If the associated stream is errored when the lock is released, the reader will appear errored in the same way\n         * from now on; otherwise, the reader will appear closed.\n         *\n         * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by\n         * the reader's {@link ReadableStreamDefaultReader.read | read()} method has not yet been settled. Attempting to\n         * do so will throw a `TypeError` and leave the reader locked to the stream.\n         */\n        releaseLock() {\n            if (!IsReadableStreamDefaultReader(this)) {\n                throw defaultReaderBrandCheckException('releaseLock');\n            }\n            if (this._ownerReadableStream === undefined) {\n                return;\n            }\n            if (this._readRequests.length > 0) {\n                throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');\n            }\n            ReadableStreamReaderGenericRelease(this);\n        }\n    }\n    Object.defineProperties(ReadableStreamDefaultReader.prototype, {\n        cancel: { enumerable: true },\n        read: { enumerable: true },\n        releaseLock: { enumerable: true },\n        closed: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(ReadableStreamDefaultReader.prototype, SymbolPolyfill.toStringTag, {\n            value: 'ReadableStreamDefaultReader',\n            configurable: true\n        });\n    }\n    // Abstract operations for the readers.\n    function IsReadableStreamDefaultReader(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {\n            return false;\n        }\n        return x instanceof ReadableStreamDefaultReader;\n    }\n    function ReadableStreamDefaultReaderRead(reader, readRequest) {\n        const stream = reader._ownerReadableStream;\n        stream._disturbed = true;\n        if (stream._state === 'closed') {\n            readRequest._closeSteps();\n        }\n        else if (stream._state === 'errored') {\n            readRequest._errorSteps(stream._storedError);\n        }\n        else {\n            stream._readableStreamController[PullSteps](readRequest);\n        }\n    }\n    // Helper functions for the ReadableStreamDefaultReader.\n    function defaultReaderBrandCheckException(name) {\n        return new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);\n    }\n\n    /// <reference lib=\"es2018.asynciterable\" />\n    /* eslint-disable @typescript-eslint/no-empty-function */\n    const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () { }).prototype);\n\n    /// <reference lib=\"es2018.asynciterable\" />\n    class ReadableStreamAsyncIteratorImpl {\n        constructor(reader, preventCancel) {\n            this._ongoingPromise = undefined;\n            this._isFinished = false;\n            this._reader = reader;\n            this._preventCancel = preventCancel;\n        }\n        next() {\n            const nextSteps = () => this._nextSteps();\n            this._ongoingPromise = this._ongoingPromise ?\n                transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) :\n                nextSteps();\n            return this._ongoingPromise;\n        }\n        return(value) {\n            const returnSteps = () => this._returnSteps(value);\n            return this._ongoingPromise ?\n                transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) :\n                returnSteps();\n        }\n        _nextSteps() {\n            if (this._isFinished) {\n                return Promise.resolve({ value: undefined, done: true });\n            }\n            const reader = this._reader;\n            if (reader._ownerReadableStream === undefined) {\n                return promiseRejectedWith(readerLockException('iterate'));\n            }\n            let resolvePromise;\n            let rejectPromise;\n            const promise = newPromise((resolve, reject) => {\n                resolvePromise = resolve;\n                rejectPromise = reject;\n            });\n            const readRequest = {\n                _chunkSteps: chunk => {\n                    this._ongoingPromise = undefined;\n                    // This needs to be delayed by one microtask, otherwise we stop pulling too early which breaks a test.\n                    // FIXME Is this a bug in the specification, or in the test?\n                    queueMicrotask(() => resolvePromise({ value: chunk, done: false }));\n                },\n                _closeSteps: () => {\n                    this._ongoingPromise = undefined;\n                    this._isFinished = true;\n                    ReadableStreamReaderGenericRelease(reader);\n                    resolvePromise({ value: undefined, done: true });\n                },\n                _errorSteps: reason => {\n                    this._ongoingPromise = undefined;\n                    this._isFinished = true;\n                    ReadableStreamReaderGenericRelease(reader);\n                    rejectPromise(reason);\n                }\n            };\n            ReadableStreamDefaultReaderRead(reader, readRequest);\n            return promise;\n        }\n        _returnSteps(value) {\n            if (this._isFinished) {\n                return Promise.resolve({ value, done: true });\n            }\n            this._isFinished = true;\n            const reader = this._reader;\n            if (reader._ownerReadableStream === undefined) {\n                return promiseRejectedWith(readerLockException('finish iterating'));\n            }\n            if (!this._preventCancel) {\n                const result = ReadableStreamReaderGenericCancel(reader, value);\n                ReadableStreamReaderGenericRelease(reader);\n                return transformPromiseWith(result, () => ({ value, done: true }));\n            }\n            ReadableStreamReaderGenericRelease(reader);\n            return promiseResolvedWith({ value, done: true });\n        }\n    }\n    const ReadableStreamAsyncIteratorPrototype = {\n        next() {\n            if (!IsReadableStreamAsyncIterator(this)) {\n                return promiseRejectedWith(streamAsyncIteratorBrandCheckException('next'));\n            }\n            return this._asyncIteratorImpl.next();\n        },\n        return(value) {\n            if (!IsReadableStreamAsyncIterator(this)) {\n                return promiseRejectedWith(streamAsyncIteratorBrandCheckException('return'));\n            }\n            return this._asyncIteratorImpl.return(value);\n        }\n    };\n    if (AsyncIteratorPrototype !== undefined) {\n        Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);\n    }\n    // Abstract operations for the ReadableStream.\n    function AcquireReadableStreamAsyncIterator(stream, preventCancel) {\n        const reader = AcquireReadableStreamDefaultReader(stream);\n        const impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel);\n        const iterator = Object.create(ReadableStreamAsyncIteratorPrototype);\n        iterator._asyncIteratorImpl = impl;\n        return iterator;\n    }\n    function IsReadableStreamAsyncIterator(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_asyncIteratorImpl')) {\n            return false;\n        }\n        try {\n            // noinspection SuspiciousTypeOfGuard\n            return x._asyncIteratorImpl instanceof\n                ReadableStreamAsyncIteratorImpl;\n        }\n        catch (_a) {\n            return false;\n        }\n    }\n    // Helper functions for the ReadableStream.\n    function streamAsyncIteratorBrandCheckException(name) {\n        return new TypeError(`ReadableStreamAsyncIterator.${name} can only be used on a ReadableSteamAsyncIterator`);\n    }\n\n    /// <reference lib=\"es2015.core\" />\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN#Polyfill\n    const NumberIsNaN = Number.isNaN || function (x) {\n        // eslint-disable-next-line no-self-compare\n        return x !== x;\n    };\n\n    function CreateArrayFromList(elements) {\n        // We use arrays to represent lists, so this is basically a no-op.\n        // Do a slice though just in case we happen to depend on the unique-ness.\n        return elements.slice();\n    }\n    function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) {\n        new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);\n    }\n    // Not implemented correctly\n    function TransferArrayBuffer(O) {\n        return O;\n    }\n    // Not implemented correctly\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    function IsDetachedBuffer(O) {\n        return false;\n    }\n    function ArrayBufferSlice(buffer, begin, end) {\n        // ArrayBuffer.prototype.slice is not available on IE10\n        // https://www.caniuse.com/mdn-javascript_builtins_arraybuffer_slice\n        if (buffer.slice) {\n            return buffer.slice(begin, end);\n        }\n        const length = end - begin;\n        const slice = new ArrayBuffer(length);\n        CopyDataBlockBytes(slice, 0, buffer, begin, length);\n        return slice;\n    }\n\n    function IsNonNegativeNumber(v) {\n        if (typeof v !== 'number') {\n            return false;\n        }\n        if (NumberIsNaN(v)) {\n            return false;\n        }\n        if (v < 0) {\n            return false;\n        }\n        return true;\n    }\n    function CloneAsUint8Array(O) {\n        const buffer = ArrayBufferSlice(O.buffer, O.byteOffset, O.byteOffset + O.byteLength);\n        return new Uint8Array(buffer);\n    }\n\n    function DequeueValue(container) {\n        const pair = container._queue.shift();\n        container._queueTotalSize -= pair.size;\n        if (container._queueTotalSize < 0) {\n            container._queueTotalSize = 0;\n        }\n        return pair.value;\n    }\n    function EnqueueValueWithSize(container, value, size) {\n        if (!IsNonNegativeNumber(size) || size === Infinity) {\n            throw new RangeError('Size must be a finite, non-NaN, non-negative number.');\n        }\n        container._queue.push({ value, size });\n        container._queueTotalSize += size;\n    }\n    function PeekQueueValue(container) {\n        const pair = container._queue.peek();\n        return pair.value;\n    }\n    function ResetQueue(container) {\n        container._queue = new SimpleQueue();\n        container._queueTotalSize = 0;\n    }\n\n    /**\n     * A pull-into request in a {@link ReadableByteStreamController}.\n     *\n     * @public\n     */\n    class ReadableStreamBYOBRequest {\n        constructor() {\n            throw new TypeError('Illegal constructor');\n        }\n        /**\n         * Returns the view for writing in to, or `null` if the BYOB request has already been responded to.\n         */\n        get view() {\n            if (!IsReadableStreamBYOBRequest(this)) {\n                throw byobRequestBrandCheckException('view');\n            }\n            return this._view;\n        }\n        respond(bytesWritten) {\n            if (!IsReadableStreamBYOBRequest(this)) {\n                throw byobRequestBrandCheckException('respond');\n            }\n            assertRequiredArgument(bytesWritten, 1, 'respond');\n            bytesWritten = convertUnsignedLongLongWithEnforceRange(bytesWritten, 'First parameter');\n            if (this._associatedReadableByteStreamController === undefined) {\n                throw new TypeError('This BYOB request has been invalidated');\n            }\n            if (IsDetachedBuffer(this._view.buffer)) ;\n            ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);\n        }\n        respondWithNewView(view) {\n            if (!IsReadableStreamBYOBRequest(this)) {\n                throw byobRequestBrandCheckException('respondWithNewView');\n            }\n            assertRequiredArgument(view, 1, 'respondWithNewView');\n            if (!ArrayBuffer.isView(view)) {\n                throw new TypeError('You can only respond with array buffer views');\n            }\n            if (this._associatedReadableByteStreamController === undefined) {\n                throw new TypeError('This BYOB request has been invalidated');\n            }\n            if (IsDetachedBuffer(view.buffer)) ;\n            ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);\n        }\n    }\n    Object.defineProperties(ReadableStreamBYOBRequest.prototype, {\n        respond: { enumerable: true },\n        respondWithNewView: { enumerable: true },\n        view: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(ReadableStreamBYOBRequest.prototype, SymbolPolyfill.toStringTag, {\n            value: 'ReadableStreamBYOBRequest',\n            configurable: true\n        });\n    }\n    /**\n     * Allows control of a {@link ReadableStream | readable byte stream}'s state and internal queue.\n     *\n     * @public\n     */\n    class ReadableByteStreamController {\n        constructor() {\n            throw new TypeError('Illegal constructor');\n        }\n        /**\n         * Returns the current BYOB pull request, or `null` if there isn't one.\n         */\n        get byobRequest() {\n            if (!IsReadableByteStreamController(this)) {\n                throw byteStreamControllerBrandCheckException('byobRequest');\n            }\n            return ReadableByteStreamControllerGetBYOBRequest(this);\n        }\n        /**\n         * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is\n         * over-full. An underlying byte source ought to use this information to determine when and how to apply backpressure.\n         */\n        get desiredSize() {\n            if (!IsReadableByteStreamController(this)) {\n                throw byteStreamControllerBrandCheckException('desiredSize');\n            }\n            return ReadableByteStreamControllerGetDesiredSize(this);\n        }\n        /**\n         * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from\n         * the stream, but once those are read, the stream will become closed.\n         */\n        close() {\n            if (!IsReadableByteStreamController(this)) {\n                throw byteStreamControllerBrandCheckException('close');\n            }\n            if (this._closeRequested) {\n                throw new TypeError('The stream has already been closed; do not close it again!');\n            }\n            const state = this._controlledReadableByteStream._state;\n            if (state !== 'readable') {\n                throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be closed`);\n            }\n            ReadableByteStreamControllerClose(this);\n        }\n        enqueue(chunk) {\n            if (!IsReadableByteStreamController(this)) {\n                throw byteStreamControllerBrandCheckException('enqueue');\n            }\n            assertRequiredArgument(chunk, 1, 'enqueue');\n            if (!ArrayBuffer.isView(chunk)) {\n                throw new TypeError('chunk must be an array buffer view');\n            }\n            if (chunk.byteLength === 0) {\n                throw new TypeError('chunk must have non-zero byteLength');\n            }\n            if (chunk.buffer.byteLength === 0) {\n                throw new TypeError(`chunk's buffer must have non-zero byteLength`);\n            }\n            if (this._closeRequested) {\n                throw new TypeError('stream is closed or draining');\n            }\n            const state = this._controlledReadableByteStream._state;\n            if (state !== 'readable') {\n                throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be enqueued to`);\n            }\n            ReadableByteStreamControllerEnqueue(this, chunk);\n        }\n        /**\n         * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.\n         */\n        error(e = undefined) {\n            if (!IsReadableByteStreamController(this)) {\n                throw byteStreamControllerBrandCheckException('error');\n            }\n            ReadableByteStreamControllerError(this, e);\n        }\n        /** @internal */\n        [CancelSteps](reason) {\n            ReadableByteStreamControllerClearPendingPullIntos(this);\n            ResetQueue(this);\n            const result = this._cancelAlgorithm(reason);\n            ReadableByteStreamControllerClearAlgorithms(this);\n            return result;\n        }\n        /** @internal */\n        [PullSteps](readRequest) {\n            const stream = this._controlledReadableByteStream;\n            if (this._queueTotalSize > 0) {\n                const entry = this._queue.shift();\n                this._queueTotalSize -= entry.byteLength;\n                ReadableByteStreamControllerHandleQueueDrain(this);\n                const view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);\n                readRequest._chunkSteps(view);\n                return;\n            }\n            const autoAllocateChunkSize = this._autoAllocateChunkSize;\n            if (autoAllocateChunkSize !== undefined) {\n                let buffer;\n                try {\n                    buffer = new ArrayBuffer(autoAllocateChunkSize);\n                }\n                catch (bufferE) {\n                    readRequest._errorSteps(bufferE);\n                    return;\n                }\n                const pullIntoDescriptor = {\n                    buffer,\n                    bufferByteLength: autoAllocateChunkSize,\n                    byteOffset: 0,\n                    byteLength: autoAllocateChunkSize,\n                    bytesFilled: 0,\n                    elementSize: 1,\n                    viewConstructor: Uint8Array,\n                    readerType: 'default'\n                };\n                this._pendingPullIntos.push(pullIntoDescriptor);\n            }\n            ReadableStreamAddReadRequest(stream, readRequest);\n            ReadableByteStreamControllerCallPullIfNeeded(this);\n        }\n    }\n    Object.defineProperties(ReadableByteStreamController.prototype, {\n        close: { enumerable: true },\n        enqueue: { enumerable: true },\n        error: { enumerable: true },\n        byobRequest: { enumerable: true },\n        desiredSize: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(ReadableByteStreamController.prototype, SymbolPolyfill.toStringTag, {\n            value: 'ReadableByteStreamController',\n            configurable: true\n        });\n    }\n    // Abstract operations for the ReadableByteStreamController.\n    function IsReadableByteStreamController(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableByteStream')) {\n            return false;\n        }\n        return x instanceof ReadableByteStreamController;\n    }\n    function IsReadableStreamBYOBRequest(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {\n            return false;\n        }\n        return x instanceof ReadableStreamBYOBRequest;\n    }\n    function ReadableByteStreamControllerCallPullIfNeeded(controller) {\n        const shouldPull = ReadableByteStreamControllerShouldCallPull(controller);\n        if (!shouldPull) {\n            return;\n        }\n        if (controller._pulling) {\n            controller._pullAgain = true;\n            return;\n        }\n        controller._pulling = true;\n        // TODO: Test controller argument\n        const pullPromise = controller._pullAlgorithm();\n        uponPromise(pullPromise, () => {\n            controller._pulling = false;\n            if (controller._pullAgain) {\n                controller._pullAgain = false;\n                ReadableByteStreamControllerCallPullIfNeeded(controller);\n            }\n        }, e => {\n            ReadableByteStreamControllerError(controller, e);\n        });\n    }\n    function ReadableByteStreamControllerClearPendingPullIntos(controller) {\n        ReadableByteStreamControllerInvalidateBYOBRequest(controller);\n        controller._pendingPullIntos = new SimpleQueue();\n    }\n    function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {\n        let done = false;\n        if (stream._state === 'closed') {\n            done = true;\n        }\n        const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);\n        if (pullIntoDescriptor.readerType === 'default') {\n            ReadableStreamFulfillReadRequest(stream, filledView, done);\n        }\n        else {\n            ReadableStreamFulfillReadIntoRequest(stream, filledView, done);\n        }\n    }\n    function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {\n        const bytesFilled = pullIntoDescriptor.bytesFilled;\n        const elementSize = pullIntoDescriptor.elementSize;\n        return new pullIntoDescriptor.viewConstructor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize);\n    }\n    function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) {\n        controller._queue.push({ buffer, byteOffset, byteLength });\n        controller._queueTotalSize += byteLength;\n    }\n    function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {\n        const elementSize = pullIntoDescriptor.elementSize;\n        const currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize;\n        const maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);\n        const maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;\n        const maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize;\n        let totalBytesToCopyRemaining = maxBytesToCopy;\n        let ready = false;\n        if (maxAlignedBytes > currentAlignedBytes) {\n            totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;\n            ready = true;\n        }\n        const queue = controller._queue;\n        while (totalBytesToCopyRemaining > 0) {\n            const headOfQueue = queue.peek();\n            const bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength);\n            const destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;\n            CopyDataBlockBytes(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy);\n            if (headOfQueue.byteLength === bytesToCopy) {\n                queue.shift();\n            }\n            else {\n                headOfQueue.byteOffset += bytesToCopy;\n                headOfQueue.byteLength -= bytesToCopy;\n            }\n            controller._queueTotalSize -= bytesToCopy;\n            ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor);\n            totalBytesToCopyRemaining -= bytesToCopy;\n        }\n        return ready;\n    }\n    function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {\n        pullIntoDescriptor.bytesFilled += size;\n    }\n    function ReadableByteStreamControllerHandleQueueDrain(controller) {\n        if (controller._queueTotalSize === 0 && controller._closeRequested) {\n            ReadableByteStreamControllerClearAlgorithms(controller);\n            ReadableStreamClose(controller._controlledReadableByteStream);\n        }\n        else {\n            ReadableByteStreamControllerCallPullIfNeeded(controller);\n        }\n    }\n    function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {\n        if (controller._byobRequest === null) {\n            return;\n        }\n        controller._byobRequest._associatedReadableByteStreamController = undefined;\n        controller._byobRequest._view = null;\n        controller._byobRequest = null;\n    }\n    function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {\n        while (controller._pendingPullIntos.length > 0) {\n            if (controller._queueTotalSize === 0) {\n                return;\n            }\n            const pullIntoDescriptor = controller._pendingPullIntos.peek();\n            if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {\n                ReadableByteStreamControllerShiftPendingPullInto(controller);\n                ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);\n            }\n        }\n    }\n    function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest) {\n        const stream = controller._controlledReadableByteStream;\n        let elementSize = 1;\n        if (view.constructor !== DataView) {\n            elementSize = view.constructor.BYTES_PER_ELEMENT;\n        }\n        const ctor = view.constructor;\n        // try {\n        const buffer = TransferArrayBuffer(view.buffer);\n        // } catch (e) {\n        //   readIntoRequest._errorSteps(e);\n        //   return;\n        // }\n        const pullIntoDescriptor = {\n            buffer,\n            bufferByteLength: buffer.byteLength,\n            byteOffset: view.byteOffset,\n            byteLength: view.byteLength,\n            bytesFilled: 0,\n            elementSize,\n            viewConstructor: ctor,\n            readerType: 'byob'\n        };\n        if (controller._pendingPullIntos.length > 0) {\n            controller._pendingPullIntos.push(pullIntoDescriptor);\n            // No ReadableByteStreamControllerCallPullIfNeeded() call since:\n            // - No change happens on desiredSize\n            // - The source has already been notified of that there's at least 1 pending read(view)\n            ReadableStreamAddReadIntoRequest(stream, readIntoRequest);\n            return;\n        }\n        if (stream._state === 'closed') {\n            const emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);\n            readIntoRequest._closeSteps(emptyView);\n            return;\n        }\n        if (controller._queueTotalSize > 0) {\n            if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {\n                const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);\n                ReadableByteStreamControllerHandleQueueDrain(controller);\n                readIntoRequest._chunkSteps(filledView);\n                return;\n            }\n            if (controller._closeRequested) {\n                const e = new TypeError('Insufficient bytes to fill elements in the given buffer');\n                ReadableByteStreamControllerError(controller, e);\n                readIntoRequest._errorSteps(e);\n                return;\n            }\n        }\n        controller._pendingPullIntos.push(pullIntoDescriptor);\n        ReadableStreamAddReadIntoRequest(stream, readIntoRequest);\n        ReadableByteStreamControllerCallPullIfNeeded(controller);\n    }\n    function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {\n        const stream = controller._controlledReadableByteStream;\n        if (ReadableStreamHasBYOBReader(stream)) {\n            while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {\n                const pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);\n                ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);\n            }\n        }\n    }\n    function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {\n        ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);\n        if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {\n            return;\n        }\n        ReadableByteStreamControllerShiftPendingPullInto(controller);\n        const remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;\n        if (remainderSize > 0) {\n            const end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;\n            const remainder = ArrayBufferSlice(pullIntoDescriptor.buffer, end - remainderSize, end);\n            ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);\n        }\n        pullIntoDescriptor.bytesFilled -= remainderSize;\n        ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);\n        ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);\n    }\n    function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {\n        const firstDescriptor = controller._pendingPullIntos.peek();\n        ReadableByteStreamControllerInvalidateBYOBRequest(controller);\n        const state = controller._controlledReadableByteStream._state;\n        if (state === 'closed') {\n            ReadableByteStreamControllerRespondInClosedState(controller);\n        }\n        else {\n            ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);\n        }\n        ReadableByteStreamControllerCallPullIfNeeded(controller);\n    }\n    function ReadableByteStreamControllerShiftPendingPullInto(controller) {\n        const descriptor = controller._pendingPullIntos.shift();\n        return descriptor;\n    }\n    function ReadableByteStreamControllerShouldCallPull(controller) {\n        const stream = controller._controlledReadableByteStream;\n        if (stream._state !== 'readable') {\n            return false;\n        }\n        if (controller._closeRequested) {\n            return false;\n        }\n        if (!controller._started) {\n            return false;\n        }\n        if (ReadableStreamHasDefaultReader(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {\n            return true;\n        }\n        if (ReadableStreamHasBYOBReader(stream) && ReadableStreamGetNumReadIntoRequests(stream) > 0) {\n            return true;\n        }\n        const desiredSize = ReadableByteStreamControllerGetDesiredSize(controller);\n        if (desiredSize > 0) {\n            return true;\n        }\n        return false;\n    }\n    function ReadableByteStreamControllerClearAlgorithms(controller) {\n        controller._pullAlgorithm = undefined;\n        controller._cancelAlgorithm = undefined;\n    }\n    // A client of ReadableByteStreamController may use these functions directly to bypass state check.\n    function ReadableByteStreamControllerClose(controller) {\n        const stream = controller._controlledReadableByteStream;\n        if (controller._closeRequested || stream._state !== 'readable') {\n            return;\n        }\n        if (controller._queueTotalSize > 0) {\n            controller._closeRequested = true;\n            return;\n        }\n        if (controller._pendingPullIntos.length > 0) {\n            const firstPendingPullInto = controller._pendingPullIntos.peek();\n            if (firstPendingPullInto.bytesFilled > 0) {\n                const e = new TypeError('Insufficient bytes to fill elements in the given buffer');\n                ReadableByteStreamControllerError(controller, e);\n                throw e;\n            }\n        }\n        ReadableByteStreamControllerClearAlgorithms(controller);\n        ReadableStreamClose(stream);\n    }\n    function ReadableByteStreamControllerEnqueue(controller, chunk) {\n        const stream = controller._controlledReadableByteStream;\n        if (controller._closeRequested || stream._state !== 'readable') {\n            return;\n        }\n        const buffer = chunk.buffer;\n        const byteOffset = chunk.byteOffset;\n        const byteLength = chunk.byteLength;\n        const transferredBuffer = TransferArrayBuffer(buffer);\n        if (controller._pendingPullIntos.length > 0) {\n            const firstPendingPullInto = controller._pendingPullIntos.peek();\n            if (IsDetachedBuffer(firstPendingPullInto.buffer)) ;\n            firstPendingPullInto.buffer = TransferArrayBuffer(firstPendingPullInto.buffer);\n        }\n        ReadableByteStreamControllerInvalidateBYOBRequest(controller);\n        if (ReadableStreamHasDefaultReader(stream)) {\n            if (ReadableStreamGetNumReadRequests(stream) === 0) {\n                ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);\n            }\n            else {\n                if (controller._pendingPullIntos.length > 0) {\n                    ReadableByteStreamControllerShiftPendingPullInto(controller);\n                }\n                const transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);\n                ReadableStreamFulfillReadRequest(stream, transferredView, false);\n            }\n        }\n        else if (ReadableStreamHasBYOBReader(stream)) {\n            // TODO: Ideally in this branch detaching should happen only if the buffer is not consumed fully.\n            ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);\n            ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);\n        }\n        else {\n            ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);\n        }\n        ReadableByteStreamControllerCallPullIfNeeded(controller);\n    }\n    function ReadableByteStreamControllerError(controller, e) {\n        const stream = controller._controlledReadableByteStream;\n        if (stream._state !== 'readable') {\n            return;\n        }\n        ReadableByteStreamControllerClearPendingPullIntos(controller);\n        ResetQueue(controller);\n        ReadableByteStreamControllerClearAlgorithms(controller);\n        ReadableStreamError(stream, e);\n    }\n    function ReadableByteStreamControllerGetBYOBRequest(controller) {\n        if (controller._byobRequest === null && controller._pendingPullIntos.length > 0) {\n            const firstDescriptor = controller._pendingPullIntos.peek();\n            const view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);\n            const byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);\n            SetUpReadableStreamBYOBRequest(byobRequest, controller, view);\n            controller._byobRequest = byobRequest;\n        }\n        return controller._byobRequest;\n    }\n    function ReadableByteStreamControllerGetDesiredSize(controller) {\n        const state = controller._controlledReadableByteStream._state;\n        if (state === 'errored') {\n            return null;\n        }\n        if (state === 'closed') {\n            return 0;\n        }\n        return controller._strategyHWM - controller._queueTotalSize;\n    }\n    function ReadableByteStreamControllerRespond(controller, bytesWritten) {\n        const firstDescriptor = controller._pendingPullIntos.peek();\n        const state = controller._controlledReadableByteStream._state;\n        if (state === 'closed') {\n            if (bytesWritten !== 0) {\n                throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream');\n            }\n        }\n        else {\n            if (bytesWritten === 0) {\n                throw new TypeError('bytesWritten must be greater than 0 when calling respond() on a readable stream');\n            }\n            if (firstDescriptor.bytesFilled + bytesWritten > firstDescriptor.byteLength) {\n                throw new RangeError('bytesWritten out of range');\n            }\n        }\n        firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);\n        ReadableByteStreamControllerRespondInternal(controller, bytesWritten);\n    }\n    function ReadableByteStreamControllerRespondWithNewView(controller, view) {\n        const firstDescriptor = controller._pendingPullIntos.peek();\n        const state = controller._controlledReadableByteStream._state;\n        if (state === 'closed') {\n            if (view.byteLength !== 0) {\n                throw new TypeError('The view\\'s length must be 0 when calling respondWithNewView() on a closed stream');\n            }\n        }\n        else {\n            if (view.byteLength === 0) {\n                throw new TypeError('The view\\'s length must be greater than 0 when calling respondWithNewView() on a readable stream');\n            }\n        }\n        if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) {\n            throw new RangeError('The region specified by view does not match byobRequest');\n        }\n        if (firstDescriptor.bufferByteLength !== view.buffer.byteLength) {\n            throw new RangeError('The buffer of view has different capacity than byobRequest');\n        }\n        if (firstDescriptor.bytesFilled + view.byteLength > firstDescriptor.byteLength) {\n            throw new RangeError('The region specified by view is larger than byobRequest');\n        }\n        const viewByteLength = view.byteLength;\n        firstDescriptor.buffer = TransferArrayBuffer(view.buffer);\n        ReadableByteStreamControllerRespondInternal(controller, viewByteLength);\n    }\n    function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) {\n        controller._controlledReadableByteStream = stream;\n        controller._pullAgain = false;\n        controller._pulling = false;\n        controller._byobRequest = null;\n        // Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly.\n        controller._queue = controller._queueTotalSize = undefined;\n        ResetQueue(controller);\n        controller._closeRequested = false;\n        controller._started = false;\n        controller._strategyHWM = highWaterMark;\n        controller._pullAlgorithm = pullAlgorithm;\n        controller._cancelAlgorithm = cancelAlgorithm;\n        controller._autoAllocateChunkSize = autoAllocateChunkSize;\n        controller._pendingPullIntos = new SimpleQueue();\n        stream._readableStreamController = controller;\n        const startResult = startAlgorithm();\n        uponPromise(promiseResolvedWith(startResult), () => {\n            controller._started = true;\n            ReadableByteStreamControllerCallPullIfNeeded(controller);\n        }, r => {\n            ReadableByteStreamControllerError(controller, r);\n        });\n    }\n    function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) {\n        const controller = Object.create(ReadableByteStreamController.prototype);\n        let startAlgorithm = () => undefined;\n        let pullAlgorithm = () => promiseResolvedWith(undefined);\n        let cancelAlgorithm = () => promiseResolvedWith(undefined);\n        if (underlyingByteSource.start !== undefined) {\n            startAlgorithm = () => underlyingByteSource.start(controller);\n        }\n        if (underlyingByteSource.pull !== undefined) {\n            pullAlgorithm = () => underlyingByteSource.pull(controller);\n        }\n        if (underlyingByteSource.cancel !== undefined) {\n            cancelAlgorithm = reason => underlyingByteSource.cancel(reason);\n        }\n        const autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;\n        if (autoAllocateChunkSize === 0) {\n            throw new TypeError('autoAllocateChunkSize must be greater than 0');\n        }\n        SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize);\n    }\n    function SetUpReadableStreamBYOBRequest(request, controller, view) {\n        request._associatedReadableByteStreamController = controller;\n        request._view = view;\n    }\n    // Helper functions for the ReadableStreamBYOBRequest.\n    function byobRequestBrandCheckException(name) {\n        return new TypeError(`ReadableStreamBYOBRequest.prototype.${name} can only be used on a ReadableStreamBYOBRequest`);\n    }\n    // Helper functions for the ReadableByteStreamController.\n    function byteStreamControllerBrandCheckException(name) {\n        return new TypeError(`ReadableByteStreamController.prototype.${name} can only be used on a ReadableByteStreamController`);\n    }\n\n    // Abstract operations for the ReadableStream.\n    function AcquireReadableStreamBYOBReader(stream) {\n        return new ReadableStreamBYOBReader(stream);\n    }\n    // ReadableStream API exposed for controllers.\n    function ReadableStreamAddReadIntoRequest(stream, readIntoRequest) {\n        stream._reader._readIntoRequests.push(readIntoRequest);\n    }\n    function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {\n        const reader = stream._reader;\n        const readIntoRequest = reader._readIntoRequests.shift();\n        if (done) {\n            readIntoRequest._closeSteps(chunk);\n        }\n        else {\n            readIntoRequest._chunkSteps(chunk);\n        }\n    }\n    function ReadableStreamGetNumReadIntoRequests(stream) {\n        return stream._reader._readIntoRequests.length;\n    }\n    function ReadableStreamHasBYOBReader(stream) {\n        const reader = stream._reader;\n        if (reader === undefined) {\n            return false;\n        }\n        if (!IsReadableStreamBYOBReader(reader)) {\n            return false;\n        }\n        return true;\n    }\n    /**\n     * A BYOB reader vended by a {@link ReadableStream}.\n     *\n     * @public\n     */\n    class ReadableStreamBYOBReader {\n        constructor(stream) {\n            assertRequiredArgument(stream, 1, 'ReadableStreamBYOBReader');\n            assertReadableStream(stream, 'First parameter');\n            if (IsReadableStreamLocked(stream)) {\n                throw new TypeError('This stream has already been locked for exclusive reading by another reader');\n            }\n            if (!IsReadableByteStreamController(stream._readableStreamController)) {\n                throw new TypeError('Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte ' +\n                    'source');\n            }\n            ReadableStreamReaderGenericInitialize(this, stream);\n            this._readIntoRequests = new SimpleQueue();\n        }\n        /**\n         * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or\n         * the reader's lock is released before the stream finishes closing.\n         */\n        get closed() {\n            if (!IsReadableStreamBYOBReader(this)) {\n                return promiseRejectedWith(byobReaderBrandCheckException('closed'));\n            }\n            return this._closedPromise;\n        }\n        /**\n         * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.\n         */\n        cancel(reason = undefined) {\n            if (!IsReadableStreamBYOBReader(this)) {\n                return promiseRejectedWith(byobReaderBrandCheckException('cancel'));\n            }\n            if (this._ownerReadableStream === undefined) {\n                return promiseRejectedWith(readerLockException('cancel'));\n            }\n            return ReadableStreamReaderGenericCancel(this, reason);\n        }\n        /**\n         * Attempts to reads bytes into view, and returns a promise resolved with the result.\n         *\n         * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.\n         */\n        read(view) {\n            if (!IsReadableStreamBYOBReader(this)) {\n                return promiseRejectedWith(byobReaderBrandCheckException('read'));\n            }\n            if (!ArrayBuffer.isView(view)) {\n                return promiseRejectedWith(new TypeError('view must be an array buffer view'));\n            }\n            if (view.byteLength === 0) {\n                return promiseRejectedWith(new TypeError('view must have non-zero byteLength'));\n            }\n            if (view.buffer.byteLength === 0) {\n                return promiseRejectedWith(new TypeError(`view's buffer must have non-zero byteLength`));\n            }\n            if (IsDetachedBuffer(view.buffer)) ;\n            if (this._ownerReadableStream === undefined) {\n                return promiseRejectedWith(readerLockException('read from'));\n            }\n            let resolvePromise;\n            let rejectPromise;\n            const promise = newPromise((resolve, reject) => {\n                resolvePromise = resolve;\n                rejectPromise = reject;\n            });\n            const readIntoRequest = {\n                _chunkSteps: chunk => resolvePromise({ value: chunk, done: false }),\n                _closeSteps: chunk => resolvePromise({ value: chunk, done: true }),\n                _errorSteps: e => rejectPromise(e)\n            };\n            ReadableStreamBYOBReaderRead(this, view, readIntoRequest);\n            return promise;\n        }\n        /**\n         * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.\n         * If the associated stream is errored when the lock is released, the reader will appear errored in the same way\n         * from now on; otherwise, the reader will appear closed.\n         *\n         * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by\n         * the reader's {@link ReadableStreamBYOBReader.read | read()} method has not yet been settled. Attempting to\n         * do so will throw a `TypeError` and leave the reader locked to the stream.\n         */\n        releaseLock() {\n            if (!IsReadableStreamBYOBReader(this)) {\n                throw byobReaderBrandCheckException('releaseLock');\n            }\n            if (this._ownerReadableStream === undefined) {\n                return;\n            }\n            if (this._readIntoRequests.length > 0) {\n                throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');\n            }\n            ReadableStreamReaderGenericRelease(this);\n        }\n    }\n    Object.defineProperties(ReadableStreamBYOBReader.prototype, {\n        cancel: { enumerable: true },\n        read: { enumerable: true },\n        releaseLock: { enumerable: true },\n        closed: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(ReadableStreamBYOBReader.prototype, SymbolPolyfill.toStringTag, {\n            value: 'ReadableStreamBYOBReader',\n            configurable: true\n        });\n    }\n    // Abstract operations for the readers.\n    function IsReadableStreamBYOBReader(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {\n            return false;\n        }\n        return x instanceof ReadableStreamBYOBReader;\n    }\n    function ReadableStreamBYOBReaderRead(reader, view, readIntoRequest) {\n        const stream = reader._ownerReadableStream;\n        stream._disturbed = true;\n        if (stream._state === 'errored') {\n            readIntoRequest._errorSteps(stream._storedError);\n        }\n        else {\n            ReadableByteStreamControllerPullInto(stream._readableStreamController, view, readIntoRequest);\n        }\n    }\n    // Helper functions for the ReadableStreamBYOBReader.\n    function byobReaderBrandCheckException(name) {\n        return new TypeError(`ReadableStreamBYOBReader.prototype.${name} can only be used on a ReadableStreamBYOBReader`);\n    }\n\n    function ExtractHighWaterMark(strategy, defaultHWM) {\n        const { highWaterMark } = strategy;\n        if (highWaterMark === undefined) {\n            return defaultHWM;\n        }\n        if (NumberIsNaN(highWaterMark) || highWaterMark < 0) {\n            throw new RangeError('Invalid highWaterMark');\n        }\n        return highWaterMark;\n    }\n    function ExtractSizeAlgorithm(strategy) {\n        const { size } = strategy;\n        if (!size) {\n            return () => 1;\n        }\n        return size;\n    }\n\n    function convertQueuingStrategy(init, context) {\n        assertDictionary(init, context);\n        const highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;\n        const size = init === null || init === void 0 ? void 0 : init.size;\n        return {\n            highWaterMark: highWaterMark === undefined ? undefined : convertUnrestrictedDouble(highWaterMark),\n            size: size === undefined ? undefined : convertQueuingStrategySize(size, `${context} has member 'size' that`)\n        };\n    }\n    function convertQueuingStrategySize(fn, context) {\n        assertFunction(fn, context);\n        return chunk => convertUnrestrictedDouble(fn(chunk));\n    }\n\n    function convertUnderlyingSink(original, context) {\n        assertDictionary(original, context);\n        const abort = original === null || original === void 0 ? void 0 : original.abort;\n        const close = original === null || original === void 0 ? void 0 : original.close;\n        const start = original === null || original === void 0 ? void 0 : original.start;\n        const type = original === null || original === void 0 ? void 0 : original.type;\n        const write = original === null || original === void 0 ? void 0 : original.write;\n        return {\n            abort: abort === undefined ?\n                undefined :\n                convertUnderlyingSinkAbortCallback(abort, original, `${context} has member 'abort' that`),\n            close: close === undefined ?\n                undefined :\n                convertUnderlyingSinkCloseCallback(close, original, `${context} has member 'close' that`),\n            start: start === undefined ?\n                undefined :\n                convertUnderlyingSinkStartCallback(start, original, `${context} has member 'start' that`),\n            write: write === undefined ?\n                undefined :\n                convertUnderlyingSinkWriteCallback(write, original, `${context} has member 'write' that`),\n            type\n        };\n    }\n    function convertUnderlyingSinkAbortCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return (reason) => promiseCall(fn, original, [reason]);\n    }\n    function convertUnderlyingSinkCloseCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return () => promiseCall(fn, original, []);\n    }\n    function convertUnderlyingSinkStartCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return (controller) => reflectCall(fn, original, [controller]);\n    }\n    function convertUnderlyingSinkWriteCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return (chunk, controller) => promiseCall(fn, original, [chunk, controller]);\n    }\n\n    function assertWritableStream(x, context) {\n        if (!IsWritableStream(x)) {\n            throw new TypeError(`${context} is not a WritableStream.`);\n        }\n    }\n\n    function isAbortSignal(value) {\n        if (typeof value !== 'object' || value === null) {\n            return false;\n        }\n        try {\n            return typeof value.aborted === 'boolean';\n        }\n        catch (_a) {\n            // AbortSignal.prototype.aborted throws if its brand check fails\n            return false;\n        }\n    }\n    const supportsAbortController = typeof AbortController === 'function';\n    /**\n     * Construct a new AbortController, if supported by the platform.\n     *\n     * @internal\n     */\n    function createAbortController() {\n        if (supportsAbortController) {\n            return new AbortController();\n        }\n        return undefined;\n    }\n\n    /**\n     * A writable stream represents a destination for data, into which you can write.\n     *\n     * @public\n     */\n    class WritableStream {\n        constructor(rawUnderlyingSink = {}, rawStrategy = {}) {\n            if (rawUnderlyingSink === undefined) {\n                rawUnderlyingSink = null;\n            }\n            else {\n                assertObject(rawUnderlyingSink, 'First parameter');\n            }\n            const strategy = convertQueuingStrategy(rawStrategy, 'Second parameter');\n            const underlyingSink = convertUnderlyingSink(rawUnderlyingSink, 'First parameter');\n            InitializeWritableStream(this);\n            const type = underlyingSink.type;\n            if (type !== undefined) {\n                throw new RangeError('Invalid type is specified');\n            }\n            const sizeAlgorithm = ExtractSizeAlgorithm(strategy);\n            const highWaterMark = ExtractHighWaterMark(strategy, 1);\n            SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm);\n        }\n        /**\n         * Returns whether or not the writable stream is locked to a writer.\n         */\n        get locked() {\n            if (!IsWritableStream(this)) {\n                throw streamBrandCheckException$2('locked');\n            }\n            return IsWritableStreamLocked(this);\n        }\n        /**\n         * Aborts the stream, signaling that the producer can no longer successfully write to the stream and it is to be\n         * immediately moved to an errored state, with any queued-up writes discarded. This will also execute any abort\n         * mechanism of the underlying sink.\n         *\n         * The returned promise will fulfill if the stream shuts down successfully, or reject if the underlying sink signaled\n         * that there was an error doing so. Additionally, it will reject with a `TypeError` (without attempting to cancel\n         * the stream) if the stream is currently locked.\n         */\n        abort(reason = undefined) {\n            if (!IsWritableStream(this)) {\n                return promiseRejectedWith(streamBrandCheckException$2('abort'));\n            }\n            if (IsWritableStreamLocked(this)) {\n                return promiseRejectedWith(new TypeError('Cannot abort a stream that already has a writer'));\n            }\n            return WritableStreamAbort(this, reason);\n        }\n        /**\n         * Closes the stream. The underlying sink will finish processing any previously-written chunks, before invoking its\n         * close behavior. During this time any further attempts to write will fail (without erroring the stream).\n         *\n         * The method returns a promise that will fulfill if all remaining chunks are successfully written and the stream\n         * successfully closes, or rejects if an error is encountered during this process. Additionally, it will reject with\n         * a `TypeError` (without attempting to cancel the stream) if the stream is currently locked.\n         */\n        close() {\n            if (!IsWritableStream(this)) {\n                return promiseRejectedWith(streamBrandCheckException$2('close'));\n            }\n            if (IsWritableStreamLocked(this)) {\n                return promiseRejectedWith(new TypeError('Cannot close a stream that already has a writer'));\n            }\n            if (WritableStreamCloseQueuedOrInFlight(this)) {\n                return promiseRejectedWith(new TypeError('Cannot close an already-closing stream'));\n            }\n            return WritableStreamClose(this);\n        }\n        /**\n         * Creates a {@link WritableStreamDefaultWriter | writer} and locks the stream to the new writer. While the stream\n         * is locked, no other writer can be acquired until this one is released.\n         *\n         * This functionality is especially useful for creating abstractions that desire the ability to write to a stream\n         * without interruption or interleaving. By getting a writer for the stream, you can ensure nobody else can write at\n         * the same time, which would cause the resulting written data to be unpredictable and probably useless.\n         */\n        getWriter() {\n            if (!IsWritableStream(this)) {\n                throw streamBrandCheckException$2('getWriter');\n            }\n            return AcquireWritableStreamDefaultWriter(this);\n        }\n    }\n    Object.defineProperties(WritableStream.prototype, {\n        abort: { enumerable: true },\n        close: { enumerable: true },\n        getWriter: { enumerable: true },\n        locked: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(WritableStream.prototype, SymbolPolyfill.toStringTag, {\n            value: 'WritableStream',\n            configurable: true\n        });\n    }\n    // Abstract operations for the WritableStream.\n    function AcquireWritableStreamDefaultWriter(stream) {\n        return new WritableStreamDefaultWriter(stream);\n    }\n    // Throws if and only if startAlgorithm throws.\n    function CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark = 1, sizeAlgorithm = () => 1) {\n        const stream = Object.create(WritableStream.prototype);\n        InitializeWritableStream(stream);\n        const controller = Object.create(WritableStreamDefaultController.prototype);\n        SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);\n        return stream;\n    }\n    function InitializeWritableStream(stream) {\n        stream._state = 'writable';\n        // The error that will be reported by new method calls once the state becomes errored. Only set when [[state]] is\n        // 'erroring' or 'errored'. May be set to an undefined value.\n        stream._storedError = undefined;\n        stream._writer = undefined;\n        // Initialize to undefined first because the constructor of the controller checks this\n        // variable to validate the caller.\n        stream._writableStreamController = undefined;\n        // This queue is placed here instead of the writer class in order to allow for passing a writer to the next data\n        // producer without waiting for the queued writes to finish.\n        stream._writeRequests = new SimpleQueue();\n        // Write requests are removed from _writeRequests when write() is called on the underlying sink. This prevents\n        // them from being erroneously rejected on error. If a write() call is in-flight, the request is stored here.\n        stream._inFlightWriteRequest = undefined;\n        // The promise that was returned from writer.close(). Stored here because it may be fulfilled after the writer\n        // has been detached.\n        stream._closeRequest = undefined;\n        // Close request is removed from _closeRequest when close() is called on the underlying sink. This prevents it\n        // from being erroneously rejected on error. If a close() call is in-flight, the request is stored here.\n        stream._inFlightCloseRequest = undefined;\n        // The promise that was returned from writer.abort(). This may also be fulfilled after the writer has detached.\n        stream._pendingAbortRequest = undefined;\n        // The backpressure signal set by the controller.\n        stream._backpressure = false;\n    }\n    function IsWritableStream(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) {\n            return false;\n        }\n        return x instanceof WritableStream;\n    }\n    function IsWritableStreamLocked(stream) {\n        if (stream._writer === undefined) {\n            return false;\n        }\n        return true;\n    }\n    function WritableStreamAbort(stream, reason) {\n        var _a;\n        if (stream._state === 'closed' || stream._state === 'errored') {\n            return promiseResolvedWith(undefined);\n        }\n        stream._writableStreamController._abortReason = reason;\n        (_a = stream._writableStreamController._abortController) === null || _a === void 0 ? void 0 : _a.abort();\n        // TypeScript narrows the type of `stream._state` down to 'writable' | 'erroring',\n        // but it doesn't know that signaling abort runs author code that might have changed the state.\n        // Widen the type again by casting to WritableStreamState.\n        const state = stream._state;\n        if (state === 'closed' || state === 'errored') {\n            return promiseResolvedWith(undefined);\n        }\n        if (stream._pendingAbortRequest !== undefined) {\n            return stream._pendingAbortRequest._promise;\n        }\n        let wasAlreadyErroring = false;\n        if (state === 'erroring') {\n            wasAlreadyErroring = true;\n            // reason will not be used, so don't keep a reference to it.\n            reason = undefined;\n        }\n        const promise = newPromise((resolve, reject) => {\n            stream._pendingAbortRequest = {\n                _promise: undefined,\n                _resolve: resolve,\n                _reject: reject,\n                _reason: reason,\n                _wasAlreadyErroring: wasAlreadyErroring\n            };\n        });\n        stream._pendingAbortRequest._promise = promise;\n        if (!wasAlreadyErroring) {\n            WritableStreamStartErroring(stream, reason);\n        }\n        return promise;\n    }\n    function WritableStreamClose(stream) {\n        const state = stream._state;\n        if (state === 'closed' || state === 'errored') {\n            return promiseRejectedWith(new TypeError(`The stream (in ${state} state) is not in the writable state and cannot be closed`));\n        }\n        const promise = newPromise((resolve, reject) => {\n            const closeRequest = {\n                _resolve: resolve,\n                _reject: reject\n            };\n            stream._closeRequest = closeRequest;\n        });\n        const writer = stream._writer;\n        if (writer !== undefined && stream._backpressure && state === 'writable') {\n            defaultWriterReadyPromiseResolve(writer);\n        }\n        WritableStreamDefaultControllerClose(stream._writableStreamController);\n        return promise;\n    }\n    // WritableStream API exposed for controllers.\n    function WritableStreamAddWriteRequest(stream) {\n        const promise = newPromise((resolve, reject) => {\n            const writeRequest = {\n                _resolve: resolve,\n                _reject: reject\n            };\n            stream._writeRequests.push(writeRequest);\n        });\n        return promise;\n    }\n    function WritableStreamDealWithRejection(stream, error) {\n        const state = stream._state;\n        if (state === 'writable') {\n            WritableStreamStartErroring(stream, error);\n            return;\n        }\n        WritableStreamFinishErroring(stream);\n    }\n    function WritableStreamStartErroring(stream, reason) {\n        const controller = stream._writableStreamController;\n        stream._state = 'erroring';\n        stream._storedError = reason;\n        const writer = stream._writer;\n        if (writer !== undefined) {\n            WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);\n        }\n        if (!WritableStreamHasOperationMarkedInFlight(stream) && controller._started) {\n            WritableStreamFinishErroring(stream);\n        }\n    }\n    function WritableStreamFinishErroring(stream) {\n        stream._state = 'errored';\n        stream._writableStreamController[ErrorSteps]();\n        const storedError = stream._storedError;\n        stream._writeRequests.forEach(writeRequest => {\n            writeRequest._reject(storedError);\n        });\n        stream._writeRequests = new SimpleQueue();\n        if (stream._pendingAbortRequest === undefined) {\n            WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);\n            return;\n        }\n        const abortRequest = stream._pendingAbortRequest;\n        stream._pendingAbortRequest = undefined;\n        if (abortRequest._wasAlreadyErroring) {\n            abortRequest._reject(storedError);\n            WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);\n            return;\n        }\n        const promise = stream._writableStreamController[AbortSteps](abortRequest._reason);\n        uponPromise(promise, () => {\n            abortRequest._resolve();\n            WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);\n        }, (reason) => {\n            abortRequest._reject(reason);\n            WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);\n        });\n    }\n    function WritableStreamFinishInFlightWrite(stream) {\n        stream._inFlightWriteRequest._resolve(undefined);\n        stream._inFlightWriteRequest = undefined;\n    }\n    function WritableStreamFinishInFlightWriteWithError(stream, error) {\n        stream._inFlightWriteRequest._reject(error);\n        stream._inFlightWriteRequest = undefined;\n        WritableStreamDealWithRejection(stream, error);\n    }\n    function WritableStreamFinishInFlightClose(stream) {\n        stream._inFlightCloseRequest._resolve(undefined);\n        stream._inFlightCloseRequest = undefined;\n        const state = stream._state;\n        if (state === 'erroring') {\n            // The error was too late to do anything, so it is ignored.\n            stream._storedError = undefined;\n            if (stream._pendingAbortRequest !== undefined) {\n                stream._pendingAbortRequest._resolve();\n                stream._pendingAbortRequest = undefined;\n            }\n        }\n        stream._state = 'closed';\n        const writer = stream._writer;\n        if (writer !== undefined) {\n            defaultWriterClosedPromiseResolve(writer);\n        }\n    }\n    function WritableStreamFinishInFlightCloseWithError(stream, error) {\n        stream._inFlightCloseRequest._reject(error);\n        stream._inFlightCloseRequest = undefined;\n        // Never execute sink abort() after sink close().\n        if (stream._pendingAbortRequest !== undefined) {\n            stream._pendingAbortRequest._reject(error);\n            stream._pendingAbortRequest = undefined;\n        }\n        WritableStreamDealWithRejection(stream, error);\n    }\n    // TODO(ricea): Fix alphabetical order.\n    function WritableStreamCloseQueuedOrInFlight(stream) {\n        if (stream._closeRequest === undefined && stream._inFlightCloseRequest === undefined) {\n            return false;\n        }\n        return true;\n    }\n    function WritableStreamHasOperationMarkedInFlight(stream) {\n        if (stream._inFlightWriteRequest === undefined && stream._inFlightCloseRequest === undefined) {\n            return false;\n        }\n        return true;\n    }\n    function WritableStreamMarkCloseRequestInFlight(stream) {\n        stream._inFlightCloseRequest = stream._closeRequest;\n        stream._closeRequest = undefined;\n    }\n    function WritableStreamMarkFirstWriteRequestInFlight(stream) {\n        stream._inFlightWriteRequest = stream._writeRequests.shift();\n    }\n    function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {\n        if (stream._closeRequest !== undefined) {\n            stream._closeRequest._reject(stream._storedError);\n            stream._closeRequest = undefined;\n        }\n        const writer = stream._writer;\n        if (writer !== undefined) {\n            defaultWriterClosedPromiseReject(writer, stream._storedError);\n        }\n    }\n    function WritableStreamUpdateBackpressure(stream, backpressure) {\n        const writer = stream._writer;\n        if (writer !== undefined && backpressure !== stream._backpressure) {\n            if (backpressure) {\n                defaultWriterReadyPromiseReset(writer);\n            }\n            else {\n                defaultWriterReadyPromiseResolve(writer);\n            }\n        }\n        stream._backpressure = backpressure;\n    }\n    /**\n     * A default writer vended by a {@link WritableStream}.\n     *\n     * @public\n     */\n    class WritableStreamDefaultWriter {\n        constructor(stream) {\n            assertRequiredArgument(stream, 1, 'WritableStreamDefaultWriter');\n            assertWritableStream(stream, 'First parameter');\n            if (IsWritableStreamLocked(stream)) {\n                throw new TypeError('This stream has already been locked for exclusive writing by another writer');\n            }\n            this._ownerWritableStream = stream;\n            stream._writer = this;\n            const state = stream._state;\n            if (state === 'writable') {\n                if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._backpressure) {\n                    defaultWriterReadyPromiseInitialize(this);\n                }\n                else {\n                    defaultWriterReadyPromiseInitializeAsResolved(this);\n                }\n                defaultWriterClosedPromiseInitialize(this);\n            }\n            else if (state === 'erroring') {\n                defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError);\n                defaultWriterClosedPromiseInitialize(this);\n            }\n            else if (state === 'closed') {\n                defaultWriterReadyPromiseInitializeAsResolved(this);\n                defaultWriterClosedPromiseInitializeAsResolved(this);\n            }\n            else {\n                const storedError = stream._storedError;\n                defaultWriterReadyPromiseInitializeAsRejected(this, storedError);\n                defaultWriterClosedPromiseInitializeAsRejected(this, storedError);\n            }\n        }\n        /**\n         * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or\n         * the writer’s lock is released before the stream finishes closing.\n         */\n        get closed() {\n            if (!IsWritableStreamDefaultWriter(this)) {\n                return promiseRejectedWith(defaultWriterBrandCheckException('closed'));\n            }\n            return this._closedPromise;\n        }\n        /**\n         * Returns the desired size to fill the stream’s internal queue. It can be negative, if the queue is over-full.\n         * A producer can use this information to determine the right amount of data to write.\n         *\n         * It will be `null` if the stream cannot be successfully written to (due to either being errored, or having an abort\n         * queued up). It will return zero if the stream is closed. And the getter will throw an exception if invoked when\n         * the writer’s lock is released.\n         */\n        get desiredSize() {\n            if (!IsWritableStreamDefaultWriter(this)) {\n                throw defaultWriterBrandCheckException('desiredSize');\n            }\n            if (this._ownerWritableStream === undefined) {\n                throw defaultWriterLockException('desiredSize');\n            }\n            return WritableStreamDefaultWriterGetDesiredSize(this);\n        }\n        /**\n         * Returns a promise that will be fulfilled when the desired size to fill the stream’s internal queue transitions\n         * from non-positive to positive, signaling that it is no longer applying backpressure. Once the desired size dips\n         * back to zero or below, the getter will return a new promise that stays pending until the next transition.\n         *\n         * If the stream becomes errored or aborted, or the writer’s lock is released, the returned promise will become\n         * rejected.\n         */\n        get ready() {\n            if (!IsWritableStreamDefaultWriter(this)) {\n                return promiseRejectedWith(defaultWriterBrandCheckException('ready'));\n            }\n            return this._readyPromise;\n        }\n        /**\n         * If the reader is active, behaves the same as {@link WritableStream.abort | stream.abort(reason)}.\n         */\n        abort(reason = undefined) {\n            if (!IsWritableStreamDefaultWriter(this)) {\n                return promiseRejectedWith(defaultWriterBrandCheckException('abort'));\n            }\n            if (this._ownerWritableStream === undefined) {\n                return promiseRejectedWith(defaultWriterLockException('abort'));\n            }\n            return WritableStreamDefaultWriterAbort(this, reason);\n        }\n        /**\n         * If the reader is active, behaves the same as {@link WritableStream.close | stream.close()}.\n         */\n        close() {\n            if (!IsWritableStreamDefaultWriter(this)) {\n                return promiseRejectedWith(defaultWriterBrandCheckException('close'));\n            }\n            const stream = this._ownerWritableStream;\n            if (stream === undefined) {\n                return promiseRejectedWith(defaultWriterLockException('close'));\n            }\n            if (WritableStreamCloseQueuedOrInFlight(stream)) {\n                return promiseRejectedWith(new TypeError('Cannot close an already-closing stream'));\n            }\n            return WritableStreamDefaultWriterClose(this);\n        }\n        /**\n         * Releases the writer’s lock on the corresponding stream. After the lock is released, the writer is no longer active.\n         * If the associated stream is errored when the lock is released, the writer will appear errored in the same way from\n         * now on; otherwise, the writer will appear closed.\n         *\n         * Note that the lock can still be released even if some ongoing writes have not yet finished (i.e. even if the\n         * promises returned from previous calls to {@link WritableStreamDefaultWriter.write | write()} have not yet settled).\n         * It’s not necessary to hold the lock on the writer for the duration of the write; the lock instead simply prevents\n         * other producers from writing in an interleaved manner.\n         */\n        releaseLock() {\n            if (!IsWritableStreamDefaultWriter(this)) {\n                throw defaultWriterBrandCheckException('releaseLock');\n            }\n            const stream = this._ownerWritableStream;\n            if (stream === undefined) {\n                return;\n            }\n            WritableStreamDefaultWriterRelease(this);\n        }\n        write(chunk = undefined) {\n            if (!IsWritableStreamDefaultWriter(this)) {\n                return promiseRejectedWith(defaultWriterBrandCheckException('write'));\n            }\n            if (this._ownerWritableStream === undefined) {\n                return promiseRejectedWith(defaultWriterLockException('write to'));\n            }\n            return WritableStreamDefaultWriterWrite(this, chunk);\n        }\n    }\n    Object.defineProperties(WritableStreamDefaultWriter.prototype, {\n        abort: { enumerable: true },\n        close: { enumerable: true },\n        releaseLock: { enumerable: true },\n        write: { enumerable: true },\n        closed: { enumerable: true },\n        desiredSize: { enumerable: true },\n        ready: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(WritableStreamDefaultWriter.prototype, SymbolPolyfill.toStringTag, {\n            value: 'WritableStreamDefaultWriter',\n            configurable: true\n        });\n    }\n    // Abstract operations for the WritableStreamDefaultWriter.\n    function IsWritableStreamDefaultWriter(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) {\n            return false;\n        }\n        return x instanceof WritableStreamDefaultWriter;\n    }\n    // A client of WritableStreamDefaultWriter may use these functions directly to bypass state check.\n    function WritableStreamDefaultWriterAbort(writer, reason) {\n        const stream = writer._ownerWritableStream;\n        return WritableStreamAbort(stream, reason);\n    }\n    function WritableStreamDefaultWriterClose(writer) {\n        const stream = writer._ownerWritableStream;\n        return WritableStreamClose(stream);\n    }\n    function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {\n        const stream = writer._ownerWritableStream;\n        const state = stream._state;\n        if (WritableStreamCloseQueuedOrInFlight(stream) || state === 'closed') {\n            return promiseResolvedWith(undefined);\n        }\n        if (state === 'errored') {\n            return promiseRejectedWith(stream._storedError);\n        }\n        return WritableStreamDefaultWriterClose(writer);\n    }\n    function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {\n        if (writer._closedPromiseState === 'pending') {\n            defaultWriterClosedPromiseReject(writer, error);\n        }\n        else {\n            defaultWriterClosedPromiseResetToRejected(writer, error);\n        }\n    }\n    function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {\n        if (writer._readyPromiseState === 'pending') {\n            defaultWriterReadyPromiseReject(writer, error);\n        }\n        else {\n            defaultWriterReadyPromiseResetToRejected(writer, error);\n        }\n    }\n    function WritableStreamDefaultWriterGetDesiredSize(writer) {\n        const stream = writer._ownerWritableStream;\n        const state = stream._state;\n        if (state === 'errored' || state === 'erroring') {\n            return null;\n        }\n        if (state === 'closed') {\n            return 0;\n        }\n        return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);\n    }\n    function WritableStreamDefaultWriterRelease(writer) {\n        const stream = writer._ownerWritableStream;\n        const releasedError = new TypeError(`Writer was released and can no longer be used to monitor the stream's closedness`);\n        WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);\n        // The state transitions to \"errored\" before the sink abort() method runs, but the writer.closed promise is not\n        // rejected until afterwards. This means that simply testing state will not work.\n        WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);\n        stream._writer = undefined;\n        writer._ownerWritableStream = undefined;\n    }\n    function WritableStreamDefaultWriterWrite(writer, chunk) {\n        const stream = writer._ownerWritableStream;\n        const controller = stream._writableStreamController;\n        const chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);\n        if (stream !== writer._ownerWritableStream) {\n            return promiseRejectedWith(defaultWriterLockException('write to'));\n        }\n        const state = stream._state;\n        if (state === 'errored') {\n            return promiseRejectedWith(stream._storedError);\n        }\n        if (WritableStreamCloseQueuedOrInFlight(stream) || state === 'closed') {\n            return promiseRejectedWith(new TypeError('The stream is closing or closed and cannot be written to'));\n        }\n        if (state === 'erroring') {\n            return promiseRejectedWith(stream._storedError);\n        }\n        const promise = WritableStreamAddWriteRequest(stream);\n        WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);\n        return promise;\n    }\n    const closeSentinel = {};\n    /**\n     * Allows control of a {@link WritableStream | writable stream}'s state and internal queue.\n     *\n     * @public\n     */\n    class WritableStreamDefaultController {\n        constructor() {\n            throw new TypeError('Illegal constructor');\n        }\n        /**\n         * The reason which was passed to `WritableStream.abort(reason)` when the stream was aborted.\n         *\n         * @deprecated\n         *  This property has been removed from the specification, see https://github.com/whatwg/streams/pull/1177.\n         *  Use {@link WritableStreamDefaultController.signal}'s `reason` instead.\n         */\n        get abortReason() {\n            if (!IsWritableStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException$2('abortReason');\n            }\n            return this._abortReason;\n        }\n        /**\n         * An `AbortSignal` that can be used to abort the pending write or close operation when the stream is aborted.\n         */\n        get signal() {\n            if (!IsWritableStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException$2('signal');\n            }\n            if (this._abortController === undefined) {\n                // Older browsers or older Node versions may not support `AbortController` or `AbortSignal`.\n                // We don't want to bundle and ship an `AbortController` polyfill together with our polyfill,\n                // so instead we only implement support for `signal` if we find a global `AbortController` constructor.\n                throw new TypeError('WritableStreamDefaultController.prototype.signal is not supported');\n            }\n            return this._abortController.signal;\n        }\n        /**\n         * Closes the controlled writable stream, making all future interactions with it fail with the given error `e`.\n         *\n         * This method is rarely used, since usually it suffices to return a rejected promise from one of the underlying\n         * sink's methods. However, it can be useful for suddenly shutting down a stream in response to an event outside the\n         * normal lifecycle of interactions with the underlying sink.\n         */\n        error(e = undefined) {\n            if (!IsWritableStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException$2('error');\n            }\n            const state = this._controlledWritableStream._state;\n            if (state !== 'writable') {\n                // The stream is closed, errored or will be soon. The sink can't do anything useful if it gets an error here, so\n                // just treat it as a no-op.\n                return;\n            }\n            WritableStreamDefaultControllerError(this, e);\n        }\n        /** @internal */\n        [AbortSteps](reason) {\n            const result = this._abortAlgorithm(reason);\n            WritableStreamDefaultControllerClearAlgorithms(this);\n            return result;\n        }\n        /** @internal */\n        [ErrorSteps]() {\n            ResetQueue(this);\n        }\n    }\n    Object.defineProperties(WritableStreamDefaultController.prototype, {\n        abortReason: { enumerable: true },\n        signal: { enumerable: true },\n        error: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(WritableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {\n            value: 'WritableStreamDefaultController',\n            configurable: true\n        });\n    }\n    // Abstract operations implementing interface required by the WritableStream.\n    function IsWritableStreamDefaultController(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_controlledWritableStream')) {\n            return false;\n        }\n        return x instanceof WritableStreamDefaultController;\n    }\n    function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {\n        controller._controlledWritableStream = stream;\n        stream._writableStreamController = controller;\n        // Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly.\n        controller._queue = undefined;\n        controller._queueTotalSize = undefined;\n        ResetQueue(controller);\n        controller._abortReason = undefined;\n        controller._abortController = createAbortController();\n        controller._started = false;\n        controller._strategySizeAlgorithm = sizeAlgorithm;\n        controller._strategyHWM = highWaterMark;\n        controller._writeAlgorithm = writeAlgorithm;\n        controller._closeAlgorithm = closeAlgorithm;\n        controller._abortAlgorithm = abortAlgorithm;\n        const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);\n        WritableStreamUpdateBackpressure(stream, backpressure);\n        const startResult = startAlgorithm();\n        const startPromise = promiseResolvedWith(startResult);\n        uponPromise(startPromise, () => {\n            controller._started = true;\n            WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);\n        }, r => {\n            controller._started = true;\n            WritableStreamDealWithRejection(stream, r);\n        });\n    }\n    function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, highWaterMark, sizeAlgorithm) {\n        const controller = Object.create(WritableStreamDefaultController.prototype);\n        let startAlgorithm = () => undefined;\n        let writeAlgorithm = () => promiseResolvedWith(undefined);\n        let closeAlgorithm = () => promiseResolvedWith(undefined);\n        let abortAlgorithm = () => promiseResolvedWith(undefined);\n        if (underlyingSink.start !== undefined) {\n            startAlgorithm = () => underlyingSink.start(controller);\n        }\n        if (underlyingSink.write !== undefined) {\n            writeAlgorithm = chunk => underlyingSink.write(chunk, controller);\n        }\n        if (underlyingSink.close !== undefined) {\n            closeAlgorithm = () => underlyingSink.close();\n        }\n        if (underlyingSink.abort !== undefined) {\n            abortAlgorithm = reason => underlyingSink.abort(reason);\n        }\n        SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);\n    }\n    // ClearAlgorithms may be called twice. Erroring the same stream in multiple ways will often result in redundant calls.\n    function WritableStreamDefaultControllerClearAlgorithms(controller) {\n        controller._writeAlgorithm = undefined;\n        controller._closeAlgorithm = undefined;\n        controller._abortAlgorithm = undefined;\n        controller._strategySizeAlgorithm = undefined;\n    }\n    function WritableStreamDefaultControllerClose(controller) {\n        EnqueueValueWithSize(controller, closeSentinel, 0);\n        WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);\n    }\n    function WritableStreamDefaultControllerGetChunkSize(controller, chunk) {\n        try {\n            return controller._strategySizeAlgorithm(chunk);\n        }\n        catch (chunkSizeE) {\n            WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);\n            return 1;\n        }\n    }\n    function WritableStreamDefaultControllerGetDesiredSize(controller) {\n        return controller._strategyHWM - controller._queueTotalSize;\n    }\n    function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) {\n        try {\n            EnqueueValueWithSize(controller, chunk, chunkSize);\n        }\n        catch (enqueueE) {\n            WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);\n            return;\n        }\n        const stream = controller._controlledWritableStream;\n        if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._state === 'writable') {\n            const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);\n            WritableStreamUpdateBackpressure(stream, backpressure);\n        }\n        WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);\n    }\n    // Abstract operations for the WritableStreamDefaultController.\n    function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {\n        const stream = controller._controlledWritableStream;\n        if (!controller._started) {\n            return;\n        }\n        if (stream._inFlightWriteRequest !== undefined) {\n            return;\n        }\n        const state = stream._state;\n        if (state === 'erroring') {\n            WritableStreamFinishErroring(stream);\n            return;\n        }\n        if (controller._queue.length === 0) {\n            return;\n        }\n        const value = PeekQueueValue(controller);\n        if (value === closeSentinel) {\n            WritableStreamDefaultControllerProcessClose(controller);\n        }\n        else {\n            WritableStreamDefaultControllerProcessWrite(controller, value);\n        }\n    }\n    function WritableStreamDefaultControllerErrorIfNeeded(controller, error) {\n        if (controller._controlledWritableStream._state === 'writable') {\n            WritableStreamDefaultControllerError(controller, error);\n        }\n    }\n    function WritableStreamDefaultControllerProcessClose(controller) {\n        const stream = controller._controlledWritableStream;\n        WritableStreamMarkCloseRequestInFlight(stream);\n        DequeueValue(controller);\n        const sinkClosePromise = controller._closeAlgorithm();\n        WritableStreamDefaultControllerClearAlgorithms(controller);\n        uponPromise(sinkClosePromise, () => {\n            WritableStreamFinishInFlightClose(stream);\n        }, reason => {\n            WritableStreamFinishInFlightCloseWithError(stream, reason);\n        });\n    }\n    function WritableStreamDefaultControllerProcessWrite(controller, chunk) {\n        const stream = controller._controlledWritableStream;\n        WritableStreamMarkFirstWriteRequestInFlight(stream);\n        const sinkWritePromise = controller._writeAlgorithm(chunk);\n        uponPromise(sinkWritePromise, () => {\n            WritableStreamFinishInFlightWrite(stream);\n            const state = stream._state;\n            DequeueValue(controller);\n            if (!WritableStreamCloseQueuedOrInFlight(stream) && state === 'writable') {\n                const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);\n                WritableStreamUpdateBackpressure(stream, backpressure);\n            }\n            WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);\n        }, reason => {\n            if (stream._state === 'writable') {\n                WritableStreamDefaultControllerClearAlgorithms(controller);\n            }\n            WritableStreamFinishInFlightWriteWithError(stream, reason);\n        });\n    }\n    function WritableStreamDefaultControllerGetBackpressure(controller) {\n        const desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);\n        return desiredSize <= 0;\n    }\n    // A client of WritableStreamDefaultController may use these functions directly to bypass state check.\n    function WritableStreamDefaultControllerError(controller, error) {\n        const stream = controller._controlledWritableStream;\n        WritableStreamDefaultControllerClearAlgorithms(controller);\n        WritableStreamStartErroring(stream, error);\n    }\n    // Helper functions for the WritableStream.\n    function streamBrandCheckException$2(name) {\n        return new TypeError(`WritableStream.prototype.${name} can only be used on a WritableStream`);\n    }\n    // Helper functions for the WritableStreamDefaultController.\n    function defaultControllerBrandCheckException$2(name) {\n        return new TypeError(`WritableStreamDefaultController.prototype.${name} can only be used on a WritableStreamDefaultController`);\n    }\n    // Helper functions for the WritableStreamDefaultWriter.\n    function defaultWriterBrandCheckException(name) {\n        return new TypeError(`WritableStreamDefaultWriter.prototype.${name} can only be used on a WritableStreamDefaultWriter`);\n    }\n    function defaultWriterLockException(name) {\n        return new TypeError('Cannot ' + name + ' a stream using a released writer');\n    }\n    function defaultWriterClosedPromiseInitialize(writer) {\n        writer._closedPromise = newPromise((resolve, reject) => {\n            writer._closedPromise_resolve = resolve;\n            writer._closedPromise_reject = reject;\n            writer._closedPromiseState = 'pending';\n        });\n    }\n    function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) {\n        defaultWriterClosedPromiseInitialize(writer);\n        defaultWriterClosedPromiseReject(writer, reason);\n    }\n    function defaultWriterClosedPromiseInitializeAsResolved(writer) {\n        defaultWriterClosedPromiseInitialize(writer);\n        defaultWriterClosedPromiseResolve(writer);\n    }\n    function defaultWriterClosedPromiseReject(writer, reason) {\n        if (writer._closedPromise_reject === undefined) {\n            return;\n        }\n        setPromiseIsHandledToTrue(writer._closedPromise);\n        writer._closedPromise_reject(reason);\n        writer._closedPromise_resolve = undefined;\n        writer._closedPromise_reject = undefined;\n        writer._closedPromiseState = 'rejected';\n    }\n    function defaultWriterClosedPromiseResetToRejected(writer, reason) {\n        defaultWriterClosedPromiseInitializeAsRejected(writer, reason);\n    }\n    function defaultWriterClosedPromiseResolve(writer) {\n        if (writer._closedPromise_resolve === undefined) {\n            return;\n        }\n        writer._closedPromise_resolve(undefined);\n        writer._closedPromise_resolve = undefined;\n        writer._closedPromise_reject = undefined;\n        writer._closedPromiseState = 'resolved';\n    }\n    function defaultWriterReadyPromiseInitialize(writer) {\n        writer._readyPromise = newPromise((resolve, reject) => {\n            writer._readyPromise_resolve = resolve;\n            writer._readyPromise_reject = reject;\n        });\n        writer._readyPromiseState = 'pending';\n    }\n    function defaultWriterReadyPromiseInitializeAsRejected(writer, reason) {\n        defaultWriterReadyPromiseInitialize(writer);\n        defaultWriterReadyPromiseReject(writer, reason);\n    }\n    function defaultWriterReadyPromiseInitializeAsResolved(writer) {\n        defaultWriterReadyPromiseInitialize(writer);\n        defaultWriterReadyPromiseResolve(writer);\n    }\n    function defaultWriterReadyPromiseReject(writer, reason) {\n        if (writer._readyPromise_reject === undefined) {\n            return;\n        }\n        setPromiseIsHandledToTrue(writer._readyPromise);\n        writer._readyPromise_reject(reason);\n        writer._readyPromise_resolve = undefined;\n        writer._readyPromise_reject = undefined;\n        writer._readyPromiseState = 'rejected';\n    }\n    function defaultWriterReadyPromiseReset(writer) {\n        defaultWriterReadyPromiseInitialize(writer);\n    }\n    function defaultWriterReadyPromiseResetToRejected(writer, reason) {\n        defaultWriterReadyPromiseInitializeAsRejected(writer, reason);\n    }\n    function defaultWriterReadyPromiseResolve(writer) {\n        if (writer._readyPromise_resolve === undefined) {\n            return;\n        }\n        writer._readyPromise_resolve(undefined);\n        writer._readyPromise_resolve = undefined;\n        writer._readyPromise_reject = undefined;\n        writer._readyPromiseState = 'fulfilled';\n    }\n\n    /// <reference lib=\"dom\" />\n    const NativeDOMException = typeof DOMException !== 'undefined' ? DOMException : undefined;\n\n    /// <reference types=\"node\" />\n    function isDOMExceptionConstructor(ctor) {\n        if (!(typeof ctor === 'function' || typeof ctor === 'object')) {\n            return false;\n        }\n        try {\n            new ctor();\n            return true;\n        }\n        catch (_a) {\n            return false;\n        }\n    }\n    function createDOMExceptionPolyfill() {\n        // eslint-disable-next-line no-shadow\n        const ctor = function DOMException(message, name) {\n            this.message = message || '';\n            this.name = name || 'Error';\n            if (Error.captureStackTrace) {\n                Error.captureStackTrace(this, this.constructor);\n            }\n        };\n        ctor.prototype = Object.create(Error.prototype);\n        Object.defineProperty(ctor.prototype, 'constructor', { value: ctor, writable: true, configurable: true });\n        return ctor;\n    }\n    // eslint-disable-next-line no-redeclare\n    const DOMException$1 = isDOMExceptionConstructor(NativeDOMException) ? NativeDOMException : createDOMExceptionPolyfill();\n\n    function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {\n        const reader = AcquireReadableStreamDefaultReader(source);\n        const writer = AcquireWritableStreamDefaultWriter(dest);\n        source._disturbed = true;\n        let shuttingDown = false;\n        // This is used to keep track of the spec's requirement that we wait for ongoing writes during shutdown.\n        let currentWrite = promiseResolvedWith(undefined);\n        return newPromise((resolve, reject) => {\n            let abortAlgorithm;\n            if (signal !== undefined) {\n                abortAlgorithm = () => {\n                    const error = new DOMException$1('Aborted', 'AbortError');\n                    const actions = [];\n                    if (!preventAbort) {\n                        actions.push(() => {\n                            if (dest._state === 'writable') {\n                                return WritableStreamAbort(dest, error);\n                            }\n                            return promiseResolvedWith(undefined);\n                        });\n                    }\n                    if (!preventCancel) {\n                        actions.push(() => {\n                            if (source._state === 'readable') {\n                                return ReadableStreamCancel(source, error);\n                            }\n                            return promiseResolvedWith(undefined);\n                        });\n                    }\n                    shutdownWithAction(() => Promise.all(actions.map(action => action())), true, error);\n                };\n                if (signal.aborted) {\n                    abortAlgorithm();\n                    return;\n                }\n                signal.addEventListener('abort', abortAlgorithm);\n            }\n            // Using reader and writer, read all chunks from this and write them to dest\n            // - Backpressure must be enforced\n            // - Shutdown must stop all activity\n            function pipeLoop() {\n                return newPromise((resolveLoop, rejectLoop) => {\n                    function next(done) {\n                        if (done) {\n                            resolveLoop();\n                        }\n                        else {\n                            // Use `PerformPromiseThen` instead of `uponPromise` to avoid\n                            // adding unnecessary `.catch(rethrowAssertionErrorRejection)` handlers\n                            PerformPromiseThen(pipeStep(), next, rejectLoop);\n                        }\n                    }\n                    next(false);\n                });\n            }\n            function pipeStep() {\n                if (shuttingDown) {\n                    return promiseResolvedWith(true);\n                }\n                return PerformPromiseThen(writer._readyPromise, () => {\n                    return newPromise((resolveRead, rejectRead) => {\n                        ReadableStreamDefaultReaderRead(reader, {\n                            _chunkSteps: chunk => {\n                                currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, chunk), undefined, noop);\n                                resolveRead(false);\n                            },\n                            _closeSteps: () => resolveRead(true),\n                            _errorSteps: rejectRead\n                        });\n                    });\n                });\n            }\n            // Errors must be propagated forward\n            isOrBecomesErrored(source, reader._closedPromise, storedError => {\n                if (!preventAbort) {\n                    shutdownWithAction(() => WritableStreamAbort(dest, storedError), true, storedError);\n                }\n                else {\n                    shutdown(true, storedError);\n                }\n            });\n            // Errors must be propagated backward\n            isOrBecomesErrored(dest, writer._closedPromise, storedError => {\n                if (!preventCancel) {\n                    shutdownWithAction(() => ReadableStreamCancel(source, storedError), true, storedError);\n                }\n                else {\n                    shutdown(true, storedError);\n                }\n            });\n            // Closing must be propagated forward\n            isOrBecomesClosed(source, reader._closedPromise, () => {\n                if (!preventClose) {\n                    shutdownWithAction(() => WritableStreamDefaultWriterCloseWithErrorPropagation(writer));\n                }\n                else {\n                    shutdown();\n                }\n            });\n            // Closing must be propagated backward\n            if (WritableStreamCloseQueuedOrInFlight(dest) || dest._state === 'closed') {\n                const destClosed = new TypeError('the destination writable stream closed before all data could be piped to it');\n                if (!preventCancel) {\n                    shutdownWithAction(() => ReadableStreamCancel(source, destClosed), true, destClosed);\n                }\n                else {\n                    shutdown(true, destClosed);\n                }\n            }\n            setPromiseIsHandledToTrue(pipeLoop());\n            function waitForWritesToFinish() {\n                // Another write may have started while we were waiting on this currentWrite, so we have to be sure to wait\n                // for that too.\n                const oldCurrentWrite = currentWrite;\n                return PerformPromiseThen(currentWrite, () => oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : undefined);\n            }\n            function isOrBecomesErrored(stream, promise, action) {\n                if (stream._state === 'errored') {\n                    action(stream._storedError);\n                }\n                else {\n                    uponRejection(promise, action);\n                }\n            }\n            function isOrBecomesClosed(stream, promise, action) {\n                if (stream._state === 'closed') {\n                    action();\n                }\n                else {\n                    uponFulfillment(promise, action);\n                }\n            }\n            function shutdownWithAction(action, originalIsError, originalError) {\n                if (shuttingDown) {\n                    return;\n                }\n                shuttingDown = true;\n                if (dest._state === 'writable' && !WritableStreamCloseQueuedOrInFlight(dest)) {\n                    uponFulfillment(waitForWritesToFinish(), doTheRest);\n                }\n                else {\n                    doTheRest();\n                }\n                function doTheRest() {\n                    uponPromise(action(), () => finalize(originalIsError, originalError), newError => finalize(true, newError));\n                }\n            }\n            function shutdown(isError, error) {\n                if (shuttingDown) {\n                    return;\n                }\n                shuttingDown = true;\n                if (dest._state === 'writable' && !WritableStreamCloseQueuedOrInFlight(dest)) {\n                    uponFulfillment(waitForWritesToFinish(), () => finalize(isError, error));\n                }\n                else {\n                    finalize(isError, error);\n                }\n            }\n            function finalize(isError, error) {\n                WritableStreamDefaultWriterRelease(writer);\n                ReadableStreamReaderGenericRelease(reader);\n                if (signal !== undefined) {\n                    signal.removeEventListener('abort', abortAlgorithm);\n                }\n                if (isError) {\n                    reject(error);\n                }\n                else {\n                    resolve(undefined);\n                }\n            }\n        });\n    }\n\n    /**\n     * Allows control of a {@link ReadableStream | readable stream}'s state and internal queue.\n     *\n     * @public\n     */\n    class ReadableStreamDefaultController {\n        constructor() {\n            throw new TypeError('Illegal constructor');\n        }\n        /**\n         * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is\n         * over-full. An underlying source ought to use this information to determine when and how to apply backpressure.\n         */\n        get desiredSize() {\n            if (!IsReadableStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException$1('desiredSize');\n            }\n            return ReadableStreamDefaultControllerGetDesiredSize(this);\n        }\n        /**\n         * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from\n         * the stream, but once those are read, the stream will become closed.\n         */\n        close() {\n            if (!IsReadableStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException$1('close');\n            }\n            if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {\n                throw new TypeError('The stream is not in a state that permits close');\n            }\n            ReadableStreamDefaultControllerClose(this);\n        }\n        enqueue(chunk = undefined) {\n            if (!IsReadableStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException$1('enqueue');\n            }\n            if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {\n                throw new TypeError('The stream is not in a state that permits enqueue');\n            }\n            return ReadableStreamDefaultControllerEnqueue(this, chunk);\n        }\n        /**\n         * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.\n         */\n        error(e = undefined) {\n            if (!IsReadableStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException$1('error');\n            }\n            ReadableStreamDefaultControllerError(this, e);\n        }\n        /** @internal */\n        [CancelSteps](reason) {\n            ResetQueue(this);\n            const result = this._cancelAlgorithm(reason);\n            ReadableStreamDefaultControllerClearAlgorithms(this);\n            return result;\n        }\n        /** @internal */\n        [PullSteps](readRequest) {\n            const stream = this._controlledReadableStream;\n            if (this._queue.length > 0) {\n                const chunk = DequeueValue(this);\n                if (this._closeRequested && this._queue.length === 0) {\n                    ReadableStreamDefaultControllerClearAlgorithms(this);\n                    ReadableStreamClose(stream);\n                }\n                else {\n                    ReadableStreamDefaultControllerCallPullIfNeeded(this);\n                }\n                readRequest._chunkSteps(chunk);\n            }\n            else {\n                ReadableStreamAddReadRequest(stream, readRequest);\n                ReadableStreamDefaultControllerCallPullIfNeeded(this);\n            }\n        }\n    }\n    Object.defineProperties(ReadableStreamDefaultController.prototype, {\n        close: { enumerable: true },\n        enqueue: { enumerable: true },\n        error: { enumerable: true },\n        desiredSize: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(ReadableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {\n            value: 'ReadableStreamDefaultController',\n            configurable: true\n        });\n    }\n    // Abstract operations for the ReadableStreamDefaultController.\n    function IsReadableStreamDefaultController(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableStream')) {\n            return false;\n        }\n        return x instanceof ReadableStreamDefaultController;\n    }\n    function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {\n        const shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);\n        if (!shouldPull) {\n            return;\n        }\n        if (controller._pulling) {\n            controller._pullAgain = true;\n            return;\n        }\n        controller._pulling = true;\n        const pullPromise = controller._pullAlgorithm();\n        uponPromise(pullPromise, () => {\n            controller._pulling = false;\n            if (controller._pullAgain) {\n                controller._pullAgain = false;\n                ReadableStreamDefaultControllerCallPullIfNeeded(controller);\n            }\n        }, e => {\n            ReadableStreamDefaultControllerError(controller, e);\n        });\n    }\n    function ReadableStreamDefaultControllerShouldCallPull(controller) {\n        const stream = controller._controlledReadableStream;\n        if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {\n            return false;\n        }\n        if (!controller._started) {\n            return false;\n        }\n        if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {\n            return true;\n        }\n        const desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);\n        if (desiredSize > 0) {\n            return true;\n        }\n        return false;\n    }\n    function ReadableStreamDefaultControllerClearAlgorithms(controller) {\n        controller._pullAlgorithm = undefined;\n        controller._cancelAlgorithm = undefined;\n        controller._strategySizeAlgorithm = undefined;\n    }\n    // A client of ReadableStreamDefaultController may use these functions directly to bypass state check.\n    function ReadableStreamDefaultControllerClose(controller) {\n        if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {\n            return;\n        }\n        const stream = controller._controlledReadableStream;\n        controller._closeRequested = true;\n        if (controller._queue.length === 0) {\n            ReadableStreamDefaultControllerClearAlgorithms(controller);\n            ReadableStreamClose(stream);\n        }\n    }\n    function ReadableStreamDefaultControllerEnqueue(controller, chunk) {\n        if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {\n            return;\n        }\n        const stream = controller._controlledReadableStream;\n        if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {\n            ReadableStreamFulfillReadRequest(stream, chunk, false);\n        }\n        else {\n            let chunkSize;\n            try {\n                chunkSize = controller._strategySizeAlgorithm(chunk);\n            }\n            catch (chunkSizeE) {\n                ReadableStreamDefaultControllerError(controller, chunkSizeE);\n                throw chunkSizeE;\n            }\n            try {\n                EnqueueValueWithSize(controller, chunk, chunkSize);\n            }\n            catch (enqueueE) {\n                ReadableStreamDefaultControllerError(controller, enqueueE);\n                throw enqueueE;\n            }\n        }\n        ReadableStreamDefaultControllerCallPullIfNeeded(controller);\n    }\n    function ReadableStreamDefaultControllerError(controller, e) {\n        const stream = controller._controlledReadableStream;\n        if (stream._state !== 'readable') {\n            return;\n        }\n        ResetQueue(controller);\n        ReadableStreamDefaultControllerClearAlgorithms(controller);\n        ReadableStreamError(stream, e);\n    }\n    function ReadableStreamDefaultControllerGetDesiredSize(controller) {\n        const state = controller._controlledReadableStream._state;\n        if (state === 'errored') {\n            return null;\n        }\n        if (state === 'closed') {\n            return 0;\n        }\n        return controller._strategyHWM - controller._queueTotalSize;\n    }\n    // This is used in the implementation of TransformStream.\n    function ReadableStreamDefaultControllerHasBackpressure(controller) {\n        if (ReadableStreamDefaultControllerShouldCallPull(controller)) {\n            return false;\n        }\n        return true;\n    }\n    function ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) {\n        const state = controller._controlledReadableStream._state;\n        if (!controller._closeRequested && state === 'readable') {\n            return true;\n        }\n        return false;\n    }\n    function SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) {\n        controller._controlledReadableStream = stream;\n        controller._queue = undefined;\n        controller._queueTotalSize = undefined;\n        ResetQueue(controller);\n        controller._started = false;\n        controller._closeRequested = false;\n        controller._pullAgain = false;\n        controller._pulling = false;\n        controller._strategySizeAlgorithm = sizeAlgorithm;\n        controller._strategyHWM = highWaterMark;\n        controller._pullAlgorithm = pullAlgorithm;\n        controller._cancelAlgorithm = cancelAlgorithm;\n        stream._readableStreamController = controller;\n        const startResult = startAlgorithm();\n        uponPromise(promiseResolvedWith(startResult), () => {\n            controller._started = true;\n            ReadableStreamDefaultControllerCallPullIfNeeded(controller);\n        }, r => {\n            ReadableStreamDefaultControllerError(controller, r);\n        });\n    }\n    function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) {\n        const controller = Object.create(ReadableStreamDefaultController.prototype);\n        let startAlgorithm = () => undefined;\n        let pullAlgorithm = () => promiseResolvedWith(undefined);\n        let cancelAlgorithm = () => promiseResolvedWith(undefined);\n        if (underlyingSource.start !== undefined) {\n            startAlgorithm = () => underlyingSource.start(controller);\n        }\n        if (underlyingSource.pull !== undefined) {\n            pullAlgorithm = () => underlyingSource.pull(controller);\n        }\n        if (underlyingSource.cancel !== undefined) {\n            cancelAlgorithm = reason => underlyingSource.cancel(reason);\n        }\n        SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);\n    }\n    // Helper functions for the ReadableStreamDefaultController.\n    function defaultControllerBrandCheckException$1(name) {\n        return new TypeError(`ReadableStreamDefaultController.prototype.${name} can only be used on a ReadableStreamDefaultController`);\n    }\n\n    function ReadableStreamTee(stream, cloneForBranch2) {\n        if (IsReadableByteStreamController(stream._readableStreamController)) {\n            return ReadableByteStreamTee(stream);\n        }\n        return ReadableStreamDefaultTee(stream);\n    }\n    function ReadableStreamDefaultTee(stream, cloneForBranch2) {\n        const reader = AcquireReadableStreamDefaultReader(stream);\n        let reading = false;\n        let readAgain = false;\n        let canceled1 = false;\n        let canceled2 = false;\n        let reason1;\n        let reason2;\n        let branch1;\n        let branch2;\n        let resolveCancelPromise;\n        const cancelPromise = newPromise(resolve => {\n            resolveCancelPromise = resolve;\n        });\n        function pullAlgorithm() {\n            if (reading) {\n                readAgain = true;\n                return promiseResolvedWith(undefined);\n            }\n            reading = true;\n            const readRequest = {\n                _chunkSteps: chunk => {\n                    // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using\n                    // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let\n                    // successful synchronously-available reads get ahead of asynchronously-available errors.\n                    queueMicrotask(() => {\n                        readAgain = false;\n                        const chunk1 = chunk;\n                        const chunk2 = chunk;\n                        // There is no way to access the cloning code right now in the reference implementation.\n                        // If we add one then we'll need an implementation for serializable objects.\n                        // if (!canceled2 && cloneForBranch2) {\n                        //   chunk2 = StructuredDeserialize(StructuredSerialize(chunk2));\n                        // }\n                        if (!canceled1) {\n                            ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, chunk1);\n                        }\n                        if (!canceled2) {\n                            ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, chunk2);\n                        }\n                        reading = false;\n                        if (readAgain) {\n                            pullAlgorithm();\n                        }\n                    });\n                },\n                _closeSteps: () => {\n                    reading = false;\n                    if (!canceled1) {\n                        ReadableStreamDefaultControllerClose(branch1._readableStreamController);\n                    }\n                    if (!canceled2) {\n                        ReadableStreamDefaultControllerClose(branch2._readableStreamController);\n                    }\n                    if (!canceled1 || !canceled2) {\n                        resolveCancelPromise(undefined);\n                    }\n                },\n                _errorSteps: () => {\n                    reading = false;\n                }\n            };\n            ReadableStreamDefaultReaderRead(reader, readRequest);\n            return promiseResolvedWith(undefined);\n        }\n        function cancel1Algorithm(reason) {\n            canceled1 = true;\n            reason1 = reason;\n            if (canceled2) {\n                const compositeReason = CreateArrayFromList([reason1, reason2]);\n                const cancelResult = ReadableStreamCancel(stream, compositeReason);\n                resolveCancelPromise(cancelResult);\n            }\n            return cancelPromise;\n        }\n        function cancel2Algorithm(reason) {\n            canceled2 = true;\n            reason2 = reason;\n            if (canceled1) {\n                const compositeReason = CreateArrayFromList([reason1, reason2]);\n                const cancelResult = ReadableStreamCancel(stream, compositeReason);\n                resolveCancelPromise(cancelResult);\n            }\n            return cancelPromise;\n        }\n        function startAlgorithm() {\n            // do nothing\n        }\n        branch1 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm);\n        branch2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm);\n        uponRejection(reader._closedPromise, (r) => {\n            ReadableStreamDefaultControllerError(branch1._readableStreamController, r);\n            ReadableStreamDefaultControllerError(branch2._readableStreamController, r);\n            if (!canceled1 || !canceled2) {\n                resolveCancelPromise(undefined);\n            }\n        });\n        return [branch1, branch2];\n    }\n    function ReadableByteStreamTee(stream) {\n        let reader = AcquireReadableStreamDefaultReader(stream);\n        let reading = false;\n        let readAgainForBranch1 = false;\n        let readAgainForBranch2 = false;\n        let canceled1 = false;\n        let canceled2 = false;\n        let reason1;\n        let reason2;\n        let branch1;\n        let branch2;\n        let resolveCancelPromise;\n        const cancelPromise = newPromise(resolve => {\n            resolveCancelPromise = resolve;\n        });\n        function forwardReaderError(thisReader) {\n            uponRejection(thisReader._closedPromise, r => {\n                if (thisReader !== reader) {\n                    return;\n                }\n                ReadableByteStreamControllerError(branch1._readableStreamController, r);\n                ReadableByteStreamControllerError(branch2._readableStreamController, r);\n                if (!canceled1 || !canceled2) {\n                    resolveCancelPromise(undefined);\n                }\n            });\n        }\n        function pullWithDefaultReader() {\n            if (IsReadableStreamBYOBReader(reader)) {\n                ReadableStreamReaderGenericRelease(reader);\n                reader = AcquireReadableStreamDefaultReader(stream);\n                forwardReaderError(reader);\n            }\n            const readRequest = {\n                _chunkSteps: chunk => {\n                    // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using\n                    // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let\n                    // successful synchronously-available reads get ahead of asynchronously-available errors.\n                    queueMicrotask(() => {\n                        readAgainForBranch1 = false;\n                        readAgainForBranch2 = false;\n                        const chunk1 = chunk;\n                        let chunk2 = chunk;\n                        if (!canceled1 && !canceled2) {\n                            try {\n                                chunk2 = CloneAsUint8Array(chunk);\n                            }\n                            catch (cloneE) {\n                                ReadableByteStreamControllerError(branch1._readableStreamController, cloneE);\n                                ReadableByteStreamControllerError(branch2._readableStreamController, cloneE);\n                                resolveCancelPromise(ReadableStreamCancel(stream, cloneE));\n                                return;\n                            }\n                        }\n                        if (!canceled1) {\n                            ReadableByteStreamControllerEnqueue(branch1._readableStreamController, chunk1);\n                        }\n                        if (!canceled2) {\n                            ReadableByteStreamControllerEnqueue(branch2._readableStreamController, chunk2);\n                        }\n                        reading = false;\n                        if (readAgainForBranch1) {\n                            pull1Algorithm();\n                        }\n                        else if (readAgainForBranch2) {\n                            pull2Algorithm();\n                        }\n                    });\n                },\n                _closeSteps: () => {\n                    reading = false;\n                    if (!canceled1) {\n                        ReadableByteStreamControllerClose(branch1._readableStreamController);\n                    }\n                    if (!canceled2) {\n                        ReadableByteStreamControllerClose(branch2._readableStreamController);\n                    }\n                    if (branch1._readableStreamController._pendingPullIntos.length > 0) {\n                        ReadableByteStreamControllerRespond(branch1._readableStreamController, 0);\n                    }\n                    if (branch2._readableStreamController._pendingPullIntos.length > 0) {\n                        ReadableByteStreamControllerRespond(branch2._readableStreamController, 0);\n                    }\n                    if (!canceled1 || !canceled2) {\n                        resolveCancelPromise(undefined);\n                    }\n                },\n                _errorSteps: () => {\n                    reading = false;\n                }\n            };\n            ReadableStreamDefaultReaderRead(reader, readRequest);\n        }\n        function pullWithBYOBReader(view, forBranch2) {\n            if (IsReadableStreamDefaultReader(reader)) {\n                ReadableStreamReaderGenericRelease(reader);\n                reader = AcquireReadableStreamBYOBReader(stream);\n                forwardReaderError(reader);\n            }\n            const byobBranch = forBranch2 ? branch2 : branch1;\n            const otherBranch = forBranch2 ? branch1 : branch2;\n            const readIntoRequest = {\n                _chunkSteps: chunk => {\n                    // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using\n                    // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let\n                    // successful synchronously-available reads get ahead of asynchronously-available errors.\n                    queueMicrotask(() => {\n                        readAgainForBranch1 = false;\n                        readAgainForBranch2 = false;\n                        const byobCanceled = forBranch2 ? canceled2 : canceled1;\n                        const otherCanceled = forBranch2 ? canceled1 : canceled2;\n                        if (!otherCanceled) {\n                            let clonedChunk;\n                            try {\n                                clonedChunk = CloneAsUint8Array(chunk);\n                            }\n                            catch (cloneE) {\n                                ReadableByteStreamControllerError(byobBranch._readableStreamController, cloneE);\n                                ReadableByteStreamControllerError(otherBranch._readableStreamController, cloneE);\n                                resolveCancelPromise(ReadableStreamCancel(stream, cloneE));\n                                return;\n                            }\n                            if (!byobCanceled) {\n                                ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);\n                            }\n                            ReadableByteStreamControllerEnqueue(otherBranch._readableStreamController, clonedChunk);\n                        }\n                        else if (!byobCanceled) {\n                            ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);\n                        }\n                        reading = false;\n                        if (readAgainForBranch1) {\n                            pull1Algorithm();\n                        }\n                        else if (readAgainForBranch2) {\n                            pull2Algorithm();\n                        }\n                    });\n                },\n                _closeSteps: chunk => {\n                    reading = false;\n                    const byobCanceled = forBranch2 ? canceled2 : canceled1;\n                    const otherCanceled = forBranch2 ? canceled1 : canceled2;\n                    if (!byobCanceled) {\n                        ReadableByteStreamControllerClose(byobBranch._readableStreamController);\n                    }\n                    if (!otherCanceled) {\n                        ReadableByteStreamControllerClose(otherBranch._readableStreamController);\n                    }\n                    if (chunk !== undefined) {\n                        if (!byobCanceled) {\n                            ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);\n                        }\n                        if (!otherCanceled && otherBranch._readableStreamController._pendingPullIntos.length > 0) {\n                            ReadableByteStreamControllerRespond(otherBranch._readableStreamController, 0);\n                        }\n                    }\n                    if (!byobCanceled || !otherCanceled) {\n                        resolveCancelPromise(undefined);\n                    }\n                },\n                _errorSteps: () => {\n                    reading = false;\n                }\n            };\n            ReadableStreamBYOBReaderRead(reader, view, readIntoRequest);\n        }\n        function pull1Algorithm() {\n            if (reading) {\n                readAgainForBranch1 = true;\n                return promiseResolvedWith(undefined);\n            }\n            reading = true;\n            const byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch1._readableStreamController);\n            if (byobRequest === null) {\n                pullWithDefaultReader();\n            }\n            else {\n                pullWithBYOBReader(byobRequest._view, false);\n            }\n            return promiseResolvedWith(undefined);\n        }\n        function pull2Algorithm() {\n            if (reading) {\n                readAgainForBranch2 = true;\n                return promiseResolvedWith(undefined);\n            }\n            reading = true;\n            const byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch2._readableStreamController);\n            if (byobRequest === null) {\n                pullWithDefaultReader();\n            }\n            else {\n                pullWithBYOBReader(byobRequest._view, true);\n            }\n            return promiseResolvedWith(undefined);\n        }\n        function cancel1Algorithm(reason) {\n            canceled1 = true;\n            reason1 = reason;\n            if (canceled2) {\n                const compositeReason = CreateArrayFromList([reason1, reason2]);\n                const cancelResult = ReadableStreamCancel(stream, compositeReason);\n                resolveCancelPromise(cancelResult);\n            }\n            return cancelPromise;\n        }\n        function cancel2Algorithm(reason) {\n            canceled2 = true;\n            reason2 = reason;\n            if (canceled1) {\n                const compositeReason = CreateArrayFromList([reason1, reason2]);\n                const cancelResult = ReadableStreamCancel(stream, compositeReason);\n                resolveCancelPromise(cancelResult);\n            }\n            return cancelPromise;\n        }\n        function startAlgorithm() {\n            return;\n        }\n        branch1 = CreateReadableByteStream(startAlgorithm, pull1Algorithm, cancel1Algorithm);\n        branch2 = CreateReadableByteStream(startAlgorithm, pull2Algorithm, cancel2Algorithm);\n        forwardReaderError(reader);\n        return [branch1, branch2];\n    }\n\n    function convertUnderlyingDefaultOrByteSource(source, context) {\n        assertDictionary(source, context);\n        const original = source;\n        const autoAllocateChunkSize = original === null || original === void 0 ? void 0 : original.autoAllocateChunkSize;\n        const cancel = original === null || original === void 0 ? void 0 : original.cancel;\n        const pull = original === null || original === void 0 ? void 0 : original.pull;\n        const start = original === null || original === void 0 ? void 0 : original.start;\n        const type = original === null || original === void 0 ? void 0 : original.type;\n        return {\n            autoAllocateChunkSize: autoAllocateChunkSize === undefined ?\n                undefined :\n                convertUnsignedLongLongWithEnforceRange(autoAllocateChunkSize, `${context} has member 'autoAllocateChunkSize' that`),\n            cancel: cancel === undefined ?\n                undefined :\n                convertUnderlyingSourceCancelCallback(cancel, original, `${context} has member 'cancel' that`),\n            pull: pull === undefined ?\n                undefined :\n                convertUnderlyingSourcePullCallback(pull, original, `${context} has member 'pull' that`),\n            start: start === undefined ?\n                undefined :\n                convertUnderlyingSourceStartCallback(start, original, `${context} has member 'start' that`),\n            type: type === undefined ? undefined : convertReadableStreamType(type, `${context} has member 'type' that`)\n        };\n    }\n    function convertUnderlyingSourceCancelCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return (reason) => promiseCall(fn, original, [reason]);\n    }\n    function convertUnderlyingSourcePullCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return (controller) => promiseCall(fn, original, [controller]);\n    }\n    function convertUnderlyingSourceStartCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return (controller) => reflectCall(fn, original, [controller]);\n    }\n    function convertReadableStreamType(type, context) {\n        type = `${type}`;\n        if (type !== 'bytes') {\n            throw new TypeError(`${context} '${type}' is not a valid enumeration value for ReadableStreamType`);\n        }\n        return type;\n    }\n\n    function convertReaderOptions(options, context) {\n        assertDictionary(options, context);\n        const mode = options === null || options === void 0 ? void 0 : options.mode;\n        return {\n            mode: mode === undefined ? undefined : convertReadableStreamReaderMode(mode, `${context} has member 'mode' that`)\n        };\n    }\n    function convertReadableStreamReaderMode(mode, context) {\n        mode = `${mode}`;\n        if (mode !== 'byob') {\n            throw new TypeError(`${context} '${mode}' is not a valid enumeration value for ReadableStreamReaderMode`);\n        }\n        return mode;\n    }\n\n    function convertIteratorOptions(options, context) {\n        assertDictionary(options, context);\n        const preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;\n        return { preventCancel: Boolean(preventCancel) };\n    }\n\n    function convertPipeOptions(options, context) {\n        assertDictionary(options, context);\n        const preventAbort = options === null || options === void 0 ? void 0 : options.preventAbort;\n        const preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;\n        const preventClose = options === null || options === void 0 ? void 0 : options.preventClose;\n        const signal = options === null || options === void 0 ? void 0 : options.signal;\n        if (signal !== undefined) {\n            assertAbortSignal(signal, `${context} has member 'signal' that`);\n        }\n        return {\n            preventAbort: Boolean(preventAbort),\n            preventCancel: Boolean(preventCancel),\n            preventClose: Boolean(preventClose),\n            signal\n        };\n    }\n    function assertAbortSignal(signal, context) {\n        if (!isAbortSignal(signal)) {\n            throw new TypeError(`${context} is not an AbortSignal.`);\n        }\n    }\n\n    function convertReadableWritablePair(pair, context) {\n        assertDictionary(pair, context);\n        const readable = pair === null || pair === void 0 ? void 0 : pair.readable;\n        assertRequiredField(readable, 'readable', 'ReadableWritablePair');\n        assertReadableStream(readable, `${context} has member 'readable' that`);\n        const writable = pair === null || pair === void 0 ? void 0 : pair.writable;\n        assertRequiredField(writable, 'writable', 'ReadableWritablePair');\n        assertWritableStream(writable, `${context} has member 'writable' that`);\n        return { readable, writable };\n    }\n\n    /**\n     * A readable stream represents a source of data, from which you can read.\n     *\n     * @public\n     */\n    class ReadableStream {\n        constructor(rawUnderlyingSource = {}, rawStrategy = {}) {\n            if (rawUnderlyingSource === undefined) {\n                rawUnderlyingSource = null;\n            }\n            else {\n                assertObject(rawUnderlyingSource, 'First parameter');\n            }\n            const strategy = convertQueuingStrategy(rawStrategy, 'Second parameter');\n            const underlyingSource = convertUnderlyingDefaultOrByteSource(rawUnderlyingSource, 'First parameter');\n            InitializeReadableStream(this);\n            if (underlyingSource.type === 'bytes') {\n                if (strategy.size !== undefined) {\n                    throw new RangeError('The strategy for a byte stream cannot have a size function');\n                }\n                const highWaterMark = ExtractHighWaterMark(strategy, 0);\n                SetUpReadableByteStreamControllerFromUnderlyingSource(this, underlyingSource, highWaterMark);\n            }\n            else {\n                const sizeAlgorithm = ExtractSizeAlgorithm(strategy);\n                const highWaterMark = ExtractHighWaterMark(strategy, 1);\n                SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, highWaterMark, sizeAlgorithm);\n            }\n        }\n        /**\n         * Whether or not the readable stream is locked to a {@link ReadableStreamDefaultReader | reader}.\n         */\n        get locked() {\n            if (!IsReadableStream(this)) {\n                throw streamBrandCheckException$1('locked');\n            }\n            return IsReadableStreamLocked(this);\n        }\n        /**\n         * Cancels the stream, signaling a loss of interest in the stream by a consumer.\n         *\n         * The supplied `reason` argument will be given to the underlying source's {@link UnderlyingSource.cancel | cancel()}\n         * method, which might or might not use it.\n         */\n        cancel(reason = undefined) {\n            if (!IsReadableStream(this)) {\n                return promiseRejectedWith(streamBrandCheckException$1('cancel'));\n            }\n            if (IsReadableStreamLocked(this)) {\n                return promiseRejectedWith(new TypeError('Cannot cancel a stream that already has a reader'));\n            }\n            return ReadableStreamCancel(this, reason);\n        }\n        getReader(rawOptions = undefined) {\n            if (!IsReadableStream(this)) {\n                throw streamBrandCheckException$1('getReader');\n            }\n            const options = convertReaderOptions(rawOptions, 'First parameter');\n            if (options.mode === undefined) {\n                return AcquireReadableStreamDefaultReader(this);\n            }\n            return AcquireReadableStreamBYOBReader(this);\n        }\n        pipeThrough(rawTransform, rawOptions = {}) {\n            if (!IsReadableStream(this)) {\n                throw streamBrandCheckException$1('pipeThrough');\n            }\n            assertRequiredArgument(rawTransform, 1, 'pipeThrough');\n            const transform = convertReadableWritablePair(rawTransform, 'First parameter');\n            const options = convertPipeOptions(rawOptions, 'Second parameter');\n            if (IsReadableStreamLocked(this)) {\n                throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream');\n            }\n            if (IsWritableStreamLocked(transform.writable)) {\n                throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream');\n            }\n            const promise = ReadableStreamPipeTo(this, transform.writable, options.preventClose, options.preventAbort, options.preventCancel, options.signal);\n            setPromiseIsHandledToTrue(promise);\n            return transform.readable;\n        }\n        pipeTo(destination, rawOptions = {}) {\n            if (!IsReadableStream(this)) {\n                return promiseRejectedWith(streamBrandCheckException$1('pipeTo'));\n            }\n            if (destination === undefined) {\n                return promiseRejectedWith(`Parameter 1 is required in 'pipeTo'.`);\n            }\n            if (!IsWritableStream(destination)) {\n                return promiseRejectedWith(new TypeError(`ReadableStream.prototype.pipeTo's first argument must be a WritableStream`));\n            }\n            let options;\n            try {\n                options = convertPipeOptions(rawOptions, 'Second parameter');\n            }\n            catch (e) {\n                return promiseRejectedWith(e);\n            }\n            if (IsReadableStreamLocked(this)) {\n                return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream'));\n            }\n            if (IsWritableStreamLocked(destination)) {\n                return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream'));\n            }\n            return ReadableStreamPipeTo(this, destination, options.preventClose, options.preventAbort, options.preventCancel, options.signal);\n        }\n        /**\n         * Tees this readable stream, returning a two-element array containing the two resulting branches as\n         * new {@link ReadableStream} instances.\n         *\n         * Teeing a stream will lock it, preventing any other consumer from acquiring a reader.\n         * To cancel the stream, cancel both of the resulting branches; a composite cancellation reason will then be\n         * propagated to the stream's underlying source.\n         *\n         * Note that the chunks seen in each branch will be the same object. If the chunks are not immutable,\n         * this could allow interference between the two branches.\n         */\n        tee() {\n            if (!IsReadableStream(this)) {\n                throw streamBrandCheckException$1('tee');\n            }\n            const branches = ReadableStreamTee(this);\n            return CreateArrayFromList(branches);\n        }\n        values(rawOptions = undefined) {\n            if (!IsReadableStream(this)) {\n                throw streamBrandCheckException$1('values');\n            }\n            const options = convertIteratorOptions(rawOptions, 'First parameter');\n            return AcquireReadableStreamAsyncIterator(this, options.preventCancel);\n        }\n    }\n    Object.defineProperties(ReadableStream.prototype, {\n        cancel: { enumerable: true },\n        getReader: { enumerable: true },\n        pipeThrough: { enumerable: true },\n        pipeTo: { enumerable: true },\n        tee: { enumerable: true },\n        values: { enumerable: true },\n        locked: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(ReadableStream.prototype, SymbolPolyfill.toStringTag, {\n            value: 'ReadableStream',\n            configurable: true\n        });\n    }\n    if (typeof SymbolPolyfill.asyncIterator === 'symbol') {\n        Object.defineProperty(ReadableStream.prototype, SymbolPolyfill.asyncIterator, {\n            value: ReadableStream.prototype.values,\n            writable: true,\n            configurable: true\n        });\n    }\n    // Abstract operations for the ReadableStream.\n    // Throws if and only if startAlgorithm throws.\n    function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark = 1, sizeAlgorithm = () => 1) {\n        const stream = Object.create(ReadableStream.prototype);\n        InitializeReadableStream(stream);\n        const controller = Object.create(ReadableStreamDefaultController.prototype);\n        SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);\n        return stream;\n    }\n    // Throws if and only if startAlgorithm throws.\n    function CreateReadableByteStream(startAlgorithm, pullAlgorithm, cancelAlgorithm) {\n        const stream = Object.create(ReadableStream.prototype);\n        InitializeReadableStream(stream);\n        const controller = Object.create(ReadableByteStreamController.prototype);\n        SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, 0, undefined);\n        return stream;\n    }\n    function InitializeReadableStream(stream) {\n        stream._state = 'readable';\n        stream._reader = undefined;\n        stream._storedError = undefined;\n        stream._disturbed = false;\n    }\n    function IsReadableStream(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {\n            return false;\n        }\n        return x instanceof ReadableStream;\n    }\n    function IsReadableStreamLocked(stream) {\n        if (stream._reader === undefined) {\n            return false;\n        }\n        return true;\n    }\n    // ReadableStream API exposed for controllers.\n    function ReadableStreamCancel(stream, reason) {\n        stream._disturbed = true;\n        if (stream._state === 'closed') {\n            return promiseResolvedWith(undefined);\n        }\n        if (stream._state === 'errored') {\n            return promiseRejectedWith(stream._storedError);\n        }\n        ReadableStreamClose(stream);\n        const reader = stream._reader;\n        if (reader !== undefined && IsReadableStreamBYOBReader(reader)) {\n            reader._readIntoRequests.forEach(readIntoRequest => {\n                readIntoRequest._closeSteps(undefined);\n            });\n            reader._readIntoRequests = new SimpleQueue();\n        }\n        const sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);\n        return transformPromiseWith(sourceCancelPromise, noop);\n    }\n    function ReadableStreamClose(stream) {\n        stream._state = 'closed';\n        const reader = stream._reader;\n        if (reader === undefined) {\n            return;\n        }\n        defaultReaderClosedPromiseResolve(reader);\n        if (IsReadableStreamDefaultReader(reader)) {\n            reader._readRequests.forEach(readRequest => {\n                readRequest._closeSteps();\n            });\n            reader._readRequests = new SimpleQueue();\n        }\n    }\n    function ReadableStreamError(stream, e) {\n        stream._state = 'errored';\n        stream._storedError = e;\n        const reader = stream._reader;\n        if (reader === undefined) {\n            return;\n        }\n        defaultReaderClosedPromiseReject(reader, e);\n        if (IsReadableStreamDefaultReader(reader)) {\n            reader._readRequests.forEach(readRequest => {\n                readRequest._errorSteps(e);\n            });\n            reader._readRequests = new SimpleQueue();\n        }\n        else {\n            reader._readIntoRequests.forEach(readIntoRequest => {\n                readIntoRequest._errorSteps(e);\n            });\n            reader._readIntoRequests = new SimpleQueue();\n        }\n    }\n    // Helper functions for the ReadableStream.\n    function streamBrandCheckException$1(name) {\n        return new TypeError(`ReadableStream.prototype.${name} can only be used on a ReadableStream`);\n    }\n\n    function convertQueuingStrategyInit(init, context) {\n        assertDictionary(init, context);\n        const highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;\n        assertRequiredField(highWaterMark, 'highWaterMark', 'QueuingStrategyInit');\n        return {\n            highWaterMark: convertUnrestrictedDouble(highWaterMark)\n        };\n    }\n\n    // The size function must not have a prototype property nor be a constructor\n    const byteLengthSizeFunction = (chunk) => {\n        return chunk.byteLength;\n    };\n    try {\n        Object.defineProperty(byteLengthSizeFunction, 'name', {\n            value: 'size',\n            configurable: true\n        });\n    }\n    catch (_a) {\n        // This property is non-configurable in older browsers, so ignore if this throws.\n        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#browser_compatibility\n    }\n    /**\n     * A queuing strategy that counts the number of bytes in each chunk.\n     *\n     * @public\n     */\n    class ByteLengthQueuingStrategy {\n        constructor(options) {\n            assertRequiredArgument(options, 1, 'ByteLengthQueuingStrategy');\n            options = convertQueuingStrategyInit(options, 'First parameter');\n            this._byteLengthQueuingStrategyHighWaterMark = options.highWaterMark;\n        }\n        /**\n         * Returns the high water mark provided to the constructor.\n         */\n        get highWaterMark() {\n            if (!IsByteLengthQueuingStrategy(this)) {\n                throw byteLengthBrandCheckException('highWaterMark');\n            }\n            return this._byteLengthQueuingStrategyHighWaterMark;\n        }\n        /**\n         * Measures the size of `chunk` by returning the value of its `byteLength` property.\n         */\n        get size() {\n            if (!IsByteLengthQueuingStrategy(this)) {\n                throw byteLengthBrandCheckException('size');\n            }\n            return byteLengthSizeFunction;\n        }\n    }\n    Object.defineProperties(ByteLengthQueuingStrategy.prototype, {\n        highWaterMark: { enumerable: true },\n        size: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(ByteLengthQueuingStrategy.prototype, SymbolPolyfill.toStringTag, {\n            value: 'ByteLengthQueuingStrategy',\n            configurable: true\n        });\n    }\n    // Helper functions for the ByteLengthQueuingStrategy.\n    function byteLengthBrandCheckException(name) {\n        return new TypeError(`ByteLengthQueuingStrategy.prototype.${name} can only be used on a ByteLengthQueuingStrategy`);\n    }\n    function IsByteLengthQueuingStrategy(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_byteLengthQueuingStrategyHighWaterMark')) {\n            return false;\n        }\n        return x instanceof ByteLengthQueuingStrategy;\n    }\n\n    // The size function must not have a prototype property nor be a constructor\n    const countSizeFunction = () => {\n        return 1;\n    };\n    try {\n        Object.defineProperty(countSizeFunction, 'name', {\n            value: 'size',\n            configurable: true\n        });\n    }\n    catch (_a) {\n        // This property is non-configurable in older browsers, so ignore if this throws.\n        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#browser_compatibility\n    }\n    /**\n     * A queuing strategy that counts the number of chunks.\n     *\n     * @public\n     */\n    class CountQueuingStrategy {\n        constructor(options) {\n            assertRequiredArgument(options, 1, 'CountQueuingStrategy');\n            options = convertQueuingStrategyInit(options, 'First parameter');\n            this._countQueuingStrategyHighWaterMark = options.highWaterMark;\n        }\n        /**\n         * Returns the high water mark provided to the constructor.\n         */\n        get highWaterMark() {\n            if (!IsCountQueuingStrategy(this)) {\n                throw countBrandCheckException('highWaterMark');\n            }\n            return this._countQueuingStrategyHighWaterMark;\n        }\n        /**\n         * Measures the size of `chunk` by always returning 1.\n         * This ensures that the total queue size is a count of the number of chunks in the queue.\n         */\n        get size() {\n            if (!IsCountQueuingStrategy(this)) {\n                throw countBrandCheckException('size');\n            }\n            return countSizeFunction;\n        }\n    }\n    Object.defineProperties(CountQueuingStrategy.prototype, {\n        highWaterMark: { enumerable: true },\n        size: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(CountQueuingStrategy.prototype, SymbolPolyfill.toStringTag, {\n            value: 'CountQueuingStrategy',\n            configurable: true\n        });\n    }\n    // Helper functions for the CountQueuingStrategy.\n    function countBrandCheckException(name) {\n        return new TypeError(`CountQueuingStrategy.prototype.${name} can only be used on a CountQueuingStrategy`);\n    }\n    function IsCountQueuingStrategy(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_countQueuingStrategyHighWaterMark')) {\n            return false;\n        }\n        return x instanceof CountQueuingStrategy;\n    }\n\n    function convertTransformer(original, context) {\n        assertDictionary(original, context);\n        const flush = original === null || original === void 0 ? void 0 : original.flush;\n        const readableType = original === null || original === void 0 ? void 0 : original.readableType;\n        const start = original === null || original === void 0 ? void 0 : original.start;\n        const transform = original === null || original === void 0 ? void 0 : original.transform;\n        const writableType = original === null || original === void 0 ? void 0 : original.writableType;\n        return {\n            flush: flush === undefined ?\n                undefined :\n                convertTransformerFlushCallback(flush, original, `${context} has member 'flush' that`),\n            readableType,\n            start: start === undefined ?\n                undefined :\n                convertTransformerStartCallback(start, original, `${context} has member 'start' that`),\n            transform: transform === undefined ?\n                undefined :\n                convertTransformerTransformCallback(transform, original, `${context} has member 'transform' that`),\n            writableType\n        };\n    }\n    function convertTransformerFlushCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return (controller) => promiseCall(fn, original, [controller]);\n    }\n    function convertTransformerStartCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return (controller) => reflectCall(fn, original, [controller]);\n    }\n    function convertTransformerTransformCallback(fn, original, context) {\n        assertFunction(fn, context);\n        return (chunk, controller) => promiseCall(fn, original, [chunk, controller]);\n    }\n\n    // Class TransformStream\n    /**\n     * A transform stream consists of a pair of streams: a {@link WritableStream | writable stream},\n     * known as its writable side, and a {@link ReadableStream | readable stream}, known as its readable side.\n     * In a manner specific to the transform stream in question, writes to the writable side result in new data being\n     * made available for reading from the readable side.\n     *\n     * @public\n     */\n    class TransformStream {\n        constructor(rawTransformer = {}, rawWritableStrategy = {}, rawReadableStrategy = {}) {\n            if (rawTransformer === undefined) {\n                rawTransformer = null;\n            }\n            const writableStrategy = convertQueuingStrategy(rawWritableStrategy, 'Second parameter');\n            const readableStrategy = convertQueuingStrategy(rawReadableStrategy, 'Third parameter');\n            const transformer = convertTransformer(rawTransformer, 'First parameter');\n            if (transformer.readableType !== undefined) {\n                throw new RangeError('Invalid readableType specified');\n            }\n            if (transformer.writableType !== undefined) {\n                throw new RangeError('Invalid writableType specified');\n            }\n            const readableHighWaterMark = ExtractHighWaterMark(readableStrategy, 0);\n            const readableSizeAlgorithm = ExtractSizeAlgorithm(readableStrategy);\n            const writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1);\n            const writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy);\n            let startPromise_resolve;\n            const startPromise = newPromise(resolve => {\n                startPromise_resolve = resolve;\n            });\n            InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);\n            SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);\n            if (transformer.start !== undefined) {\n                startPromise_resolve(transformer.start(this._transformStreamController));\n            }\n            else {\n                startPromise_resolve(undefined);\n            }\n        }\n        /**\n         * The readable side of the transform stream.\n         */\n        get readable() {\n            if (!IsTransformStream(this)) {\n                throw streamBrandCheckException('readable');\n            }\n            return this._readable;\n        }\n        /**\n         * The writable side of the transform stream.\n         */\n        get writable() {\n            if (!IsTransformStream(this)) {\n                throw streamBrandCheckException('writable');\n            }\n            return this._writable;\n        }\n    }\n    Object.defineProperties(TransformStream.prototype, {\n        readable: { enumerable: true },\n        writable: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(TransformStream.prototype, SymbolPolyfill.toStringTag, {\n            value: 'TransformStream',\n            configurable: true\n        });\n    }\n    function InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) {\n        function startAlgorithm() {\n            return startPromise;\n        }\n        function writeAlgorithm(chunk) {\n            return TransformStreamDefaultSinkWriteAlgorithm(stream, chunk);\n        }\n        function abortAlgorithm(reason) {\n            return TransformStreamDefaultSinkAbortAlgorithm(stream, reason);\n        }\n        function closeAlgorithm() {\n            return TransformStreamDefaultSinkCloseAlgorithm(stream);\n        }\n        stream._writable = CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, writableHighWaterMark, writableSizeAlgorithm);\n        function pullAlgorithm() {\n            return TransformStreamDefaultSourcePullAlgorithm(stream);\n        }\n        function cancelAlgorithm(reason) {\n            TransformStreamErrorWritableAndUnblockWrite(stream, reason);\n            return promiseResolvedWith(undefined);\n        }\n        stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm);\n        // The [[backpressure]] slot is set to undefined so that it can be initialised by TransformStreamSetBackpressure.\n        stream._backpressure = undefined;\n        stream._backpressureChangePromise = undefined;\n        stream._backpressureChangePromise_resolve = undefined;\n        TransformStreamSetBackpressure(stream, true);\n        stream._transformStreamController = undefined;\n    }\n    function IsTransformStream(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) {\n            return false;\n        }\n        return x instanceof TransformStream;\n    }\n    // This is a no-op if both sides are already errored.\n    function TransformStreamError(stream, e) {\n        ReadableStreamDefaultControllerError(stream._readable._readableStreamController, e);\n        TransformStreamErrorWritableAndUnblockWrite(stream, e);\n    }\n    function TransformStreamErrorWritableAndUnblockWrite(stream, e) {\n        TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController);\n        WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e);\n        if (stream._backpressure) {\n            // Pretend that pull() was called to permit any pending write() calls to complete. TransformStreamSetBackpressure()\n            // cannot be called from enqueue() or pull() once the ReadableStream is errored, so this will will be the final time\n            // _backpressure is set.\n            TransformStreamSetBackpressure(stream, false);\n        }\n    }\n    function TransformStreamSetBackpressure(stream, backpressure) {\n        // Passes also when called during construction.\n        if (stream._backpressureChangePromise !== undefined) {\n            stream._backpressureChangePromise_resolve();\n        }\n        stream._backpressureChangePromise = newPromise(resolve => {\n            stream._backpressureChangePromise_resolve = resolve;\n        });\n        stream._backpressure = backpressure;\n    }\n    // Class TransformStreamDefaultController\n    /**\n     * Allows control of the {@link ReadableStream} and {@link WritableStream} of the associated {@link TransformStream}.\n     *\n     * @public\n     */\n    class TransformStreamDefaultController {\n        constructor() {\n            throw new TypeError('Illegal constructor');\n        }\n        /**\n         * Returns the desired size to fill the readable side’s internal queue. It can be negative, if the queue is over-full.\n         */\n        get desiredSize() {\n            if (!IsTransformStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException('desiredSize');\n            }\n            const readableController = this._controlledTransformStream._readable._readableStreamController;\n            return ReadableStreamDefaultControllerGetDesiredSize(readableController);\n        }\n        enqueue(chunk = undefined) {\n            if (!IsTransformStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException('enqueue');\n            }\n            TransformStreamDefaultControllerEnqueue(this, chunk);\n        }\n        /**\n         * Errors both the readable side and the writable side of the controlled transform stream, making all future\n         * interactions with it fail with the given error `e`. Any chunks queued for transformation will be discarded.\n         */\n        error(reason = undefined) {\n            if (!IsTransformStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException('error');\n            }\n            TransformStreamDefaultControllerError(this, reason);\n        }\n        /**\n         * Closes the readable side and errors the writable side of the controlled transform stream. This is useful when the\n         * transformer only needs to consume a portion of the chunks written to the writable side.\n         */\n        terminate() {\n            if (!IsTransformStreamDefaultController(this)) {\n                throw defaultControllerBrandCheckException('terminate');\n            }\n            TransformStreamDefaultControllerTerminate(this);\n        }\n    }\n    Object.defineProperties(TransformStreamDefaultController.prototype, {\n        enqueue: { enumerable: true },\n        error: { enumerable: true },\n        terminate: { enumerable: true },\n        desiredSize: { enumerable: true }\n    });\n    if (typeof SymbolPolyfill.toStringTag === 'symbol') {\n        Object.defineProperty(TransformStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {\n            value: 'TransformStreamDefaultController',\n            configurable: true\n        });\n    }\n    // Transform Stream Default Controller Abstract Operations\n    function IsTransformStreamDefaultController(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) {\n            return false;\n        }\n        return x instanceof TransformStreamDefaultController;\n    }\n    function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm) {\n        controller._controlledTransformStream = stream;\n        stream._transformStreamController = controller;\n        controller._transformAlgorithm = transformAlgorithm;\n        controller._flushAlgorithm = flushAlgorithm;\n    }\n    function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) {\n        const controller = Object.create(TransformStreamDefaultController.prototype);\n        let transformAlgorithm = (chunk) => {\n            try {\n                TransformStreamDefaultControllerEnqueue(controller, chunk);\n                return promiseResolvedWith(undefined);\n            }\n            catch (transformResultE) {\n                return promiseRejectedWith(transformResultE);\n            }\n        };\n        let flushAlgorithm = () => promiseResolvedWith(undefined);\n        if (transformer.transform !== undefined) {\n            transformAlgorithm = chunk => transformer.transform(chunk, controller);\n        }\n        if (transformer.flush !== undefined) {\n            flushAlgorithm = () => transformer.flush(controller);\n        }\n        SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm);\n    }\n    function TransformStreamDefaultControllerClearAlgorithms(controller) {\n        controller._transformAlgorithm = undefined;\n        controller._flushAlgorithm = undefined;\n    }\n    function TransformStreamDefaultControllerEnqueue(controller, chunk) {\n        const stream = controller._controlledTransformStream;\n        const readableController = stream._readable._readableStreamController;\n        if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController)) {\n            throw new TypeError('Readable side is not in a state that permits enqueue');\n        }\n        // We throttle transform invocations based on the backpressure of the ReadableStream, but we still\n        // accept TransformStreamDefaultControllerEnqueue() calls.\n        try {\n            ReadableStreamDefaultControllerEnqueue(readableController, chunk);\n        }\n        catch (e) {\n            // This happens when readableStrategy.size() throws.\n            TransformStreamErrorWritableAndUnblockWrite(stream, e);\n            throw stream._readable._storedError;\n        }\n        const backpressure = ReadableStreamDefaultControllerHasBackpressure(readableController);\n        if (backpressure !== stream._backpressure) {\n            TransformStreamSetBackpressure(stream, true);\n        }\n    }\n    function TransformStreamDefaultControllerError(controller, e) {\n        TransformStreamError(controller._controlledTransformStream, e);\n    }\n    function TransformStreamDefaultControllerPerformTransform(controller, chunk) {\n        const transformPromise = controller._transformAlgorithm(chunk);\n        return transformPromiseWith(transformPromise, undefined, r => {\n            TransformStreamError(controller._controlledTransformStream, r);\n            throw r;\n        });\n    }\n    function TransformStreamDefaultControllerTerminate(controller) {\n        const stream = controller._controlledTransformStream;\n        const readableController = stream._readable._readableStreamController;\n        ReadableStreamDefaultControllerClose(readableController);\n        const error = new TypeError('TransformStream terminated');\n        TransformStreamErrorWritableAndUnblockWrite(stream, error);\n    }\n    // TransformStreamDefaultSink Algorithms\n    function TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) {\n        const controller = stream._transformStreamController;\n        if (stream._backpressure) {\n            const backpressureChangePromise = stream._backpressureChangePromise;\n            return transformPromiseWith(backpressureChangePromise, () => {\n                const writable = stream._writable;\n                const state = writable._state;\n                if (state === 'erroring') {\n                    throw writable._storedError;\n                }\n                return TransformStreamDefaultControllerPerformTransform(controller, chunk);\n            });\n        }\n        return TransformStreamDefaultControllerPerformTransform(controller, chunk);\n    }\n    function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) {\n        // abort() is not called synchronously, so it is possible for abort() to be called when the stream is already\n        // errored.\n        TransformStreamError(stream, reason);\n        return promiseResolvedWith(undefined);\n    }\n    function TransformStreamDefaultSinkCloseAlgorithm(stream) {\n        // stream._readable cannot change after construction, so caching it across a call to user code is safe.\n        const readable = stream._readable;\n        const controller = stream._transformStreamController;\n        const flushPromise = controller._flushAlgorithm();\n        TransformStreamDefaultControllerClearAlgorithms(controller);\n        // Return a promise that is fulfilled with undefined on success.\n        return transformPromiseWith(flushPromise, () => {\n            if (readable._state === 'errored') {\n                throw readable._storedError;\n            }\n            ReadableStreamDefaultControllerClose(readable._readableStreamController);\n        }, r => {\n            TransformStreamError(stream, r);\n            throw readable._storedError;\n        });\n    }\n    // TransformStreamDefaultSource Algorithms\n    function TransformStreamDefaultSourcePullAlgorithm(stream) {\n        // Invariant. Enforced by the promises returned by start() and pull().\n        TransformStreamSetBackpressure(stream, false);\n        // Prevent the next pull() call until there is backpressure.\n        return stream._backpressureChangePromise;\n    }\n    // Helper functions for the TransformStreamDefaultController.\n    function defaultControllerBrandCheckException(name) {\n        return new TypeError(`TransformStreamDefaultController.prototype.${name} can only be used on a TransformStreamDefaultController`);\n    }\n    // Helper functions for the TransformStream.\n    function streamBrandCheckException(name) {\n        return new TypeError(`TransformStream.prototype.${name} can only be used on a TransformStream`);\n    }\n\n    exports.ByteLengthQueuingStrategy = ByteLengthQueuingStrategy;\n    exports.CountQueuingStrategy = CountQueuingStrategy;\n    exports.ReadableByteStreamController = ReadableByteStreamController;\n    exports.ReadableStream = ReadableStream;\n    exports.ReadableStreamBYOBReader = ReadableStreamBYOBReader;\n    exports.ReadableStreamBYOBRequest = ReadableStreamBYOBRequest;\n    exports.ReadableStreamDefaultController = ReadableStreamDefaultController;\n    exports.ReadableStreamDefaultReader = ReadableStreamDefaultReader;\n    exports.TransformStream = TransformStream;\n    exports.TransformStreamDefaultController = TransformStreamDefaultController;\n    exports.WritableStream = WritableStream;\n    exports.WritableStreamDefaultController = WritableStreamDefaultController;\n    exports.WritableStreamDefaultWriter = WritableStreamDefaultWriter;\n\n    Object.defineProperty(exports, '__esModule', { value: true });\n\n})));\n//# sourceMappingURL=ponyfill.es2018.js.map\n","/// <reference lib=\"es2015.symbol\" />\n\nconst SymbolPolyfill: (description?: string) => symbol =\n  typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ?\n    Symbol :\n    description => `Symbol(${description})` as any as symbol;\n\nexport default SymbolPolyfill;\n","/// <reference lib=\"dom\" />\n\nexport function noop(): undefined {\n  return undefined;\n}\n\nfunction getGlobals() {\n  if (typeof self !== 'undefined') {\n    return self;\n  } else if (typeof window !== 'undefined') {\n    return window;\n  } else if (typeof global !== 'undefined') {\n    return global;\n  }\n  return undefined;\n}\n\nexport const globals = getGlobals();\n","import { noop } from '../../utils';\nimport { AssertionError } from '../../stub/assert';\n\nexport function typeIsObject(x: any): x is object {\n  return (typeof x === 'object' && x !== null) || typeof x === 'function';\n}\n\nexport const rethrowAssertionErrorRejection: (e: any) => void =\n  DEBUG ? e => {\n    // Used throughout the reference implementation, as `.catch(rethrowAssertionErrorRejection)`, to ensure any errors\n    // get shown. There are places in the spec where we do promise transformations and purposefully ignore or don't\n    // expect any errors, but assertion errors are always problematic.\n    if (e && e instanceof AssertionError) {\n      setTimeout(() => {\n        throw e;\n      }, 0);\n    }\n  } : noop;\n","import { globals } from '../../utils';\nimport { rethrowAssertionErrorRejection } from './miscellaneous';\nimport assert from '../../stub/assert';\n\nconst originalPromise = Promise;\nconst originalPromiseThen = Promise.prototype.then;\nconst originalPromiseResolve = Promise.resolve.bind(originalPromise);\nconst originalPromiseReject = Promise.reject.bind(originalPromise);\n\nexport function newPromise<T>(executor: (\n  resolve: (value: T | PromiseLike<T>) => void,\n  reject: (reason?: any) => void\n) => void): Promise<T> {\n  return new originalPromise(executor);\n}\n\nexport function promiseResolvedWith<T>(value: T | PromiseLike<T>): Promise<T> {\n  return originalPromiseResolve(value);\n}\n\nexport function promiseRejectedWith<T = never>(reason: any): Promise<T> {\n  return originalPromiseReject(reason);\n}\n\nexport function PerformPromiseThen<T, TResult1 = T, TResult2 = never>(\n  promise: Promise<T>,\n  onFulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>,\n  onRejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2> {\n  // There doesn't appear to be any way to correctly emulate the behaviour from JavaScript, so this is just an\n  // approximation.\n  return originalPromiseThen.call(promise, onFulfilled, onRejected) as Promise<TResult1 | TResult2>;\n}\n\nexport function uponPromise<T>(\n  promise: Promise<T>,\n  onFulfilled?: (value: T) => void | PromiseLike<void>,\n  onRejected?: (reason: any) => void | PromiseLike<void>): void {\n  PerformPromiseThen(\n    PerformPromiseThen(promise, onFulfilled, onRejected),\n    undefined,\n    rethrowAssertionErrorRejection\n  );\n}\n\nexport function uponFulfillment<T>(promise: Promise<T>, onFulfilled: (value: T) => void | PromiseLike<void>): void {\n  uponPromise(promise, onFulfilled);\n}\n\nexport function uponRejection(promise: Promise<unknown>, onRejected: (reason: any) => void | PromiseLike<void>): void {\n  uponPromise(promise, undefined, onRejected);\n}\n\nexport function transformPromiseWith<T, TResult1 = T, TResult2 = never>(\n  promise: Promise<T>,\n  fulfillmentHandler?: (value: T) => TResult1 | PromiseLike<TResult1>,\n  rejectionHandler?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2> {\n  return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler);\n}\n\nexport function setPromiseIsHandledToTrue(promise: Promise<unknown>): void {\n  PerformPromiseThen(promise, undefined, rethrowAssertionErrorRejection);\n}\n\nexport const queueMicrotask: (fn: () => void) => void = (() => {\n  const globalQueueMicrotask = globals && globals.queueMicrotask;\n  if (typeof globalQueueMicrotask === 'function') {\n    return globalQueueMicrotask;\n  }\n\n  const resolvedPromise = promiseResolvedWith(undefined);\n  return (fn: () => void) => PerformPromiseThen(resolvedPromise, fn);\n})();\n\nexport function reflectCall<T, A extends any[], R>(F: (this: T, ...fnArgs: A) => R, V: T, args: A): R {\n  if (typeof F !== 'function') {\n    throw new TypeError('Argument is not a function');\n  }\n  return Function.prototype.apply.call(F, V, args);\n}\n\nexport function promiseCall<T, A extends any[], R>(F: (this: T, ...fnArgs: A) => R | PromiseLike<R>,\n                                                   V: T,\n                                                   args: A): Promise<R> {\n  assert(typeof F === 'function');\n  assert(V !== undefined);\n  assert(Array.isArray(args));\n  try {\n    return promiseResolvedWith(reflectCall(F, V, args));\n  } catch (value) {\n    return promiseRejectedWith(value);\n  }\n}\n","import assert from '../stub/assert';\n\n// Original from Chromium\n// https://chromium.googlesource.com/chromium/src/+/0aee4434a4dba42a42abaea9bfbc0cd196a63bc1/third_party/blink/renderer/core/streams/SimpleQueue.js\n\nconst QUEUE_MAX_ARRAY_SIZE = 16384;\n\ninterface Node<T> {\n  _elements: T[];\n  _next: Node<T> | undefined;\n}\n\n/**\n * Simple queue structure.\n *\n * Avoids scalability issues with using a packed array directly by using\n * multiple arrays in a linked list and keeping the array size bounded.\n */\nexport class SimpleQueue<T> {\n  private _front: Node<T>;\n  private _back: Node<T>;\n  private _cursor = 0;\n  private _size = 0;\n\n  constructor() {\n    // _front and _back are always defined.\n    this._front = {\n      _elements: [],\n      _next: undefined\n    };\n    this._back = this._front;\n    // The cursor is used to avoid calling Array.shift().\n    // It contains the index of the front element of the array inside the\n    // front-most node. It is always in the range [0, QUEUE_MAX_ARRAY_SIZE).\n    this._cursor = 0;\n    // When there is only one node, size === elements.length - cursor.\n    this._size = 0;\n  }\n\n  get length(): number {\n    return this._size;\n  }\n\n  // For exception safety, this method is structured in order:\n  // 1. Read state\n  // 2. Calculate required state mutations\n  // 3. Perform state mutations\n  push(element: T): void {\n    const oldBack = this._back;\n    let newBack = oldBack;\n    assert(oldBack._next === undefined);\n    if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) {\n      newBack = {\n        _elements: [],\n        _next: undefined\n      };\n    }\n\n    // push() is the mutation most likely to throw an exception, so it\n    // goes first.\n    oldBack._elements.push(element);\n    if (newBack !== oldBack) {\n      this._back = newBack;\n      oldBack._next = newBack;\n    }\n    ++this._size;\n  }\n\n  // Like push(), shift() follows the read -> calculate -> mutate pattern for\n  // exception safety.\n  shift(): T {\n    assert(this._size > 0); // must not be called on an empty queue\n\n    const oldFront = this._front;\n    let newFront = oldFront;\n    const oldCursor = this._cursor;\n    let newCursor = oldCursor + 1;\n\n    const elements = oldFront._elements;\n    const element = elements[oldCursor];\n\n    if (newCursor === QUEUE_MAX_ARRAY_SIZE) {\n      assert(elements.length === QUEUE_MAX_ARRAY_SIZE);\n      assert(oldFront._next !== undefined);\n      newFront = oldFront._next!;\n      newCursor = 0;\n    }\n\n    // No mutations before this point.\n    --this._size;\n    this._cursor = newCursor;\n    if (oldFront !== newFront) {\n      this._front = newFront;\n    }\n\n    // Permit shifted element to be garbage collected.\n    elements[oldCursor] = undefined!;\n\n    return element;\n  }\n\n  // The tricky thing about forEach() is that it can be called\n  // re-entrantly. The queue may be mutated inside the callback. It is easy to\n  // see that push() within the callback has no negative effects since the end\n  // of the queue is checked for on every iteration. If shift() is called\n  // repeatedly within the callback then the next iteration may return an\n  // element that has been removed. In this case the callback will be called\n  // with undefined values until we either \"catch up\" with elements that still\n  // exist or reach the back of the queue.\n  forEach(callback: (element: T) => void): void {\n    let i = this._cursor;\n    let node = this._front;\n    let elements = node._elements;\n    while (i !== elements.length || node._next !== undefined) {\n      if (i === elements.length) {\n        assert(node._next !== undefined);\n        assert(i === QUEUE_MAX_ARRAY_SIZE);\n        node = node._next!;\n        elements = node._elements;\n        i = 0;\n        if (elements.length === 0) {\n          break;\n        }\n      }\n      callback(elements[i]);\n      ++i;\n    }\n  }\n\n  // Return the element that would be returned if shift() was called now,\n  // without modifying the queue.\n  peek(): T {\n    assert(this._size > 0); // must not be called on an empty queue\n\n    const front = this._front;\n    const cursor = this._cursor;\n    return front._elements[cursor];\n  }\n}\n","import assert from '../../stub/assert';\nimport { ReadableStream, ReadableStreamCancel, ReadableStreamReader } from '../readable-stream';\nimport { newPromise, setPromiseIsHandledToTrue } from '../helpers/webidl';\n\nexport function ReadableStreamReaderGenericInitialize<R>(reader: ReadableStreamReader<R>, stream: ReadableStream<R>) {\n  reader._ownerReadableStream = stream;\n  stream._reader = reader;\n\n  if (stream._state === 'readable') {\n    defaultReaderClosedPromiseInitialize(reader);\n  } else if (stream._state === 'closed') {\n    defaultReaderClosedPromiseInitializeAsResolved(reader);\n  } else {\n    assert(stream._state === 'errored');\n\n    defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);\n  }\n}\n\n// A client of ReadableStreamDefaultReader and ReadableStreamBYOBReader may use these functions directly to bypass state\n// check.\n\nexport function ReadableStreamReaderGenericCancel(reader: ReadableStreamReader<any>, reason: any): Promise<undefined> {\n  const stream = reader._ownerReadableStream;\n  assert(stream !== undefined);\n  return ReadableStreamCancel(stream, reason);\n}\n\nexport function ReadableStreamReaderGenericRelease(reader: ReadableStreamReader<any>) {\n  assert(reader._ownerReadableStream !== undefined);\n  assert(reader._ownerReadableStream._reader === reader);\n\n  if (reader._ownerReadableStream._state === 'readable') {\n    defaultReaderClosedPromiseReject(\n      reader,\n      new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));\n  } else {\n    defaultReaderClosedPromiseResetToRejected(\n      reader,\n      new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));\n  }\n\n  reader._ownerReadableStream._reader = undefined;\n  reader._ownerReadableStream = undefined!;\n}\n\n// Helper functions for the readers.\n\nexport function readerLockException(name: string): TypeError {\n  return new TypeError('Cannot ' + name + ' a stream using a released reader');\n}\n\n// Helper functions for the ReadableStreamDefaultReader.\n\nexport function defaultReaderClosedPromiseInitialize(reader: ReadableStreamReader<any>) {\n  reader._closedPromise = newPromise((resolve, reject) => {\n    reader._closedPromise_resolve = resolve;\n    reader._closedPromise_reject = reject;\n  });\n}\n\nexport function defaultReaderClosedPromiseInitializeAsRejected(reader: ReadableStreamReader<any>, reason: any) {\n  defaultReaderClosedPromiseInitialize(reader);\n  defaultReaderClosedPromiseReject(reader, reason);\n}\n\nexport function defaultReaderClosedPromiseInitializeAsResolved(reader: ReadableStreamReader<any>) {\n  defaultReaderClosedPromiseInitialize(reader);\n  defaultReaderClosedPromiseResolve(reader);\n}\n\nexport function defaultReaderClosedPromiseReject(reader: ReadableStreamReader<any>, reason: any) {\n  if (reader._closedPromise_reject === undefined) {\n    return;\n  }\n\n  setPromiseIsHandledToTrue(reader._closedPromise);\n  reader._closedPromise_reject(reason);\n  reader._closedPromise_resolve = undefined;\n  reader._closedPromise_reject = undefined;\n}\n\nexport function defaultReaderClosedPromiseResetToRejected(reader: ReadableStreamReader<any>, reason: any) {\n  assert(reader._closedPromise_resolve === undefined);\n  assert(reader._closedPromise_reject === undefined);\n\n  defaultReaderClosedPromiseInitializeAsRejected(reader, reason);\n}\n\nexport function defaultReaderClosedPromiseResolve(reader: ReadableStreamReader<any>) {\n  if (reader._closedPromise_resolve === undefined) {\n    return;\n  }\n\n  reader._closedPromise_resolve(undefined);\n  reader._closedPromise_resolve = undefined;\n  reader._closedPromise_reject = undefined;\n}\n","export const AbortSteps = Symbol('[[AbortSteps]]');\nexport const ErrorSteps = Symbol('[[ErrorSteps]]');\nexport const CancelSteps = Symbol('[[CancelSteps]]');\nexport const PullSteps = Symbol('[[PullSteps]]');\n","/// <reference lib=\"es2015.core\" />\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite#Polyfill\nconst NumberIsFinite: typeof Number.isFinite = Number.isFinite || function (x) {\n  return typeof x === 'number' && isFinite(x);\n};\n\nexport default NumberIsFinite;\n","/// <reference lib=\"es2015.core\" />\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc#Polyfill\nconst MathTrunc: typeof Math.trunc = Math.trunc || function (v) {\n  return v < 0 ? Math.ceil(v) : Math.floor(v);\n};\n\nexport default MathTrunc;\n","import NumberIsFinite from '../../stub/number-isfinite';\nimport MathTrunc from '../../stub/math-trunc';\n\n// https://heycam.github.io/webidl/#idl-dictionaries\nexport function isDictionary(x: any): x is object | null {\n  return typeof x === 'object' || typeof x === 'function';\n}\n\nexport function assertDictionary(obj: unknown,\n                                 context: string): asserts obj is object | null | undefined {\n  if (obj !== undefined && !isDictionary(obj)) {\n    throw new TypeError(`${context} is not an object.`);\n  }\n}\n\nexport type AnyFunction = (...args: any[]) => any;\n\n// https://heycam.github.io/webidl/#idl-callback-functions\nexport function assertFunction(x: unknown, context: string): asserts x is AnyFunction {\n  if (typeof x !== 'function') {\n    throw new TypeError(`${context} is not a function.`);\n  }\n}\n\n// https://heycam.github.io/webidl/#idl-object\nexport function isObject(x: any): x is object {\n  return (typeof x === 'object' && x !== null) || typeof x === 'function';\n}\n\nexport function assertObject(x: unknown,\n                             context: string): asserts x is object {\n  if (!isObject(x)) {\n    throw new TypeError(`${context} is not an object.`);\n  }\n}\n\nexport function assertRequiredArgument<T extends any>(x: T | undefined,\n                                                      position: number,\n                                                      context: string): asserts x is T {\n  if (x === undefined) {\n    throw new TypeError(`Parameter ${position} is required in '${context}'.`);\n  }\n}\n\nexport function assertRequiredField<T extends any>(x: T | undefined,\n                                                   field: string,\n                                                   context: string): asserts x is T {\n  if (x === undefined) {\n    throw new TypeError(`${field} is required in '${context}'.`);\n  }\n}\n\n// https://heycam.github.io/webidl/#idl-unrestricted-double\nexport function convertUnrestrictedDouble(value: unknown): number {\n  return Number(value);\n}\n\nfunction censorNegativeZero(x: number): number {\n  return x === 0 ? 0 : x;\n}\n\nfunction integerPart(x: number): number {\n  return censorNegativeZero(MathTrunc(x));\n}\n\n// https://heycam.github.io/webidl/#idl-unsigned-long-long\nexport function convertUnsignedLongLongWithEnforceRange(value: unknown, context: string): number {\n  const lowerBound = 0;\n  const upperBound = Number.MAX_SAFE_INTEGER;\n\n  let x = Number(value);\n  x = censorNegativeZero(x);\n\n  if (!NumberIsFinite(x)) {\n    throw new TypeError(`${context} is not a finite number`);\n  }\n\n  x = integerPart(x);\n\n  if (x < lowerBound || x > upperBound) {\n    throw new TypeError(`${context} is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`);\n  }\n\n  if (!NumberIsFinite(x) || x === 0) {\n    return 0;\n  }\n\n  // TODO Use BigInt if supported?\n  // let xBigInt = BigInt(integerPart(x));\n  // xBigInt = BigInt.asUintN(64, xBigInt);\n  // return Number(xBigInt);\n\n  return x;\n}\n","import { IsReadableStream, ReadableStream } from '../readable-stream';\n\nexport function assertReadableStream(x: unknown, context: string): asserts x is ReadableStream {\n  if (!IsReadableStream(x)) {\n    throw new TypeError(`${context} is not a ReadableStream.`);\n  }\n}\n","import assert from '../../stub/assert';\nimport { SimpleQueue } from '../simple-queue';\nimport {\n  ReadableStreamReaderGenericCancel,\n  ReadableStreamReaderGenericInitialize,\n  ReadableStreamReaderGenericRelease,\n  readerLockException\n} from './generic-reader';\nimport { IsReadableStreamLocked, ReadableStream } from '../readable-stream';\nimport { typeIsObject } from '../helpers/miscellaneous';\nimport { PullSteps } from '../abstract-ops/internal-methods';\nimport { newPromise, promiseRejectedWith } from '../helpers/webidl';\nimport { assertRequiredArgument } from '../validators/basic';\nimport { assertReadableStream } from '../validators/readable-stream';\n\n/**\n * A result returned by {@link ReadableStreamDefaultReader.read}.\n *\n * @public\n */\nexport type ReadableStreamDefaultReadResult<T> = {\n  done: false;\n  value: T;\n} | {\n  done: true;\n  value?: undefined;\n}\n\n// Abstract operations for the ReadableStream.\n\nexport function AcquireReadableStreamDefaultReader<R>(stream: ReadableStream): ReadableStreamDefaultReader<R> {\n  return new ReadableStreamDefaultReader(stream);\n}\n\n// ReadableStream API exposed for controllers.\n\nexport function ReadableStreamAddReadRequest<R>(stream: ReadableStream<R>,\n                                                readRequest: ReadRequest<R>): void {\n  assert(IsReadableStreamDefaultReader(stream._reader));\n  assert(stream._state === 'readable');\n\n  (stream._reader! as ReadableStreamDefaultReader<R>)._readRequests.push(readRequest);\n}\n\nexport function ReadableStreamFulfillReadRequest<R>(stream: ReadableStream<R>, chunk: R | undefined, done: boolean) {\n  const reader = stream._reader as ReadableStreamDefaultReader<R>;\n\n  assert(reader._readRequests.length > 0);\n\n  const readRequest = reader._readRequests.shift()!;\n  if (done) {\n    readRequest._closeSteps();\n  } else {\n    readRequest._chunkSteps(chunk!);\n  }\n}\n\nexport function ReadableStreamGetNumReadRequests<R>(stream: ReadableStream<R>): number {\n  return (stream._reader as ReadableStreamDefaultReader<R>)._readRequests.length;\n}\n\nexport function ReadableStreamHasDefaultReader(stream: ReadableStream): boolean {\n  const reader = stream._reader;\n\n  if (reader === undefined) {\n    return false;\n  }\n\n  if (!IsReadableStreamDefaultReader(reader)) {\n    return false;\n  }\n\n  return true;\n}\n\n// Readers\n\nexport interface ReadRequest<R> {\n  _chunkSteps(chunk: R): void;\n\n  _closeSteps(): void;\n\n  _errorSteps(e: any): void;\n}\n\n/**\n * A default reader vended by a {@link ReadableStream}.\n *\n * @public\n */\nexport class ReadableStreamDefaultReader<R = any> {\n  /** @internal */\n  _ownerReadableStream!: ReadableStream<R>;\n  /** @internal */\n  _closedPromise!: Promise<undefined>;\n  /** @internal */\n  _closedPromise_resolve?: (value?: undefined) => void;\n  /** @internal */\n  _closedPromise_reject?: (reason: any) => void;\n  /** @internal */\n  _readRequests: SimpleQueue<ReadRequest<R>>;\n\n  constructor(stream: ReadableStream<R>) {\n    assertRequiredArgument(stream, 1, 'ReadableStreamDefaultReader');\n    assertReadableStream(stream, 'First parameter');\n\n    if (IsReadableStreamLocked(stream)) {\n      throw new TypeError('This stream has already been locked for exclusive reading by another reader');\n    }\n\n    ReadableStreamReaderGenericInitialize(this, stream);\n\n    this._readRequests = new SimpleQueue();\n  }\n\n  /**\n   * Returns a promise that will be fulfilled when the stream becomes closed,\n   * or rejected if the stream ever errors or the reader's lock is released before the stream finishes closing.\n   */\n  get closed(): Promise<undefined> {\n    if (!IsReadableStreamDefaultReader(this)) {\n      return promiseRejectedWith(defaultReaderBrandCheckException('closed'));\n    }\n\n    return this._closedPromise;\n  }\n\n  /**\n   * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.\n   */\n  cancel(reason: any = undefined): Promise<void> {\n    if (!IsReadableStreamDefaultReader(this)) {\n      return promiseRejectedWith(defaultReaderBrandCheckException('cancel'));\n    }\n\n    if (this._ownerReadableStream === undefined) {\n      return promiseRejectedWith(readerLockException('cancel'));\n    }\n\n    return ReadableStreamReaderGenericCancel(this, reason);\n  }\n\n  /**\n   * Returns a promise that allows access to the next chunk from the stream's internal queue, if available.\n   *\n   * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.\n   */\n  read(): Promise<ReadableStreamDefaultReadResult<R>> {\n    if (!IsReadableStreamDefaultReader(this)) {\n      return promiseRejectedWith(defaultReaderBrandCheckException('read'));\n    }\n\n    if (this._ownerReadableStream === undefined) {\n      return promiseRejectedWith(readerLockException('read from'));\n    }\n\n    let resolvePromise!: (result: ReadableStreamDefaultReadResult<R>) => void;\n    let rejectPromise!: (reason: any) => void;\n    const promise = newPromise<ReadableStreamDefaultReadResult<R>>((resolve, reject) => {\n      resolvePromise = resolve;\n      rejectPromise = reject;\n    });\n    const readRequest: ReadRequest<R> = {\n      _chunkSteps: chunk => resolvePromise({ value: chunk, done: false }),\n      _closeSteps: () => resolvePromise({ value: undefined, done: true }),\n      _errorSteps: e => rejectPromise(e)\n    };\n    ReadableStreamDefaultReaderRead(this, readRequest);\n    return promise;\n  }\n\n  /**\n   * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.\n   * If the associated stream is errored when the lock is released, the reader will appear errored in the same way\n   * from now on; otherwise, the reader will appear closed.\n   *\n   * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by\n   * the reader's {@link ReadableStreamDefaultReader.read | read()} method has not yet been settled. Attempting to\n   * do so will throw a `TypeError` and leave the reader locked to the stream.\n   */\n  releaseLock(): void {\n    if (!IsReadableStreamDefaultReader(this)) {\n      throw defaultReaderBrandCheckException('releaseLock');\n    }\n\n    if (this._ownerReadableStream === undefined) {\n      return;\n    }\n\n    if (this._readRequests.length > 0) {\n      throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');\n    }\n\n    ReadableStreamReaderGenericRelease(this);\n  }\n}\n\nObject.defineProperties(ReadableStreamDefaultReader.prototype, {\n  cancel: { enumerable: true },\n  read: { enumerable: true },\n  releaseLock: { enumerable: true },\n  closed: { enumerable: true }\n});\nif (typeof Symbol.toStringTag === 'symbol') {\n  Object.defineProperty(ReadableStreamDefaultReader.prototype, Symbol.toStringTag, {\n    value: 'ReadableStreamDefaultReader',\n    configurable: true\n  });\n}\n\n// Abstract operations for the readers.\n\nexport function IsReadableStreamDefaultReader<R = any>(x: any): x is ReadableStreamDefaultReader<R> {\n  if (!typeIsObject(x)) {\n    return false;\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {\n    return false;\n  }\n\n  return x instanceof ReadableStreamDefaultReader;\n}\n\nexport function ReadableStreamDefaultReaderRead<R>(reader: ReadableStreamDefaultReader<R>,\n                                                   readRequest: ReadRequest<R>): void {\n  const stream = reader._ownerReadableStream;\n\n  assert(stream !== undefined);\n\n  stream._disturbed = true;\n\n  if (stream._state === 'closed') {\n    readRequest._closeSteps();\n  } else if (stream._state === 'errored') {\n    readRequest._errorSteps(stream._storedError);\n  } else {\n    assert(stream._state === 'readable');\n    stream._readableStreamController[PullSteps](readRequest as ReadRequest<any>);\n  }\n}\n\n// Helper functions for the ReadableStreamDefaultReader.\n\nfunction defaultReaderBrandCheckException(name: string): TypeError {\n  return new TypeError(\n    `ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);\n}\n","/// <reference lib=\"es2018.asynciterable\" />\n\n/* eslint-disable @typescript-eslint/no-empty-function */\nexport const AsyncIteratorPrototype: AsyncIterable<any> | undefined =\n  Object.getPrototypeOf(Object.getPrototypeOf(async function* (): AsyncIterableIterator<any> {}).prototype);\n","/// <reference lib=\"es2018.asynciterable\" />\n\nimport { ReadableStream } from '../readable-stream';\nimport {\n  AcquireReadableStreamDefaultReader,\n  ReadableStreamDefaultReader,\n  ReadableStreamDefaultReaderRead,\n  ReadableStreamDefaultReadResult,\n  ReadRequest\n} from './default-reader';\nimport {\n  ReadableStreamReaderGenericCancel,\n  ReadableStreamReaderGenericRelease,\n  readerLockException\n} from './generic-reader';\nimport assert from '../../stub/assert';\nimport { AsyncIteratorPrototype } from '@@target/stub/async-iterator-prototype';\nimport { typeIsObject } from '../helpers/miscellaneous';\nimport {\n  newPromise,\n  promiseRejectedWith,\n  promiseResolvedWith,\n  queueMicrotask,\n  transformPromiseWith\n} from '../helpers/webidl';\n\n/**\n * An async iterator returned by {@link ReadableStream.values}.\n *\n * @public\n */\nexport interface ReadableStreamAsyncIterator<R> extends AsyncIterator<R> {\n  next(): Promise<IteratorResult<R, undefined>>;\n\n  return(value?: any): Promise<IteratorResult<any>>;\n}\n\nexport class ReadableStreamAsyncIteratorImpl<R> {\n  private readonly _reader: ReadableStreamDefaultReader<R>;\n  private readonly _preventCancel: boolean;\n  private _ongoingPromise: Promise<ReadableStreamDefaultReadResult<R>> | undefined = undefined;\n  private _isFinished = false;\n\n  constructor(reader: ReadableStreamDefaultReader<R>, preventCancel: boolean) {\n    this._reader = reader;\n    this._preventCancel = preventCancel;\n  }\n\n  next(): Promise<ReadableStreamDefaultReadResult<R>> {\n    const nextSteps = () => this._nextSteps();\n    this._ongoingPromise = this._ongoingPromise ?\n      transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) :\n      nextSteps();\n    return this._ongoingPromise;\n  }\n\n  return(value: any): Promise<ReadableStreamDefaultReadResult<any>> {\n    const returnSteps = () => this._returnSteps(value);\n    return this._ongoingPromise ?\n      transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) :\n      returnSteps();\n  }\n\n  private _nextSteps(): Promise<ReadableStreamDefaultReadResult<R>> {\n    if (this._isFinished) {\n      return Promise.resolve({ value: undefined, done: true });\n    }\n\n    const reader = this._reader;\n    if (reader._ownerReadableStream === undefined) {\n      return promiseRejectedWith(readerLockException('iterate'));\n    }\n\n    let resolvePromise!: (result: ReadableStreamDefaultReadResult<R>) => void;\n    let rejectPromise!: (reason: any) => void;\n    const promise = newPromise<ReadableStreamDefaultReadResult<R>>((resolve, reject) => {\n      resolvePromise = resolve;\n      rejectPromise = reject;\n    });\n    const readRequest: ReadRequest<R> = {\n      _chunkSteps: chunk => {\n        this._ongoingPromise = undefined;\n        // This needs to be delayed by one microtask, otherwise we stop pulling too early which breaks a test.\n        // FIXME Is this a bug in the specification, or in the test?\n        queueMicrotask(() => resolvePromise({ value: chunk, done: false }));\n      },\n      _closeSteps: () => {\n        this._ongoingPromise = undefined;\n        this._isFinished = true;\n        ReadableStreamReaderGenericRelease(reader);\n        resolvePromise({ value: undefined, done: true });\n      },\n      _errorSteps: reason => {\n        this._ongoingPromise = undefined;\n        this._isFinished = true;\n        ReadableStreamReaderGenericRelease(reader);\n        rejectPromise(reason);\n      }\n    };\n    ReadableStreamDefaultReaderRead(reader, readRequest);\n    return promise;\n  }\n\n  private _returnSteps(value: any): Promise<ReadableStreamDefaultReadResult<any>> {\n    if (this._isFinished) {\n      return Promise.resolve({ value, done: true });\n    }\n    this._isFinished = true;\n\n    const reader = this._reader;\n    if (reader._ownerReadableStream === undefined) {\n      return promiseRejectedWith(readerLockException('finish iterating'));\n    }\n\n    assert(reader._readRequests.length === 0);\n\n    if (!this._preventCancel) {\n      const result = ReadableStreamReaderGenericCancel(reader, value);\n      ReadableStreamReaderGenericRelease(reader);\n      return transformPromiseWith(result, () => ({ value, done: true }));\n    }\n\n    ReadableStreamReaderGenericRelease(reader);\n    return promiseResolvedWith({ value, done: true });\n  }\n}\n\ndeclare class ReadableStreamAsyncIteratorInstance<R> implements ReadableStreamAsyncIterator<R> {\n  /** @interal */\n  _asyncIteratorImpl: ReadableStreamAsyncIteratorImpl<R>;\n\n  next(): Promise<IteratorResult<R, undefined>>;\n\n  return(value?: any): Promise<IteratorResult<any>>;\n}\n\nconst ReadableStreamAsyncIteratorPrototype: ReadableStreamAsyncIteratorInstance<any> = {\n  next(this: ReadableStreamAsyncIteratorInstance<any>): Promise<ReadableStreamDefaultReadResult<any>> {\n    if (!IsReadableStreamAsyncIterator(this)) {\n      return promiseRejectedWith(streamAsyncIteratorBrandCheckException('next'));\n    }\n    return this._asyncIteratorImpl.next();\n  },\n\n  return(this: ReadableStreamAsyncIteratorInstance<any>, value: any): Promise<ReadableStreamDefaultReadResult<any>> {\n    if (!IsReadableStreamAsyncIterator(this)) {\n      return promiseRejectedWith(streamAsyncIteratorBrandCheckException('return'));\n    }\n    return this._asyncIteratorImpl.return(value);\n  }\n} as any;\nif (AsyncIteratorPrototype !== undefined) {\n  Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);\n}\n\n// Abstract operations for the ReadableStream.\n\nexport function AcquireReadableStreamAsyncIterator<R>(stream: ReadableStream<R>,\n                                                      preventCancel: boolean): ReadableStreamAsyncIterator<R> {\n  const reader = AcquireReadableStreamDefaultReader<R>(stream);\n  const impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel);\n  const iterator: ReadableStreamAsyncIteratorInstance<R> = Object.create(ReadableStreamAsyncIteratorPrototype);\n  iterator._asyncIteratorImpl = impl;\n  return iterator;\n}\n\nfunction IsReadableStreamAsyncIterator<R = any>(x: any): x is ReadableStreamAsyncIterator<R> {\n  if (!typeIsObject(x)) {\n    return false;\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(x, '_asyncIteratorImpl')) {\n    return false;\n  }\n\n  try {\n    // noinspection SuspiciousTypeOfGuard\n    return (x as ReadableStreamAsyncIteratorInstance<any>)._asyncIteratorImpl instanceof\n      ReadableStreamAsyncIteratorImpl;\n  } catch {\n    return false;\n  }\n}\n\n// Helper functions for the ReadableStream.\n\nfunction streamAsyncIteratorBrandCheckException(name: string): TypeError {\n  return new TypeError(`ReadableStreamAsyncIterator.${name} can only be used on a ReadableSteamAsyncIterator`);\n}\n","/// <reference lib=\"es2015.core\" />\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN#Polyfill\nconst NumberIsNaN: typeof Number.isNaN = Number.isNaN || function (x) {\n  // eslint-disable-next-line no-self-compare\n  return x !== x;\n};\n\nexport default NumberIsNaN;\n","export function CreateArrayFromList<T extends any[]>(elements: T): T {\n  // We use arrays to represent lists, so this is basically a no-op.\n  // Do a slice though just in case we happen to depend on the unique-ness.\n  return elements.slice() as T;\n}\n\nexport function CopyDataBlockBytes(dest: ArrayBuffer,\n                                   destOffset: number,\n                                   src: ArrayBuffer,\n                                   srcOffset: number,\n                                   n: number) {\n  new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);\n}\n\n// Not implemented correctly\nexport function TransferArrayBuffer<T extends ArrayBufferLike>(O: T): T {\n  return O;\n}\n\n// Not implemented correctly\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function CanTransferArrayBuffer(O: ArrayBufferLike): boolean {\n  return true;\n}\n\n// Not implemented correctly\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function IsDetachedBuffer(O: ArrayBufferLike): boolean {\n  return false;\n}\n\nexport function ArrayBufferSlice(buffer: ArrayBufferLike, begin: number, end: number): ArrayBufferLike {\n  // ArrayBuffer.prototype.slice is not available on IE10\n  // https://www.caniuse.com/mdn-javascript_builtins_arraybuffer_slice\n  if (buffer.slice) {\n    return buffer.slice(begin, end);\n  }\n  const length = end - begin;\n  const slice = new ArrayBuffer(length);\n  CopyDataBlockBytes(slice, 0, buffer, begin, length);\n  return slice;\n}\n","import NumberIsNaN from '../../stub/number-isnan';\nimport { ArrayBufferSlice } from './ecmascript';\n\nexport function IsNonNegativeNumber(v: number): boolean {\n  if (typeof v !== 'number') {\n    return false;\n  }\n\n  if (NumberIsNaN(v)) {\n    return false;\n  }\n\n  if (v < 0) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function CloneAsUint8Array(O: ArrayBufferView): Uint8Array {\n  const buffer = ArrayBufferSlice(O.buffer, O.byteOffset, O.byteOffset + O.byteLength);\n  return new Uint8Array(buffer);\n}\n","import assert from '../../stub/assert';\nimport { SimpleQueue } from '../simple-queue';\nimport { IsNonNegativeNumber } from './miscellaneous';\n\nexport interface QueueContainer<T> {\n  _queue: SimpleQueue<T>;\n  _queueTotalSize: number;\n}\n\nexport interface QueuePair<T> {\n  value: T;\n  size: number;\n}\n\nexport function DequeueValue<T>(container: QueueContainer<QueuePair<T>>): T {\n  assert('_queue' in container && '_queueTotalSize' in container);\n  assert(container._queue.length > 0);\n\n  const pair = container._queue.shift()!;\n  container._queueTotalSize -= pair.size;\n  if (container._queueTotalSize < 0) {\n    container._queueTotalSize = 0;\n  }\n\n  return pair.value;\n}\n\nexport function EnqueueValueWithSize<T>(container: QueueContainer<QueuePair<T>>, value: T, size: number) {\n  assert('_queue' in container && '_queueTotalSize' in container);\n\n  if (!IsNonNegativeNumber(size) || size === Infinity) {\n    throw new RangeError('Size must be a finite, non-NaN, non-negative number.');\n  }\n\n  container._queue.push({ value, size });\n  container._queueTotalSize += size;\n}\n\nexport function PeekQueueValue<T>(container: QueueContainer<QueuePair<T>>): T {\n  assert('_queue' in container && '_queueTotalSize' in container);\n  assert(container._queue.length > 0);\n\n  const pair = container._queue.peek();\n  return pair.value;\n}\n\nexport function ResetQueue<T>(container: QueueContainer<T>) {\n  assert('_queue' in container && '_queueTotalSize' in container);\n\n  container._queue = new SimpleQueue<T>();\n  container._queueTotalSize = 0;\n}\n","import assert from '../../stub/assert';\nimport { SimpleQueue } from '../simple-queue';\nimport { ResetQueue } from '../abstract-ops/queue-with-sizes';\nimport {\n  ReadableStreamAddReadRequest,\n  ReadableStreamFulfillReadRequest,\n  ReadableStreamGetNumReadRequests,\n  ReadableStreamHasDefaultReader,\n  ReadRequest\n} from './default-reader';\nimport {\n  ReadableStreamAddReadIntoRequest,\n  ReadableStreamFulfillReadIntoRequest,\n  ReadableStreamGetNumReadIntoRequests,\n  ReadableStreamHasBYOBReader,\n  ReadIntoRequest\n} from './byob-reader';\nimport NumberIsInteger from '../../stub/number-isinteger';\nimport {\n  IsReadableStreamLocked,\n  ReadableByteStream,\n  ReadableStreamClose,\n  ReadableStreamError\n} from '../readable-stream';\nimport { ValidatedUnderlyingByteSource } from './underlying-source';\nimport { typeIsObject } from '../helpers/miscellaneous';\nimport {\n  ArrayBufferSlice,\n  CanTransferArrayBuffer,\n  CopyDataBlockBytes,\n  IsDetachedBuffer,\n  TransferArrayBuffer\n} from '../abstract-ops/ecmascript';\nimport { CancelSteps, PullSteps } from '../abstract-ops/internal-methods';\nimport { promiseResolvedWith, uponPromise } from '../helpers/webidl';\nimport { assertRequiredArgument, convertUnsignedLongLongWithEnforceRange } from '../validators/basic';\n\n/**\n * A pull-into request in a {@link ReadableByteStreamController}.\n *\n * @public\n */\nexport class ReadableStreamBYOBRequest {\n  /** @internal */\n  _associatedReadableByteStreamController!: ReadableByteStreamController;\n  /** @internal */\n  _view!: ArrayBufferView | null;\n\n  private constructor() {\n    throw new TypeError('Illegal constructor');\n  }\n\n  /**\n   * Returns the view for writing in to, or `null` if the BYOB request has already been responded to.\n   */\n  get view(): ArrayBufferView | null {\n    if (!IsReadableStreamBYOBRequest(this)) {\n      throw byobRequestBrandCheckException('view');\n    }\n\n    return this._view;\n  }\n\n  /**\n   * Indicates to the associated readable byte stream that `bytesWritten` bytes were written into\n   * {@link ReadableStreamBYOBRequest.view | view}, causing the result be surfaced to the consumer.\n   *\n   * After this method is called, {@link ReadableStreamBYOBRequest.view | view} will be transferred and no longer\n   * modifiable.\n   */\n  respond(bytesWritten: number): void;\n  respond(bytesWritten: number | undefined): void {\n    if (!IsReadableStreamBYOBRequest(this)) {\n      throw byobRequestBrandCheckException('respond');\n    }\n    assertRequiredArgument(bytesWritten, 1, 'respond');\n    bytesWritten = convertUnsignedLongLongWithEnforceRange(bytesWritten, 'First parameter');\n\n    if (this._associatedReadableByteStreamController === undefined) {\n      throw new TypeError('This BYOB request has been invalidated');\n    }\n\n    if (IsDetachedBuffer(this._view!.buffer)) {\n      throw new TypeError(`The BYOB request's buffer has been detached and so cannot be used as a response`);\n    }\n\n    assert(this._view!.byteLength > 0);\n    assert(this._view!.buffer.byteLength > 0);\n\n    ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);\n  }\n\n  /**\n   * Indicates to the associated readable byte stream that instead of writing into\n   * {@link ReadableStreamBYOBRequest.view | view}, the underlying byte source is providing a new `ArrayBufferView`,\n   * which will be given to the consumer of the readable byte stream.\n   *\n   * After this method is called, `view` will be transferred and no longer modifiable.\n   */\n  respondWithNewView(view: ArrayBufferView): void;\n  respondWithNewView(view: ArrayBufferView | undefined): void {\n    if (!IsReadableStreamBYOBRequest(this)) {\n      throw byobRequestBrandCheckException('respondWithNewView');\n    }\n    assertRequiredArgument(view, 1, 'respondWithNewView');\n\n    if (!ArrayBuffer.isView(view)) {\n      throw new TypeError('You can only respond with array buffer views');\n    }\n\n    if (this._associatedReadableByteStreamController === undefined) {\n      throw new TypeError('This BYOB request has been invalidated');\n    }\n\n    if (IsDetachedBuffer(view.buffer)) {\n      throw new TypeError('The given view\\'s buffer has been detached and so cannot be used as a response');\n    }\n\n    ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);\n  }\n}\n\nObject.defineProperties(ReadableStreamBYOBRequest.prototype, {\n  respond: { enumerable: true },\n  respondWithNewView: { enumerable: true },\n  view: { enumerable: true }\n});\nif (typeof Symbol.toStringTag === 'symbol') {\n  Object.defineProperty(ReadableStreamBYOBRequest.prototype, Symbol.toStringTag, {\n    value: 'ReadableStreamBYOBRequest',\n    configurable: true\n  });\n}\n\ninterface ArrayBufferViewConstructor<T extends ArrayBufferView = ArrayBufferView> {\n  new(buffer: ArrayBufferLike, byteOffset: number, length?: number): T;\n\n  readonly prototype: T;\n  readonly BYTES_PER_ELEMENT: number;\n}\n\ninterface ByteQueueElement {\n  buffer: ArrayBufferLike;\n  byteOffset: number;\n  byteLength: number;\n}\n\ntype PullIntoDescriptor<T extends ArrayBufferView = ArrayBufferView> =\n  DefaultPullIntoDescriptor\n  | BYOBPullIntoDescriptor<T>;\n\ninterface DefaultPullIntoDescriptor {\n  buffer: ArrayBufferLike;\n  bufferByteLength: number;\n  byteOffset: number;\n  byteLength: number;\n  bytesFilled: number;\n  elementSize: number;\n  viewConstructor: ArrayBufferViewConstructor<Uint8Array>;\n  readerType: 'default';\n}\n\ninterface BYOBPullIntoDescriptor<T extends ArrayBufferView = ArrayBufferView> {\n  buffer: ArrayBufferLike;\n  bufferByteLength: number;\n  byteOffset: number;\n  byteLength: number;\n  bytesFilled: number;\n  elementSize: number;\n  viewConstructor: ArrayBufferViewConstructor<T>;\n  readerType: 'byob';\n}\n\n/**\n * Allows control of a {@link ReadableStream | readable byte stream}'s state and internal queue.\n *\n * @public\n */\nexport class ReadableByteStreamController {\n  /** @internal */\n  _controlledReadableByteStream!: ReadableByteStream;\n  /** @internal */\n  _queue!: SimpleQueue<ByteQueueElement>;\n  /** @internal */\n  _queueTotalSize!: number;\n  /** @internal */\n  _started!: boolean;\n  /** @internal */\n  _closeRequested!: boolean;\n  /** @internal */\n  _pullAgain!: boolean;\n  /** @internal */\n  _pulling !: boolean;\n  /** @internal */\n  _strategyHWM!: number;\n  /** @internal */\n  _pullAlgorithm!: () => Promise<void>;\n  /** @internal */\n  _cancelAlgorithm!: (reason: any) => Promise<void>;\n  /** @internal */\n  _autoAllocateChunkSize: number | undefined;\n  /** @internal */\n  _byobRequest: ReadableStreamBYOBRequest | null;\n  /** @internal */\n  _pendingPullIntos!: SimpleQueue<PullIntoDescriptor>;\n\n  private constructor() {\n    throw new TypeError('Illegal constructor');\n  }\n\n  /**\n   * Returns the current BYOB pull request, or `null` if there isn't one.\n   */\n  get byobRequest(): ReadableStreamBYOBRequest | null {\n    if (!IsReadableByteStreamController(this)) {\n      throw byteStreamControllerBrandCheckException('byobRequest');\n    }\n\n    return ReadableByteStreamControllerGetBYOBRequest(this);\n  }\n\n  /**\n   * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is\n   * over-full. An underlying byte source ought to use this information to determine when and how to apply backpressure.\n   */\n  get desiredSize(): number | null {\n    if (!IsReadableByteStreamController(this)) {\n      throw byteStreamControllerBrandCheckException('desiredSize');\n    }\n\n    return ReadableByteStreamControllerGetDesiredSize(this);\n  }\n\n  /**\n   * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from\n   * the stream, but once those are read, the stream will become closed.\n   */\n  close(): void {\n    if (!IsReadableByteStreamController(this)) {\n      throw byteStreamControllerBrandCheckException('close');\n    }\n\n    if (this._closeRequested) {\n      throw new TypeError('The stream has already been closed; do not close it again!');\n    }\n\n    const state = this._controlledReadableByteStream._state;\n    if (state !== 'readable') {\n      throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be closed`);\n    }\n\n    ReadableByteStreamControllerClose(this);\n  }\n\n  /**\n   * Enqueues the given chunk chunk in the controlled readable stream.\n   * The chunk has to be an `ArrayBufferView` instance, or else a `TypeError` will be thrown.\n   */\n  enqueue(chunk: ArrayBufferView): void;\n  enqueue(chunk: ArrayBufferView | undefined): void {\n    if (!IsReadableByteStreamController(this)) {\n      throw byteStreamControllerBrandCheckException('enqueue');\n    }\n\n    assertRequiredArgument(chunk, 1, 'enqueue');\n    if (!ArrayBuffer.isView(chunk)) {\n      throw new TypeError('chunk must be an array buffer view');\n    }\n    if (chunk.byteLength === 0) {\n      throw new TypeError('chunk must have non-zero byteLength');\n    }\n    if (chunk.buffer.byteLength === 0) {\n      throw new TypeError(`chunk's buffer must have non-zero byteLength`);\n    }\n\n    if (this._closeRequested) {\n      throw new TypeError('stream is closed or draining');\n    }\n\n    const state = this._controlledReadableByteStream._state;\n    if (state !== 'readable') {\n      throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be enqueued to`);\n    }\n\n    ReadableByteStreamControllerEnqueue(this, chunk);\n  }\n\n  /**\n   * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.\n   */\n  error(e: any = undefined): void {\n    if (!IsReadableByteStreamController(this)) {\n      throw byteStreamControllerBrandCheckException('error');\n    }\n\n    ReadableByteStreamControllerError(this, e);\n  }\n\n  /** @internal */\n  [CancelSteps](reason: any): Promise<void> {\n    ReadableByteStreamControllerClearPendingPullIntos(this);\n\n    ResetQueue(this);\n\n    const result = this._cancelAlgorithm(reason);\n    ReadableByteStreamControllerClearAlgorithms(this);\n    return result;\n  }\n\n  /** @internal */\n  [PullSteps](readRequest: ReadRequest<Uint8Array>): void {\n    const stream = this._controlledReadableByteStream;\n    assert(ReadableStreamHasDefaultReader(stream));\n\n    if (this._queueTotalSize > 0) {\n      assert(ReadableStreamGetNumReadRequests(stream) === 0);\n\n      const entry = this._queue.shift()!;\n      this._queueTotalSize -= entry.byteLength;\n\n      ReadableByteStreamControllerHandleQueueDrain(this);\n\n      const view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);\n\n      readRequest._chunkSteps(view);\n      return;\n    }\n\n    const autoAllocateChunkSize = this._autoAllocateChunkSize;\n    if (autoAllocateChunkSize !== undefined) {\n      let buffer: ArrayBuffer;\n      try {\n        buffer = new ArrayBuffer(autoAllocateChunkSize);\n      } catch (bufferE) {\n        readRequest._errorSteps(bufferE);\n        return;\n      }\n\n      const pullIntoDescriptor: DefaultPullIntoDescriptor = {\n        buffer,\n        bufferByteLength: autoAllocateChunkSize,\n        byteOffset: 0,\n        byteLength: autoAllocateChunkSize,\n        bytesFilled: 0,\n        elementSize: 1,\n        viewConstructor: Uint8Array,\n        readerType: 'default'\n      };\n\n      this._pendingPullIntos.push(pullIntoDescriptor);\n    }\n\n    ReadableStreamAddReadRequest(stream, readRequest);\n    ReadableByteStreamControllerCallPullIfNeeded(this);\n  }\n}\n\nObject.defineProperties(ReadableByteStreamController.prototype, {\n  close: { enumerable: true },\n  enqueue: { enumerable: true },\n  error: { enumerable: true },\n  byobRequest: { enumerable: true },\n  desiredSize: { enumerable: true }\n});\nif (typeof Symbol.toStringTag === 'symbol') {\n  Object.defineProperty(ReadableByteStreamController.prototype, Symbol.toStringTag, {\n    value: 'ReadableByteStreamController',\n    configurable: true\n  });\n}\n\n// Abstract operations for the ReadableByteStreamController.\n\nexport function IsReadableByteStreamController(x: any): x is ReadableByteStreamController {\n  if (!typeIsObject(x)) {\n    return false;\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableByteStream')) {\n    return false;\n  }\n\n  return x instanceof ReadableByteStreamController;\n}\n\nfunction IsReadableStreamBYOBRequest(x: any): x is ReadableStreamBYOBRequest {\n  if (!typeIsObject(x)) {\n    return false;\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {\n    return false;\n  }\n\n  return x instanceof ReadableStreamBYOBRequest;\n}\n\nfunction ReadableByteStreamControllerCallPullIfNeeded(controller: ReadableByteStreamController): void {\n  const shouldPull = ReadableByteStreamControllerShouldCallPull(controller);\n  if (!shouldPull) {\n    return;\n  }\n\n  if (controller._pulling) {\n    controller._pullAgain = true;\n    return;\n  }\n\n  assert(!controller._pullAgain);\n\n  controller._pulling = true;\n\n  // TODO: Test controller argument\n  const pullPromise = controller._pullAlgorithm();\n  uponPromise(\n    pullPromise,\n    () => {\n      controller._pulling = false;\n\n      if (controller._pullAgain) {\n        controller._pullAgain = false;\n        ReadableByteStreamControllerCallPullIfNeeded(controller);\n      }\n    },\n    e => {\n      ReadableByteStreamControllerError(controller, e);\n    }\n  );\n}\n\nfunction ReadableByteStreamControllerClearPendingPullIntos(controller: ReadableByteStreamController) {\n  ReadableByteStreamControllerInvalidateBYOBRequest(controller);\n  controller._pendingPullIntos = new SimpleQueue();\n}\n\nfunction ReadableByteStreamControllerCommitPullIntoDescriptor<T extends ArrayBufferView>(\n  stream: ReadableByteStream,\n  pullIntoDescriptor: PullIntoDescriptor<T>\n) {\n  assert(stream._state !== 'errored');\n\n  let done = false;\n  if (stream._state === 'closed') {\n    assert(pullIntoDescriptor.bytesFilled === 0);\n    done = true;\n  }\n\n  const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor<T>(pullIntoDescriptor);\n  if (pullIntoDescriptor.readerType === 'default') {\n    ReadableStreamFulfillReadRequest(stream, filledView as unknown as Uint8Array, done);\n  } else {\n    assert(pullIntoDescriptor.readerType === 'byob');\n    ReadableStreamFulfillReadIntoRequest(stream, filledView, done);\n  }\n}\n\nfunction ReadableByteStreamControllerConvertPullIntoDescriptor<T extends ArrayBufferView>(\n  pullIntoDescriptor: PullIntoDescriptor<T>\n): T {\n  const bytesFilled = pullIntoDescriptor.bytesFilled;\n  const elementSize = pullIntoDescriptor.elementSize;\n\n  assert(bytesFilled <= pullIntoDescriptor.byteLength);\n  assert(bytesFilled % elementSize === 0);\n\n  return new pullIntoDescriptor.viewConstructor(\n    pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize) as T;\n}\n\nfunction ReadableByteStreamControllerEnqueueChunkToQueue(controller: ReadableByteStreamController,\n                                                         buffer: ArrayBufferLike,\n                                                         byteOffset: number,\n                                                         byteLength: number) {\n  controller._queue.push({ buffer, byteOffset, byteLength });\n  controller._queueTotalSize += byteLength;\n}\n\nfunction ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller: ReadableByteStreamController,\n                                                                     pullIntoDescriptor: PullIntoDescriptor) {\n  const elementSize = pullIntoDescriptor.elementSize;\n\n  const currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize;\n\n  const maxBytesToCopy = Math.min(controller._queueTotalSize,\n                                  pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);\n  const maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;\n  const maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize;\n\n  let totalBytesToCopyRemaining = maxBytesToCopy;\n  let ready = false;\n  if (maxAlignedBytes > currentAlignedBytes) {\n    totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;\n    ready = true;\n  }\n\n  const queue = controller._queue;\n\n  while (totalBytesToCopyRemaining > 0) {\n    const headOfQueue = queue.peek();\n\n    const bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength);\n\n    const destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;\n    CopyDataBlockBytes(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy);\n\n    if (headOfQueue.byteLength === bytesToCopy) {\n      queue.shift();\n    } else {\n      headOfQueue.byteOffset += bytesToCopy;\n      headOfQueue.byteLength -= bytesToCopy;\n    }\n    controller._queueTotalSize -= bytesToCopy;\n\n    ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor);\n\n    totalBytesToCopyRemaining -= bytesToCopy;\n  }\n\n  if (!ready) {\n    assert(controller._queueTotalSize === 0);\n    assert(pullIntoDescriptor.bytesFilled > 0);\n    assert(pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize);\n  }\n\n  return ready;\n}\n\nfunction ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller: ReadableByteStreamController,\n                                                                size: number,\n                                                                pullIntoDescriptor: PullIntoDescriptor) {\n  assert(controller._pendingPullIntos.length === 0 || controller._pendingPullIntos.peek() === pullIntoDescriptor);\n  assert(controller._byobRequest === null);\n  pullIntoDescriptor.bytesFilled += size;\n}\n\nfunction ReadableByteStreamControllerHandleQueueDrain(controller: ReadableByteStreamController) {\n  assert(controller._controlledReadableByteStream._state === 'readable');\n\n  if (controller._queueTotalSize === 0 && controller._closeRequested) {\n    ReadableByteStreamControllerClearAlgorithms(controller);\n    ReadableStreamClose(controller._controlledReadableByteStream);\n  } else {\n    ReadableByteStreamControllerCallPullIfNeeded(controller);\n  }\n}\n\nfunction ReadableByteStreamControllerInvalidateBYOBRequest(controller: ReadableByteStreamController) {\n  if (controller._byobRequest === null) {\n    return;\n  }\n\n  controller._byobRequest._associatedReadableByteStreamController = undefined!;\n  controller._byobRequest._view = null!;\n  controller._byobRequest = null;\n}\n\nfunction ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller: ReadableByteStreamController) {\n  assert(!controller._closeRequested);\n\n  while (controller._pendingPullIntos.length > 0) {\n    if (controller._queueTotalSize === 0) {\n      return;\n    }\n\n    const pullIntoDescriptor = controller._pendingPullIntos.peek();\n\n    if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {\n      ReadableByteStreamControllerShiftPendingPullInto(controller);\n\n      ReadableByteStreamControllerCommitPullIntoDescriptor(\n        controller._controlledReadableByteStream,\n        pullIntoDescriptor\n      );\n    }\n  }\n}\n\nexport function ReadableByteStreamControllerPullInto<T extends ArrayBufferView>(\n  controller: ReadableByteStreamController,\n  view: T,\n  readIntoRequest: ReadIntoRequest<T>\n): void {\n  const stream = controller._controlledReadableByteStream;\n\n  let elementSize = 1;\n  if (view.constructor !== DataView) {\n    elementSize = (view.constructor as ArrayBufferViewConstructor<T>).BYTES_PER_ELEMENT;\n  }\n\n  const ctor = view.constructor as ArrayBufferViewConstructor<T>;\n\n  // try {\n  const buffer = TransferArrayBuffer(view.buffer);\n  // } catch (e) {\n  //   readIntoRequest._errorSteps(e);\n  //   return;\n  // }\n\n  const pullIntoDescriptor: BYOBPullIntoDescriptor<T> = {\n    buffer,\n    bufferByteLength: buffer.byteLength,\n    byteOffset: view.byteOffset,\n    byteLength: view.byteLength,\n    bytesFilled: 0,\n    elementSize,\n    viewConstructor: ctor,\n    readerType: 'byob'\n  };\n\n  if (controller._pendingPullIntos.length > 0) {\n    controller._pendingPullIntos.push(pullIntoDescriptor);\n\n    // No ReadableByteStreamControllerCallPullIfNeeded() call since:\n    // - No change happens on desiredSize\n    // - The source has already been notified of that there's at least 1 pending read(view)\n\n    ReadableStreamAddReadIntoRequest(stream, readIntoRequest);\n    return;\n  }\n\n  if (stream._state === 'closed') {\n    const emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);\n    readIntoRequest._closeSteps(emptyView);\n    return;\n  }\n\n  if (controller._queueTotalSize > 0) {\n    if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {\n      const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor<T>(pullIntoDescriptor);\n\n      ReadableByteStreamControllerHandleQueueDrain(controller);\n\n      readIntoRequest._chunkSteps(filledView);\n      return;\n    }\n\n    if (controller._closeRequested) {\n      const e = new TypeError('Insufficient bytes to fill elements in the given buffer');\n      ReadableByteStreamControllerError(controller, e);\n\n      readIntoRequest._errorSteps(e);\n      return;\n    }\n  }\n\n  controller._pendingPullIntos.push(pullIntoDescriptor);\n\n  ReadableStreamAddReadIntoRequest<T>(stream, readIntoRequest);\n  ReadableByteStreamControllerCallPullIfNeeded(controller);\n}\n\nfunction ReadableByteStreamControllerRespondInClosedState(controller: ReadableByteStreamController,\n                                                          firstDescriptor: PullIntoDescriptor) {\n  assert(firstDescriptor.bytesFilled === 0);\n\n  const stream = controller._controlledReadableByteStream;\n  if (ReadableStreamHasBYOBReader(stream)) {\n    while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {\n      const pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);\n      ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);\n    }\n  }\n}\n\nfunction ReadableByteStreamControllerRespondInReadableState(controller: ReadableByteStreamController,\n                                                            bytesWritten: number,\n                                                            pullIntoDescriptor: PullIntoDescriptor) {\n  assert(pullIntoDescriptor.bytesFilled + bytesWritten <= pullIntoDescriptor.byteLength);\n\n  ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);\n\n  if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {\n    return;\n  }\n\n  ReadableByteStreamControllerShiftPendingPullInto(controller);\n\n  const remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;\n  if (remainderSize > 0) {\n    const end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;\n    const remainder = ArrayBufferSlice(pullIntoDescriptor.buffer, end - remainderSize, end);\n    ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);\n  }\n\n  pullIntoDescriptor.bytesFilled -= remainderSize;\n  ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);\n\n  ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);\n}\n\nfunction ReadableByteStreamControllerRespondInternal(controller: ReadableByteStreamController, bytesWritten: number) {\n  const firstDescriptor = controller._pendingPullIntos.peek();\n  assert(CanTransferArrayBuffer(firstDescriptor.buffer));\n\n  ReadableByteStreamControllerInvalidateBYOBRequest(controller);\n\n  const state = controller._controlledReadableByteStream._state;\n  if (state === 'closed') {\n    assert(bytesWritten === 0);\n    ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);\n  } else {\n    assert(state === 'readable');\n    assert(bytesWritten > 0);\n    ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);\n  }\n\n  ReadableByteStreamControllerCallPullIfNeeded(controller);\n}\n\nfunction ReadableByteStreamControllerShiftPendingPullInto(\n  controller: ReadableByteStreamController\n): PullIntoDescriptor {\n  assert(controller._byobRequest === null);\n  const descriptor = controller._pendingPullIntos.shift()!;\n  return descriptor;\n}\n\nfunction ReadableByteStreamControllerShouldCallPull(controller: ReadableByteStreamController): boolean {\n  const stream = controller._controlledReadableByteStream;\n\n  if (stream._state !== 'readable') {\n    return false;\n  }\n\n  if (controller._closeRequested) {\n    return false;\n  }\n\n  if (!controller._started) {\n    return false;\n  }\n\n  if (ReadableStreamHasDefaultReader(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {\n    return true;\n  }\n\n  if (ReadableStreamHasBYOBReader(stream) && ReadableStreamGetNumReadIntoRequests(stream) > 0) {\n    return true;\n  }\n\n  const desiredSize = ReadableByteStreamControllerGetDesiredSize(controller);\n  assert(desiredSize !== null);\n  if (desiredSize! > 0) {\n    return true;\n  }\n\n  return false;\n}\n\nfunction ReadableByteStreamControllerClearAlgorithms(controller: ReadableByteStreamController) {\n  controller._pullAlgorithm = undefined!;\n  controller._cancelAlgorithm = undefined!;\n}\n\n// A client of ReadableByteStreamController may use these functions directly to bypass state check.\n\nexport function ReadableByteStreamControllerClose(controller: ReadableByteStreamController) {\n  const stream = controller._controlledReadableByteStream;\n\n  if (controller._closeRequested || stream._state !== 'readable') {\n    return;\n  }\n\n  if (controller._queueTotalSize > 0) {\n    controller._closeRequested = true;\n\n    return;\n  }\n\n  if (controller._pendingPullIntos.length > 0) {\n    const firstPendingPullInto = controller._pendingPullIntos.peek();\n    if (firstPendingPullInto.bytesFilled > 0) {\n      const e = new TypeError('Insufficient bytes to fill elements in the given buffer');\n      ReadableByteStreamControllerError(controller, e);\n\n      throw e;\n    }\n  }\n\n  ReadableByteStreamControllerClearAlgorithms(controller);\n  ReadableStreamClose(stream);\n}\n\nexport function ReadableByteStreamControllerEnqueue(controller: ReadableByteStreamController, chunk: ArrayBufferView) {\n  const stream = controller._controlledReadableByteStream;\n\n  if (controller._closeRequested || stream._state !== 'readable') {\n    return;\n  }\n\n  const buffer = chunk.buffer;\n  const byteOffset = chunk.byteOffset;\n  const byteLength = chunk.byteLength;\n  if (IsDetachedBuffer(buffer)) {\n    throw new TypeError('chunk\\'s buffer is detached and so cannot be enqueued');\n  }\n  const transferredBuffer = TransferArrayBuffer(buffer);\n\n  if (controller._pendingPullIntos.length > 0) {\n    const firstPendingPullInto = controller._pendingPullIntos.peek();\n    if (IsDetachedBuffer(firstPendingPullInto.buffer)) {\n      throw new TypeError(\n        'The BYOB request\\'s buffer has been detached and so cannot be filled with an enqueued chunk'\n      );\n    }\n    firstPendingPullInto.buffer = TransferArrayBuffer(firstPendingPullInto.buffer);\n  }\n\n  ReadableByteStreamControllerInvalidateBYOBRequest(controller);\n\n  if (ReadableStreamHasDefaultReader(stream)) {\n    if (ReadableStreamGetNumReadRequests(stream) === 0) {\n      assert(controller._pendingPullIntos.length === 0);\n      ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);\n    } else {\n      assert(controller._queue.length === 0);\n      if (controller._pendingPullIntos.length > 0) {\n        assert(controller._pendingPullIntos.peek().readerType === 'default');\n        ReadableByteStreamControllerShiftPendingPullInto(controller);\n      }\n      const transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);\n      ReadableStreamFulfillReadRequest(stream, transferredView, false);\n    }\n  } else if (ReadableStreamHasBYOBReader(stream)) {\n    // TODO: Ideally in this branch detaching should happen only if the buffer is not consumed fully.\n    ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);\n    ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);\n  } else {\n    assert(!IsReadableStreamLocked(stream));\n    ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);\n  }\n\n  ReadableByteStreamControllerCallPullIfNeeded(controller);\n}\n\nexport function ReadableByteStreamControllerError(controller: ReadableByteStreamController, e: any) {\n  const stream = controller._controlledReadableByteStream;\n\n  if (stream._state !== 'readable') {\n    return;\n  }\n\n  ReadableByteStreamControllerClearPendingPullIntos(controller);\n\n  ResetQueue(controller);\n  ReadableByteStreamControllerClearAlgorithms(controller);\n  ReadableStreamError(stream, e);\n}\n\nexport function ReadableByteStreamControllerGetBYOBRequest(\n  controller: ReadableByteStreamController\n): ReadableStreamBYOBRequest | null {\n  if (controller._byobRequest === null && controller._pendingPullIntos.length > 0) {\n    const firstDescriptor = controller._pendingPullIntos.peek();\n    const view = new Uint8Array(firstDescriptor.buffer,\n                                firstDescriptor.byteOffset + firstDescriptor.bytesFilled,\n                                firstDescriptor.byteLength - firstDescriptor.bytesFilled);\n\n    const byobRequest: ReadableStreamBYOBRequest = Object.create(ReadableStreamBYOBRequest.prototype);\n    SetUpReadableStreamBYOBRequest(byobRequest, controller, view);\n    controller._byobRequest = byobRequest;\n  }\n  return controller._byobRequest;\n}\n\nfunction ReadableByteStreamControllerGetDesiredSize(controller: ReadableByteStreamController): number | null {\n  const state = controller._controlledReadableByteStream._state;\n\n  if (state === 'errored') {\n    return null;\n  }\n  if (state === 'closed') {\n    return 0;\n  }\n\n  return controller._strategyHWM - controller._queueTotalSize;\n}\n\nexport function ReadableByteStreamControllerRespond(controller: ReadableByteStreamController, bytesWritten: number) {\n  assert(controller._pendingPullIntos.length > 0);\n\n  const firstDescriptor = controller._pendingPullIntos.peek();\n  const state = controller._controlledReadableByteStream._state;\n\n  if (state === 'closed') {\n    if (bytesWritten !== 0) {\n      throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream');\n    }\n  } else {\n    assert(state === 'readable');\n    if (bytesWritten === 0) {\n      throw new TypeError('bytesWritten must be greater than 0 when calling respond() on a readable stream');\n    }\n    if (firstDescriptor.bytesFilled + bytesWritten > firstDescriptor.byteLength) {\n      throw new RangeError('bytesWritten out of range');\n    }\n  }\n\n  firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);\n\n  ReadableByteStreamControllerRespondInternal(controller, bytesWritten);\n}\n\nexport function ReadableByteStreamControllerRespondWithNewView(controller: ReadableByteStreamController,\n                                                               view: ArrayBufferView) {\n  assert(controller._pendingPullIntos.length > 0);\n  assert(!IsDetachedBuffer(view.buffer));\n\n  const firstDescriptor = controller._pendingPullIntos.peek();\n  const state = controller._controlledReadableByteStream._state;\n\n  if (state === 'closed') {\n    if (view.byteLength !== 0) {\n      throw new TypeError('The view\\'s length must be 0 when calling respondWithNewView() on a closed stream');\n    }\n  } else {\n    assert(state === 'readable');\n    if (view.byteLength === 0) {\n      throw new TypeError(\n        'The view\\'s length must be greater than 0 when calling respondWithNewView() on a readable stream'\n      );\n    }\n  }\n\n  if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) {\n    throw new RangeError('The region specified by view does not match byobRequest');\n  }\n  if (firstDescriptor.bufferByteLength !== view.buffer.byteLength) {\n    throw new RangeError('The buffer of view has different capacity than byobRequest');\n  }\n  if (firstDescriptor.bytesFilled + view.byteLength > firstDescriptor.byteLength) {\n    throw new RangeError('The region specified by view is larger than byobRequest');\n  }\n\n  const viewByteLength = view.byteLength;\n  firstDescriptor.buffer = TransferArrayBuffer(view.buffer);\n  ReadableByteStreamControllerRespondInternal(controller, viewByteLength);\n}\n\nexport function SetUpReadableByteStreamController(stream: ReadableByteStream,\n                                                  controller: ReadableByteStreamController,\n                                                  startAlgorithm: () => void | PromiseLike<void>,\n                                                  pullAlgorithm: () => Promise<void>,\n                                                  cancelAlgorithm: (reason: any) => Promise<void>,\n                                                  highWaterMark: number,\n                                                  autoAllocateChunkSize: number | undefined) {\n  assert(stream._readableStreamController === undefined);\n  if (autoAllocateChunkSize !== undefined) {\n    assert(NumberIsInteger(autoAllocateChunkSize));\n    assert(autoAllocateChunkSize > 0);\n  }\n\n  controller._controlledReadableByteStream = stream;\n\n  controller._pullAgain = false;\n  controller._pulling = false;\n\n  controller._byobRequest = null;\n\n  // Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly.\n  controller._queue = controller._queueTotalSize = undefined!;\n  ResetQueue(controller);\n\n  controller._closeRequested = false;\n  controller._started = false;\n\n  controller._strategyHWM = highWaterMark;\n\n  controller._pullAlgorithm = pullAlgorithm;\n  controller._cancelAlgorithm = cancelAlgorithm;\n\n  controller._autoAllocateChunkSize = autoAllocateChunkSize;\n\n  controller._pendingPullIntos = new SimpleQueue();\n\n  stream._readableStreamController = controller;\n\n  const startResult = startAlgorithm();\n  uponPromise(\n    promiseResolvedWith(startResult),\n    () => {\n      controller._started = true;\n\n      assert(!controller._pulling);\n      assert(!controller._pullAgain);\n\n      ReadableByteStreamControllerCallPullIfNeeded(controller);\n    },\n    r => {\n      ReadableByteStreamControllerError(controller, r);\n    }\n  );\n}\n\nexport function SetUpReadableByteStreamControllerFromUnderlyingSource(\n  stream: ReadableByteStream,\n  underlyingByteSource: ValidatedUnderlyingByteSource,\n  highWaterMark: number\n) {\n  const controller: ReadableByteStreamController = Object.create(ReadableByteStreamController.prototype);\n\n  let startAlgorithm: () => void | PromiseLike<void> = () => undefined;\n  let pullAlgorithm: () => Promise<void> = () => promiseResolvedWith(undefined);\n  let cancelAlgorithm: (reason: any) => Promise<void> = () => promiseResolvedWith(undefined);\n\n  if (underlyingByteSource.start !== undefined) {\n    startAlgorithm = () => underlyingByteSource.start!(controller);\n  }\n  if (underlyingByteSource.pull !== undefined) {\n    pullAlgorithm = () => underlyingByteSource.pull!(controller);\n  }\n  if (underlyingByteSource.cancel !== undefined) {\n    cancelAlgorithm = reason => underlyingByteSource.cancel!(reason);\n  }\n\n  const autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;\n  if (autoAllocateChunkSize === 0) {\n    throw new TypeError('autoAllocateChunkSize must be greater than 0');\n  }\n\n  SetUpReadableByteStreamController(\n    stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize\n  );\n}\n\nfunction SetUpReadableStreamBYOBRequest(request: ReadableStreamBYOBRequest,\n                                        controller: ReadableByteStreamController,\n                                        view: ArrayBufferView) {\n  assert(IsReadableByteStreamController(controller));\n  assert(typeof view === 'object');\n  assert(ArrayBuffer.isView(view));\n  assert(!IsDetachedBuffer(view.buffer));\n  request._associatedReadableByteStreamController = controller;\n  request._view = view;\n}\n\n// Helper functions for the ReadableStreamBYOBRequest.\n\nfunction byobRequestBrandCheckException(name: string): TypeError {\n  return new TypeError(\n    `ReadableStreamBYOBRequest.prototype.${name} can only be used on a ReadableStreamBYOBRequest`);\n}\n\n// Helper functions for the ReadableByteStreamController.\n\nfunction byteStreamControllerBrandCheckException(name: string): TypeError {\n  return new TypeError(\n    `ReadableByteStreamController.prototype.${name} can only be used on a ReadableByteStreamController`);\n}\n","import assert from '../../stub/assert';\nimport { SimpleQueue } from '../simple-queue';\nimport {\n  ReadableStreamReaderGenericCancel,\n  ReadableStreamReaderGenericInitialize,\n  ReadableStreamReaderGenericRelease,\n  readerLockException\n} from './generic-reader';\nimport { IsReadableStreamLocked, ReadableByteStream, ReadableStream } from '../readable-stream';\nimport {\n  IsReadableByteStreamController,\n  ReadableByteStreamController,\n  ReadableByteStreamControllerPullInto\n} from './byte-stream-controller';\nimport { typeIsObject } from '../helpers/miscellaneous';\nimport { newPromise, promiseRejectedWith } from '../helpers/webidl';\nimport { assertRequiredArgument } from '../validators/basic';\nimport { assertReadableStream } from '../validators/readable-stream';\nimport { IsDetachedBuffer } from '../abstract-ops/ecmascript';\n\n/**\n * A result returned by {@link ReadableStreamBYOBReader.read}.\n *\n * @public\n */\nexport type ReadableStreamBYOBReadResult<T extends ArrayBufferView> = {\n  done: false;\n  value: T;\n} | {\n  done: true;\n  value: T | undefined;\n};\n\n// Abstract operations for the ReadableStream.\n\nexport function AcquireReadableStreamBYOBReader(stream: ReadableByteStream): ReadableStreamBYOBReader {\n  return new ReadableStreamBYOBReader(stream);\n}\n\n// ReadableStream API exposed for controllers.\n\nexport function ReadableStreamAddReadIntoRequest<T extends ArrayBufferView>(stream: ReadableByteStream,\n                                                                            readIntoRequest: ReadIntoRequest<T>): void {\n  assert(IsReadableStreamBYOBReader(stream._reader));\n  assert(stream._state === 'readable' || stream._state === 'closed');\n\n  (stream._reader! as ReadableStreamBYOBReader)._readIntoRequests.push(readIntoRequest);\n}\n\nexport function ReadableStreamFulfillReadIntoRequest(stream: ReadableByteStream,\n                                                     chunk: ArrayBufferView,\n                                                     done: boolean) {\n  const reader = stream._reader as ReadableStreamBYOBReader;\n\n  assert(reader._readIntoRequests.length > 0);\n\n  const readIntoRequest = reader._readIntoRequests.shift()!;\n  if (done) {\n    readIntoRequest._closeSteps(chunk);\n  } else {\n    readIntoRequest._chunkSteps(chunk);\n  }\n}\n\nexport function ReadableStreamGetNumReadIntoRequests(stream: ReadableByteStream): number {\n  return (stream._reader as ReadableStreamBYOBReader)._readIntoRequests.length;\n}\n\nexport function ReadableStreamHasBYOBReader(stream: ReadableByteStream): boolean {\n  const reader = stream._reader;\n\n  if (reader === undefined) {\n    return false;\n  }\n\n  if (!IsReadableStreamBYOBReader(reader)) {\n    return false;\n  }\n\n  return true;\n}\n\n// Readers\n\nexport interface ReadIntoRequest<T extends ArrayBufferView> {\n  _chunkSteps(chunk: T): void;\n\n  _closeSteps(chunk: T | undefined): void;\n\n  _errorSteps(e: any): void;\n}\n\n/**\n * A BYOB reader vended by a {@link ReadableStream}.\n *\n * @public\n */\nexport class ReadableStreamBYOBReader {\n  /** @internal */\n  _ownerReadableStream!: ReadableByteStream;\n  /** @internal */\n  _closedPromise!: Promise<undefined>;\n  /** @internal */\n  _closedPromise_resolve?: (value?: undefined) => void;\n  /** @internal */\n  _closedPromise_reject?: (reason: any) => void;\n  /** @internal */\n  _readIntoRequests: SimpleQueue<ReadIntoRequest<any>>;\n\n  constructor(stream: ReadableByteStream) {\n    assertRequiredArgument(stream, 1, 'ReadableStreamBYOBReader');\n    assertReadableStream(stream, 'First parameter');\n\n    if (IsReadableStreamLocked(stream)) {\n      throw new TypeError('This stream has already been locked for exclusive reading by another reader');\n    }\n\n    if (!IsReadableByteStreamController(stream._readableStreamController)) {\n      throw new TypeError('Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte ' +\n        'source');\n    }\n\n    ReadableStreamReaderGenericInitialize(this, stream);\n\n    this._readIntoRequests = new SimpleQueue();\n  }\n\n  /**\n   * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or\n   * the reader's lock is released before the stream finishes closing.\n   */\n  get closed(): Promise<undefined> {\n    if (!IsReadableStreamBYOBReader(this)) {\n      return promiseRejectedWith(byobReaderBrandCheckException('closed'));\n    }\n\n    return this._closedPromise;\n  }\n\n  /**\n   * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.\n   */\n  cancel(reason: any = undefined): Promise<void> {\n    if (!IsReadableStreamBYOBReader(this)) {\n      return promiseRejectedWith(byobReaderBrandCheckException('cancel'));\n    }\n\n    if (this._ownerReadableStream === undefined) {\n      return promiseRejectedWith(readerLockException('cancel'));\n    }\n\n    return ReadableStreamReaderGenericCancel(this, reason);\n  }\n\n  /**\n   * Attempts to reads bytes into view, and returns a promise resolved with the result.\n   *\n   * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.\n   */\n  read<T extends ArrayBufferView>(view: T): Promise<ReadableStreamBYOBReadResult<T>> {\n    if (!IsReadableStreamBYOBReader(this)) {\n      return promiseRejectedWith(byobReaderBrandCheckException('read'));\n    }\n\n    if (!ArrayBuffer.isView(view)) {\n      return promiseRejectedWith(new TypeError('view must be an array buffer view'));\n    }\n    if (view.byteLength === 0) {\n      return promiseRejectedWith(new TypeError('view must have non-zero byteLength'));\n    }\n    if (view.buffer.byteLength === 0) {\n      return promiseRejectedWith(new TypeError(`view's buffer must have non-zero byteLength`));\n    }\n    if (IsDetachedBuffer(view.buffer)) {\n      return promiseRejectedWith(new TypeError('view\\'s buffer has been detached'));\n    }\n\n    if (this._ownerReadableStream === undefined) {\n      return promiseRejectedWith(readerLockException('read from'));\n    }\n\n    let resolvePromise!: (result: ReadableStreamBYOBReadResult<T>) => void;\n    let rejectPromise!: (reason: any) => void;\n    const promise = newPromise<ReadableStreamBYOBReadResult<T>>((resolve, reject) => {\n      resolvePromise = resolve;\n      rejectPromise = reject;\n    });\n    const readIntoRequest: ReadIntoRequest<T> = {\n      _chunkSteps: chunk => resolvePromise({ value: chunk, done: false }),\n      _closeSteps: chunk => resolvePromise({ value: chunk, done: true }),\n      _errorSteps: e => rejectPromise(e)\n    };\n    ReadableStreamBYOBReaderRead(this, view, readIntoRequest);\n    return promise;\n  }\n\n  /**\n   * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.\n   * If the associated stream is errored when the lock is released, the reader will appear errored in the same way\n   * from now on; otherwise, the reader will appear closed.\n   *\n   * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by\n   * the reader's {@link ReadableStreamBYOBReader.read | read()} method has not yet been settled. Attempting to\n   * do so will throw a `TypeError` and leave the reader locked to the stream.\n   */\n  releaseLock(): void {\n    if (!IsReadableStreamBYOBReader(this)) {\n      throw byobReaderBrandCheckException('releaseLock');\n    }\n\n    if (this._ownerReadableStream === undefined) {\n      return;\n    }\n\n    if (this._readIntoRequests.length > 0) {\n      throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');\n    }\n\n    ReadableStreamReaderGenericRelease(this);\n  }\n}\n\nObject.defineProperties(ReadableStreamBYOBReader.prototype, {\n  cancel: { enumerable: true },\n  read: { enumerable: true },\n  releaseLock: { enumerable: true },\n  closed: { enumerable: true }\n});\nif (typeof Symbol.toStringTag === 'symbol') {\n  Object.defineProperty(ReadableStreamBYOBReader.prototype, Symbol.toStringTag, {\n    value: 'ReadableStreamBYOBReader',\n    configurable: true\n  });\n}\n\n// Abstract operations for the readers.\n\nexport function IsReadableStreamBYOBReader(x: any): x is ReadableStreamBYOBReader {\n  if (!typeIsObject(x)) {\n    return false;\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {\n    return false;\n  }\n\n  return x instanceof ReadableStreamBYOBReader;\n}\n\nexport function ReadableStreamBYOBReaderRead<T extends ArrayBufferView>(\n  reader: ReadableStreamBYOBReader,\n  view: T,\n  readIntoRequest: ReadIntoRequest<T>\n): void {\n  const stream = reader._ownerReadableStream;\n\n  assert(stream !== undefined);\n\n  stream._disturbed = true;\n\n  if (stream._state === 'errored') {\n    readIntoRequest._errorSteps(stream._storedError);\n  } else {\n    ReadableByteStreamControllerPullInto(\n      stream._readableStreamController as ReadableByteStreamController,\n      view,\n      readIntoRequest\n    );\n  }\n}\n\n// Helper functions for the ReadableStreamBYOBReader.\n\nfunction byobReaderBrandCheckException(name: string): TypeError {\n  return new TypeError(\n    `ReadableStreamBYOBReader.prototype.${name} can only be used on a ReadableStreamBYOBReader`);\n}\n","import { QueuingStrategy, QueuingStrategySizeCallback } from '../queuing-strategy';\nimport NumberIsNaN from '../../stub/number-isnan';\n\nexport function ExtractHighWaterMark(strategy: QueuingStrategy, defaultHWM: number): number {\n  const { highWaterMark } = strategy;\n\n  if (highWaterMark === undefined) {\n    return defaultHWM;\n  }\n\n  if (NumberIsNaN(highWaterMark) || highWaterMark < 0) {\n    throw new RangeError('Invalid highWaterMark');\n  }\n\n  return highWaterMark;\n}\n\nexport function ExtractSizeAlgorithm<T>(strategy: QueuingStrategy<T>): QueuingStrategySizeCallback<T> {\n  const { size } = strategy;\n\n  if (!size) {\n    return () => 1;\n  }\n\n  return size;\n}\n","import { QueuingStrategy, QueuingStrategySizeCallback } from '../queuing-strategy';\nimport { assertDictionary, assertFunction, convertUnrestrictedDouble } from './basic';\n\nexport function convertQueuingStrategy<T>(init: QueuingStrategy<T> | null | undefined,\n                                          context: string): QueuingStrategy<T> {\n  assertDictionary(init, context);\n  const highWaterMark = init?.highWaterMark;\n  const size = init?.size;\n  return {\n    highWaterMark: highWaterMark === undefined ? undefined : convertUnrestrictedDouble(highWaterMark),\n    size: size === undefined ? undefined : convertQueuingStrategySize(size, `${context} has member 'size' that`)\n  };\n}\n\nfunction convertQueuingStrategySize<T>(fn: QueuingStrategySizeCallback<T>,\n                                       context: string): QueuingStrategySizeCallback<T> {\n  assertFunction(fn, context);\n  return chunk => convertUnrestrictedDouble(fn(chunk));\n}\n","import { assertDictionary, assertFunction } from './basic';\nimport { promiseCall, reflectCall } from '../helpers/webidl';\nimport {\n  UnderlyingSink,\n  UnderlyingSinkAbortCallback,\n  UnderlyingSinkCloseCallback,\n  UnderlyingSinkStartCallback,\n  UnderlyingSinkWriteCallback,\n  ValidatedUnderlyingSink\n} from '../writable-stream/underlying-sink';\nimport { WritableStreamDefaultController } from '../writable-stream';\n\nexport function convertUnderlyingSink<W>(original: UnderlyingSink<W> | null,\n                                         context: string): ValidatedUnderlyingSink<W> {\n  assertDictionary(original, context);\n  const abort = original?.abort;\n  const close = original?.close;\n  const start = original?.start;\n  const type = original?.type;\n  const write = original?.write;\n  return {\n    abort: abort === undefined ?\n      undefined :\n      convertUnderlyingSinkAbortCallback(abort, original!, `${context} has member 'abort' that`),\n    close: close === undefined ?\n      undefined :\n      convertUnderlyingSinkCloseCallback(close, original!, `${context} has member 'close' that`),\n    start: start === undefined ?\n      undefined :\n      convertUnderlyingSinkStartCallback(start, original!, `${context} has member 'start' that`),\n    write: write === undefined ?\n      undefined :\n      convertUnderlyingSinkWriteCallback(write, original!, `${context} has member 'write' that`),\n    type\n  };\n}\n\nfunction convertUnderlyingSinkAbortCallback(\n  fn: UnderlyingSinkAbortCallback,\n  original: UnderlyingSink,\n  context: string\n): (reason: any) => Promise<void> {\n  assertFunction(fn, context);\n  return (reason: any) => promiseCall(fn, original, [reason]);\n}\n\nfunction convertUnderlyingSinkCloseCallback(\n  fn: UnderlyingSinkCloseCallback,\n  original: UnderlyingSink,\n  context: string\n): () => Promise<void> {\n  assertFunction(fn, context);\n  return () => promiseCall(fn, original, []);\n}\n\nfunction convertUnderlyingSinkStartCallback(\n  fn: UnderlyingSinkStartCallback,\n  original: UnderlyingSink,\n  context: string\n): UnderlyingSinkStartCallback {\n  assertFunction(fn, context);\n  return (controller: WritableStreamDefaultController) => reflectCall(fn, original, [controller]);\n}\n\nfunction convertUnderlyingSinkWriteCallback<W>(\n  fn: UnderlyingSinkWriteCallback<W>,\n  original: UnderlyingSink<W>,\n  context: string\n): (chunk: W, controller: WritableStreamDefaultController) => Promise<void> {\n  assertFunction(fn, context);\n  return (chunk: W, controller: WritableStreamDefaultController) => promiseCall(fn, original, [chunk, controller]);\n}\n","import { IsWritableStream, WritableStream } from '../writable-stream';\n\nexport function assertWritableStream(x: unknown, context: string): asserts x is WritableStream {\n  if (!IsWritableStream(x)) {\n    throw new TypeError(`${context} is not a WritableStream.`);\n  }\n}\n","/**\n * A signal object that allows you to communicate with a request and abort it if required\n * via its associated `AbortController` object.\n *\n * @remarks\n *   This interface is compatible with the `AbortSignal` interface defined in TypeScript's DOM types.\n *   It is redefined here, so it can be polyfilled without a DOM, for example with\n *   {@link https://www.npmjs.com/package/abortcontroller-polyfill | abortcontroller-polyfill} in a Node environment.\n *\n * @public\n */\nexport interface AbortSignal {\n  /**\n   * Whether the request is aborted.\n   */\n  readonly aborted: boolean;\n\n  /**\n   * Add an event listener to be triggered when this signal becomes aborted.\n   */\n  addEventListener(type: 'abort', listener: () => void): void;\n\n  /**\n   * Remove an event listener that was previously added with {@link AbortSignal.addEventListener}.\n   */\n  removeEventListener(type: 'abort', listener: () => void): void;\n}\n\nexport function isAbortSignal(value: unknown): value is AbortSignal {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  try {\n    return typeof (value as AbortSignal).aborted === 'boolean';\n  } catch {\n    // AbortSignal.prototype.aborted throws if its brand check fails\n    return false;\n  }\n}\n\n/**\n * A controller object that allows you to abort an `AbortSignal` when desired.\n *\n * @remarks\n *   This interface is compatible with the `AbortController` interface defined in TypeScript's DOM types.\n *   It is redefined here, so it can be polyfilled without a DOM, for example with\n *   {@link https://www.npmjs.com/package/abortcontroller-polyfill | abortcontroller-polyfill} in a Node environment.\n *\n * @internal\n */\nexport interface AbortController {\n  readonly signal: AbortSignal;\n\n  abort(): void;\n}\n\ninterface AbortControllerConstructor {\n  new(): AbortController;\n}\n\nconst supportsAbortController = typeof (AbortController as any) === 'function';\n\n/**\n * Construct a new AbortController, if supported by the platform.\n *\n * @internal\n */\nexport function createAbortController(): AbortController | undefined {\n  if (supportsAbortController) {\n    return new (AbortController as AbortControllerConstructor)();\n  }\n  return undefined;\n}\n","import assert from '../stub/assert';\nimport {\n  newPromise,\n  promiseRejectedWith,\n  promiseResolvedWith,\n  setPromiseIsHandledToTrue,\n  uponPromise\n} from './helpers/webidl';\nimport {\n  DequeueValue,\n  EnqueueValueWithSize,\n  PeekQueueValue,\n  QueuePair,\n  ResetQueue\n} from './abstract-ops/queue-with-sizes';\nimport { QueuingStrategy, QueuingStrategySizeCallback } from './queuing-strategy';\nimport { SimpleQueue } from './simple-queue';\nimport { typeIsObject } from './helpers/miscellaneous';\nimport { AbortSteps, ErrorSteps } from './abstract-ops/internal-methods';\nimport { IsNonNegativeNumber } from './abstract-ops/miscellaneous';\nimport { ExtractHighWaterMark, ExtractSizeAlgorithm } from './abstract-ops/queuing-strategy';\nimport { convertQueuingStrategy } from './validators/queuing-strategy';\nimport {\n  UnderlyingSink,\n  UnderlyingSinkAbortCallback,\n  UnderlyingSinkCloseCallback,\n  UnderlyingSinkStartCallback,\n  UnderlyingSinkWriteCallback,\n  ValidatedUnderlyingSink\n} from './writable-stream/underlying-sink';\nimport { assertObject, assertRequiredArgument } from './validators/basic';\nimport { convertUnderlyingSink } from './validators/underlying-sink';\nimport { assertWritableStream } from './validators/writable-stream';\nimport { AbortController, AbortSignal, createAbortController } from './abort-signal';\n\ntype WritableStreamState = 'writable' | 'closed' | 'erroring' | 'errored';\n\ninterface WriteOrCloseRequest {\n  _resolve: (value?: undefined) => void;\n  _reject: (reason: any) => void;\n}\n\ntype WriteRequest = WriteOrCloseRequest;\ntype CloseRequest = WriteOrCloseRequest;\n\ninterface PendingAbortRequest {\n  _promise: Promise<undefined>;\n  _resolve: (value?: undefined) => void;\n  _reject: (reason: any) => void;\n  _reason: any;\n  _wasAlreadyErroring: boolean;\n}\n\n/**\n * A writable stream represents a destination for data, into which you can write.\n *\n * @public\n */\nclass WritableStream<W = any> {\n  /** @internal */\n  _state!: WritableStreamState;\n  /** @internal */\n  _storedError: any;\n  /** @internal */\n  _writer: WritableStreamDefaultWriter<W> | undefined;\n  /** @internal */\n  _writableStreamController!: WritableStreamDefaultController<W>;\n  /** @internal */\n  _writeRequests!: SimpleQueue<WriteRequest>;\n  /** @internal */\n  _inFlightWriteRequest: WriteRequest | undefined;\n  /** @internal */\n  _closeRequest: CloseRequest | undefined;\n  /** @internal */\n  _inFlightCloseRequest: CloseRequest | undefined;\n  /** @internal */\n  _pendingAbortRequest: PendingAbortRequest | undefined;\n  /** @internal */\n  _backpressure!: boolean;\n\n  constructor(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>);\n  constructor(rawUnderlyingSink: UnderlyingSink<W> | null | undefined = {},\n              rawStrategy: QueuingStrategy<W> | null | undefined = {}) {\n    if (rawUnderlyingSink === undefined) {\n      rawUnderlyingSink = null;\n    } else {\n      assertObject(rawUnderlyingSink, 'First parameter');\n    }\n\n    const strategy = convertQueuingStrategy(rawStrategy, 'Second parameter');\n    const underlyingSink = convertUnderlyingSink(rawUnderlyingSink, 'First parameter');\n\n    InitializeWritableStream(this);\n\n    const type = underlyingSink.type;\n    if (type !== undefined) {\n      throw new RangeError('Invalid type is specified');\n    }\n\n    const sizeAlgorithm = ExtractSizeAlgorithm(strategy);\n    const highWaterMark = ExtractHighWaterMark(strategy, 1);\n\n    SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm);\n  }\n\n  /**\n   * Returns whether or not the writable stream is locked to a writer.\n   */\n  get locked(): boolean {\n    if (!IsWritableStream(this)) {\n      throw streamBrandCheckException('locked');\n    }\n\n    return IsWritableStreamLocked(this);\n  }\n\n  /**\n   * Aborts the stream, signaling that the producer can no longer successfully write to the stream and it is to be\n   * immediately moved to an errored state, with any queued-up writes discarded. This will also execute any abort\n   * mechanism of the underlying sink.\n   *\n   * The returned promise will fulfill if the stream shuts down successfully, or reject if the underlying sink signaled\n   * that there was an error doing so. Additionally, it will reject with a `TypeError` (without attempting to cancel\n   * the stream) if the stream is currently locked.\n   */\n  abort(reason: any = undefined): Promise<void> {\n    if (!IsWritableStream(this)) {\n      return promiseRejectedWith(streamBrandCheckException('abort'));\n    }\n\n    if (IsWritableStreamLocked(this)) {\n      return promiseRejectedWith(new TypeError('Cannot abort a stream that already has a writer'));\n    }\n\n    return WritableStreamAbort(this, reason);\n  }\n\n  /**\n   * Closes the stream. The underlying sink will finish processing any previously-written chunks, before invoking its\n   * close behavior. During this time any further attempts to write will fail (without erroring the stream).\n   *\n   * The method returns a promise that will fulfill if all remaining chunks are successfully written and the stream\n   * successfully closes, or rejects if an error is encountered during this process. Additionally, it will reject with\n   * a `TypeError` (without attempting to cancel the stream) if the stream is currently locked.\n   */\n  close() {\n    if (!IsWritableStream(this)) {\n      return promiseRejectedWith(streamBrandCheckException('close'));\n    }\n\n    if (IsWritableStreamLocked(this)) {\n      return promiseRejectedWith(new TypeError('Cannot close a stream that already has a writer'));\n    }\n\n    if (WritableStreamCloseQueuedOrInFlight(this)) {\n      return promiseRejectedWith(new TypeError('Cannot close an already-closing stream'));\n    }\n\n    return WritableStreamClose(this);\n  }\n\n  /**\n   * Creates a {@link WritableStreamDefaultWriter | writer} and locks the stream to the new writer. While the stream\n   * is locked, no other writer can be acquired until this one is released.\n   *\n   * This functionality is especially useful for creating abstractions that desire the ability to write to a stream\n   * without interruption or interleaving. By getting a writer for the stream, you can ensure nobody else can write at\n   * the same time, which would cause the resulting written data to be unpredictable and probably useless.\n   */\n  getWriter(): WritableStreamDefaultWriter<W> {\n    if (!IsWritableStream(this)) {\n      throw streamBrandCheckException('getWriter');\n    }\n\n    return AcquireWritableStreamDefaultWriter(this);\n  }\n}\n\nObject.defineProperties(WritableStream.prototype, {\n  abort: { enumerable: true },\n  close: { enumerable: true },\n  getWriter: { enumerable: true },\n  locked: { enumerable: true }\n});\nif (typeof Symbol.toStringTag === 'symbol') {\n  Object.defineProperty(WritableStream.prototype, Symbol.toStringTag, {\n    value: 'WritableStream',\n    configurable: true\n  });\n}\n\nexport {\n  AcquireWritableStreamDefaultWriter,\n  CreateWritableStream,\n  IsWritableStream,\n  IsWritableStreamLocked,\n  WritableStream,\n  WritableStreamAbort,\n  WritableStreamDefaultControllerErrorIfNeeded,\n  WritableStreamDefaultWriterCloseWithErrorPropagation,\n  WritableStreamDefaultWriterRelease,\n  WritableStreamDefaultWriterWrite,\n  WritableStreamCloseQueuedOrInFlight,\n  UnderlyingSink,\n  UnderlyingSinkStartCallback,\n  UnderlyingSinkWriteCallback,\n  UnderlyingSinkCloseCallback,\n  UnderlyingSinkAbortCallback\n};\n\n// Abstract operations for the WritableStream.\n\nfunction AcquireWritableStreamDefaultWriter<W>(stream: WritableStream<W>): WritableStreamDefaultWriter<W> {\n  return new WritableStreamDefaultWriter(stream);\n}\n\n// Throws if and only if startAlgorithm throws.\nfunction CreateWritableStream<W>(startAlgorithm: () => void | PromiseLike<void>,\n                                 writeAlgorithm: (chunk: W) => Promise<void>,\n                                 closeAlgorithm: () => Promise<void>,\n                                 abortAlgorithm: (reason: any) => Promise<void>,\n                                 highWaterMark = 1,\n                                 sizeAlgorithm: QueuingStrategySizeCallback<W> = () => 1) {\n  assert(IsNonNegativeNumber(highWaterMark));\n\n  const stream: WritableStream<W> = Object.create(WritableStream.prototype);\n  InitializeWritableStream(stream);\n\n  const controller: WritableStreamDefaultController<W> = Object.create(WritableStreamDefaultController.prototype);\n\n  SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm,\n                                       abortAlgorithm, highWaterMark, sizeAlgorithm);\n  return stream;\n}\n\nfunction InitializeWritableStream<W>(stream: WritableStream<W>) {\n  stream._state = 'writable';\n\n  // The error that will be reported by new method calls once the state becomes errored. Only set when [[state]] is\n  // 'erroring' or 'errored'. May be set to an undefined value.\n  stream._storedError = undefined;\n\n  stream._writer = undefined;\n\n  // Initialize to undefined first because the constructor of the controller checks this\n  // variable to validate the caller.\n  stream._writableStreamController = undefined!;\n\n  // This queue is placed here instead of the writer class in order to allow for passing a writer to the next data\n  // producer without waiting for the queued writes to finish.\n  stream._writeRequests = new SimpleQueue();\n\n  // Write requests are removed from _writeRequests when write() is called on the underlying sink. This prevents\n  // them from being erroneously rejected on error. If a write() call is in-flight, the request is stored here.\n  stream._inFlightWriteRequest = undefined;\n\n  // The promise that was returned from writer.close(). Stored here because it may be fulfilled after the writer\n  // has been detached.\n  stream._closeRequest = undefined;\n\n  // Close request is removed from _closeRequest when close() is called on the underlying sink. This prevents it\n  // from being erroneously rejected on error. If a close() call is in-flight, the request is stored here.\n  stream._inFlightCloseRequest = undefined;\n\n  // The promise that was returned from writer.abort(). This may also be fulfilled after the writer has detached.\n  stream._pendingAbortRequest = undefined;\n\n  // The backpressure signal set by the controller.\n  stream._backpressure = false;\n}\n\nfunction IsWritableStream(x: unknown): x is WritableStream {\n  if (!typeIsObject(x)) {\n    return false;\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) {\n    return false;\n  }\n\n  return x instanceof WritableStream;\n}\n\nfunction IsWritableStreamLocked(stream: WritableStream): boolean {\n  assert(IsWritableStream(stream));\n\n  if (stream._writer === undefined) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction WritableStreamAbort(stream: WritableStream, reason: any): Promise<undefined> {\n  if (stream._state === 'closed' || stream._state === 'errored') {\n    return promiseResolvedWith(undefined);\n  }\n  stream._writableStreamController._abortReason = reason;\n  stream._writableStreamController._abortController?.abort();\n\n  // TypeScript narrows the type of `stream._state` down to 'writable' | 'erroring',\n  // but it doesn't know that signaling abort runs author code that might have changed the state.\n  // Widen the type again by casting to WritableStreamState.\n  const state = stream._state as WritableStreamState;\n\n  if (state === 'closed' || state === 'errored') {\n    return promiseResolvedWith(undefined);\n  }\n  if (stream._pendingAbortRequest !== undefined) {\n    return stream._pendingAbortRequest._promise;\n  }\n\n  assert(state === 'writable' || state === 'erroring');\n\n  let wasAlreadyErroring = false;\n  if (state === 'erroring') {\n    wasAlreadyErroring = true;\n    // reason will not be used, so don't keep a reference to it.\n    reason = undefined;\n  }\n\n  const promise = newPromise<undefined>((resolve, reject) => {\n    stream._pendingAbortRequest = {\n      _promise: undefined!,\n      _resolve: resolve,\n      _reject: reject,\n      _reason: reason,\n      _wasAlreadyErroring: wasAlreadyErroring\n    };\n  });\n  stream._pendingAbortRequest!._promise = promise;\n\n  if (!wasAlreadyErroring) {\n    WritableStreamStartErroring(stream, reason);\n  }\n\n  return promise;\n}\n\nfunction WritableStreamClose(stream: WritableStream<any>): Promise<undefined> {\n  const state = stream._state;\n  if (state === 'closed' || state === 'errored') {\n    return promiseRejectedWith(new TypeError(\n      `The stream (in ${state} state) is not in the writable state and cannot be closed`));\n  }\n\n  assert(state === 'writable' || state === 'erroring');\n  assert(!WritableStreamCloseQueuedOrInFlight(stream));\n\n  const promise = newPromise<undefined>((resolve, reject) => {\n    const closeRequest: CloseRequest = {\n      _resolve: resolve,\n      _reject: reject\n    };\n\n    stream._closeRequest = closeRequest;\n  });\n\n  const writer = stream._writer;\n  if (writer !== undefined && stream._backpressure && state === 'writable') {\n    defaultWriterReadyPromiseResolve(writer);\n  }\n\n  WritableStreamDefaultControllerClose(stream._writableStreamController);\n\n  return promise;\n}\n\n// WritableStream API exposed for controllers.\n\nfunction WritableStreamAddWriteRequest(stream: WritableStream): Promise<undefined> {\n  assert(IsWritableStreamLocked(stream));\n  assert(stream._state === 'writable');\n\n  const promise = newPromise<undefined>((resolve, reject) => {\n    const writeRequest: WriteRequest = {\n      _resolve: resolve,\n      _reject: reject\n    };\n\n    stream._writeRequests.push(writeRequest);\n  });\n\n  return promise;\n}\n\nfunction WritableStreamDealWithRejection(stream: WritableStream, error: any) {\n  const state = stream._state;\n\n  if (state === 'writable') {\n    WritableStreamStartErroring(stream, error);\n    return;\n  }\n\n  assert(state === 'erroring');\n  WritableStreamFinishErroring(stream);\n}\n\nfunction WritableStreamStartErroring(stream: WritableStream, reason: any) {\n  assert(stream._storedError === undefined);\n  assert(stream._state === 'writable');\n\n  const controller = stream._writableStreamController;\n  assert(controller !== undefined);\n\n  stream._state = 'erroring';\n  stream._storedError = reason;\n  const writer = stream._writer;\n  if (writer !== undefined) {\n    WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);\n  }\n\n  if (!WritableStreamHasOperationMarkedInFlight(stream) && controller._started) {\n    WritableStreamFinishErroring(stream);\n  }\n}\n\nfunction WritableStreamFinishErroring(stream: WritableStream) {\n  assert(stream._state === 'erroring');\n  assert(!WritableStreamHasOperationMarkedInFlight(stream));\n  stream._state = 'errored';\n  stream._writableStreamController[ErrorSteps]();\n\n  const storedError = stream._storedError;\n  stream._writeRequests.forEach(writeRequest => {\n    writeRequest._reject(storedError);\n  });\n  stream._writeRequests = new SimpleQueue();\n\n  if (stream._pendingAbortRequest === undefined) {\n    WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);\n    return;\n  }\n\n  const abortRequest = stream._pendingAbortRequest;\n  stream._pendingAbortRequest = undefined;\n\n  if (abortRequest._wasAlreadyErroring) {\n    abortRequest._reject(storedError);\n    WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);\n    return;\n  }\n\n  const promise = stream._writableStreamController[AbortSteps](abortRequest._reason);\n  uponPromise(\n    promise,\n    () => {\n      abortRequest._resolve();\n      WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);\n    },\n    (reason: any) => {\n      abortRequest._reject(reason);\n      WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);\n    });\n}\n\nfunction WritableStreamFinishInFlightWrite(stream: WritableStream) {\n  assert(stream._inFlightWriteRequest !== undefined);\n  stream._inFlightWriteRequest!._resolve(undefined);\n  stream._inFlightWriteRequest = undefined;\n}\n\nfunction WritableStreamFinishInFlightWriteWithError(stream: WritableStream, error: any) {\n  assert(stream._inFlightWriteRequest !== undefined);\n  stream._inFlightWriteRequest!._reject(error);\n  stream._inFlightWriteRequest = undefined;\n\n  assert(stream._state === 'writable' || stream._state === 'erroring');\n\n  WritableStreamDealWithRejection(stream, error);\n}\n\nfunction WritableStreamFinishInFlightClose(stream: WritableStream) {\n  assert(stream._inFlightCloseRequest !== undefined);\n  stream._inFlightCloseRequest!._resolve(undefined);\n  stream._inFlightCloseRequest = undefined;\n\n  const state = stream._state;\n\n  assert(state === 'writable' || state === 'erroring');\n\n  if (state === 'erroring') {\n    // The error was too late to do anything, so it is ignored.\n    stream._storedError = undefined;\n    if (stream._pendingAbortRequest !== undefined) {\n      stream._pendingAbortRequest._resolve();\n      stream._pendingAbortRequest = undefined;\n    }\n  }\n\n  stream._state = 'closed';\n\n  const writer = stream._writer;\n  if (writer !== undefined) {\n    defaultWriterClosedPromiseResolve(writer);\n  }\n\n  assert(stream._pendingAbortRequest === undefined);\n  assert(stream._storedError === undefined);\n}\n\nfunction WritableStreamFinishInFlightCloseWithError(stream: WritableStream, error: any) {\n  assert(stream._inFlightCloseRequest !== undefined);\n  stream._inFlightCloseRequest!._reject(error);\n  stream._inFlightCloseRequest = undefined;\n\n  assert(stream._state === 'writable' || stream._state === 'erroring');\n\n  // Never execute sink abort() after sink close().\n  if (stream._pendingAbortRequest !== undefined) {\n    stream._pendingAbortRequest._reject(error);\n    stream._pendingAbortRequest = undefined;\n  }\n  WritableStreamDealWithRejection(stream, error);\n}\n\n// TODO(ricea): Fix alphabetical order.\nfunction WritableStreamCloseQueuedOrInFlight(stream: WritableStream): boolean {\n  if (stream._closeRequest === undefined && stream._inFlightCloseRequest === undefined) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction WritableStreamHasOperationMarkedInFlight(stream: WritableStream): boolean {\n  if (stream._inFlightWriteRequest === undefined && stream._inFlightCloseRequest === undefined) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction WritableStreamMarkCloseRequestInFlight(stream: WritableStream) {\n  assert(stream._inFlightCloseRequest === undefined);\n  assert(stream._closeRequest !== undefined);\n  stream._inFlightCloseRequest = stream._closeRequest;\n  stream._closeRequest = undefined;\n}\n\nfunction WritableStreamMarkFirstWriteRequestInFlight(stream: WritableStream) {\n  assert(stream._inFlightWriteRequest === undefined);\n  assert(stream._writeRequests.length !== 0);\n  stream._inFlightWriteRequest = stream._writeRequests.shift();\n}\n\nfunction WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream: WritableStream) {\n  assert(stream._state === 'errored');\n  if (stream._closeRequest !== undefined) {\n    assert(stream._inFlightCloseRequest === undefined);\n\n    stream._closeRequest._reject(stream._storedError);\n    stream._closeRequest = undefined;\n  }\n  const writer = stream._writer;\n  if (writer !== undefined) {\n    defaultWriterClosedPromiseReject(writer, stream._storedError);\n  }\n}\n\nfunction WritableStreamUpdateBackpressure(stream: WritableStream, backpressure: boolean) {\n  assert(stream._state === 'writable');\n  assert(!WritableStreamCloseQueuedOrInFlight(stream));\n\n  const writer = stream._writer;\n  if (writer !== undefined && backpressure !== stream._backpressure) {\n    if (backpressure) {\n      defaultWriterReadyPromiseReset(writer);\n    } else {\n      assert(!backpressure);\n\n      defaultWriterReadyPromiseResolve(writer);\n    }\n  }\n\n  stream._backpressure = backpressure;\n}\n\n/**\n * A default writer vended by a {@link WritableStream}.\n *\n * @public\n */\nexport class WritableStreamDefaultWriter<W = any> {\n  /** @internal */\n  _ownerWritableStream: WritableStream<W>;\n  /** @internal */\n  _closedPromise!: Promise<undefined>;\n  /** @internal */\n  _closedPromise_resolve?: (value?: undefined) => void;\n  /** @internal */\n  _closedPromise_reject?: (reason: any) => void;\n  /** @internal */\n  _closedPromiseState!: 'pending' | 'resolved' | 'rejected';\n  /** @internal */\n  _readyPromise!: Promise<undefined>;\n  /** @internal */\n  _readyPromise_resolve?: (value?: undefined) => void;\n  /** @internal */\n  _readyPromise_reject?: (reason: any) => void;\n  /** @internal */\n  _readyPromiseState!: 'pending' | 'fulfilled' | 'rejected';\n\n  constructor(stream: WritableStream<W>) {\n    assertRequiredArgument(stream, 1, 'WritableStreamDefaultWriter');\n    assertWritableStream(stream, 'First parameter');\n\n    if (IsWritableStreamLocked(stream)) {\n      throw new TypeError('This stream has already been locked for exclusive writing by another writer');\n    }\n\n    this._ownerWritableStream = stream;\n    stream._writer = this;\n\n    const state = stream._state;\n\n    if (state === 'writable') {\n      if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._backpressure) {\n        defaultWriterReadyPromiseInitialize(this);\n      } else {\n        defaultWriterReadyPromiseInitializeAsResolved(this);\n      }\n\n      defaultWriterClosedPromiseInitialize(this);\n    } else if (state === 'erroring') {\n      defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError);\n      defaultWriterClosedPromiseInitialize(this);\n    } else if (state === 'closed') {\n      defaultWriterReadyPromiseInitializeAsResolved(this);\n      defaultWriterClosedPromiseInitializeAsResolved(this);\n    } else {\n      assert(state === 'errored');\n\n      const storedError = stream._storedError;\n      defaultWriterReadyPromiseInitializeAsRejected(this, storedError);\n      defaultWriterClosedPromiseInitializeAsRejected(this, storedError);\n    }\n  }\n\n  /**\n   * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or\n   * the writer’s lock is released before the stream finishes closing.\n   */\n  get closed(): Promise<undefined> {\n    if (!IsWritableStreamDefaultWriter(this)) {\n      return promiseRejectedWith(defaultWriterBrandCheckException('closed'));\n    }\n\n    return this._closedPromise;\n  }\n\n  /**\n   * Returns the desired size to fill the stream’s internal queue. It can be negative, if the queue is over-full.\n   * A producer can use this information to determine the right amount of data to write.\n   *\n   * It will be `null` if the stream cannot be successfully written to (due to either being errored, or having an abort\n   * queued up). It will return zero if the stream is closed. And the getter will throw an exception if invoked when\n   * the writer’s lock is released.\n   */\n  get desiredSize(): number | null {\n    if (!IsWritableStreamDefaultWriter(this)) {\n      throw defaultWriterBrandCheckException('desiredSize');\n    }\n\n    if (this._ownerWritableStream === undefined) {\n      throw defaultWriterLockException('desiredSize');\n    }\n\n    return WritableStreamDefaultWriterGetDesiredSize(this);\n  }\n\n  /**\n   * Returns a promise that will be fulfilled when the desired size to fill the stream’s internal queue transitions\n   * from non-positive to positive, signaling that it is no longer applying backpressure. Once the desired size dips\n   * back to zero or below, the getter will return a new promise that stays pending until the next transition.\n   *\n   * If the stream becomes errored or aborted, or the writer’s lock is released, the returned promise will become\n   * rejected.\n   */\n  get ready(): Promise<undefined> {\n    if (!IsWritableStreamDefaultWriter(this)) {\n      return promiseRejectedWith(defaultWriterBrandCheckException('ready'));\n    }\n\n    return this._readyPromise;\n  }\n\n  /**\n   * If the reader is active, behaves the same as {@link WritableStream.abort | stream.abort(reason)}.\n   */\n  abort(reason: any = undefined): Promise<void> {\n    if (!IsWritableStreamDefaultWriter(this)) {\n      return promiseRejectedWith(defaultWriterBrandCheckException('abort'));\n    }\n\n    if (this._ownerWritableStream === undefined) {\n      return promiseRejectedWith(defaultWriterLockException('abort'));\n    }\n\n    return WritableStreamDefaultWriterAbort(this, reason);\n  }\n\n  /**\n   * If the reader is active, behaves the same as {@link WritableStream.close | stream.close()}.\n   */\n  close(): Promise<void> {\n    if (!IsWritableStreamDefaultWriter(this)) {\n      return promiseRejectedWith(defaultWriterBrandCheckException('close'));\n    }\n\n    const stream = this._ownerWritableStream;\n\n    if (stream === undefined) {\n      return promiseRejectedWith(defaultWriterLockException('close'));\n    }\n\n    if (WritableStreamCloseQueuedOrInFlight(stream)) {\n      return promiseRejectedWith(new TypeError('Cannot close an already-closing stream'));\n    }\n\n    return WritableStreamDefaultWriterClose(this);\n  }\n\n  /**\n   * Releases the writer’s lock on the corresponding stream. After the lock is released, the writer is no longer active.\n   * If the associated stream is errored when the lock is released, the writer will appear errored in the same way from\n   * now on; otherwise, the writer will appear closed.\n   *\n   * Note that the lock can still be released even if some ongoing writes have not yet finished (i.e. even if the\n   * promises returned from previous calls to {@link WritableStreamDefaultWriter.write | write()} have not yet settled).\n   * It’s not necessary to hold the lock on the writer for the duration of the write; the lock instead simply prevents\n   * other producers from writing in an interleaved manner.\n   */\n  releaseLock(): void {\n    if (!IsWritableStreamDefaultWriter(this)) {\n      throw defaultWriterBrandCheckException('releaseLock');\n    }\n\n    const stream = this._ownerWritableStream;\n\n    if (stream === undefined) {\n      return;\n    }\n\n    assert(stream._writer !== undefined);\n\n    WritableStreamDefaultWriterRelease(this);\n  }\n\n  /**\n   * Writes the given chunk to the writable stream, by waiting until any previous writes have finished successfully,\n   * and then sending the chunk to the underlying sink's {@link UnderlyingSink.write | write()} method. It will return\n   * a promise that fulfills with undefined upon a successful write, or rejects if the write fails or stream becomes\n   * errored before the writing process is initiated.\n   *\n   * Note that what \"success\" means is up to the underlying sink; it might indicate simply that the chunk has been\n   * accepted, and not necessarily that it is safely saved to its ultimate destination.\n   */\n  write(chunk: W): Promise<void>;\n  write(chunk: W = undefined!): Promise<void> {\n    if (!IsWritableStreamDefaultWriter(this)) {\n      return promiseRejectedWith(defaultWriterBrandCheckException('write'));\n    }\n\n    if (this._ownerWritableStream === undefined) {\n      return promiseRejectedWith(defaultWriterLockException('write to'));\n    }\n\n    return WritableStreamDefaultWriterWrite(this, chunk);\n  }\n}\n\nObject.defineProperties(WritableStreamDefaultWriter.prototype, {\n  abort: { enumerable: true },\n  close: { enumerable: true },\n  releaseLock: { enumerable: true },\n  write: { enumerable: true },\n  closed: { enumerable: true },\n  desiredSize: { enumerable: true },\n  ready: { enumerable: true }\n});\nif (typeof Symbol.toStringTag === 'symbol') {\n  Object.defineProperty(WritableStreamDefaultWriter.prototype, Symbol.toStringTag, {\n    value: 'WritableStreamDefaultWriter',\n    configurable: true\n  });\n}\n\n// Abstract operations for the WritableStreamDefaultWriter.\n\nfunction IsWritableStreamDefaultWriter<W = any>(x: any): x is WritableStreamDefaultWriter<W> {\n  if (!typeIsObject(x)) {\n    return false;\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) {\n    return false;\n  }\n\n  return x instanceof WritableStreamDefaultWriter;\n}\n\n// A client of WritableStreamDefaultWriter may use these functions directly to bypass state check.\n\nfunction WritableStreamDefaultWriterAbort(writer: WritableStreamDefaultWriter, reason: any) {\n  const stream = writer._ownerWritableStream;\n\n  assert(stream !== undefined);\n\n  return WritableStreamAbort(stream, reason);\n}\n\nfunction WritableStreamDefaultWriterClose(writer: WritableStreamDefaultWriter): Promise<undefined> {\n  const stream = writer._ownerWritableStream;\n\n  assert(stream !== undefined);\n\n  return WritableStreamClose(stream);\n}\n\nfunction WritableStreamDefaultWriterCloseWithErrorPropagation(writer: WritableStreamDefaultWriter): Promise<undefined> {\n  const stream = writer._ownerWritableStream;\n\n  assert(stream !== undefined);\n\n  const state = stream._state;\n  if (WritableStreamCloseQueuedOrInFlight(stream) || state === 'closed') {\n    return promiseResolvedWith(undefined);\n  }\n\n  if (state === 'errored') {\n    return promiseRejectedWith(stream._storedError);\n  }\n\n  assert(state === 'writable' || state === 'erroring');\n\n  return WritableStreamDefaultWriterClose(writer);\n}\n\nfunction WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer: WritableStreamDefaultWriter, error: any) {\n  if (writer._closedPromiseState === 'pending') {\n    defaultWriterClosedPromiseReject(writer, error);\n  } else {\n    defaultWriterClosedPromiseResetToRejected(writer, error);\n  }\n}\n\nfunction WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer: WritableStreamDefaultWriter, error: any) {\n  if (writer._readyPromiseState === 'pending') {\n    defaultWriterReadyPromiseReject(writer, error);\n  } else {\n    defaultWriterReadyPromiseResetToRejected(writer, error);\n  }\n}\n\nfunction WritableStreamDefaultWriterGetDesiredSize(writer: WritableStreamDefaultWriter): number | null {\n  const stream = writer._ownerWritableStream;\n  const state = stream._state;\n\n  if (state === 'errored' || state === 'erroring') {\n    return null;\n  }\n\n  if (state === 'closed') {\n    return 0;\n  }\n\n  return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);\n}\n\nfunction WritableStreamDefaultWriterRelease(writer: WritableStreamDefaultWriter) {\n  const stream = writer._ownerWritableStream;\n  assert(stream !== undefined);\n  assert(stream._writer === writer);\n\n  const releasedError = new TypeError(\n    `Writer was released and can no longer be used to monitor the stream's closedness`);\n\n  WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);\n\n  // The state transitions to \"errored\" before the sink abort() method runs, but the writer.closed promise is not\n  // rejected until afterwards. This means that simply testing state will not work.\n  WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);\n\n  stream._writer = undefined;\n  writer._ownerWritableStream = undefined!;\n}\n\nfunction WritableStreamDefaultWriterWrite<W>(writer: WritableStreamDefaultWriter<W>, chunk: W): Promise<undefined> {\n  const stream = writer._ownerWritableStream;\n\n  assert(stream !== undefined);\n\n  const controller = stream._writableStreamController;\n\n  const chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);\n\n  if (stream !== writer._ownerWritableStream) {\n    return promiseRejectedWith(defaultWriterLockException('write to'));\n  }\n\n  const state = stream._state;\n  if (state === 'errored') {\n    return promiseRejectedWith(stream._storedError);\n  }\n  if (WritableStreamCloseQueuedOrInFlight(stream) || state === 'closed') {\n    return promiseRejectedWith(new TypeError('The stream is closing or closed and cannot be written to'));\n  }\n  if (state === 'erroring') {\n    return promiseRejectedWith(stream._storedError);\n  }\n\n  assert(state === 'writable');\n\n  const promise = WritableStreamAddWriteRequest(stream);\n\n  WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);\n\n  return promise;\n}\n\nconst closeSentinel: unique symbol = {} as any;\n\ntype QueueRecord<W> = W | typeof closeSentinel;\n\n/**\n * Allows control of a {@link WritableStream | writable stream}'s state and internal queue.\n *\n * @public\n */\nexport class WritableStreamDefaultController<W = any> {\n  /** @internal */\n  _controlledWritableStream!: WritableStream<W>;\n  /** @internal */\n  _queue!: SimpleQueue<QueuePair<QueueRecord<W>>>;\n  /** @internal */\n  _queueTotalSize!: number;\n  /** @internal */\n  _abortReason: any;\n  /** @internal */\n  _abortController: AbortController | undefined;\n  /** @internal */\n  _started!: boolean;\n  /** @internal */\n  _strategySizeAlgorithm!: QueuingStrategySizeCallback<W>;\n  /** @internal */\n  _strategyHWM!: number;\n  /** @internal */\n  _writeAlgorithm!: (chunk: W) => Promise<void>;\n  /** @internal */\n  _closeAlgorithm!: () => Promise<void>;\n  /** @internal */\n  _abortAlgorithm!: (reason: any) => Promise<void>;\n\n  private constructor() {\n    throw new TypeError('Illegal constructor');\n  }\n\n  /**\n   * The reason which was passed to `WritableStream.abort(reason)` when the stream was aborted.\n   *\n   * @deprecated\n   *  This property has been removed from the specification, see https://github.com/whatwg/streams/pull/1177.\n   *  Use {@link WritableStreamDefaultController.signal}'s `reason` instead.\n   */\n  get abortReason(): any {\n    if (!IsWritableStreamDefaultController(this)) {\n      throw defaultControllerBrandCheckException('abortReason');\n    }\n    return this._abortReason;\n  }\n\n  /**\n   * An `AbortSignal` that can be used to abort the pending write or close operation when the stream is aborted.\n   */\n  get signal(): AbortSignal {\n    if (!IsWritableStreamDefaultController(this)) {\n      throw defaultControllerBrandCheckException('signal');\n    }\n    if (this._abortController === undefined) {\n      // Older browsers or older Node versions may not support `AbortController` or `AbortSignal`.\n      // We don't want to bundle and ship an `AbortController` polyfill together with our polyfill,\n      // so instead we only implement support for `signal` if we find a global `AbortController` constructor.\n      throw new TypeError('WritableStreamDefaultController.prototype.signal is not supported');\n    }\n    return this._abortController.signal;\n  }\n\n  /**\n   * Closes the controlled writable stream, making all future interactions with it fail with the given error `e`.\n   *\n   * This method is rarely used, since usually it suffices to return a rejected promise from one of the underlying\n   * sink's methods. However, it can be useful for suddenly shutting down a stream in response to an event outside the\n   * normal lifecycle of interactions with the underlying sink.\n   */\n  error(e: any = undefined): void {\n    if (!IsWritableStreamDefaultController(this)) {\n      throw defaultControllerBrandCheckException('error');\n    }\n    const state = this._controlledWritableStream._state;\n    if (state !== 'writable') {\n      // The stream is closed, errored or will be soon. The sink can't do anything useful if it gets an error here, so\n      // just treat it as a no-op.\n      return;\n    }\n\n    WritableStreamDefaultControllerError(this, e);\n  }\n\n  /** @internal */\n  [AbortSteps](reason: any): Promise<void> {\n    const result = this._abortAlgorithm(reason);\n    WritableStreamDefaultControllerClearAlgorithms(this);\n    return result;\n  }\n\n  /** @internal */\n  [ErrorSteps]() {\n    ResetQueue(this);\n  }\n}\n\nObject.defineProperties(WritableStreamDefaultController.prototype, {\n  abortReason: { enumerable: true },\n  signal: { enumerable: true },\n  error: { enumerable: true }\n});\nif (typeof Symbol.toStringTag === 'symbol') {\n  Object.defineProperty(WritableStreamDefaultController.prototype, Symbol.toStringTag, {\n    value: 'WritableStreamDefaultController',\n    configurable: true\n  });\n}\n\n// Abstract operations implementing interface required by the WritableStream.\n\nfunction IsWritableStreamDefaultController(x: any): x is WritableStreamDefaultController<any> {\n  if (!typeIsObject(x)) {\n    return false;\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(x, '_controlledWritableStream')) {\n    return false;\n  }\n\n  return x instanceof WritableStreamDefaultController;\n}\n\nfunction SetUpWritableStreamDefaultController<W>(stream: WritableStream<W>,\n                                                 controller: WritableStreamDefaultController<W>,\n                                                 startAlgorithm: () => void | PromiseLike<void>,\n                                                 writeAlgorithm: (chunk: W) => Promise<void>,\n                                                 closeAlgorithm: () => Promise<void>,\n                                                 abortAlgorithm: (reason: any) => Promise<void>,\n                                                 highWaterMark: number,\n                                                 sizeAlgorithm: QueuingStrategySizeCallback<W>) {\n  assert(IsWritableStream(stream));\n  assert(stream._writableStreamController === undefined);\n\n  controller._controlledWritableStream = stream;\n  stream._writableStreamController = controller;\n\n  // Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly.\n  controller._queue = undefined!;\n  controller._queueTotalSize = undefined!;\n  ResetQueue(controller);\n\n  controller._abortReason = undefined;\n  controller._abortController = createAbortController();\n  controller._started = false;\n\n  controller._strategySizeAlgorithm = sizeAlgorithm;\n  controller._strategyHWM = highWaterMark;\n\n  controller._writeAlgorithm = writeAlgorithm;\n  controller._closeAlgorithm = closeAlgorithm;\n  controller._abortAlgorithm = abortAlgorithm;\n\n  const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);\n  WritableStreamUpdateBackpressure(stream, backpressure);\n\n  const startResult = startAlgorithm();\n  const startPromise = promiseResolvedWith(startResult);\n  uponPromise(\n    startPromise,\n    () => {\n      assert(stream._state === 'writable' || stream._state === 'erroring');\n      controller._started = true;\n      WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);\n    },\n    r => {\n      assert(stream._state === 'writable' || stream._state === 'erroring');\n      controller._started = true;\n      WritableStreamDealWithRejection(stream, r);\n    }\n  );\n}\n\nfunction SetUpWritableStreamDefaultControllerFromUnderlyingSink<W>(stream: WritableStream<W>,\n                                                                   underlyingSink: ValidatedUnderlyingSink<W>,\n                                                                   highWaterMark: number,\n                                                                   sizeAlgorithm: QueuingStrategySizeCallback<W>) {\n  const controller = Object.create(WritableStreamDefaultController.prototype);\n\n  let startAlgorithm: () => void | PromiseLike<void> = () => undefined;\n  let writeAlgorithm: (chunk: W) => Promise<void> = () => promiseResolvedWith(undefined);\n  let closeAlgorithm: () => Promise<void> = () => promiseResolvedWith(undefined);\n  let abortAlgorithm: (reason: any) => Promise<void> = () => promiseResolvedWith(undefined);\n\n  if (underlyingSink.start !== undefined) {\n    startAlgorithm = () => underlyingSink.start!(controller);\n  }\n  if (underlyingSink.write !== undefined) {\n    writeAlgorithm = chunk => underlyingSink.write!(chunk, controller);\n  }\n  if (underlyingSink.close !== undefined) {\n    closeAlgorithm = () => underlyingSink.close!();\n  }\n  if (underlyingSink.abort !== undefined) {\n    abortAlgorithm = reason => underlyingSink.abort!(reason);\n  }\n\n  SetUpWritableStreamDefaultController(\n    stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm\n  );\n}\n\n// ClearAlgorithms may be called twice. Erroring the same stream in multiple ways will often result in redundant calls.\nfunction WritableStreamDefaultControllerClearAlgorithms(controller: WritableStreamDefaultController<any>) {\n  controller._writeAlgorithm = undefined!;\n  controller._closeAlgorithm = undefined!;\n  controller._abortAlgorithm = undefined!;\n  controller._strategySizeAlgorithm = undefined!;\n}\n\nfunction WritableStreamDefaultControllerClose<W>(controller: WritableStreamDefaultController<W>) {\n  EnqueueValueWithSize(controller, closeSentinel, 0);\n  WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);\n}\n\nfunction WritableStreamDefaultControllerGetChunkSize<W>(controller: WritableStreamDefaultController<W>,\n                                                        chunk: W): number {\n  try {\n    return controller._strategySizeAlgorithm(chunk);\n  } catch (chunkSizeE) {\n    WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);\n    return 1;\n  }\n}\n\nfunction WritableStreamDefaultControllerGetDesiredSize(controller: WritableStreamDefaultController<any>): number {\n  return controller._strategyHWM - controller._queueTotalSize;\n}\n\nfunction WritableStreamDefaultControllerWrite<W>(controller: WritableStreamDefaultController<W>,\n                                                 chunk: W,\n                                                 chunkSize: number) {\n  try {\n    EnqueueValueWithSize(controller, chunk, chunkSize);\n  } catch (enqueueE) {\n    WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);\n    return;\n  }\n\n  const stream = controller._controlledWritableStream;\n  if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._state === 'writable') {\n    const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);\n    WritableStreamUpdateBackpressure(stream, backpressure);\n  }\n\n  WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);\n}\n\n// Abstract operations for the WritableStreamDefaultController.\n\nfunction WritableStreamDefaultControllerAdvanceQueueIfNeeded<W>(controller: WritableStreamDefaultController<W>) {\n  const stream = controller._controlledWritableStream;\n\n  if (!controller._started) {\n    return;\n  }\n\n  if (stream._inFlightWriteRequest !== undefined) {\n    return;\n  }\n\n  const state = stream._state;\n  assert(state !== 'closed' && state !== 'errored');\n  if (state === 'erroring') {\n    WritableStreamFinishErroring(stream);\n    return;\n  }\n\n  if (controller._queue.length === 0) {\n    return;\n  }\n\n  const value = PeekQueueValue(controller);\n  if (value === closeSentinel) {\n    WritableStreamDefaultControllerProcessClose(controller);\n  } else {\n    WritableStreamDefaultControllerProcessWrite(controller, value);\n  }\n}\n\nfunction WritableStreamDefaultControllerErrorIfNeeded(controller: WritableStreamDefaultController<any>, error: any) {\n  if (controller._controlledWritableStream._state === 'writable') {\n    WritableStreamDefaultControllerError(controller, error);\n  }\n}\n\nfunction WritableStreamDefaultControllerProcessClose(controller: WritableStreamDefaultController<any>) {\n  const stream = controller._controlledWritableStream;\n\n  WritableStreamMarkCloseRequestInFlight(stream);\n\n  DequeueValue(controller);\n  assert(controller._queue.length === 0);\n\n  const sinkClosePromise = controller._closeAlgorithm();\n  WritableStreamDefaultControllerClearAlgorithms(controller);\n  uponPromise(\n    sinkClosePromise,\n    () => {\n      WritableStreamFinishInFlightClose(stream);\n    },\n    reason => {\n      WritableStreamFinishInFlightCloseWithError(stream, reason);\n    }\n  );\n}\n\nfunction WritableStreamDefaultControllerProcessWrite<W>(controller: WritableStreamDefaultController<W>, chunk: W) {\n  const stream = controller._controlledWritableStream;\n\n  WritableStreamMarkFirstWriteRequestInFlight(stream);\n\n  const sinkWritePromise = controller._writeAlgorithm(chunk);\n  uponPromise(\n    sinkWritePromise,\n    () => {\n      WritableStreamFinishInFlightWrite(stream);\n\n      const state = stream._state;\n      assert(state === 'writable' || state === 'erroring');\n\n      DequeueValue(controller);\n\n      if (!WritableStreamCloseQueuedOrInFlight(stream) && state === 'writable') {\n        const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);\n        WritableStreamUpdateBackpressure(stream, backpressure);\n      }\n\n      WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);\n    },\n    reason => {\n      if (stream._state === 'writable') {\n        WritableStreamDefaultControllerClearAlgorithms(controller);\n      }\n      WritableStreamFinishInFlightWriteWithError(stream, reason);\n    }\n  );\n}\n\nfunction WritableStreamDefaultControllerGetBackpressure(controller: WritableStreamDefaultController<any>): boolean {\n  const desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);\n  return desiredSize <= 0;\n}\n\n// A client of WritableStreamDefaultController may use these functions directly to bypass state check.\n\nfunction WritableStreamDefaultControllerError(controller: WritableStreamDefaultController<any>, error: any) {\n  const stream = controller._controlledWritableStream;\n\n  assert(stream._state === 'writable');\n\n  WritableStreamDefaultControllerClearAlgorithms(controller);\n  WritableStreamStartErroring(stream, error);\n}\n\n// Helper functions for the WritableStream.\n\nfunction streamBrandCheckException(name: string): TypeError {\n  return new TypeError(`WritableStream.prototype.${name} can only be used on a WritableStream`);\n}\n\n// Helper functions for the WritableStreamDefaultController.\n\nfunction defaultControllerBrandCheckException(name: string): TypeError {\n  return new TypeError(\n    `WritableStreamDefaultController.prototype.${name} can only be used on a WritableStreamDefaultController`);\n}\n\n\n// Helper functions for the WritableStreamDefaultWriter.\n\nfunction defaultWriterBrandCheckException(name: string): TypeError {\n  return new TypeError(\n    `WritableStreamDefaultWriter.prototype.${name} can only be used on a WritableStreamDefaultWriter`);\n}\n\nfunction defaultWriterLockException(name: string): TypeError {\n  return new TypeError('Cannot ' + name + ' a stream using a released writer');\n}\n\nfunction defaultWriterClosedPromiseInitialize(writer: WritableStreamDefaultWriter) {\n  writer._closedPromise = newPromise((resolve, reject) => {\n    writer._closedPromise_resolve = resolve;\n    writer._closedPromise_reject = reject;\n    writer._closedPromiseState = 'pending';\n  });\n}\n\nfunction defaultWriterClosedPromiseInitializeAsRejected(writer: WritableStreamDefaultWriter, reason: any) {\n  defaultWriterClosedPromiseInitialize(writer);\n  defaultWriterClosedPromiseReject(writer, reason);\n}\n\nfunction defaultWriterClosedPromiseInitializeAsResolved(writer: WritableStreamDefaultWriter) {\n  defaultWriterClosedPromiseInitialize(writer);\n  defaultWriterClosedPromiseResolve(writer);\n}\n\nfunction defaultWriterClosedPromiseReject(writer: WritableStreamDefaultWriter, reason: any) {\n  if (writer._closedPromise_reject === undefined) {\n    return;\n  }\n  assert(writer._closedPromiseState === 'pending');\n\n  setPromiseIsHandledToTrue(writer._closedPromise);\n  writer._closedPromise_reject(reason);\n  writer._closedPromise_resolve = undefined;\n  writer._closedPromise_reject = undefined;\n  writer._closedPromiseState = 'rejected';\n}\n\nfunction defaultWriterClosedPromiseResetToRejected(writer: WritableStreamDefaultWriter, reason: any) {\n  assert(writer._closedPromise_resolve === undefined);\n  assert(writer._closedPromise_reject === undefined);\n  assert(writer._closedPromiseState !== 'pending');\n\n  defaultWriterClosedPromiseInitializeAsRejected(writer, reason);\n}\n\nfunction defaultWriterClosedPromiseResolve(writer: WritableStreamDefaultWriter) {\n  if (writer._closedPromise_resolve === undefined) {\n    return;\n  }\n  assert(writer._closedPromiseState === 'pending');\n\n  writer._closedPromise_resolve(undefined);\n  writer._closedPromise_resolve = undefined;\n  writer._closedPromise_reject = undefined;\n  writer._closedPromiseState = 'resolved';\n}\n\nfunction defaultWriterReadyPromiseInitialize(writer: WritableStreamDefaultWriter) {\n  writer._readyPromise = newPromise((resolve, reject) => {\n    writer._readyPromise_resolve = resolve;\n    writer._readyPromise_reject = reject;\n  });\n  writer._readyPromiseState = 'pending';\n}\n\nfunction defaultWriterReadyPromiseInitializeAsRejected(writer: WritableStreamDefaultWriter, reason: any) {\n  defaultWriterReadyPromiseInitialize(writer);\n  defaultWriterReadyPromiseReject(writer, reason);\n}\n\nfunction defaultWriterReadyPromiseInitializeAsResolved(writer: WritableStreamDefaultWriter) {\n  defaultWriterReadyPromiseInitialize(writer);\n  defaultWriterReadyPromiseResolve(writer);\n}\n\nfunction defaultWriterReadyPromiseReject(writer: WritableStreamDefaultWriter, reason: any) {\n  if (writer._readyPromise_reject === undefined) {\n    return;\n  }\n\n  setPromiseIsHandledToTrue(writer._readyPromise);\n  writer._readyPromise_reject(reason);\n  writer._readyPromise_resolve = undefined;\n  writer._readyPromise_reject = undefined;\n  writer._readyPromiseState = 'rejected';\n}\n\nfunction defaultWriterReadyPromiseReset(writer: WritableStreamDefaultWriter) {\n  assert(writer._readyPromise_resolve === undefined);\n  assert(writer._readyPromise_reject === undefined);\n\n  defaultWriterReadyPromiseInitialize(writer);\n}\n\nfunction defaultWriterReadyPromiseResetToRejected(writer: WritableStreamDefaultWriter, reason: any) {\n  assert(writer._readyPromise_resolve === undefined);\n  assert(writer._readyPromise_reject === undefined);\n\n  defaultWriterReadyPromiseInitializeAsRejected(writer, reason);\n}\n\nfunction defaultWriterReadyPromiseResolve(writer: WritableStreamDefaultWriter) {\n  if (writer._readyPromise_resolve === undefined) {\n    return;\n  }\n\n  writer._readyPromise_resolve(undefined);\n  writer._readyPromise_resolve = undefined;\n  writer._readyPromise_reject = undefined;\n  writer._readyPromiseState = 'fulfilled';\n}\n","/// <reference lib=\"dom\" />\nexport const NativeDOMException: typeof DOMException | undefined =\n  typeof DOMException !== 'undefined' ? DOMException : undefined;\n","/// <reference types=\"node\" />\nimport { NativeDOMException } from './native';\n\ndeclare class DOMExceptionClass extends Error {\n  constructor(message?: string, name?: string);\n\n  name: string;\n  message: string;\n}\n\ntype DOMException = DOMExceptionClass;\ntype DOMExceptionConstructor = typeof DOMExceptionClass;\n\nfunction isDOMExceptionConstructor(ctor: unknown): ctor is DOMExceptionConstructor {\n  if (!(typeof ctor === 'function' || typeof ctor === 'object')) {\n    return false;\n  }\n  try {\n    new (ctor as DOMExceptionConstructor)();\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nfunction createDOMExceptionPolyfill(): DOMExceptionConstructor {\n  // eslint-disable-next-line no-shadow\n  const ctor = function DOMException(this: DOMException, message?: string, name?: string) {\n    this.message = message || '';\n    this.name = name || 'Error';\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor);\n    }\n  } as any;\n  ctor.prototype = Object.create(Error.prototype);\n  Object.defineProperty(ctor.prototype, 'constructor', { value: ctor, writable: true, configurable: true });\n  return ctor;\n}\n\n// eslint-disable-next-line no-redeclare\nconst DOMException: DOMExceptionConstructor =\n  isDOMExceptionConstructor(NativeDOMException) ? NativeDOMException : createDOMExceptionPolyfill();\n\nexport { DOMException };\n","import { IsReadableStream, IsReadableStreamLocked, ReadableStream, ReadableStreamCancel } from '../readable-stream';\nimport { AcquireReadableStreamDefaultReader, ReadableStreamDefaultReaderRead } from './default-reader';\nimport { ReadableStreamReaderGenericRelease } from './generic-reader';\nimport {\n  AcquireWritableStreamDefaultWriter,\n  IsWritableStream,\n  IsWritableStreamLocked,\n  WritableStream,\n  WritableStreamAbort,\n  WritableStreamCloseQueuedOrInFlight,\n  WritableStreamDefaultWriterCloseWithErrorPropagation,\n  WritableStreamDefaultWriterRelease,\n  WritableStreamDefaultWriterWrite\n} from '../writable-stream';\nimport assert from '../../stub/assert';\nimport {\n  newPromise,\n  PerformPromiseThen,\n  promiseResolvedWith,\n  setPromiseIsHandledToTrue,\n  uponFulfillment,\n  uponPromise,\n  uponRejection\n} from '../helpers/webidl';\nimport { noop } from '../../utils';\nimport { AbortSignal, isAbortSignal } from '../abort-signal';\nimport { DOMException } from '../../stub/dom-exception';\n\nexport function ReadableStreamPipeTo<T>(source: ReadableStream<T>,\n                                        dest: WritableStream<T>,\n                                        preventClose: boolean,\n                                        preventAbort: boolean,\n                                        preventCancel: boolean,\n                                        signal: AbortSignal | undefined): Promise<undefined> {\n  assert(IsReadableStream(source));\n  assert(IsWritableStream(dest));\n  assert(typeof preventClose === 'boolean');\n  assert(typeof preventAbort === 'boolean');\n  assert(typeof preventCancel === 'boolean');\n  assert(signal === undefined || isAbortSignal(signal));\n  assert(!IsReadableStreamLocked(source));\n  assert(!IsWritableStreamLocked(dest));\n\n  const reader = AcquireReadableStreamDefaultReader<T>(source);\n  const writer = AcquireWritableStreamDefaultWriter<T>(dest);\n\n  source._disturbed = true;\n\n  let shuttingDown = false;\n\n  // This is used to keep track of the spec's requirement that we wait for ongoing writes during shutdown.\n  let currentWrite = promiseResolvedWith<void>(undefined);\n\n  return newPromise((resolve, reject) => {\n    let abortAlgorithm: () => void;\n    if (signal !== undefined) {\n      abortAlgorithm = () => {\n        const error = new DOMException('Aborted', 'AbortError');\n        const actions: Array<() => Promise<void>> = [];\n        if (!preventAbort) {\n          actions.push(() => {\n            if (dest._state === 'writable') {\n              return WritableStreamAbort(dest, error);\n            }\n            return promiseResolvedWith(undefined);\n          });\n        }\n        if (!preventCancel) {\n          actions.push(() => {\n            if (source._state === 'readable') {\n              return ReadableStreamCancel(source, error);\n            }\n            return promiseResolvedWith(undefined);\n          });\n        }\n        shutdownWithAction(() => Promise.all(actions.map(action => action())), true, error);\n      };\n\n      if (signal.aborted) {\n        abortAlgorithm();\n        return;\n      }\n\n      signal.addEventListener('abort', abortAlgorithm);\n    }\n\n    // Using reader and writer, read all chunks from this and write them to dest\n    // - Backpressure must be enforced\n    // - Shutdown must stop all activity\n    function pipeLoop() {\n      return newPromise<void>((resolveLoop, rejectLoop) => {\n        function next(done: boolean) {\n          if (done) {\n            resolveLoop();\n          } else {\n            // Use `PerformPromiseThen` instead of `uponPromise` to avoid\n            // adding unnecessary `.catch(rethrowAssertionErrorRejection)` handlers\n            PerformPromiseThen(pipeStep(), next, rejectLoop);\n          }\n        }\n\n        next(false);\n      });\n    }\n\n    function pipeStep(): Promise<boolean> {\n      if (shuttingDown) {\n        return promiseResolvedWith(true);\n      }\n\n      return PerformPromiseThen(writer._readyPromise, () => {\n        return newPromise<boolean>((resolveRead, rejectRead) => {\n          ReadableStreamDefaultReaderRead(\n            reader,\n            {\n              _chunkSteps: chunk => {\n                currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, chunk), undefined, noop);\n                resolveRead(false);\n              },\n              _closeSteps: () => resolveRead(true),\n              _errorSteps: rejectRead\n            }\n          );\n        });\n      });\n    }\n\n    // Errors must be propagated forward\n    isOrBecomesErrored(source, reader._closedPromise, storedError => {\n      if (!preventAbort) {\n        shutdownWithAction(() => WritableStreamAbort(dest, storedError), true, storedError);\n      } else {\n        shutdown(true, storedError);\n      }\n    });\n\n    // Errors must be propagated backward\n    isOrBecomesErrored(dest, writer._closedPromise, storedError => {\n      if (!preventCancel) {\n        shutdownWithAction(() => ReadableStreamCancel(source, storedError), true, storedError);\n      } else {\n        shutdown(true, storedError);\n      }\n    });\n\n    // Closing must be propagated forward\n    isOrBecomesClosed(source, reader._closedPromise, () => {\n      if (!preventClose) {\n        shutdownWithAction(() => WritableStreamDefaultWriterCloseWithErrorPropagation(writer));\n      } else {\n        shutdown();\n      }\n    });\n\n    // Closing must be propagated backward\n    if (WritableStreamCloseQueuedOrInFlight(dest) || dest._state === 'closed') {\n      const destClosed = new TypeError('the destination writable stream closed before all data could be piped to it');\n\n      if (!preventCancel) {\n        shutdownWithAction(() => ReadableStreamCancel(source, destClosed), true, destClosed);\n      } else {\n        shutdown(true, destClosed);\n      }\n    }\n\n    setPromiseIsHandledToTrue(pipeLoop());\n\n    function waitForWritesToFinish(): Promise<void> {\n      // Another write may have started while we were waiting on this currentWrite, so we have to be sure to wait\n      // for that too.\n      const oldCurrentWrite = currentWrite;\n      return PerformPromiseThen(\n        currentWrite,\n        () => oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : undefined\n      );\n    }\n\n    function isOrBecomesErrored(stream: ReadableStream | WritableStream,\n                                promise: Promise<void>,\n                                action: (reason: any) => void) {\n      if (stream._state === 'errored') {\n        action(stream._storedError);\n      } else {\n        uponRejection(promise, action);\n      }\n    }\n\n    function isOrBecomesClosed(stream: ReadableStream | WritableStream, promise: Promise<void>, action: () => void) {\n      if (stream._state === 'closed') {\n        action();\n      } else {\n        uponFulfillment(promise, action);\n      }\n    }\n\n    function shutdownWithAction(action: () => Promise<unknown>, originalIsError?: boolean, originalError?: any) {\n      if (shuttingDown) {\n        return;\n      }\n      shuttingDown = true;\n\n      if (dest._state === 'writable' && !WritableStreamCloseQueuedOrInFlight(dest)) {\n        uponFulfillment(waitForWritesToFinish(), doTheRest);\n      } else {\n        doTheRest();\n      }\n\n      function doTheRest() {\n        uponPromise(\n          action(),\n          () => finalize(originalIsError, originalError),\n          newError => finalize(true, newError)\n        );\n      }\n    }\n\n    function shutdown(isError?: boolean, error?: any) {\n      if (shuttingDown) {\n        return;\n      }\n      shuttingDown = true;\n\n      if (dest._state === 'writable' && !WritableStreamCloseQueuedOrInFlight(dest)) {\n        uponFulfillment(waitForWritesToFinish(), () => finalize(isError, error));\n      } else {\n        finalize(isError, error);\n      }\n    }\n\n    function finalize(isError?: boolean, error?: any) {\n      WritableStreamDefaultWriterRelease(writer);\n      ReadableStreamReaderGenericRelease(reader);\n\n      if (signal !== undefined) {\n        signal.removeEventListener('abort', abortAlgorithm);\n      }\n      if (isError) {\n        reject(error);\n      } else {\n        resolve(undefined);\n      }\n    }\n  });\n}\n","import { QueuingStrategySizeCallback } from '../queuing-strategy';\nimport assert from '../../stub/assert';\nimport { DequeueValue, EnqueueValueWithSize, QueuePair, ResetQueue } from '../abstract-ops/queue-with-sizes';\nimport {\n  ReadableStreamAddReadRequest,\n  ReadableStreamFulfillReadRequest,\n  ReadableStreamGetNumReadRequests,\n  ReadRequest\n} from './default-reader';\nimport { SimpleQueue } from '../simple-queue';\nimport { IsReadableStreamLocked, ReadableStream, ReadableStreamClose, ReadableStreamError } from '../readable-stream';\nimport { ValidatedUnderlyingSource } from './underlying-source';\nimport { typeIsObject } from '../helpers/miscellaneous';\nimport { CancelSteps, PullSteps } from '../abstract-ops/internal-methods';\nimport { promiseResolvedWith, uponPromise } from '../helpers/webidl';\n\n/**\n * Allows control of a {@link ReadableStream | readable stream}'s state and internal queue.\n *\n * @public\n */\nexport class ReadableStreamDefaultController<R> {\n  /** @internal */\n  _controlledReadableStream!: ReadableStream<R>;\n  /** @internal */\n  _queue!: SimpleQueue<QueuePair<R>>;\n  /** @internal */\n  _queueTotalSize!: number;\n  /** @internal */\n  _started!: boolean;\n  /** @internal */\n  _closeRequested!: boolean;\n  /** @internal */\n  _pullAgain!: boolean;\n  /** @internal */\n  _pulling !: boolean;\n  /** @internal */\n  _strategySizeAlgorithm!: QueuingStrategySizeCallback<R>;\n  /** @internal */\n  _strategyHWM!: number;\n  /** @internal */\n  _pullAlgorithm!: () => Promise<void>;\n  /** @internal */\n  _cancelAlgorithm!: (reason: any) => Promise<void>;\n\n  private constructor() {\n    throw new TypeError('Illegal constructor');\n  }\n\n  /**\n   * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is\n   * over-full. An underlying source ought to use this information to determine when and how to apply backpressure.\n   */\n  get desiredSize(): number | null {\n    if (!IsReadableStreamDefaultController(this)) {\n      throw defaultControllerBrandCheckException('desiredSize');\n    }\n\n    return ReadableStreamDefaultControllerGetDesiredSize(this);\n  }\n\n  /**\n   * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from\n   * the stream, but once those are read, the stream will become closed.\n   */\n  close(): void {\n    if (!IsReadableStreamDefaultController(this)) {\n      throw defaultControllerBrandCheckException('close');\n    }\n\n    if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {\n      throw new TypeError('The stream is not in a state that permits close');\n    }\n\n    ReadableStreamDefaultControllerClose(this);\n  }\n\n  /**\n   * Enqueues the given chunk `chunk` in the controlled readable stream.\n   */\n  enqueue(chunk: R): void;\n  enqueue(chunk: R = undefined!): void {\n    if (!IsReadableStreamDefaultController(this)) {\n      throw defaultControllerBrandCheckException('enqueue');\n    }\n\n    if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {\n      throw new TypeError('The stream is not in a state that permits enqueue');\n    }\n\n    return ReadableStreamDefaultControllerEnqueue(this, chunk);\n  }\n\n  /**\n   * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.\n   */\n  error(e: any = undefined): void {\n    if (!IsReadableStreamDefaultController(this)) {\n      throw defaultControllerBrandCheckException('error');\n    }\n\n    ReadableStreamDefaultControllerError(this, e);\n  }\n\n  /** @internal */\n  [CancelSteps](reason: any): Promise<void> {\n    ResetQueue(this);\n    const result = this._cancelAlgorithm(reason);\n    ReadableStreamDefaultControllerClearAlgorithms(this);\n    return result;\n  }\n\n  /** @internal */\n  [PullSteps](readRequest: ReadRequest<R>): void {\n    const stream = this._controlledReadableStream;\n\n    if (this._queue.length > 0) {\n      const chunk = DequeueValue(this);\n\n      if (this._closeRequested && this._queue.length === 0) {\n        ReadableStreamDefaultControllerClearAlgorithms(this);\n        ReadableStreamClose(stream);\n      } else {\n        ReadableStreamDefaultControllerCallPullIfNeeded(this);\n      }\n\n      readRequest._chunkSteps(chunk);\n    } else {\n      ReadableStreamAddReadRequest(stream, readRequest);\n      ReadableStreamDefaultControllerCallPullIfNeeded(this);\n    }\n  }\n}\n\nObject.defineProperties(ReadableStreamDefaultController.prototype, {\n  close: { enumerable: true },\n  enqueue: { enumerable: true },\n  error: { enumerable: true },\n  desiredSize: { enumerable: true }\n});\nif (typeof Symbol.toStringTag === 'symbol') {\n  Object.defineProperty(ReadableStreamDefaultController.prototype, Symbol.toStringTag, {\n    value: 'ReadableStreamDefaultController',\n    configurable: true\n  });\n}\n\n// Abstract operations for the ReadableStreamDefaultController.\n\nfunction IsReadableStreamDefaultController<R = any>(x: any): x is ReadableStreamDefaultController<R> {\n  if (!typeIsObject(x)) {\n    return false;\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableStream')) {\n    return false;\n  }\n\n  return x instanceof ReadableStreamDefaultController;\n}\n\nfunction ReadableStreamDefaultControllerCallPullIfNeeded(controller: ReadableStreamDefaultController<any>): void {\n  const shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);\n  if (!shouldPull) {\n    return;\n  }\n\n  if (controller._pulling) {\n    controller._pullAgain = true;\n    return;\n  }\n\n  assert(!controller._pullAgain);\n\n  controller._pulling = true;\n\n  const pullPromise = controller._pullAlgorithm();\n  uponPromise(\n    pullPromise,\n    () => {\n      controller._pulling = false;\n\n      if (controller._pullAgain) {\n        controller._pullAgain = false;\n        ReadableStreamDefaultControllerCallPullIfNeeded(controller);\n      }\n    },\n    e => {\n      ReadableStreamDefaultControllerError(controller, e);\n    }\n  );\n}\n\nfunction ReadableStreamDefaultControllerShouldCallPull(controller: ReadableStreamDefaultController<any>): boolean {\n  const stream = controller._controlledReadableStream;\n\n  if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {\n    return false;\n  }\n\n  if (!controller._started) {\n    return false;\n  }\n\n  if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {\n    return true;\n  }\n\n  const desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);\n  assert(desiredSize !== null);\n  if (desiredSize! > 0) {\n    return true;\n  }\n\n  return false;\n}\n\nfunction ReadableStreamDefaultControllerClearAlgorithms(controller: ReadableStreamDefaultController<any>) {\n  controller._pullAlgorithm = undefined!;\n  controller._cancelAlgorithm = undefined!;\n  controller._strategySizeAlgorithm = undefined!;\n}\n\n// A client of ReadableStreamDefaultController may use these functions directly to bypass state check.\n\nexport function ReadableStreamDefaultControllerClose(controller: ReadableStreamDefaultController<any>) {\n  if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {\n    return;\n  }\n\n  const stream = controller._controlledReadableStream;\n\n  controller._closeRequested = true;\n\n  if (controller._queue.length === 0) {\n    ReadableStreamDefaultControllerClearAlgorithms(controller);\n    ReadableStreamClose(stream);\n  }\n}\n\nexport function ReadableStreamDefaultControllerEnqueue<R>(\n  controller: ReadableStreamDefaultController<R>,\n  chunk: R\n): void {\n  if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {\n    return;\n  }\n\n  const stream = controller._controlledReadableStream;\n\n  if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {\n    ReadableStreamFulfillReadRequest(stream, chunk, false);\n  } else {\n    let chunkSize;\n    try {\n      chunkSize = controller._strategySizeAlgorithm(chunk);\n    } catch (chunkSizeE) {\n      ReadableStreamDefaultControllerError(controller, chunkSizeE);\n      throw chunkSizeE;\n    }\n\n    try {\n      EnqueueValueWithSize(controller, chunk, chunkSize);\n    } catch (enqueueE) {\n      ReadableStreamDefaultControllerError(controller, enqueueE);\n      throw enqueueE;\n    }\n  }\n\n  ReadableStreamDefaultControllerCallPullIfNeeded(controller);\n}\n\nexport function ReadableStreamDefaultControllerError(controller: ReadableStreamDefaultController<any>, e: any) {\n  const stream = controller._controlledReadableStream;\n\n  if (stream._state !== 'readable') {\n    return;\n  }\n\n  ResetQueue(controller);\n\n  ReadableStreamDefaultControllerClearAlgorithms(controller);\n  ReadableStreamError(stream, e);\n}\n\nexport function ReadableStreamDefaultControllerGetDesiredSize(\n  controller: ReadableStreamDefaultController<any>\n): number | null {\n  const state = controller._controlledReadableStream._state;\n\n  if (state === 'errored') {\n    return null;\n  }\n  if (state === 'closed') {\n    return 0;\n  }\n\n  return controller._strategyHWM - controller._queueTotalSize;\n}\n\n// This is used in the implementation of TransformStream.\nexport function ReadableStreamDefaultControllerHasBackpressure(\n  controller: ReadableStreamDefaultController<any>\n): boolean {\n  if (ReadableStreamDefaultControllerShouldCallPull(controller)) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function ReadableStreamDefaultControllerCanCloseOrEnqueue(\n  controller: ReadableStreamDefaultController<any>\n): boolean {\n  const state = controller._controlledReadableStream._state;\n\n  if (!controller._closeRequested && state === 'readable') {\n    return true;\n  }\n\n  return false;\n}\n\nexport function SetUpReadableStreamDefaultController<R>(stream: ReadableStream<R>,\n                                                        controller: ReadableStreamDefaultController<R>,\n                                                        startAlgorithm: () => void | PromiseLike<void>,\n                                                        pullAlgorithm: () => Promise<void>,\n                                                        cancelAlgorithm: (reason: any) => Promise<void>,\n                                                        highWaterMark: number,\n                                                        sizeAlgorithm: QueuingStrategySizeCallback<R>) {\n  assert(stream._readableStreamController === undefined);\n\n  controller._controlledReadableStream = stream;\n\n  controller._queue = undefined!;\n  controller._queueTotalSize = undefined!;\n  ResetQueue(controller);\n\n  controller._started = false;\n  controller._closeRequested = false;\n  controller._pullAgain = false;\n  controller._pulling = false;\n\n  controller._strategySizeAlgorithm = sizeAlgorithm;\n  controller._strategyHWM = highWaterMark;\n\n  controller._pullAlgorithm = pullAlgorithm;\n  controller._cancelAlgorithm = cancelAlgorithm;\n\n  stream._readableStreamController = controller;\n\n  const startResult = startAlgorithm();\n  uponPromise(\n    promiseResolvedWith(startResult),\n    () => {\n      controller._started = true;\n\n      assert(!controller._pulling);\n      assert(!controller._pullAgain);\n\n      ReadableStreamDefaultControllerCallPullIfNeeded(controller);\n    },\n    r => {\n      ReadableStreamDefaultControllerError(controller, r);\n    }\n  );\n}\n\nexport function SetUpReadableStreamDefaultControllerFromUnderlyingSource<R>(\n  stream: ReadableStream<R>,\n  underlyingSource: ValidatedUnderlyingSource<R>,\n  highWaterMark: number,\n  sizeAlgorithm: QueuingStrategySizeCallback<R>\n) {\n  const controller: ReadableStreamDefaultController<R> = Object.create(ReadableStreamDefaultController.prototype);\n\n  let startAlgorithm: () => void | PromiseLike<void> = () => undefined;\n  let pullAlgorithm: () => Promise<void> = () => promiseResolvedWith(undefined);\n  let cancelAlgorithm: (reason: any) => Promise<void> = () => promiseResolvedWith(undefined);\n\n  if (underlyingSource.start !== undefined) {\n    startAlgorithm = () => underlyingSource.start!(controller);\n  }\n  if (underlyingSource.pull !== undefined) {\n    pullAlgorithm = () => underlyingSource.pull!(controller);\n  }\n  if (underlyingSource.cancel !== undefined) {\n    cancelAlgorithm = reason => underlyingSource.cancel!(reason);\n  }\n\n  SetUpReadableStreamDefaultController(\n    stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm\n  );\n}\n\n// Helper functions for the ReadableStreamDefaultController.\n\nfunction defaultControllerBrandCheckException(name: string): TypeError {\n  return new TypeError(\n    `ReadableStreamDefaultController.prototype.${name} can only be used on a ReadableStreamDefaultController`);\n}\n","import {\n  CreateReadableByteStream,\n  CreateReadableStream,\n  IsReadableStream,\n  ReadableByteStream,\n  ReadableStream,\n  ReadableStreamCancel,\n  ReadableStreamReader\n} from '../readable-stream';\nimport { ReadableStreamReaderGenericRelease } from './generic-reader';\nimport {\n  AcquireReadableStreamDefaultReader,\n  IsReadableStreamDefaultReader,\n  ReadableStreamDefaultReaderRead,\n  ReadRequest\n} from './default-reader';\nimport {\n  AcquireReadableStreamBYOBReader,\n  IsReadableStreamBYOBReader,\n  ReadableStreamBYOBReaderRead,\n  ReadIntoRequest\n} from './byob-reader';\nimport assert from '../../stub/assert';\nimport { newPromise, promiseResolvedWith, queueMicrotask, uponRejection } from '../helpers/webidl';\nimport {\n  ReadableStreamDefaultController,\n  ReadableStreamDefaultControllerClose,\n  ReadableStreamDefaultControllerEnqueue,\n  ReadableStreamDefaultControllerError\n} from './default-controller';\nimport {\n  IsReadableByteStreamController,\n  ReadableByteStreamControllerClose,\n  ReadableByteStreamControllerEnqueue,\n  ReadableByteStreamControllerError,\n  ReadableByteStreamControllerGetBYOBRequest,\n  ReadableByteStreamControllerRespond,\n  ReadableByteStreamControllerRespondWithNewView\n} from './byte-stream-controller';\nimport { CreateArrayFromList } from '../abstract-ops/ecmascript';\nimport { CloneAsUint8Array } from '../abstract-ops/miscellaneous';\n\nexport function ReadableStreamTee<R>(stream: ReadableStream<R>,\n                                     cloneForBranch2: boolean): [ReadableStream<R>, ReadableStream<R>] {\n  assert(IsReadableStream(stream));\n  assert(typeof cloneForBranch2 === 'boolean');\n  if (IsReadableByteStreamController(stream._readableStreamController)) {\n    return ReadableByteStreamTee(stream as unknown as ReadableByteStream) as\n      unknown as [ReadableStream<R>, ReadableStream<R>];\n  }\n  return ReadableStreamDefaultTee(stream, cloneForBranch2);\n}\n\nexport function ReadableStreamDefaultTee<R>(stream: ReadableStream<R>,\n                                            cloneForBranch2: boolean): [ReadableStream<R>, ReadableStream<R>] {\n  assert(IsReadableStream(stream));\n  assert(typeof cloneForBranch2 === 'boolean');\n\n  const reader = AcquireReadableStreamDefaultReader<R>(stream);\n\n  let reading = false;\n  let readAgain = false;\n  let canceled1 = false;\n  let canceled2 = false;\n  let reason1: any;\n  let reason2: any;\n  let branch1: ReadableStream<R>;\n  let branch2: ReadableStream<R>;\n\n  let resolveCancelPromise: (value: undefined | Promise<undefined>) => void;\n  const cancelPromise = newPromise<undefined>(resolve => {\n    resolveCancelPromise = resolve;\n  });\n\n  function pullAlgorithm(): Promise<void> {\n    if (reading) {\n      readAgain = true;\n      return promiseResolvedWith(undefined);\n    }\n\n    reading = true;\n\n    const readRequest: ReadRequest<R> = {\n      _chunkSteps: chunk => {\n        // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using\n        // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let\n        // successful synchronously-available reads get ahead of asynchronously-available errors.\n        queueMicrotask(() => {\n          readAgain = false;\n          const chunk1 = chunk;\n          const chunk2 = chunk;\n\n          // There is no way to access the cloning code right now in the reference implementation.\n          // If we add one then we'll need an implementation for serializable objects.\n          // if (!canceled2 && cloneForBranch2) {\n          //   chunk2 = StructuredDeserialize(StructuredSerialize(chunk2));\n          // }\n\n          if (!canceled1) {\n            ReadableStreamDefaultControllerEnqueue(\n              branch1._readableStreamController as ReadableStreamDefaultController<R>,\n              chunk1\n            );\n          }\n          if (!canceled2) {\n            ReadableStreamDefaultControllerEnqueue(\n              branch2._readableStreamController as ReadableStreamDefaultController<R>,\n              chunk2\n            );\n          }\n\n          reading = false;\n          if (readAgain) {\n            pullAlgorithm();\n          }\n        });\n      },\n      _closeSteps: () => {\n        reading = false;\n        if (!canceled1) {\n          ReadableStreamDefaultControllerClose(branch1._readableStreamController as ReadableStreamDefaultController<R>);\n        }\n        if (!canceled2) {\n          ReadableStreamDefaultControllerClose(branch2._readableStreamController as ReadableStreamDefaultController<R>);\n        }\n\n        if (!canceled1 || !canceled2) {\n          resolveCancelPromise(undefined);\n        }\n      },\n      _errorSteps: () => {\n        reading = false;\n      }\n    };\n    ReadableStreamDefaultReaderRead(reader, readRequest);\n\n    return promiseResolvedWith(undefined);\n  }\n\n  function cancel1Algorithm(reason: any): Promise<void> {\n    canceled1 = true;\n    reason1 = reason;\n    if (canceled2) {\n      const compositeReason = CreateArrayFromList([reason1, reason2]);\n      const cancelResult = ReadableStreamCancel(stream, compositeReason);\n      resolveCancelPromise(cancelResult);\n    }\n    return cancelPromise;\n  }\n\n  function cancel2Algorithm(reason: any): Promise<void> {\n    canceled2 = true;\n    reason2 = reason;\n    if (canceled1) {\n      const compositeReason = CreateArrayFromList([reason1, reason2]);\n      const cancelResult = ReadableStreamCancel(stream, compositeReason);\n      resolveCancelPromise(cancelResult);\n    }\n    return cancelPromise;\n  }\n\n  function startAlgorithm() {\n    // do nothing\n  }\n\n  branch1 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm);\n  branch2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm);\n\n  uponRejection(reader._closedPromise, (r: any) => {\n    ReadableStreamDefaultControllerError(branch1._readableStreamController as ReadableStreamDefaultController<R>, r);\n    ReadableStreamDefaultControllerError(branch2._readableStreamController as ReadableStreamDefaultController<R>, r);\n    if (!canceled1 || !canceled2) {\n      resolveCancelPromise(undefined);\n    }\n  });\n\n  return [branch1, branch2];\n}\n\nexport function ReadableByteStreamTee(stream: ReadableByteStream): [ReadableByteStream, ReadableByteStream] {\n  assert(IsReadableStream(stream));\n  assert(IsReadableByteStreamController(stream._readableStreamController));\n\n  let reader: ReadableStreamReader<Uint8Array> = AcquireReadableStreamDefaultReader(stream);\n  let reading = false;\n  let readAgainForBranch1 = false;\n  let readAgainForBranch2 = false;\n  let canceled1 = false;\n  let canceled2 = false;\n  let reason1: any;\n  let reason2: any;\n  let branch1: ReadableByteStream;\n  let branch2: ReadableByteStream;\n\n  let resolveCancelPromise: (value: undefined | Promise<undefined>) => void;\n  const cancelPromise = newPromise<void>(resolve => {\n    resolveCancelPromise = resolve;\n  });\n\n  function forwardReaderError(thisReader: ReadableStreamReader<Uint8Array>) {\n    uponRejection(thisReader._closedPromise, r => {\n      if (thisReader !== reader) {\n        return;\n      }\n      ReadableByteStreamControllerError(branch1._readableStreamController, r);\n      ReadableByteStreamControllerError(branch2._readableStreamController, r);\n      if (!canceled1 || !canceled2) {\n        resolveCancelPromise(undefined);\n      }\n    });\n  }\n\n  function pullWithDefaultReader() {\n    if (IsReadableStreamBYOBReader(reader)) {\n      assert(reader._readIntoRequests.length === 0);\n      ReadableStreamReaderGenericRelease(reader);\n\n      reader = AcquireReadableStreamDefaultReader(stream);\n      forwardReaderError(reader);\n    }\n\n    const readRequest: ReadRequest<Uint8Array> = {\n      _chunkSteps: chunk => {\n        // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using\n        // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let\n        // successful synchronously-available reads get ahead of asynchronously-available errors.\n        queueMicrotask(() => {\n          readAgainForBranch1 = false;\n          readAgainForBranch2 = false;\n\n          const chunk1 = chunk;\n          let chunk2 = chunk;\n          if (!canceled1 && !canceled2) {\n            try {\n              chunk2 = CloneAsUint8Array(chunk);\n            } catch (cloneE) {\n              ReadableByteStreamControllerError(branch1._readableStreamController, cloneE);\n              ReadableByteStreamControllerError(branch2._readableStreamController, cloneE);\n              resolveCancelPromise(ReadableStreamCancel(stream, cloneE));\n              return;\n            }\n          }\n\n          if (!canceled1) {\n            ReadableByteStreamControllerEnqueue(branch1._readableStreamController, chunk1);\n          }\n          if (!canceled2) {\n            ReadableByteStreamControllerEnqueue(branch2._readableStreamController, chunk2);\n          }\n\n          reading = false;\n          if (readAgainForBranch1) {\n            pull1Algorithm();\n          } else if (readAgainForBranch2) {\n            pull2Algorithm();\n          }\n        });\n      },\n      _closeSteps: () => {\n        reading = false;\n        if (!canceled1) {\n          ReadableByteStreamControllerClose(branch1._readableStreamController);\n        }\n        if (!canceled2) {\n          ReadableByteStreamControllerClose(branch2._readableStreamController);\n        }\n        if (branch1._readableStreamController._pendingPullIntos.length > 0) {\n          ReadableByteStreamControllerRespond(branch1._readableStreamController, 0);\n        }\n        if (branch2._readableStreamController._pendingPullIntos.length > 0) {\n          ReadableByteStreamControllerRespond(branch2._readableStreamController, 0);\n        }\n        if (!canceled1 || !canceled2) {\n          resolveCancelPromise(undefined);\n        }\n      },\n      _errorSteps: () => {\n        reading = false;\n      }\n    };\n    ReadableStreamDefaultReaderRead(reader, readRequest);\n  }\n\n  function pullWithBYOBReader(view: ArrayBufferView, forBranch2: boolean) {\n    if (IsReadableStreamDefaultReader<Uint8Array>(reader)) {\n      assert(reader._readRequests.length === 0);\n      ReadableStreamReaderGenericRelease(reader);\n\n      reader = AcquireReadableStreamBYOBReader(stream);\n      forwardReaderError(reader);\n    }\n\n    const byobBranch = forBranch2 ? branch2 : branch1;\n    const otherBranch = forBranch2 ? branch1 : branch2;\n\n    const readIntoRequest: ReadIntoRequest<ArrayBufferView> = {\n      _chunkSteps: chunk => {\n        // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using\n        // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let\n        // successful synchronously-available reads get ahead of asynchronously-available errors.\n        queueMicrotask(() => {\n          readAgainForBranch1 = false;\n          readAgainForBranch2 = false;\n\n          const byobCanceled = forBranch2 ? canceled2 : canceled1;\n          const otherCanceled = forBranch2 ? canceled1 : canceled2;\n\n          if (!otherCanceled) {\n            let clonedChunk;\n            try {\n              clonedChunk = CloneAsUint8Array(chunk);\n            } catch (cloneE) {\n              ReadableByteStreamControllerError(byobBranch._readableStreamController, cloneE);\n              ReadableByteStreamControllerError(otherBranch._readableStreamController, cloneE);\n              resolveCancelPromise(ReadableStreamCancel(stream, cloneE));\n              return;\n            }\n            if (!byobCanceled) {\n              ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);\n            }\n            ReadableByteStreamControllerEnqueue(otherBranch._readableStreamController, clonedChunk);\n          } else if (!byobCanceled) {\n            ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);\n          }\n\n          reading = false;\n          if (readAgainForBranch1) {\n            pull1Algorithm();\n          } else if (readAgainForBranch2) {\n            pull2Algorithm();\n          }\n        });\n      },\n      _closeSteps: chunk => {\n        reading = false;\n\n        const byobCanceled = forBranch2 ? canceled2 : canceled1;\n        const otherCanceled = forBranch2 ? canceled1 : canceled2;\n\n        if (!byobCanceled) {\n          ReadableByteStreamControllerClose(byobBranch._readableStreamController);\n        }\n        if (!otherCanceled) {\n          ReadableByteStreamControllerClose(otherBranch._readableStreamController);\n        }\n\n        if (chunk !== undefined) {\n          assert(chunk.byteLength === 0);\n\n          if (!byobCanceled) {\n            ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);\n          }\n          if (!otherCanceled && otherBranch._readableStreamController._pendingPullIntos.length > 0) {\n            ReadableByteStreamControllerRespond(otherBranch._readableStreamController, 0);\n          }\n        }\n\n        if (!byobCanceled || !otherCanceled) {\n          resolveCancelPromise(undefined);\n        }\n      },\n      _errorSteps: () => {\n        reading = false;\n      }\n    };\n    ReadableStreamBYOBReaderRead(reader, view, readIntoRequest);\n  }\n\n  function pull1Algorithm(): Promise<void> {\n    if (reading) {\n      readAgainForBranch1 = true;\n      return promiseResolvedWith(undefined);\n    }\n\n    reading = true;\n\n    const byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch1._readableStreamController);\n    if (byobRequest === null) {\n      pullWithDefaultReader();\n    } else {\n      pullWithBYOBReader(byobRequest._view!, false);\n    }\n\n    return promiseResolvedWith(undefined);\n  }\n\n  function pull2Algorithm(): Promise<void> {\n    if (reading) {\n      readAgainForBranch2 = true;\n      return promiseResolvedWith(undefined);\n    }\n\n    reading = true;\n\n    const byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch2._readableStreamController);\n    if (byobRequest === null) {\n      pullWithDefaultReader();\n    } else {\n      pullWithBYOBReader(byobRequest._view!, true);\n    }\n\n    return promiseResolvedWith(undefined);\n  }\n\n  function cancel1Algorithm(reason: any): Promise<void> {\n    canceled1 = true;\n    reason1 = reason;\n    if (canceled2) {\n      const compositeReason = CreateArrayFromList([reason1, reason2]);\n      const cancelResult = ReadableStreamCancel(stream, compositeReason);\n      resolveCancelPromise(cancelResult);\n    }\n    return cancelPromise;\n  }\n\n  function cancel2Algorithm(reason: any): Promise<void> {\n    canceled2 = true;\n    reason2 = reason;\n    if (canceled1) {\n      const compositeReason = CreateArrayFromList([reason1, reason2]);\n      const cancelResult = ReadableStreamCancel(stream, compositeReason);\n      resolveCancelPromise(cancelResult);\n    }\n    return cancelPromise;\n  }\n\n  function startAlgorithm(): void {\n    return;\n  }\n\n  branch1 = CreateReadableByteStream(startAlgorithm, pull1Algorithm, cancel1Algorithm);\n  branch2 = CreateReadableByteStream(startAlgorithm, pull2Algorithm, cancel2Algorithm);\n\n  forwardReaderError(reader);\n\n  return [branch1, branch2];\n}\n","import { assertDictionary, assertFunction, convertUnsignedLongLongWithEnforceRange } from './basic';\nimport {\n  ReadableStreamController,\n  UnderlyingByteSource,\n  UnderlyingDefaultOrByteSource,\n  UnderlyingDefaultOrByteSourcePullCallback,\n  UnderlyingDefaultOrByteSourceStartCallback,\n  UnderlyingSource,\n  UnderlyingSourceCancelCallback,\n  ValidatedUnderlyingDefaultOrByteSource\n} from '../readable-stream/underlying-source';\nimport { promiseCall, reflectCall } from '../helpers/webidl';\n\nexport function convertUnderlyingDefaultOrByteSource<R>(\n  source: UnderlyingSource<R> | UnderlyingByteSource | null,\n  context: string\n): ValidatedUnderlyingDefaultOrByteSource<R> {\n  assertDictionary(source, context);\n  const original = source as (UnderlyingDefaultOrByteSource<R> | null);\n  const autoAllocateChunkSize = original?.autoAllocateChunkSize;\n  const cancel = original?.cancel;\n  const pull = original?.pull;\n  const start = original?.start;\n  const type = original?.type;\n  return {\n    autoAllocateChunkSize: autoAllocateChunkSize === undefined ?\n      undefined :\n      convertUnsignedLongLongWithEnforceRange(\n        autoAllocateChunkSize,\n        `${context} has member 'autoAllocateChunkSize' that`\n      ),\n    cancel: cancel === undefined ?\n      undefined :\n      convertUnderlyingSourceCancelCallback(cancel, original!, `${context} has member 'cancel' that`),\n    pull: pull === undefined ?\n      undefined :\n      convertUnderlyingSourcePullCallback(pull, original!, `${context} has member 'pull' that`),\n    start: start === undefined ?\n      undefined :\n      convertUnderlyingSourceStartCallback(start, original!, `${context} has member 'start' that`),\n    type: type === undefined ? undefined : convertReadableStreamType(type, `${context} has member 'type' that`)\n  };\n}\n\nfunction convertUnderlyingSourceCancelCallback(\n  fn: UnderlyingSourceCancelCallback,\n  original: UnderlyingDefaultOrByteSource,\n  context: string\n): (reason: any) => Promise<void> {\n  assertFunction(fn, context);\n  return (reason: any) => promiseCall(fn, original, [reason]);\n}\n\nfunction convertUnderlyingSourcePullCallback<R>(\n  fn: UnderlyingDefaultOrByteSourcePullCallback<R>,\n  original: UnderlyingDefaultOrByteSource<R>,\n  context: string\n): (controller: ReadableStreamController<R>) => Promise<void> {\n  assertFunction(fn, context);\n  return (controller: ReadableStreamController<R>) => promiseCall(fn, original, [controller]);\n}\n\nfunction convertUnderlyingSourceStartCallback<R>(\n  fn: UnderlyingDefaultOrByteSourceStartCallback<R>,\n  original: UnderlyingDefaultOrByteSource<R>,\n  context: string\n): UnderlyingDefaultOrByteSourceStartCallback<R> {\n  assertFunction(fn, context);\n  return (controller: ReadableStreamController<R>) => reflectCall(fn, original, [controller]);\n}\n\nfunction convertReadableStreamType(type: string, context: string): 'bytes' {\n  type = `${type}`;\n  if (type !== 'bytes') {\n    throw new TypeError(`${context} '${type}' is not a valid enumeration value for ReadableStreamType`);\n  }\n  return type;\n}\n","import { assertDictionary } from './basic';\nimport { ReadableStreamGetReaderOptions } from '../readable-stream/reader-options';\n\nexport function convertReaderOptions(options: ReadableStreamGetReaderOptions | null | undefined,\n                                     context: string): ReadableStreamGetReaderOptions {\n  assertDictionary(options, context);\n  const mode = options?.mode;\n  return {\n    mode: mode === undefined ? undefined : convertReadableStreamReaderMode(mode, `${context} has member 'mode' that`)\n  };\n}\n\nfunction convertReadableStreamReaderMode(mode: string, context: string): 'byob' {\n  mode = `${mode}`;\n  if (mode !== 'byob') {\n    throw new TypeError(`${context} '${mode}' is not a valid enumeration value for ReadableStreamReaderMode`);\n  }\n  return mode;\n}\n","import { assertDictionary } from './basic';\nimport {\n  ReadableStreamIteratorOptions,\n  ValidatedReadableStreamIteratorOptions\n} from '../readable-stream/iterator-options';\n\nexport function convertIteratorOptions(options: ReadableStreamIteratorOptions | null | undefined,\n                                       context: string): ValidatedReadableStreamIteratorOptions {\n  assertDictionary(options, context);\n  const preventCancel = options?.preventCancel;\n  return { preventCancel: Boolean(preventCancel) };\n}\n","import { assertDictionary } from './basic';\nimport { StreamPipeOptions, ValidatedStreamPipeOptions } from '../readable-stream/pipe-options';\nimport { AbortSignal, isAbortSignal } from '../abort-signal';\n\nexport function convertPipeOptions(options: StreamPipeOptions | null | undefined,\n                                   context: string): ValidatedStreamPipeOptions {\n  assertDictionary(options, context);\n  const preventAbort = options?.preventAbort;\n  const preventCancel = options?.preventCancel;\n  const preventClose = options?.preventClose;\n  const signal = options?.signal;\n  if (signal !== undefined) {\n    assertAbortSignal(signal, `${context} has member 'signal' that`);\n  }\n  return {\n    preventAbort: Boolean(preventAbort),\n    preventCancel: Boolean(preventCancel),\n    preventClose: Boolean(preventClose),\n    signal\n  };\n}\n\nfunction assertAbortSignal(signal: unknown, context: string): asserts signal is AbortSignal {\n  if (!isAbortSignal(signal)) {\n    throw new TypeError(`${context} is not an AbortSignal.`);\n  }\n}\n","import { assertDictionary, assertRequiredField } from './basic';\nimport { ReadableStream } from '../readable-stream';\nimport { WritableStream } from '../writable-stream';\nimport { assertReadableStream } from './readable-stream';\nimport { assertWritableStream } from './writable-stream';\n\nexport function convertReadableWritablePair<RS extends ReadableStream, WS extends WritableStream>(\n  pair: { readable: RS; writable: WS } | null | undefined,\n  context: string\n): { readable: RS; writable: WS } {\n  assertDictionary(pair, context);\n\n  const readable = pair?.readable;\n  assertRequiredField(readable, 'readable', 'ReadableWritablePair');\n  assertReadableStream(readable, `${context} has member 'readable' that`);\n\n  const writable = pair?.writable;\n  assertRequiredField(writable, 'writable', 'ReadableWritablePair');\n  assertWritableStream(writable, `${context} has member 'writable' that`);\n\n  return { readable, writable };\n}\n","import assert from '../stub/assert';\nimport {\n  promiseRejectedWith,\n  promiseResolvedWith,\n  setPromiseIsHandledToTrue,\n  transformPromiseWith\n} from './helpers/webidl';\nimport { QueuingStrategy, QueuingStrategySizeCallback } from './queuing-strategy';\nimport { AcquireReadableStreamAsyncIterator, ReadableStreamAsyncIterator } from './readable-stream/async-iterator';\nimport { defaultReaderClosedPromiseReject, defaultReaderClosedPromiseResolve } from './readable-stream/generic-reader';\nimport {\n  AcquireReadableStreamDefaultReader,\n  IsReadableStreamDefaultReader,\n  ReadableStreamDefaultReader,\n  ReadableStreamDefaultReadResult\n} from './readable-stream/default-reader';\nimport {\n  AcquireReadableStreamBYOBReader,\n  IsReadableStreamBYOBReader,\n  ReadableStreamBYOBReader,\n  ReadableStreamBYOBReadResult\n} from './readable-stream/byob-reader';\nimport { ReadableStreamPipeTo } from './readable-stream/pipe';\nimport { ReadableStreamTee } from './readable-stream/tee';\nimport { IsWritableStream, IsWritableStreamLocked, WritableStream } from './writable-stream';\nimport { SimpleQueue } from './simple-queue';\nimport {\n  ReadableByteStreamController,\n  ReadableStreamBYOBRequest,\n  SetUpReadableByteStreamController,\n  SetUpReadableByteStreamControllerFromUnderlyingSource\n} from './readable-stream/byte-stream-controller';\nimport {\n  ReadableStreamDefaultController,\n  SetUpReadableStreamDefaultController,\n  SetUpReadableStreamDefaultControllerFromUnderlyingSource\n} from './readable-stream/default-controller';\nimport {\n  UnderlyingByteSource,\n  UnderlyingByteSourcePullCallback,\n  UnderlyingByteSourceStartCallback,\n  UnderlyingSource,\n  UnderlyingSourceCancelCallback,\n  UnderlyingSourcePullCallback,\n  UnderlyingSourceStartCallback\n} from './readable-stream/underlying-source';\nimport { noop } from '../utils';\nimport { typeIsObject } from './helpers/miscellaneous';\nimport { CreateArrayFromList } from './abstract-ops/ecmascript';\nimport { CancelSteps } from './abstract-ops/internal-methods';\nimport { IsNonNegativeNumber } from './abstract-ops/miscellaneous';\nimport { assertObject, assertRequiredArgument } from './validators/basic';\nimport { convertQueuingStrategy } from './validators/queuing-strategy';\nimport { ExtractHighWaterMark, ExtractSizeAlgorithm } from './abstract-ops/queuing-strategy';\nimport { convertUnderlyingDefaultOrByteSource } from './validators/underlying-source';\nimport { ReadableStreamGetReaderOptions } from './readable-stream/reader-options';\nimport { convertReaderOptions } from './validators/reader-options';\nimport { StreamPipeOptions, ValidatedStreamPipeOptions } from './readable-stream/pipe-options';\nimport { ReadableStreamIteratorOptions } from './readable-stream/iterator-options';\nimport { convertIteratorOptions } from './validators/iterator-options';\nimport { convertPipeOptions } from './validators/pipe-options';\nimport { ReadableWritablePair } from './readable-stream/readable-writable-pair';\nimport { convertReadableWritablePair } from './validators/readable-writable-pair';\n\nexport type ReadableByteStream = ReadableStream<Uint8Array> & {\n  _readableStreamController: ReadableByteStreamController\n};\n\ntype ReadableStreamState = 'readable' | 'closed' | 'errored';\n\n/**\n * A readable stream represents a source of data, from which you can read.\n *\n * @public\n */\nexport class ReadableStream<R = any> {\n  /** @internal */\n  _state!: ReadableStreamState;\n  /** @internal */\n  _reader: ReadableStreamReader<R> | undefined;\n  /** @internal */\n  _storedError: any;\n  /** @internal */\n  _disturbed!: boolean;\n  /** @internal */\n  _readableStreamController!: ReadableStreamDefaultController<R> | ReadableByteStreamController;\n\n  constructor(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number; size?: undefined });\n  constructor(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>);\n  constructor(rawUnderlyingSource: UnderlyingSource<R> | UnderlyingByteSource | null | undefined = {},\n              rawStrategy: QueuingStrategy<R> | null | undefined = {}) {\n    if (rawUnderlyingSource === undefined) {\n      rawUnderlyingSource = null;\n    } else {\n      assertObject(rawUnderlyingSource, 'First parameter');\n    }\n\n    const strategy = convertQueuingStrategy(rawStrategy, 'Second parameter');\n    const underlyingSource = convertUnderlyingDefaultOrByteSource(rawUnderlyingSource, 'First parameter');\n\n    InitializeReadableStream(this);\n\n    if (underlyingSource.type === 'bytes') {\n      if (strategy.size !== undefined) {\n        throw new RangeError('The strategy for a byte stream cannot have a size function');\n      }\n      const highWaterMark = ExtractHighWaterMark(strategy, 0);\n      SetUpReadableByteStreamControllerFromUnderlyingSource(\n        this as unknown as ReadableByteStream,\n        underlyingSource,\n        highWaterMark\n      );\n    } else {\n      assert(underlyingSource.type === undefined);\n      const sizeAlgorithm = ExtractSizeAlgorithm(strategy);\n      const highWaterMark = ExtractHighWaterMark(strategy, 1);\n      SetUpReadableStreamDefaultControllerFromUnderlyingSource(\n        this,\n        underlyingSource,\n        highWaterMark,\n        sizeAlgorithm\n      );\n    }\n  }\n\n  /**\n   * Whether or not the readable stream is locked to a {@link ReadableStreamDefaultReader | reader}.\n   */\n  get locked(): boolean {\n    if (!IsReadableStream(this)) {\n      throw streamBrandCheckException('locked');\n    }\n\n    return IsReadableStreamLocked(this);\n  }\n\n  /**\n   * Cancels the stream, signaling a loss of interest in the stream by a consumer.\n   *\n   * The supplied `reason` argument will be given to the underlying source's {@link UnderlyingSource.cancel | cancel()}\n   * method, which might or might not use it.\n   */\n  cancel(reason: any = undefined): Promise<void> {\n    if (!IsReadableStream(this)) {\n      return promiseRejectedWith(streamBrandCheckException('cancel'));\n    }\n\n    if (IsReadableStreamLocked(this)) {\n      return promiseRejectedWith(new TypeError('Cannot cancel a stream that already has a reader'));\n    }\n\n    return ReadableStreamCancel(this, reason);\n  }\n\n  /**\n   * Creates a {@link ReadableStreamBYOBReader} and locks the stream to the new reader.\n   *\n   * This call behaves the same way as the no-argument variant, except that it only works on readable byte streams,\n   * i.e. streams which were constructed specifically with the ability to handle \"bring your own buffer\" reading.\n   * The returned BYOB reader provides the ability to directly read individual chunks from the stream via its\n   * {@link ReadableStreamBYOBReader.read | read()} method, into developer-supplied buffers, allowing more precise\n   * control over allocation.\n   */\n  getReader({ mode }: { mode: 'byob' }): ReadableStreamBYOBReader;\n  /**\n   * Creates a {@link ReadableStreamDefaultReader} and locks the stream to the new reader.\n   * While the stream is locked, no other reader can be acquired until this one is released.\n   *\n   * This functionality is especially useful for creating abstractions that desire the ability to consume a stream\n   * in its entirety. By getting a reader for the stream, you can ensure nobody else can interleave reads with yours\n   * or cancel the stream, which would interfere with your abstraction.\n   */\n  getReader(): ReadableStreamDefaultReader<R>;\n  getReader(\n    rawOptions: ReadableStreamGetReaderOptions | null | undefined = undefined\n  ): ReadableStreamDefaultReader<R> | ReadableStreamBYOBReader {\n    if (!IsReadableStream(this)) {\n      throw streamBrandCheckException('getReader');\n    }\n\n    const options = convertReaderOptions(rawOptions, 'First parameter');\n\n    if (options.mode === undefined) {\n      return AcquireReadableStreamDefaultReader(this);\n    }\n\n    assert(options.mode === 'byob');\n    return AcquireReadableStreamBYOBReader(this as unknown as ReadableByteStream);\n  }\n\n  /**\n   * Provides a convenient, chainable way of piping this readable stream through a transform stream\n   * (or any other `{ writable, readable }` pair). It simply {@link ReadableStream.pipeTo | pipes} the stream\n   * into the writable side of the supplied pair, and returns the readable side for further use.\n   *\n   * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.\n   */\n  pipeThrough<RS extends ReadableStream>(\n    transform: { readable: RS; writable: WritableStream<R> },\n    options?: StreamPipeOptions\n  ): RS;\n  pipeThrough<RS extends ReadableStream>(\n    rawTransform: { readable: RS; writable: WritableStream<R> } | null | undefined,\n    rawOptions: StreamPipeOptions | null | undefined = {}\n  ): RS {\n    if (!IsReadableStream(this)) {\n      throw streamBrandCheckException('pipeThrough');\n    }\n    assertRequiredArgument(rawTransform, 1, 'pipeThrough');\n\n    const transform = convertReadableWritablePair(rawTransform, 'First parameter');\n    const options = convertPipeOptions(rawOptions, 'Second parameter');\n\n    if (IsReadableStreamLocked(this)) {\n      throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream');\n    }\n    if (IsWritableStreamLocked(transform.writable)) {\n      throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream');\n    }\n\n    const promise = ReadableStreamPipeTo(\n      this, transform.writable, options.preventClose, options.preventAbort, options.preventCancel, options.signal\n    );\n\n    setPromiseIsHandledToTrue(promise);\n\n    return transform.readable;\n  }\n\n  /**\n   * Pipes this readable stream to a given writable stream. The way in which the piping process behaves under\n   * various error conditions can be customized with a number of passed options. It returns a promise that fulfills\n   * when the piping process completes successfully, or rejects if any errors were encountered.\n   *\n   * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.\n   */\n  pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;\n  pipeTo(destination: WritableStream<R> | null | undefined,\n         rawOptions: StreamPipeOptions | null | undefined = {}): Promise<void> {\n    if (!IsReadableStream(this)) {\n      return promiseRejectedWith(streamBrandCheckException('pipeTo'));\n    }\n\n    if (destination === undefined) {\n      return promiseRejectedWith(`Parameter 1 is required in 'pipeTo'.`);\n    }\n    if (!IsWritableStream(destination)) {\n      return promiseRejectedWith(\n        new TypeError(`ReadableStream.prototype.pipeTo's first argument must be a WritableStream`)\n      );\n    }\n\n    let options: ValidatedStreamPipeOptions;\n    try {\n      options = convertPipeOptions(rawOptions, 'Second parameter');\n    } catch (e) {\n      return promiseRejectedWith(e);\n    }\n\n    if (IsReadableStreamLocked(this)) {\n      return promiseRejectedWith(\n        new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream')\n      );\n    }\n    if (IsWritableStreamLocked(destination)) {\n      return promiseRejectedWith(\n        new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream')\n      );\n    }\n\n    return ReadableStreamPipeTo<R>(\n      this, destination, options.preventClose, options.preventAbort, options.preventCancel, options.signal\n    );\n  }\n\n  /**\n   * Tees this readable stream, returning a two-element array containing the two resulting branches as\n   * new {@link ReadableStream} instances.\n   *\n   * Teeing a stream will lock it, preventing any other consumer from acquiring a reader.\n   * To cancel the stream, cancel both of the resulting branches; a composite cancellation reason will then be\n   * propagated to the stream's underlying source.\n   *\n   * Note that the chunks seen in each branch will be the same object. If the chunks are not immutable,\n   * this could allow interference between the two branches.\n   */\n  tee(): [ReadableStream<R>, ReadableStream<R>] {\n    if (!IsReadableStream(this)) {\n      throw streamBrandCheckException('tee');\n    }\n\n    const branches = ReadableStreamTee(this, false);\n    return CreateArrayFromList(branches);\n  }\n\n  /**\n   * Asynchronously iterates over the chunks in the stream's internal queue.\n   *\n   * Asynchronously iterating over the stream will lock it, preventing any other consumer from acquiring a reader.\n   * The lock will be released if the async iterator's {@link ReadableStreamAsyncIterator.return | return()} method\n   * is called, e.g. by breaking out of the loop.\n   *\n   * By default, calling the async iterator's {@link ReadableStreamAsyncIterator.return | return()} method will also\n   * cancel the stream. To prevent this, use the stream's {@link ReadableStream.values | values()} method, passing\n   * `true` for the `preventCancel` option.\n   */\n  values(options?: ReadableStreamIteratorOptions): ReadableStreamAsyncIterator<R>;\n  values(rawOptions: ReadableStreamIteratorOptions | null | undefined = undefined): ReadableStreamAsyncIterator<R> {\n    if (!IsReadableStream(this)) {\n      throw streamBrandCheckException('values');\n    }\n\n    const options = convertIteratorOptions(rawOptions, 'First parameter');\n    return AcquireReadableStreamAsyncIterator<R>(this, options.preventCancel);\n  }\n\n  /**\n   * {@inheritDoc ReadableStream.values}\n   */\n  [Symbol.asyncIterator]: (options?: ReadableStreamIteratorOptions) => ReadableStreamAsyncIterator<R>;\n}\n\nObject.defineProperties(ReadableStream.prototype, {\n  cancel: { enumerable: true },\n  getReader: { enumerable: true },\n  pipeThrough: { enumerable: true },\n  pipeTo: { enumerable: true },\n  tee: { enumerable: true },\n  values: { enumerable: true },\n  locked: { enumerable: true }\n});\nif (typeof Symbol.toStringTag === 'symbol') {\n  Object.defineProperty(ReadableStream.prototype, Symbol.toStringTag, {\n    value: 'ReadableStream',\n    configurable: true\n  });\n}\nif (typeof Symbol.asyncIterator === 'symbol') {\n  Object.defineProperty(ReadableStream.prototype, Symbol.asyncIterator, {\n    value: ReadableStream.prototype.values,\n    writable: true,\n    configurable: true\n  });\n}\n\nexport {\n  ReadableStreamAsyncIterator,\n  ReadableStreamDefaultReadResult,\n  ReadableStreamBYOBReadResult,\n  UnderlyingByteSource,\n  UnderlyingSource,\n  UnderlyingSourceStartCallback,\n  UnderlyingSourcePullCallback,\n  UnderlyingSourceCancelCallback,\n  UnderlyingByteSourceStartCallback,\n  UnderlyingByteSourcePullCallback,\n  StreamPipeOptions,\n  ReadableWritablePair,\n  ReadableStreamIteratorOptions\n};\n\n// Abstract operations for the ReadableStream.\n\n// Throws if and only if startAlgorithm throws.\nexport function CreateReadableStream<R>(startAlgorithm: () => void | PromiseLike<void>,\n                                        pullAlgorithm: () => Promise<void>,\n                                        cancelAlgorithm: (reason: any) => Promise<void>,\n                                        highWaterMark = 1,\n                                        sizeAlgorithm: QueuingStrategySizeCallback<R> = () => 1): ReadableStream<R> {\n  assert(IsNonNegativeNumber(highWaterMark));\n\n  const stream: ReadableStream<R> = Object.create(ReadableStream.prototype);\n  InitializeReadableStream(stream);\n\n  const controller: ReadableStreamDefaultController<R> = Object.create(ReadableStreamDefaultController.prototype);\n  SetUpReadableStreamDefaultController(\n    stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm\n  );\n\n  return stream;\n}\n\n// Throws if and only if startAlgorithm throws.\nexport function CreateReadableByteStream(\n  startAlgorithm: () => void | PromiseLike<void>,\n  pullAlgorithm: () => Promise<void>,\n  cancelAlgorithm: (reason: any) => Promise<void>\n): ReadableByteStream {\n  const stream: ReadableByteStream = Object.create(ReadableStream.prototype);\n  InitializeReadableStream(stream);\n\n  const controller: ReadableByteStreamController = Object.create(ReadableByteStreamController.prototype);\n  SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, 0, undefined);\n\n  return stream;\n}\n\nfunction InitializeReadableStream(stream: ReadableStream) {\n  stream._state = 'readable';\n  stream._reader = undefined;\n  stream._storedError = undefined;\n  stream._disturbed = false;\n}\n\nexport function IsReadableStream(x: unknown): x is ReadableStream {\n  if (!typeIsObject(x)) {\n    return false;\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {\n    return false;\n  }\n\n  return x instanceof ReadableStream;\n}\n\nexport function IsReadableStreamDisturbed(stream: ReadableStream): boolean {\n  assert(IsReadableStream(stream));\n\n  return stream._disturbed;\n}\n\nexport function IsReadableStreamLocked(stream: ReadableStream): boolean {\n  assert(IsReadableStream(stream));\n\n  if (stream._reader === undefined) {\n    return false;\n  }\n\n  return true;\n}\n\n// ReadableStream API exposed for controllers.\n\nexport function ReadableStreamCancel<R>(stream: ReadableStream<R>, reason: any): Promise<undefined> {\n  stream._disturbed = true;\n\n  if (stream._state === 'closed') {\n    return promiseResolvedWith(undefined);\n  }\n  if (stream._state === 'errored') {\n    return promiseRejectedWith(stream._storedError);\n  }\n\n  ReadableStreamClose(stream);\n\n  const reader = stream._reader;\n  if (reader !== undefined && IsReadableStreamBYOBReader(reader)) {\n    reader._readIntoRequests.forEach(readIntoRequest => {\n      readIntoRequest._closeSteps(undefined);\n    });\n    reader._readIntoRequests = new SimpleQueue();\n  }\n\n  const sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);\n  return transformPromiseWith(sourceCancelPromise, noop);\n}\n\nexport function ReadableStreamClose<R>(stream: ReadableStream<R>): void {\n  assert(stream._state === 'readable');\n\n  stream._state = 'closed';\n\n  const reader = stream._reader;\n\n  if (reader === undefined) {\n    return;\n  }\n\n  defaultReaderClosedPromiseResolve(reader);\n\n  if (IsReadableStreamDefaultReader<R>(reader)) {\n    reader._readRequests.forEach(readRequest => {\n      readRequest._closeSteps();\n    });\n    reader._readRequests = new SimpleQueue();\n  }\n}\n\nexport function ReadableStreamError<R>(stream: ReadableStream<R>, e: any): void {\n  assert(IsReadableStream(stream));\n  assert(stream._state === 'readable');\n\n  stream._state = 'errored';\n  stream._storedError = e;\n\n  const reader = stream._reader;\n\n  if (reader === undefined) {\n    return;\n  }\n\n  defaultReaderClosedPromiseReject(reader, e);\n\n  if (IsReadableStreamDefaultReader<R>(reader)) {\n    reader._readRequests.forEach(readRequest => {\n      readRequest._errorSteps(e);\n    });\n\n    reader._readRequests = new SimpleQueue();\n  } else {\n    assert(IsReadableStreamBYOBReader(reader));\n\n    reader._readIntoRequests.forEach(readIntoRequest => {\n      readIntoRequest._errorSteps(e);\n    });\n\n    reader._readIntoRequests = new SimpleQueue();\n  }\n}\n\n// Readers\n\nexport type ReadableStreamReader<R> = ReadableStreamDefaultReader<R> | ReadableStreamBYOBReader;\n\nexport {\n  ReadableStreamDefaultReader,\n  ReadableStreamBYOBReader\n};\n\n// Controllers\n\nexport {\n  ReadableStreamDefaultController,\n  ReadableStreamBYOBRequest,\n  ReadableByteStreamController\n};\n\n// Helper functions for the ReadableStream.\n\nfunction streamBrandCheckException(name: string): TypeError {\n  return new TypeError(`ReadableStream.prototype.${name} can only be used on a ReadableStream`);\n}\n","import { QueuingStrategyInit } from '../queuing-strategy';\nimport { assertDictionary, assertRequiredField, convertUnrestrictedDouble } from './basic';\n\nexport function convertQueuingStrategyInit(init: QueuingStrategyInit | null | undefined,\n                                           context: string): QueuingStrategyInit {\n  assertDictionary(init, context);\n  const highWaterMark = init?.highWaterMark;\n  assertRequiredField(highWaterMark, 'highWaterMark', 'QueuingStrategyInit');\n  return {\n    highWaterMark: convertUnrestrictedDouble(highWaterMark)\n  };\n}\n","import { QueuingStrategy, QueuingStrategyInit } from './queuing-strategy';\nimport { typeIsObject } from './helpers/miscellaneous';\nimport { assertRequiredArgument } from './validators/basic';\nimport { convertQueuingStrategyInit } from './validators/queuing-strategy-init';\n\n// The size function must not have a prototype property nor be a constructor\nconst byteLengthSizeFunction = (chunk: ArrayBufferView): number => {\n  return chunk.byteLength;\n};\ntry {\n  Object.defineProperty(byteLengthSizeFunction, 'name', {\n    value: 'size',\n    configurable: true\n  });\n} catch {\n  // This property is non-configurable in older browsers, so ignore if this throws.\n  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#browser_compatibility\n}\n\n/**\n * A queuing strategy that counts the number of bytes in each chunk.\n *\n * @public\n */\nexport default class ByteLengthQueuingStrategy implements QueuingStrategy<ArrayBufferView> {\n  /** @internal */\n  readonly _byteLengthQueuingStrategyHighWaterMark: number;\n\n  constructor(options: QueuingStrategyInit) {\n    assertRequiredArgument(options, 1, 'ByteLengthQueuingStrategy');\n    options = convertQueuingStrategyInit(options, 'First parameter');\n    this._byteLengthQueuingStrategyHighWaterMark = options.highWaterMark;\n  }\n\n  /**\n   * Returns the high water mark provided to the constructor.\n   */\n  get highWaterMark(): number {\n    if (!IsByteLengthQueuingStrategy(this)) {\n      throw byteLengthBrandCheckException('highWaterMark');\n    }\n    return this._byteLengthQueuingStrategyHighWaterMark;\n  }\n\n  /**\n   * Measures the size of `chunk` by returning the value of its `byteLength` property.\n   */\n  get size(): (chunk: ArrayBufferView) => number {\n    if (!IsByteLengthQueuingStrategy(this)) {\n      throw byteLengthBrandCheckException('size');\n    }\n    return byteLengthSizeFunction;\n  }\n}\n\nObject.defineProperties(ByteLengthQueuingStrategy.prototype, {\n  highWaterMark: { enumerable: true },\n  size: { enumerable: true }\n});\nif (typeof Symbol.toStringTag === 'symbol') {\n  Object.defineProperty(ByteLengthQueuingStrategy.prototype, Symbol.toStringTag, {\n    value: 'ByteLengthQueuingStrategy',\n    configurable: true\n  });\n}\n\n// Helper functions for the ByteLengthQueuingStrategy.\n\nfunction byteLengthBrandCheckException(name: string): TypeError {\n  return new TypeError(`ByteLengthQueuingStrategy.prototype.${name} can only be used on a ByteLengthQueuingStrategy`);\n}\n\nexport function IsByteLengthQueuingStrategy(x: any): x is ByteLengthQueuingStrategy {\n  if (!typeIsObject(x)) {\n    return false;\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(x, '_byteLengthQueuingStrategyHighWaterMark')) {\n    return false;\n  }\n\n  return x instanceof ByteLengthQueuingStrategy;\n}\n","import { QueuingStrategy, QueuingStrategyInit } from './queuing-strategy';\nimport { typeIsObject } from './helpers/miscellaneous';\nimport { assertRequiredArgument } from './validators/basic';\nimport { convertQueuingStrategyInit } from './validators/queuing-strategy-init';\n\n// The size function must not have a prototype property nor be a constructor\nconst countSizeFunction = (): 1 => {\n  return 1;\n};\ntry {\n  Object.defineProperty(countSizeFunction, 'name', {\n    value: 'size',\n    configurable: true\n  });\n} catch {\n  // This property is non-configurable in older browsers, so ignore if this throws.\n  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#browser_compatibility\n}\n\n/**\n * A queuing strategy that counts the number of chunks.\n *\n * @public\n */\nexport default class CountQueuingStrategy implements QueuingStrategy<any> {\n  /** @internal */\n  readonly _countQueuingStrategyHighWaterMark!: number;\n\n  constructor(options: QueuingStrategyInit) {\n    assertRequiredArgument(options, 1, 'CountQueuingStrategy');\n    options = convertQueuingStrategyInit(options, 'First parameter');\n    this._countQueuingStrategyHighWaterMark = options.highWaterMark;\n  }\n\n  /**\n   * Returns the high water mark provided to the constructor.\n   */\n  get highWaterMark(): number {\n    if (!IsCountQueuingStrategy(this)) {\n      throw countBrandCheckException('highWaterMark');\n    }\n    return this._countQueuingStrategyHighWaterMark;\n  }\n\n  /**\n   * Measures the size of `chunk` by always returning 1.\n   * This ensures that the total queue size is a count of the number of chunks in the queue.\n   */\n  get size(): (chunk: any) => 1 {\n    if (!IsCountQueuingStrategy(this)) {\n      throw countBrandCheckException('size');\n    }\n    return countSizeFunction;\n  }\n}\n\nObject.defineProperties(CountQueuingStrategy.prototype, {\n  highWaterMark: { enumerable: true },\n  size: { enumerable: true }\n});\nif (typeof Symbol.toStringTag === 'symbol') {\n  Object.defineProperty(CountQueuingStrategy.prototype, Symbol.toStringTag, {\n    value: 'CountQueuingStrategy',\n    configurable: true\n  });\n}\n\n// Helper functions for the CountQueuingStrategy.\n\nfunction countBrandCheckException(name: string): TypeError {\n  return new TypeError(`CountQueuingStrategy.prototype.${name} can only be used on a CountQueuingStrategy`);\n}\n\nexport function IsCountQueuingStrategy(x: any): x is CountQueuingStrategy {\n  if (!typeIsObject(x)) {\n    return false;\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(x, '_countQueuingStrategyHighWaterMark')) {\n    return false;\n  }\n\n  return x instanceof CountQueuingStrategy;\n}\n","import { assertDictionary, assertFunction } from './basic';\nimport { promiseCall, reflectCall } from '../helpers/webidl';\nimport {\n  Transformer,\n  TransformerFlushCallback,\n  TransformerStartCallback,\n  TransformerTransformCallback,\n  ValidatedTransformer\n} from '../transform-stream/transformer';\nimport { TransformStreamDefaultController } from '../transform-stream';\n\nexport function convertTransformer<I, O>(original: Transformer<I, O> | null,\n                                         context: string): ValidatedTransformer<I, O> {\n  assertDictionary(original, context);\n  const flush = original?.flush;\n  const readableType = original?.readableType;\n  const start = original?.start;\n  const transform = original?.transform;\n  const writableType = original?.writableType;\n  return {\n    flush: flush === undefined ?\n      undefined :\n      convertTransformerFlushCallback(flush, original!, `${context} has member 'flush' that`),\n    readableType,\n    start: start === undefined ?\n      undefined :\n      convertTransformerStartCallback(start, original!, `${context} has member 'start' that`),\n    transform: transform === undefined ?\n      undefined :\n      convertTransformerTransformCallback(transform, original!, `${context} has member 'transform' that`),\n    writableType\n  };\n}\n\nfunction convertTransformerFlushCallback<I, O>(\n  fn: TransformerFlushCallback<O>,\n  original: Transformer<I, O>,\n  context: string\n): (controller: TransformStreamDefaultController<O>) => Promise<void> {\n  assertFunction(fn, context);\n  return (controller: TransformStreamDefaultController<O>) => promiseCall(fn, original, [controller]);\n}\n\nfunction convertTransformerStartCallback<I, O>(\n  fn: TransformerStartCallback<O>,\n  original: Transformer<I, O>,\n  context: string\n): TransformerStartCallback<O> {\n  assertFunction(fn, context);\n  return (controller: TransformStreamDefaultController<O>) => reflectCall(fn, original, [controller]);\n}\n\nfunction convertTransformerTransformCallback<I, O>(\n  fn: TransformerTransformCallback<I, O>,\n  original: Transformer<I, O>,\n  context: string\n): (chunk: I, controller: TransformStreamDefaultController<O>) => Promise<void> {\n  assertFunction(fn, context);\n  return (chunk: I, controller: TransformStreamDefaultController<O>) => promiseCall(fn, original, [chunk, controller]);\n}\n","import assert from '../stub/assert';\nimport { newPromise, promiseRejectedWith, promiseResolvedWith, transformPromiseWith } from './helpers/webidl';\nimport { CreateReadableStream, ReadableStream, ReadableStreamDefaultController } from './readable-stream';\nimport {\n  ReadableStreamDefaultControllerCanCloseOrEnqueue,\n  ReadableStreamDefaultControllerClose,\n  ReadableStreamDefaultControllerEnqueue,\n  ReadableStreamDefaultControllerError,\n  ReadableStreamDefaultControllerGetDesiredSize,\n  ReadableStreamDefaultControllerHasBackpressure\n} from './readable-stream/default-controller';\nimport { QueuingStrategy, QueuingStrategySizeCallback } from './queuing-strategy';\nimport { CreateWritableStream, WritableStream, WritableStreamDefaultControllerErrorIfNeeded } from './writable-stream';\nimport { typeIsObject } from './helpers/miscellaneous';\nimport { IsNonNegativeNumber } from './abstract-ops/miscellaneous';\nimport { convertQueuingStrategy } from './validators/queuing-strategy';\nimport { ExtractHighWaterMark, ExtractSizeAlgorithm } from './abstract-ops/queuing-strategy';\nimport {\n  Transformer,\n  TransformerFlushCallback,\n  TransformerStartCallback,\n  TransformerTransformCallback,\n  ValidatedTransformer\n} from './transform-stream/transformer';\nimport { convertTransformer } from './validators/transformer';\n\n// Class TransformStream\n\n/**\n * A transform stream consists of a pair of streams: a {@link WritableStream | writable stream},\n * known as its writable side, and a {@link ReadableStream | readable stream}, known as its readable side.\n * In a manner specific to the transform stream in question, writes to the writable side result in new data being\n * made available for reading from the readable side.\n *\n * @public\n */\nexport class TransformStream<I = any, O = any> {\n  /** @internal */\n  _writable!: WritableStream<I>;\n  /** @internal */\n  _readable!: ReadableStream<O>;\n  /** @internal */\n  _backpressure!: boolean;\n  /** @internal */\n  _backpressureChangePromise!: Promise<void>;\n  /** @internal */\n  _backpressureChangePromise_resolve!: () => void;\n  /** @internal */\n  _transformStreamController!: TransformStreamDefaultController<O>;\n\n  constructor(\n    transformer?: Transformer<I, O>,\n    writableStrategy?: QueuingStrategy<I>,\n    readableStrategy?: QueuingStrategy<O>\n  );\n  constructor(rawTransformer: Transformer<I, O> | null | undefined = {},\n              rawWritableStrategy: QueuingStrategy<I> | null | undefined = {},\n              rawReadableStrategy: QueuingStrategy<O> | null | undefined = {}) {\n    if (rawTransformer === undefined) {\n      rawTransformer = null;\n    }\n\n    const writableStrategy = convertQueuingStrategy(rawWritableStrategy, 'Second parameter');\n    const readableStrategy = convertQueuingStrategy(rawReadableStrategy, 'Third parameter');\n\n    const transformer = convertTransformer(rawTransformer, 'First parameter');\n    if (transformer.readableType !== undefined) {\n      throw new RangeError('Invalid readableType specified');\n    }\n    if (transformer.writableType !== undefined) {\n      throw new RangeError('Invalid writableType specified');\n    }\n\n    const readableHighWaterMark = ExtractHighWaterMark(readableStrategy, 0);\n    const readableSizeAlgorithm = ExtractSizeAlgorithm(readableStrategy);\n    const writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1);\n    const writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy);\n\n    let startPromise_resolve!: (value: void | PromiseLike<void>) => void;\n    const startPromise = newPromise<void>(resolve => {\n      startPromise_resolve = resolve;\n    });\n\n    InitializeTransformStream(\n      this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm\n    );\n    SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);\n\n    if (transformer.start !== undefined) {\n      startPromise_resolve(transformer.start(this._transformStreamController));\n    } else {\n      startPromise_resolve(undefined);\n    }\n  }\n\n  /**\n   * The readable side of the transform stream.\n   */\n  get readable(): ReadableStream<O> {\n    if (!IsTransformStream(this)) {\n      throw streamBrandCheckException('readable');\n    }\n\n    return this._readable;\n  }\n\n  /**\n   * The writable side of the transform stream.\n   */\n  get writable(): WritableStream<I> {\n    if (!IsTransformStream(this)) {\n      throw streamBrandCheckException('writable');\n    }\n\n    return this._writable;\n  }\n}\n\nObject.defineProperties(TransformStream.prototype, {\n  readable: { enumerable: true },\n  writable: { enumerable: true }\n});\nif (typeof Symbol.toStringTag === 'symbol') {\n  Object.defineProperty(TransformStream.prototype, Symbol.toStringTag, {\n    value: 'TransformStream',\n    configurable: true\n  });\n}\n\nexport {\n  Transformer,\n  TransformerStartCallback,\n  TransformerFlushCallback,\n  TransformerTransformCallback\n};\n\n// Transform Stream Abstract Operations\n\nexport function CreateTransformStream<I, O>(startAlgorithm: () => void | PromiseLike<void>,\n                                            transformAlgorithm: (chunk: I) => Promise<void>,\n                                            flushAlgorithm: () => Promise<void>,\n                                            writableHighWaterMark = 1,\n                                            writableSizeAlgorithm: QueuingStrategySizeCallback<I> = () => 1,\n                                            readableHighWaterMark = 0,\n                                            readableSizeAlgorithm: QueuingStrategySizeCallback<O> = () => 1) {\n  assert(IsNonNegativeNumber(writableHighWaterMark));\n  assert(IsNonNegativeNumber(readableHighWaterMark));\n\n  const stream: TransformStream<I, O> = Object.create(TransformStream.prototype);\n\n  let startPromise_resolve!: (value: void | PromiseLike<void>) => void;\n  const startPromise = newPromise<void>(resolve => {\n    startPromise_resolve = resolve;\n  });\n\n  InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark,\n                            readableSizeAlgorithm);\n\n  const controller: TransformStreamDefaultController<O> = Object.create(TransformStreamDefaultController.prototype);\n\n  SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm);\n\n  const startResult = startAlgorithm();\n  startPromise_resolve(startResult);\n  return stream;\n}\n\nfunction InitializeTransformStream<I, O>(stream: TransformStream<I, O>,\n                                         startPromise: Promise<void>,\n                                         writableHighWaterMark: number,\n                                         writableSizeAlgorithm: QueuingStrategySizeCallback<I>,\n                                         readableHighWaterMark: number,\n                                         readableSizeAlgorithm: QueuingStrategySizeCallback<O>) {\n  function startAlgorithm(): Promise<void> {\n    return startPromise;\n  }\n\n  function writeAlgorithm(chunk: I): Promise<void> {\n    return TransformStreamDefaultSinkWriteAlgorithm(stream, chunk);\n  }\n\n  function abortAlgorithm(reason: any): Promise<void> {\n    return TransformStreamDefaultSinkAbortAlgorithm(stream, reason);\n  }\n\n  function closeAlgorithm(): Promise<void> {\n    return TransformStreamDefaultSinkCloseAlgorithm(stream);\n  }\n\n  stream._writable = CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm,\n                                          writableHighWaterMark, writableSizeAlgorithm);\n\n  function pullAlgorithm(): Promise<void> {\n    return TransformStreamDefaultSourcePullAlgorithm(stream);\n  }\n\n  function cancelAlgorithm(reason: any): Promise<void> {\n    TransformStreamErrorWritableAndUnblockWrite(stream, reason);\n    return promiseResolvedWith(undefined);\n  }\n\n  stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark,\n                                          readableSizeAlgorithm);\n\n  // The [[backpressure]] slot is set to undefined so that it can be initialised by TransformStreamSetBackpressure.\n  stream._backpressure = undefined!;\n  stream._backpressureChangePromise = undefined!;\n  stream._backpressureChangePromise_resolve = undefined!;\n  TransformStreamSetBackpressure(stream, true);\n\n  stream._transformStreamController = undefined!;\n}\n\nfunction IsTransformStream(x: unknown): x is TransformStream {\n  if (!typeIsObject(x)) {\n    return false;\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) {\n    return false;\n  }\n\n  return x instanceof TransformStream;\n}\n\n// This is a no-op if both sides are already errored.\nfunction TransformStreamError(stream: TransformStream, e: any) {\n  ReadableStreamDefaultControllerError(\n    stream._readable._readableStreamController as ReadableStreamDefaultController<any>,\n    e\n  );\n  TransformStreamErrorWritableAndUnblockWrite(stream, e);\n}\n\nfunction TransformStreamErrorWritableAndUnblockWrite(stream: TransformStream, e: any) {\n  TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController);\n  WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e);\n  if (stream._backpressure) {\n    // Pretend that pull() was called to permit any pending write() calls to complete. TransformStreamSetBackpressure()\n    // cannot be called from enqueue() or pull() once the ReadableStream is errored, so this will will be the final time\n    // _backpressure is set.\n    TransformStreamSetBackpressure(stream, false);\n  }\n}\n\nfunction TransformStreamSetBackpressure(stream: TransformStream, backpressure: boolean) {\n  // Passes also when called during construction.\n  assert(stream._backpressure !== backpressure);\n\n  if (stream._backpressureChangePromise !== undefined) {\n    stream._backpressureChangePromise_resolve();\n  }\n\n  stream._backpressureChangePromise = newPromise(resolve => {\n    stream._backpressureChangePromise_resolve = resolve;\n  });\n\n  stream._backpressure = backpressure;\n}\n\n// Class TransformStreamDefaultController\n\n/**\n * Allows control of the {@link ReadableStream} and {@link WritableStream} of the associated {@link TransformStream}.\n *\n * @public\n */\nexport class TransformStreamDefaultController<O> {\n  /** @internal */\n  _controlledTransformStream: TransformStream<any, O>;\n  /** @internal */\n  _transformAlgorithm: (chunk: any) => Promise<void>;\n  /** @internal */\n  _flushAlgorithm: () => Promise<void>;\n\n  private constructor() {\n    throw new TypeError('Illegal constructor');\n  }\n\n  /**\n   * Returns the desired size to fill the readable side’s internal queue. It can be negative, if the queue is over-full.\n   */\n  get desiredSize(): number | null {\n    if (!IsTransformStreamDefaultController(this)) {\n      throw defaultControllerBrandCheckException('desiredSize');\n    }\n\n    const readableController = this._controlledTransformStream._readable._readableStreamController;\n    return ReadableStreamDefaultControllerGetDesiredSize(readableController as ReadableStreamDefaultController<O>);\n  }\n\n  /**\n   * Enqueues the given chunk `chunk` in the readable side of the controlled transform stream.\n   */\n  enqueue(chunk: O): void;\n  enqueue(chunk: O = undefined!): void {\n    if (!IsTransformStreamDefaultController(this)) {\n      throw defaultControllerBrandCheckException('enqueue');\n    }\n\n    TransformStreamDefaultControllerEnqueue(this, chunk);\n  }\n\n  /**\n   * Errors both the readable side and the writable side of the controlled transform stream, making all future\n   * interactions with it fail with the given error `e`. Any chunks queued for transformation will be discarded.\n   */\n  error(reason: any = undefined): void {\n    if (!IsTransformStreamDefaultController(this)) {\n      throw defaultControllerBrandCheckException('error');\n    }\n\n    TransformStreamDefaultControllerError(this, reason);\n  }\n\n  /**\n   * Closes the readable side and errors the writable side of the controlled transform stream. This is useful when the\n   * transformer only needs to consume a portion of the chunks written to the writable side.\n   */\n  terminate(): void {\n    if (!IsTransformStreamDefaultController(this)) {\n      throw defaultControllerBrandCheckException('terminate');\n    }\n\n    TransformStreamDefaultControllerTerminate(this);\n  }\n}\n\nObject.defineProperties(TransformStreamDefaultController.prototype, {\n  enqueue: { enumerable: true },\n  error: { enumerable: true },\n  terminate: { enumerable: true },\n  desiredSize: { enumerable: true }\n});\nif (typeof Symbol.toStringTag === 'symbol') {\n  Object.defineProperty(TransformStreamDefaultController.prototype, Symbol.toStringTag, {\n    value: 'TransformStreamDefaultController',\n    configurable: true\n  });\n}\n\n// Transform Stream Default Controller Abstract Operations\n\nfunction IsTransformStreamDefaultController<O = any>(x: any): x is TransformStreamDefaultController<O> {\n  if (!typeIsObject(x)) {\n    return false;\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) {\n    return false;\n  }\n\n  return x instanceof TransformStreamDefaultController;\n}\n\nfunction SetUpTransformStreamDefaultController<I, O>(stream: TransformStream<I, O>,\n                                                     controller: TransformStreamDefaultController<O>,\n                                                     transformAlgorithm: (chunk: I) => Promise<void>,\n                                                     flushAlgorithm: () => Promise<void>) {\n  assert(IsTransformStream(stream));\n  assert(stream._transformStreamController === undefined);\n\n  controller._controlledTransformStream = stream;\n  stream._transformStreamController = controller;\n\n  controller._transformAlgorithm = transformAlgorithm;\n  controller._flushAlgorithm = flushAlgorithm;\n}\n\nfunction SetUpTransformStreamDefaultControllerFromTransformer<I, O>(stream: TransformStream<I, O>,\n                                                                    transformer: ValidatedTransformer<I, O>) {\n  const controller: TransformStreamDefaultController<O> = Object.create(TransformStreamDefaultController.prototype);\n\n  let transformAlgorithm = (chunk: I): Promise<void> => {\n    try {\n      TransformStreamDefaultControllerEnqueue(controller, chunk as unknown as O);\n      return promiseResolvedWith(undefined);\n    } catch (transformResultE) {\n      return promiseRejectedWith(transformResultE);\n    }\n  };\n\n  let flushAlgorithm: () => Promise<void> = () => promiseResolvedWith(undefined);\n\n  if (transformer.transform !== undefined) {\n    transformAlgorithm = chunk => transformer.transform!(chunk, controller);\n  }\n  if (transformer.flush !== undefined) {\n    flushAlgorithm = () => transformer.flush!(controller);\n  }\n\n  SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm);\n}\n\nfunction TransformStreamDefaultControllerClearAlgorithms(controller: TransformStreamDefaultController<any>) {\n  controller._transformAlgorithm = undefined!;\n  controller._flushAlgorithm = undefined!;\n}\n\nfunction TransformStreamDefaultControllerEnqueue<O>(controller: TransformStreamDefaultController<O>, chunk: O) {\n  const stream = controller._controlledTransformStream;\n  const readableController = stream._readable._readableStreamController as ReadableStreamDefaultController<O>;\n  if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController)) {\n    throw new TypeError('Readable side is not in a state that permits enqueue');\n  }\n\n  // We throttle transform invocations based on the backpressure of the ReadableStream, but we still\n  // accept TransformStreamDefaultControllerEnqueue() calls.\n\n  try {\n    ReadableStreamDefaultControllerEnqueue(readableController, chunk);\n  } catch (e) {\n    // This happens when readableStrategy.size() throws.\n    TransformStreamErrorWritableAndUnblockWrite(stream, e);\n\n    throw stream._readable._storedError;\n  }\n\n  const backpressure = ReadableStreamDefaultControllerHasBackpressure(readableController);\n  if (backpressure !== stream._backpressure) {\n    assert(backpressure);\n    TransformStreamSetBackpressure(stream, true);\n  }\n}\n\nfunction TransformStreamDefaultControllerError(controller: TransformStreamDefaultController<any>, e: any) {\n  TransformStreamError(controller._controlledTransformStream, e);\n}\n\nfunction TransformStreamDefaultControllerPerformTransform<I, O>(controller: TransformStreamDefaultController<O>,\n                                                                chunk: I) {\n  const transformPromise = controller._transformAlgorithm(chunk);\n  return transformPromiseWith(transformPromise, undefined, r => {\n    TransformStreamError(controller._controlledTransformStream, r);\n    throw r;\n  });\n}\n\nfunction TransformStreamDefaultControllerTerminate<O>(controller: TransformStreamDefaultController<O>) {\n  const stream = controller._controlledTransformStream;\n  const readableController = stream._readable._readableStreamController as ReadableStreamDefaultController<O>;\n\n  ReadableStreamDefaultControllerClose(readableController);\n\n  const error = new TypeError('TransformStream terminated');\n  TransformStreamErrorWritableAndUnblockWrite(stream, error);\n}\n\n// TransformStreamDefaultSink Algorithms\n\nfunction TransformStreamDefaultSinkWriteAlgorithm<I, O>(stream: TransformStream<I, O>, chunk: I): Promise<void> {\n  assert(stream._writable._state === 'writable');\n\n  const controller = stream._transformStreamController;\n\n  if (stream._backpressure) {\n    const backpressureChangePromise = stream._backpressureChangePromise;\n    assert(backpressureChangePromise !== undefined);\n    return transformPromiseWith(backpressureChangePromise, () => {\n      const writable = stream._writable;\n      const state = writable._state;\n      if (state === 'erroring') {\n        throw writable._storedError;\n      }\n      assert(state === 'writable');\n      return TransformStreamDefaultControllerPerformTransform<I, O>(controller, chunk);\n    });\n  }\n\n  return TransformStreamDefaultControllerPerformTransform<I, O>(controller, chunk);\n}\n\nfunction TransformStreamDefaultSinkAbortAlgorithm(stream: TransformStream, reason: any): Promise<void> {\n  // abort() is not called synchronously, so it is possible for abort() to be called when the stream is already\n  // errored.\n  TransformStreamError(stream, reason);\n  return promiseResolvedWith(undefined);\n}\n\nfunction TransformStreamDefaultSinkCloseAlgorithm<I, O>(stream: TransformStream<I, O>): Promise<void> {\n  // stream._readable cannot change after construction, so caching it across a call to user code is safe.\n  const readable = stream._readable;\n\n  const controller = stream._transformStreamController;\n  const flushPromise = controller._flushAlgorithm();\n  TransformStreamDefaultControllerClearAlgorithms(controller);\n\n  // Return a promise that is fulfilled with undefined on success.\n  return transformPromiseWith(flushPromise, () => {\n    if (readable._state === 'errored') {\n      throw readable._storedError;\n    }\n    ReadableStreamDefaultControllerClose(readable._readableStreamController as ReadableStreamDefaultController<O>);\n  }, r => {\n    TransformStreamError(stream, r);\n    throw readable._storedError;\n  });\n}\n\n// TransformStreamDefaultSource Algorithms\n\nfunction TransformStreamDefaultSourcePullAlgorithm(stream: TransformStream): Promise<void> {\n  // Invariant. Enforced by the promises returned by start() and pull().\n  assert(stream._backpressure);\n\n  assert(stream._backpressureChangePromise !== undefined);\n\n  TransformStreamSetBackpressure(stream, false);\n\n  // Prevent the next pull() call until there is backpressure.\n  return stream._backpressureChangePromise;\n}\n\n// Helper functions for the TransformStreamDefaultController.\n\nfunction defaultControllerBrandCheckException(name: string): TypeError {\n  return new TypeError(\n    `TransformStreamDefaultController.prototype.${name} can only be used on a TransformStreamDefaultController`);\n}\n\n// Helper functions for the TransformStream.\n\nfunction streamBrandCheckException(name: string): TypeError {\n  return new TypeError(\n    `TransformStream.prototype.${name} can only be used on a TransformStream`);\n}\n","var Er=Object.create;var N=Object.defineProperty;var dr=Object.getOwnPropertyDescriptor;var gr=Object.getOwnPropertyNames;var mr=Object.getPrototypeOf,Ir=Object.prototype.hasOwnProperty;var $=(i,r)=>()=>(r||i((r={exports:{}}).exports,r),r.exports),Fr=(i,r)=>{for(var t in r)N(i,t,{get:r[t],enumerable:!0})},L=(i,r,t,n)=>{if(r&&typeof r==\"object\"||typeof r==\"function\")for(let e of gr(r))!Ir.call(i,e)&&e!==t&&N(i,e,{get:()=>r[e],enumerable:!(n=dr(r,e))||n.enumerable});return i},S=(i,r,t)=>(L(i,r,\"default\"),t&&L(t,r,\"default\")),J=(i,r,t)=>(t=i!=null?Er(mr(i)):{},L(r||!i||!i.__esModule?N(t,\"default\",{value:i,enumerable:!0}):t,i)),Ar=i=>L(N({},\"__esModule\",{value:!0}),i);var Q=$(M=>{\"use strict\";M.byteLength=Rr;M.toByteArray=Cr;M.fromByteArray=Lr;var B=[],w=[],Ur=typeof Uint8Array<\"u\"?Uint8Array:Array,P=\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";for(m=0,K=P.length;m<K;++m)B[m]=P[m],w[P.charCodeAt(m)]=m;var m,K;w[\"-\".charCodeAt(0)]=62;w[\"_\".charCodeAt(0)]=63;function Z(i){var r=i.length;if(r%4>0)throw new Error(\"Invalid string. Length must be a multiple of 4\");var t=i.indexOf(\"=\");t===-1&&(t=r);var n=t===r?0:4-t%4;return[t,n]}function Rr(i){var r=Z(i),t=r[0],n=r[1];return(t+n)*3/4-n}function Tr(i,r,t){return(r+t)*3/4-t}function Cr(i){var r,t=Z(i),n=t[0],e=t[1],o=new Ur(Tr(i,n,e)),u=0,f=e>0?n-4:n,c;for(c=0;c<f;c+=4)r=w[i.charCodeAt(c)]<<18|w[i.charCodeAt(c+1)]<<12|w[i.charCodeAt(c+2)]<<6|w[i.charCodeAt(c+3)],o[u++]=r>>16&255,o[u++]=r>>8&255,o[u++]=r&255;return e===2&&(r=w[i.charCodeAt(c)]<<2|w[i.charCodeAt(c+1)]>>4,o[u++]=r&255),e===1&&(r=w[i.charCodeAt(c)]<<10|w[i.charCodeAt(c+1)]<<4|w[i.charCodeAt(c+2)]>>2,o[u++]=r>>8&255,o[u++]=r&255),o}function Sr(i){return B[i>>18&63]+B[i>>12&63]+B[i>>6&63]+B[i&63]}function _r(i,r,t){for(var n,e=[],o=r;o<t;o+=3)n=(i[o]<<16&16711680)+(i[o+1]<<8&65280)+(i[o+2]&255),e.push(Sr(n));return e.join(\"\")}function Lr(i){for(var r,t=i.length,n=t%3,e=[],o=16383,u=0,f=t-n;u<f;u+=o)e.push(_r(i,u,u+o>f?f:u+o));return n===1?(r=i[t-1],e.push(B[r>>2]+B[r<<4&63]+\"==\")):n===2&&(r=(i[t-2]<<8)+i[t-1],e.push(B[r>>10]+B[r>>4&63]+B[r<<2&63]+\"=\")),e.join(\"\")}});var v=$(O=>{O.read=function(i,r,t,n,e){var o,u,f=e*8-n-1,c=(1<<f)-1,l=c>>1,s=-7,p=t?e-1:0,F=t?-1:1,x=i[r+p];for(p+=F,o=x&(1<<-s)-1,x>>=-s,s+=f;s>0;o=o*256+i[r+p],p+=F,s-=8);for(u=o&(1<<-s)-1,o>>=-s,s+=n;s>0;u=u*256+i[r+p],p+=F,s-=8);if(o===0)o=1-l;else{if(o===c)return u?NaN:(x?-1:1)*(1/0);u=u+Math.pow(2,n),o=o-l}return(x?-1:1)*u*Math.pow(2,o-n)};O.write=function(i,r,t,n,e,o){var u,f,c,l=o*8-e-1,s=(1<<l)-1,p=s>>1,F=e===23?Math.pow(2,-24)-Math.pow(2,-77):0,x=n?0:o-1,b=n?1:-1,Br=r<0||r===0&&1/r<0?1:0;for(r=Math.abs(r),isNaN(r)||r===1/0?(f=isNaN(r)?1:0,u=s):(u=Math.floor(Math.log(r)/Math.LN2),r*(c=Math.pow(2,-u))<1&&(u--,c*=2),u+p>=1?r+=F/c:r+=F*Math.pow(2,1-p),r*c>=2&&(u++,c/=2),u+p>=s?(f=0,u=s):u+p>=1?(f=(r*c-1)*Math.pow(2,e),u=u+p):(f=r*Math.pow(2,p-1)*Math.pow(2,e),u=0));e>=8;i[t+x]=f&255,x+=b,f/=256,e-=8);for(u=u<<e|f,l+=e;l>0;i[t+x]=u&255,x+=b,u/=256,l-=8);i[t+x-b]|=Br*128}});var z=$(T=>{\"use strict\";var G=Q(),U=v(),rr=typeof Symbol==\"function\"&&typeof Symbol.for==\"function\"?Symbol.for(\"nodejs.util.inspect.custom\"):null;T.Buffer=h;T.SlowBuffer=$r;T.INSPECT_MAX_BYTES=50;var k=2147483647;T.kMaxLength=k;h.TYPED_ARRAY_SUPPORT=Nr();!h.TYPED_ARRAY_SUPPORT&&typeof console<\"u\"&&typeof console.error==\"function\"&&console.error(\"This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.\");function Nr(){try{let i=new Uint8Array(1),r={foo:function(){return 42}};return Object.setPrototypeOf(r,Uint8Array.prototype),Object.setPrototypeOf(i,r),i.foo()===42}catch(i){return!1}}Object.defineProperty(h.prototype,\"parent\",{enumerable:!0,get:function(){if(h.isBuffer(this))return this.buffer}});Object.defineProperty(h.prototype,\"offset\",{enumerable:!0,get:function(){if(h.isBuffer(this))return this.byteOffset}});function d(i){if(i>k)throw new RangeError('The value \"'+i+'\" is invalid for option \"size\"');let r=new Uint8Array(i);return Object.setPrototypeOf(r,h.prototype),r}function h(i,r,t){if(typeof i==\"number\"){if(typeof r==\"string\")throw new TypeError('The \"string\" argument must be of type string. Received type number');return j(i)}return er(i,r,t)}h.poolSize=8192;function er(i,r,t){if(typeof i==\"string\")return kr(i,r);if(ArrayBuffer.isView(i))return Dr(i);if(i==null)throw new TypeError(\"The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type \"+typeof i);if(E(i,ArrayBuffer)||i&&E(i.buffer,ArrayBuffer)||typeof SharedArrayBuffer<\"u\"&&(E(i,SharedArrayBuffer)||i&&E(i.buffer,SharedArrayBuffer)))return q(i,r,t);if(typeof i==\"number\")throw new TypeError('The \"value\" argument must not be of type number. Received type number');let n=i.valueOf&&i.valueOf();if(n!=null&&n!==i)return h.from(n,r,t);let e=br(i);if(e)return e;if(typeof Symbol<\"u\"&&Symbol.toPrimitive!=null&&typeof i[Symbol.toPrimitive]==\"function\")return h.from(i[Symbol.toPrimitive](\"string\"),r,t);throw new TypeError(\"The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type \"+typeof i)}h.from=function(i,r,t){return er(i,r,t)};Object.setPrototypeOf(h.prototype,Uint8Array.prototype);Object.setPrototypeOf(h,Uint8Array);function or(i){if(typeof i!=\"number\")throw new TypeError('\"size\" argument must be of type number');if(i<0)throw new RangeError('The value \"'+i+'\" is invalid for option \"size\"')}function Mr(i,r,t){return or(i),i<=0?d(i):r!==void 0?typeof t==\"string\"?d(i).fill(r,t):d(i).fill(r):d(i)}h.alloc=function(i,r,t){return Mr(i,r,t)};function j(i){return or(i),d(i<0?0:H(i)|0)}h.allocUnsafe=function(i){return j(i)};h.allocUnsafeSlow=function(i){return j(i)};function kr(i,r){if((typeof r!=\"string\"||r===\"\")&&(r=\"utf8\"),!h.isEncoding(r))throw new TypeError(\"Unknown encoding: \"+r);let t=ur(i,r)|0,n=d(t),e=n.write(i,r);return e!==t&&(n=n.slice(0,e)),n}function Y(i){let r=i.length<0?0:H(i.length)|0,t=d(r);for(let n=0;n<r;n+=1)t[n]=i[n]&255;return t}function Dr(i){if(E(i,Uint8Array)){let r=new Uint8Array(i);return q(r.buffer,r.byteOffset,r.byteLength)}return Y(i)}function q(i,r,t){if(r<0||i.byteLength<r)throw new RangeError('\"offset\" is outside of buffer bounds');if(i.byteLength<r+(t||0))throw new RangeError('\"length\" is outside of buffer bounds');let n;return r===void 0&&t===void 0?n=new Uint8Array(i):t===void 0?n=new Uint8Array(i,r):n=new Uint8Array(i,r,t),Object.setPrototypeOf(n,h.prototype),n}function br(i){if(h.isBuffer(i)){let r=H(i.length)|0,t=d(r);return t.length===0||i.copy(t,0,0,r),t}if(i.length!==void 0)return typeof i.length!=\"number\"||X(i.length)?d(0):Y(i);if(i.type===\"Buffer\"&&Array.isArray(i.data))return Y(i.data)}function H(i){if(i>=k)throw new RangeError(\"Attempt to allocate Buffer larger than maximum size: 0x\"+k.toString(16)+\" bytes\");return i|0}function $r(i){return+i!=i&&(i=0),h.alloc(+i)}h.isBuffer=function(r){return r!=null&&r._isBuffer===!0&&r!==h.prototype};h.compare=function(r,t){if(E(r,Uint8Array)&&(r=h.from(r,r.offset,r.byteLength)),E(t,Uint8Array)&&(t=h.from(t,t.offset,t.byteLength)),!h.isBuffer(r)||!h.isBuffer(t))throw new TypeError('The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array');if(r===t)return 0;let n=r.length,e=t.length;for(let o=0,u=Math.min(n,e);o<u;++o)if(r[o]!==t[o]){n=r[o],e=t[o];break}return n<e?-1:e<n?1:0};h.isEncoding=function(r){switch(String(r).toLowerCase()){case\"hex\":case\"utf8\":case\"utf-8\":case\"ascii\":case\"latin1\":case\"binary\":case\"base64\":case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":return!0;default:return!1}};h.concat=function(r,t){if(!Array.isArray(r))throw new TypeError('\"list\" argument must be an Array of Buffers');if(r.length===0)return h.alloc(0);let n;if(t===void 0)for(t=0,n=0;n<r.length;++n)t+=r[n].length;let e=h.allocUnsafe(t),o=0;for(n=0;n<r.length;++n){let u=r[n];if(E(u,Uint8Array))o+u.length>e.length?(h.isBuffer(u)||(u=h.from(u)),u.copy(e,o)):Uint8Array.prototype.set.call(e,u,o);else if(h.isBuffer(u))u.copy(e,o);else throw new TypeError('\"list\" argument must be an Array of Buffers');o+=u.length}return e};function ur(i,r){if(h.isBuffer(i))return i.length;if(ArrayBuffer.isView(i)||E(i,ArrayBuffer))return i.byteLength;if(typeof i!=\"string\")throw new TypeError('The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. Received type '+typeof i);let t=i.length,n=arguments.length>2&&arguments[2]===!0;if(!n&&t===0)return 0;let e=!1;for(;;)switch(r){case\"ascii\":case\"latin1\":case\"binary\":return t;case\"utf8\":case\"utf-8\":return W(i).length;case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":return t*2;case\"hex\":return t>>>1;case\"base64\":return wr(i).length;default:if(e)return n?-1:W(i).length;r=(\"\"+r).toLowerCase(),e=!0}}h.byteLength=ur;function Pr(i,r,t){let n=!1;if((r===void 0||r<0)&&(r=0),r>this.length||((t===void 0||t>this.length)&&(t=this.length),t<=0)||(t>>>=0,r>>>=0,t<=r))return\"\";for(i||(i=\"utf8\");;)switch(i){case\"hex\":return zr(this,r,t);case\"utf8\":case\"utf-8\":return fr(this,r,t);case\"ascii\":return Vr(this,r,t);case\"latin1\":case\"binary\":return Xr(this,r,t);case\"base64\":return jr(this,r,t);case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":return Jr(this,r,t);default:if(n)throw new TypeError(\"Unknown encoding: \"+i);i=(i+\"\").toLowerCase(),n=!0}}h.prototype._isBuffer=!0;function I(i,r,t){let n=i[r];i[r]=i[t],i[t]=n}h.prototype.swap16=function(){let r=this.length;if(r%2!==0)throw new RangeError(\"Buffer size must be a multiple of 16-bits\");for(let t=0;t<r;t+=2)I(this,t,t+1);return this};h.prototype.swap32=function(){let r=this.length;if(r%4!==0)throw new RangeError(\"Buffer size must be a multiple of 32-bits\");for(let t=0;t<r;t+=4)I(this,t,t+3),I(this,t+1,t+2);return this};h.prototype.swap64=function(){let r=this.length;if(r%8!==0)throw new RangeError(\"Buffer size must be a multiple of 64-bits\");for(let t=0;t<r;t+=8)I(this,t,t+7),I(this,t+1,t+6),I(this,t+2,t+5),I(this,t+3,t+4);return this};h.prototype.toString=function(){let r=this.length;return r===0?\"\":arguments.length===0?fr(this,0,r):Pr.apply(this,arguments)};h.prototype.toLocaleString=h.prototype.toString;h.prototype.equals=function(r){if(!h.isBuffer(r))throw new TypeError(\"Argument must be a Buffer\");return this===r?!0:h.compare(this,r)===0};h.prototype.inspect=function(){let r=\"\",t=T.INSPECT_MAX_BYTES;return r=this.toString(\"hex\",0,t).replace(/(.{2})/g,\"$1 \").trim(),this.length>t&&(r+=\" ... \"),\"<Buffer \"+r+\">\"};rr&&(h.prototype[rr]=h.prototype.inspect);h.prototype.compare=function(r,t,n,e,o){if(E(r,Uint8Array)&&(r=h.from(r,r.offset,r.byteLength)),!h.isBuffer(r))throw new TypeError('The \"target\" argument must be one of type Buffer or Uint8Array. Received type '+typeof r);if(t===void 0&&(t=0),n===void 0&&(n=r?r.length:0),e===void 0&&(e=0),o===void 0&&(o=this.length),t<0||n>r.length||e<0||o>this.length)throw new RangeError(\"out of range index\");if(e>=o&&t>=n)return 0;if(e>=o)return-1;if(t>=n)return 1;if(t>>>=0,n>>>=0,e>>>=0,o>>>=0,this===r)return 0;let u=o-e,f=n-t,c=Math.min(u,f),l=this.slice(e,o),s=r.slice(t,n);for(let p=0;p<c;++p)if(l[p]!==s[p]){u=l[p],f=s[p];break}return u<f?-1:f<u?1:0};function hr(i,r,t,n,e){if(i.length===0)return-1;if(typeof t==\"string\"?(n=t,t=0):t>2147483647?t=2147483647:t<-2147483648&&(t=-2147483648),t=+t,X(t)&&(t=e?0:i.length-1),t<0&&(t=i.length+t),t>=i.length){if(e)return-1;t=i.length-1}else if(t<0)if(e)t=0;else return-1;if(typeof r==\"string\"&&(r=h.from(r,n)),h.isBuffer(r))return r.length===0?-1:tr(i,r,t,n,e);if(typeof r==\"number\")return r=r&255,typeof Uint8Array.prototype.indexOf==\"function\"?e?Uint8Array.prototype.indexOf.call(i,r,t):Uint8Array.prototype.lastIndexOf.call(i,r,t):tr(i,[r],t,n,e);throw new TypeError(\"val must be string, number or Buffer\")}function tr(i,r,t,n,e){let o=1,u=i.length,f=r.length;if(n!==void 0&&(n=String(n).toLowerCase(),n===\"ucs2\"||n===\"ucs-2\"||n===\"utf16le\"||n===\"utf-16le\")){if(i.length<2||r.length<2)return-1;o=2,u/=2,f/=2,t/=2}function c(s,p){return o===1?s[p]:s.readUInt16BE(p*o)}let l;if(e){let s=-1;for(l=t;l<u;l++)if(c(i,l)===c(r,s===-1?0:l-s)){if(s===-1&&(s=l),l-s+1===f)return s*o}else s!==-1&&(l-=l-s),s=-1}else for(t+f>u&&(t=u-f),l=t;l>=0;l--){let s=!0;for(let p=0;p<f;p++)if(c(i,l+p)!==c(r,p)){s=!1;break}if(s)return l}return-1}h.prototype.includes=function(r,t,n){return this.indexOf(r,t,n)!==-1};h.prototype.indexOf=function(r,t,n){return hr(this,r,t,n,!0)};h.prototype.lastIndexOf=function(r,t,n){return hr(this,r,t,n,!1)};function Or(i,r,t,n){t=Number(t)||0;let e=i.length-t;n?(n=Number(n),n>e&&(n=e)):n=e;let o=r.length;n>o/2&&(n=o/2);let u;for(u=0;u<n;++u){let f=parseInt(r.substr(u*2,2),16);if(X(f))return u;i[t+u]=f}return u}function Gr(i,r,t,n){return D(W(r,i.length-t),i,t,n)}function Yr(i,r,t,n){return D(vr(r),i,t,n)}function qr(i,r,t,n){return D(wr(r),i,t,n)}function Wr(i,r,t,n){return D(rt(r,i.length-t),i,t,n)}h.prototype.write=function(r,t,n,e){if(t===void 0)e=\"utf8\",n=this.length,t=0;else if(n===void 0&&typeof t==\"string\")e=t,n=this.length,t=0;else if(isFinite(t))t=t>>>0,isFinite(n)?(n=n>>>0,e===void 0&&(e=\"utf8\")):(e=n,n=void 0);else throw new Error(\"Buffer.write(string, encoding, offset[, length]) is no longer supported\");let o=this.length-t;if((n===void 0||n>o)&&(n=o),r.length>0&&(n<0||t<0)||t>this.length)throw new RangeError(\"Attempt to write outside buffer bounds\");e||(e=\"utf8\");let u=!1;for(;;)switch(e){case\"hex\":return Or(this,r,t,n);case\"utf8\":case\"utf-8\":return Gr(this,r,t,n);case\"ascii\":case\"latin1\":case\"binary\":return Yr(this,r,t,n);case\"base64\":return qr(this,r,t,n);case\"ucs2\":case\"ucs-2\":case\"utf16le\":case\"utf-16le\":return Wr(this,r,t,n);default:if(u)throw new TypeError(\"Unknown encoding: \"+e);e=(\"\"+e).toLowerCase(),u=!0}};h.prototype.toJSON=function(){return{type:\"Buffer\",data:Array.prototype.slice.call(this._arr||this,0)}};function jr(i,r,t){return r===0&&t===i.length?G.fromByteArray(i):G.fromByteArray(i.slice(r,t))}function fr(i,r,t){t=Math.min(i.length,t);let n=[],e=r;for(;e<t;){let o=i[e],u=null,f=o>239?4:o>223?3:o>191?2:1;if(e+f<=t){let c,l,s,p;switch(f){case 1:o<128&&(u=o);break;case 2:c=i[e+1],(c&192)===128&&(p=(o&31)<<6|c&63,p>127&&(u=p));break;case 3:c=i[e+1],l=i[e+2],(c&192)===128&&(l&192)===128&&(p=(o&15)<<12|(c&63)<<6|l&63,p>2047&&(p<55296||p>57343)&&(u=p));break;case 4:c=i[e+1],l=i[e+2],s=i[e+3],(c&192)===128&&(l&192)===128&&(s&192)===128&&(p=(o&15)<<18|(c&63)<<12|(l&63)<<6|s&63,p>65535&&p<1114112&&(u=p))}}u===null?(u=65533,f=1):u>65535&&(u-=65536,n.push(u>>>10&1023|55296),u=56320|u&1023),n.push(u),e+=f}return Hr(n)}var ir=4096;function Hr(i){let r=i.length;if(r<=ir)return String.fromCharCode.apply(String,i);let t=\"\",n=0;for(;n<r;)t+=String.fromCharCode.apply(String,i.slice(n,n+=ir));return t}function Vr(i,r,t){let n=\"\";t=Math.min(i.length,t);for(let e=r;e<t;++e)n+=String.fromCharCode(i[e]&127);return n}function Xr(i,r,t){let n=\"\";t=Math.min(i.length,t);for(let e=r;e<t;++e)n+=String.fromCharCode(i[e]);return n}function zr(i,r,t){let n=i.length;(!r||r<0)&&(r=0),(!t||t<0||t>n)&&(t=n);let e=\"\";for(let o=r;o<t;++o)e+=tt[i[o]];return e}function Jr(i,r,t){let n=i.slice(r,t),e=\"\";for(let o=0;o<n.length-1;o+=2)e+=String.fromCharCode(n[o]+n[o+1]*256);return e}h.prototype.slice=function(r,t){let n=this.length;r=~~r,t=t===void 0?n:~~t,r<0?(r+=n,r<0&&(r=0)):r>n&&(r=n),t<0?(t+=n,t<0&&(t=0)):t>n&&(t=n),t<r&&(t=r);let e=this.subarray(r,t);return Object.setPrototypeOf(e,h.prototype),e};function a(i,r,t){if(i%1!==0||i<0)throw new RangeError(\"offset is not uint\");if(i+r>t)throw new RangeError(\"Trying to access beyond buffer length\")}h.prototype.readUintLE=h.prototype.readUIntLE=function(r,t,n){r=r>>>0,t=t>>>0,n||a(r,t,this.length);let e=this[r],o=1,u=0;for(;++u<t&&(o*=256);)e+=this[r+u]*o;return e};h.prototype.readUintBE=h.prototype.readUIntBE=function(r,t,n){r=r>>>0,t=t>>>0,n||a(r,t,this.length);let e=this[r+--t],o=1;for(;t>0&&(o*=256);)e+=this[r+--t]*o;return e};h.prototype.readUint8=h.prototype.readUInt8=function(r,t){return r=r>>>0,t||a(r,1,this.length),this[r]};h.prototype.readUint16LE=h.prototype.readUInt16LE=function(r,t){return r=r>>>0,t||a(r,2,this.length),this[r]|this[r+1]<<8};h.prototype.readUint16BE=h.prototype.readUInt16BE=function(r,t){return r=r>>>0,t||a(r,2,this.length),this[r]<<8|this[r+1]};h.prototype.readUint32LE=h.prototype.readUInt32LE=function(r,t){return r=r>>>0,t||a(r,4,this.length),(this[r]|this[r+1]<<8|this[r+2]<<16)+this[r+3]*16777216};h.prototype.readUint32BE=h.prototype.readUInt32BE=function(r,t){return r=r>>>0,t||a(r,4,this.length),this[r]*16777216+(this[r+1]<<16|this[r+2]<<8|this[r+3])};h.prototype.readBigUInt64LE=g(function(r){r=r>>>0,R(r,\"offset\");let t=this[r],n=this[r+7];(t===void 0||n===void 0)&&_(r,this.length-8);let e=t+this[++r]*2**8+this[++r]*2**16+this[++r]*2**24,o=this[++r]+this[++r]*2**8+this[++r]*2**16+n*2**24;return BigInt(e)+(BigInt(o)<<BigInt(32))});h.prototype.readBigUInt64BE=g(function(r){r=r>>>0,R(r,\"offset\");let t=this[r],n=this[r+7];(t===void 0||n===void 0)&&_(r,this.length-8);let e=t*2**24+this[++r]*2**16+this[++r]*2**8+this[++r],o=this[++r]*2**24+this[++r]*2**16+this[++r]*2**8+n;return(BigInt(e)<<BigInt(32))+BigInt(o)});h.prototype.readIntLE=function(r,t,n){r=r>>>0,t=t>>>0,n||a(r,t,this.length);let e=this[r],o=1,u=0;for(;++u<t&&(o*=256);)e+=this[r+u]*o;return o*=128,e>=o&&(e-=Math.pow(2,8*t)),e};h.prototype.readIntBE=function(r,t,n){r=r>>>0,t=t>>>0,n||a(r,t,this.length);let e=t,o=1,u=this[r+--e];for(;e>0&&(o*=256);)u+=this[r+--e]*o;return o*=128,u>=o&&(u-=Math.pow(2,8*t)),u};h.prototype.readInt8=function(r,t){return r=r>>>0,t||a(r,1,this.length),this[r]&128?(255-this[r]+1)*-1:this[r]};h.prototype.readInt16LE=function(r,t){r=r>>>0,t||a(r,2,this.length);let n=this[r]|this[r+1]<<8;return n&32768?n|4294901760:n};h.prototype.readInt16BE=function(r,t){r=r>>>0,t||a(r,2,this.length);let n=this[r+1]|this[r]<<8;return n&32768?n|4294901760:n};h.prototype.readInt32LE=function(r,t){return r=r>>>0,t||a(r,4,this.length),this[r]|this[r+1]<<8|this[r+2]<<16|this[r+3]<<24};h.prototype.readInt32BE=function(r,t){return r=r>>>0,t||a(r,4,this.length),this[r]<<24|this[r+1]<<16|this[r+2]<<8|this[r+3]};h.prototype.readBigInt64LE=g(function(r){r=r>>>0,R(r,\"offset\");let t=this[r],n=this[r+7];(t===void 0||n===void 0)&&_(r,this.length-8);let e=this[r+4]+this[r+5]*2**8+this[r+6]*2**16+(n<<24);return(BigInt(e)<<BigInt(32))+BigInt(t+this[++r]*2**8+this[++r]*2**16+this[++r]*2**24)});h.prototype.readBigInt64BE=g(function(r){r=r>>>0,R(r,\"offset\");let t=this[r],n=this[r+7];(t===void 0||n===void 0)&&_(r,this.length-8);let e=(t<<24)+this[++r]*2**16+this[++r]*2**8+this[++r];return(BigInt(e)<<BigInt(32))+BigInt(this[++r]*2**24+this[++r]*2**16+this[++r]*2**8+n)});h.prototype.readFloatLE=function(r,t){return r=r>>>0,t||a(r,4,this.length),U.read(this,r,!0,23,4)};h.prototype.readFloatBE=function(r,t){return r=r>>>0,t||a(r,4,this.length),U.read(this,r,!1,23,4)};h.prototype.readDoubleLE=function(r,t){return r=r>>>0,t||a(r,8,this.length),U.read(this,r,!0,52,8)};h.prototype.readDoubleBE=function(r,t){return r=r>>>0,t||a(r,8,this.length),U.read(this,r,!1,52,8)};function y(i,r,t,n,e,o){if(!h.isBuffer(i))throw new TypeError('\"buffer\" argument must be a Buffer instance');if(r>e||r<o)throw new RangeError('\"value\" argument is out of bounds');if(t+n>i.length)throw new RangeError(\"Index out of range\")}h.prototype.writeUintLE=h.prototype.writeUIntLE=function(r,t,n,e){if(r=+r,t=t>>>0,n=n>>>0,!e){let f=Math.pow(2,8*n)-1;y(this,r,t,n,f,0)}let o=1,u=0;for(this[t]=r&255;++u<n&&(o*=256);)this[t+u]=r/o&255;return t+n};h.prototype.writeUintBE=h.prototype.writeUIntBE=function(r,t,n,e){if(r=+r,t=t>>>0,n=n>>>0,!e){let f=Math.pow(2,8*n)-1;y(this,r,t,n,f,0)}let o=n-1,u=1;for(this[t+o]=r&255;--o>=0&&(u*=256);)this[t+o]=r/u&255;return t+n};h.prototype.writeUint8=h.prototype.writeUInt8=function(r,t,n){return r=+r,t=t>>>0,n||y(this,r,t,1,255,0),this[t]=r&255,t+1};h.prototype.writeUint16LE=h.prototype.writeUInt16LE=function(r,t,n){return r=+r,t=t>>>0,n||y(this,r,t,2,65535,0),this[t]=r&255,this[t+1]=r>>>8,t+2};h.prototype.writeUint16BE=h.prototype.writeUInt16BE=function(r,t,n){return r=+r,t=t>>>0,n||y(this,r,t,2,65535,0),this[t]=r>>>8,this[t+1]=r&255,t+2};h.prototype.writeUint32LE=h.prototype.writeUInt32LE=function(r,t,n){return r=+r,t=t>>>0,n||y(this,r,t,4,4294967295,0),this[t+3]=r>>>24,this[t+2]=r>>>16,this[t+1]=r>>>8,this[t]=r&255,t+4};h.prototype.writeUint32BE=h.prototype.writeUInt32BE=function(r,t,n){return r=+r,t=t>>>0,n||y(this,r,t,4,4294967295,0),this[t]=r>>>24,this[t+1]=r>>>16,this[t+2]=r>>>8,this[t+3]=r&255,t+4};function cr(i,r,t,n,e){yr(r,n,e,i,t,7);let o=Number(r&BigInt(4294967295));i[t++]=o,o=o>>8,i[t++]=o,o=o>>8,i[t++]=o,o=o>>8,i[t++]=o;let u=Number(r>>BigInt(32)&BigInt(4294967295));return i[t++]=u,u=u>>8,i[t++]=u,u=u>>8,i[t++]=u,u=u>>8,i[t++]=u,t}function pr(i,r,t,n,e){yr(r,n,e,i,t,7);let o=Number(r&BigInt(4294967295));i[t+7]=o,o=o>>8,i[t+6]=o,o=o>>8,i[t+5]=o,o=o>>8,i[t+4]=o;let u=Number(r>>BigInt(32)&BigInt(4294967295));return i[t+3]=u,u=u>>8,i[t+2]=u,u=u>>8,i[t+1]=u,u=u>>8,i[t]=u,t+8}h.prototype.writeBigUInt64LE=g(function(r,t=0){return cr(this,r,t,BigInt(0),BigInt(\"0xffffffffffffffff\"))});h.prototype.writeBigUInt64BE=g(function(r,t=0){return pr(this,r,t,BigInt(0),BigInt(\"0xffffffffffffffff\"))});h.prototype.writeIntLE=function(r,t,n,e){if(r=+r,t=t>>>0,!e){let c=Math.pow(2,8*n-1);y(this,r,t,n,c-1,-c)}let o=0,u=1,f=0;for(this[t]=r&255;++o<n&&(u*=256);)r<0&&f===0&&this[t+o-1]!==0&&(f=1),this[t+o]=(r/u>>0)-f&255;return t+n};h.prototype.writeIntBE=function(r,t,n,e){if(r=+r,t=t>>>0,!e){let c=Math.pow(2,8*n-1);y(this,r,t,n,c-1,-c)}let o=n-1,u=1,f=0;for(this[t+o]=r&255;--o>=0&&(u*=256);)r<0&&f===0&&this[t+o+1]!==0&&(f=1),this[t+o]=(r/u>>0)-f&255;return t+n};h.prototype.writeInt8=function(r,t,n){return r=+r,t=t>>>0,n||y(this,r,t,1,127,-128),r<0&&(r=255+r+1),this[t]=r&255,t+1};h.prototype.writeInt16LE=function(r,t,n){return r=+r,t=t>>>0,n||y(this,r,t,2,32767,-32768),this[t]=r&255,this[t+1]=r>>>8,t+2};h.prototype.writeInt16BE=function(r,t,n){return r=+r,t=t>>>0,n||y(this,r,t,2,32767,-32768),this[t]=r>>>8,this[t+1]=r&255,t+2};h.prototype.writeInt32LE=function(r,t,n){return r=+r,t=t>>>0,n||y(this,r,t,4,2147483647,-2147483648),this[t]=r&255,this[t+1]=r>>>8,this[t+2]=r>>>16,this[t+3]=r>>>24,t+4};h.prototype.writeInt32BE=function(r,t,n){return r=+r,t=t>>>0,n||y(this,r,t,4,2147483647,-2147483648),r<0&&(r=4294967295+r+1),this[t]=r>>>24,this[t+1]=r>>>16,this[t+2]=r>>>8,this[t+3]=r&255,t+4};h.prototype.writeBigInt64LE=g(function(r,t=0){return cr(this,r,t,-BigInt(\"0x8000000000000000\"),BigInt(\"0x7fffffffffffffff\"))});h.prototype.writeBigInt64BE=g(function(r,t=0){return pr(this,r,t,-BigInt(\"0x8000000000000000\"),BigInt(\"0x7fffffffffffffff\"))});function sr(i,r,t,n,e,o){if(t+n>i.length)throw new RangeError(\"Index out of range\");if(t<0)throw new RangeError(\"Index out of range\")}function lr(i,r,t,n,e){return r=+r,t=t>>>0,e||sr(i,r,t,4,34028234663852886e22,-34028234663852886e22),U.write(i,r,t,n,23,4),t+4}h.prototype.writeFloatLE=function(r,t,n){return lr(this,r,t,!0,n)};h.prototype.writeFloatBE=function(r,t,n){return lr(this,r,t,!1,n)};function ar(i,r,t,n,e){return r=+r,t=t>>>0,e||sr(i,r,t,8,17976931348623157e292,-17976931348623157e292),U.write(i,r,t,n,52,8),t+8}h.prototype.writeDoubleLE=function(r,t,n){return ar(this,r,t,!0,n)};h.prototype.writeDoubleBE=function(r,t,n){return ar(this,r,t,!1,n)};h.prototype.copy=function(r,t,n,e){if(!h.isBuffer(r))throw new TypeError(\"argument should be a Buffer\");if(n||(n=0),!e&&e!==0&&(e=this.length),t>=r.length&&(t=r.length),t||(t=0),e>0&&e<n&&(e=n),e===n||r.length===0||this.length===0)return 0;if(t<0)throw new RangeError(\"targetStart out of bounds\");if(n<0||n>=this.length)throw new RangeError(\"Index out of range\");if(e<0)throw new RangeError(\"sourceEnd out of bounds\");e>this.length&&(e=this.length),r.length-t<e-n&&(e=r.length-t+n);let o=e-n;return this===r&&typeof Uint8Array.prototype.copyWithin==\"function\"?this.copyWithin(t,n,e):Uint8Array.prototype.set.call(r,this.subarray(n,e),t),o};h.prototype.fill=function(r,t,n,e){if(typeof r==\"string\"){if(typeof t==\"string\"?(e=t,t=0,n=this.length):typeof n==\"string\"&&(e=n,n=this.length),e!==void 0&&typeof e!=\"string\")throw new TypeError(\"encoding must be a string\");if(typeof e==\"string\"&&!h.isEncoding(e))throw new TypeError(\"Unknown encoding: \"+e);if(r.length===1){let u=r.charCodeAt(0);(e===\"utf8\"&&u<128||e===\"latin1\")&&(r=u)}}else typeof r==\"number\"?r=r&255:typeof r==\"boolean\"&&(r=Number(r));if(t<0||this.length<t||this.length<n)throw new RangeError(\"Out of range index\");if(n<=t)return this;t=t>>>0,n=n===void 0?this.length:n>>>0,r||(r=0);let o;if(typeof r==\"number\")for(o=t;o<n;++o)this[o]=r;else{let u=h.isBuffer(r)?r:h.from(r,e),f=u.length;if(f===0)throw new TypeError('The value \"'+r+'\" is invalid for argument \"value\"');for(o=0;o<n-t;++o)this[o+t]=u[o%f]}return this};var A={};function V(i,r,t){A[i]=class extends t{constructor(){super(),Object.defineProperty(this,\"message\",{value:r.apply(this,arguments),writable:!0,configurable:!0}),this.name=`${this.name} [${i}]`,this.stack,delete this.name}get code(){return i}set code(e){Object.defineProperty(this,\"code\",{configurable:!0,enumerable:!0,value:e,writable:!0})}toString(){return`${this.name} [${i}]: ${this.message}`}}}V(\"ERR_BUFFER_OUT_OF_BOUNDS\",function(i){return i?`${i} is outside of buffer bounds`:\"Attempt to access memory outside buffer bounds\"},RangeError);V(\"ERR_INVALID_ARG_TYPE\",function(i,r){return`The \"${i}\" argument must be of type number. Received type ${typeof r}`},TypeError);V(\"ERR_OUT_OF_RANGE\",function(i,r,t){let n=`The value of \"${i}\" is out of range.`,e=t;return Number.isInteger(t)&&Math.abs(t)>2**32?e=nr(String(t)):typeof t==\"bigint\"&&(e=String(t),(t>BigInt(2)**BigInt(32)||t<-(BigInt(2)**BigInt(32)))&&(e=nr(e)),e+=\"n\"),n+=` It must be ${r}. Received ${e}`,n},RangeError);function nr(i){let r=\"\",t=i.length,n=i[0]===\"-\"?1:0;for(;t>=n+4;t-=3)r=`_${i.slice(t-3,t)}${r}`;return`${i.slice(0,t)}${r}`}function Kr(i,r,t){R(r,\"offset\"),(i[r]===void 0||i[r+t]===void 0)&&_(r,i.length-(t+1))}function yr(i,r,t,n,e,o){if(i>t||i<r){let u=typeof r==\"bigint\"?\"n\":\"\",f;throw o>3?r===0||r===BigInt(0)?f=`>= 0${u} and < 2${u} ** ${(o+1)*8}${u}`:f=`>= -(2${u} ** ${(o+1)*8-1}${u}) and < 2 ** ${(o+1)*8-1}${u}`:f=`>= ${r}${u} and <= ${t}${u}`,new A.ERR_OUT_OF_RANGE(\"value\",f,i)}Kr(n,e,o)}function R(i,r){if(typeof i!=\"number\")throw new A.ERR_INVALID_ARG_TYPE(r,\"number\",i)}function _(i,r,t){throw Math.floor(i)!==i?(R(i,t),new A.ERR_OUT_OF_RANGE(t||\"offset\",\"an integer\",i)):r<0?new A.ERR_BUFFER_OUT_OF_BOUNDS:new A.ERR_OUT_OF_RANGE(t||\"offset\",`>= ${t?1:0} and <= ${r}`,i)}var Zr=/[^+/0-9A-Za-z-_]/g;function Qr(i){if(i=i.split(\"=\")[0],i=i.trim().replace(Zr,\"\"),i.length<2)return\"\";for(;i.length%4!==0;)i=i+\"=\";return i}function W(i,r){r=r||1/0;let t,n=i.length,e=null,o=[];for(let u=0;u<n;++u){if(t=i.charCodeAt(u),t>55295&&t<57344){if(!e){if(t>56319){(r-=3)>-1&&o.push(239,191,189);continue}else if(u+1===n){(r-=3)>-1&&o.push(239,191,189);continue}e=t;continue}if(t<56320){(r-=3)>-1&&o.push(239,191,189),e=t;continue}t=(e-55296<<10|t-56320)+65536}else e&&(r-=3)>-1&&o.push(239,191,189);if(e=null,t<128){if((r-=1)<0)break;o.push(t)}else if(t<2048){if((r-=2)<0)break;o.push(t>>6|192,t&63|128)}else if(t<65536){if((r-=3)<0)break;o.push(t>>12|224,t>>6&63|128,t&63|128)}else if(t<1114112){if((r-=4)<0)break;o.push(t>>18|240,t>>12&63|128,t>>6&63|128,t&63|128)}else throw new Error(\"Invalid code point\")}return o}function vr(i){let r=[];for(let t=0;t<i.length;++t)r.push(i.charCodeAt(t)&255);return r}function rt(i,r){let t,n,e,o=[];for(let u=0;u<i.length&&!((r-=2)<0);++u)t=i.charCodeAt(u),n=t>>8,e=t%256,o.push(e),o.push(n);return o}function wr(i){return G.toByteArray(Qr(i))}function D(i,r,t,n){let e;for(e=0;e<n&&!(e+t>=r.length||e>=i.length);++e)r[e+t]=i[e];return e}function E(i,r){return i instanceof r||i!=null&&i.constructor!=null&&i.constructor.name!=null&&i.constructor.name===r.name}function X(i){return i!==i}var tt=function(){let i=\"0123456789abcdef\",r=new Array(256);for(let t=0;t<16;++t){let n=t*16;for(let e=0;e<16;++e)r[n+e]=i[t]+i[e]}return r}();function g(i){return typeof BigInt>\"u\"?it:i}function it(){throw new Error(\"BigInt not supported\")}});var C={};Fr(C,{default:()=>nt});module.exports=Ar(C);var xr=J(z());S(C,J(z()),module.exports);var nt=xr.default;\n/*! Bundled license information:\n\nieee754/index.js:\n  (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)\n\nbuffer/index.js:\n  (*!\n   * The buffer module from node.js, for the browser.\n   *\n   * @author   Feross Aboukhadijeh <https://feross.org>\n   * @license  MIT\n   *)\n*/\n","exports.interopDefault = function (a) {\n  return a && a.__esModule ? a : {default: a};\n};\n\nexports.defineInteropFlag = function (a) {\n  Object.defineProperty(a, '__esModule', {value: true});\n};\n\nexports.exportAll = function (source, dest) {\n  Object.keys(source).forEach(function (key) {\n    if (key === 'default' || key === '__esModule' || dest.hasOwnProperty(key)) {\n      return;\n    }\n\n    Object.defineProperty(dest, key, {\n      enumerable: true,\n      get: function () {\n        return source[key];\n      },\n    });\n  });\n\n  return dest;\n};\n\nexports.export = function (dest, destName, get) {\n  Object.defineProperty(dest, destName, {\n    enumerable: true,\n    get: get,\n  });\n};\n","/*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */\n\nimport C from 'fetch-blob'\nimport F from 'fetch-blob/file.js'\n\nvar {toStringTag:t,iterator:i,hasInstance:h}=Symbol,\nr=Math.random,\nm='append,set,get,getAll,delete,keys,values,entries,forEach,constructor'.split(','),\nf=(a,b,c)=>(a+='',/^(Blob|File)$/.test(b && b[t])?[(c=c!==void 0?c+'':b[t]=='File'?b.name:'blob',a),b.name!==c||b[t]=='blob'?new F([b],c,b):b]:[a,b+'']),\ne=(c,f)=>(f?c:c.replace(/\\r?\\n|\\r/g,'\\r\\n')).replace(/\\n/g,'%0A').replace(/\\r/g,'%0D').replace(/\"/g,'%22'),\nx=(n, a, e)=>{if(a.length<e){throw new TypeError(`Failed to execute '${n}' on 'FormData': ${e} arguments required, but only ${a.length} present.`)}}\n\nexport const File = F\n\n/** @type {typeof globalThis.FormData} */\nexport const FormData = class FormData {\n#d=[];\nconstructor(...a){if(a.length)throw new TypeError(`Failed to construct 'FormData': parameter 1 is not of type 'HTMLFormElement'.`)}\nget [t]() {return 'FormData'}\n[i](){return this.entries()}\nstatic [h](o) {return o&&typeof o==='object'&&o[t]==='FormData'&&!m.some(m=>typeof o[m]!='function')}\nappend(...a){x('append',arguments,2);this.#d.push(f(...a))}\ndelete(a){x('delete',arguments,1);a+='';this.#d=this.#d.filter(([b])=>b!==a)}\nget(a){x('get',arguments,1);a+='';for(var b=this.#d,l=b.length,c=0;c<l;c++)if(b[c][0]===a)return b[c][1];return null}\ngetAll(a,b){x('getAll',arguments,1);b=[];a+='';this.#d.forEach(c=>c[0]===a&&b.push(c[1]));return b}\nhas(a){x('has',arguments,1);a+='';return this.#d.some(b=>b[0]===a)}\nforEach(a,b){x('forEach',arguments,1);for(var [c,d]of this)a.call(b,d,c,this)}\nset(...a){x('set',arguments,2);var b=[],c=!0;a=f(...a);this.#d.forEach(d=>{d[0]===a[0]?c&&(c=!b.push(a)):b.push(d)});c&&b.push(a);this.#d=b}\n*entries(){yield*this.#d}\n*keys(){for(var[a]of this)yield a}\n*values(){for(var[,a]of this)yield a}}\n\n/** @param {FormData} F */\nexport function formDataToBlob (F,B=C){\nvar b=`${r()}${r()}`.replace(/\\./g, '').slice(-28).padStart(32, '-'),c=[],p=`--${b}\\r\\nContent-Disposition: form-data; name=\"`\nF.forEach((v,n)=>typeof v=='string'\n?c.push(p+e(n)+`\"\\r\\n\\r\\n${v.replace(/\\r(?!\\n)|(?<!\\r)\\n/g, '\\r\\n')}\\r\\n`)\n:c.push(p+e(n)+`\"; filename=\"${e(v.name, 1)}\"\\r\\nContent-Type: ${v.type||\"application/octet-stream\"}\\r\\n\\r\\n`, v, '\\r\\n'))\nc.push(`--${b}--`)\nreturn new B(c,{type:\"multipart/form-data; boundary=\"+b})}\n"],"names":["Symbol","streamBrandCheckException","defaultControllerBrandCheckException","DOMException"],"version":3,"file":"multipart-parser.bcc4a7d3.js.map"}
|
|
globalThis.define=__define; })(globalThis.define); |