tenvoy
Version:
PGP, NaCl, and PBKDF2 in node.js and the browser (hashing, random, encryption, decryption, signatures, conversions), used by TogaTech.org
836 lines (834 loc) • 1.66 MB
JavaScript
// Start OpenPGP.js Import
/*! OpenPGP.js v4.10.10 - 2021-01-24 - this is LGPL licensed code, see LICENSE/our website https://openpgpjs.org/ for more information. */
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.openpgp = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
(function (global){
"use strict";
!function (e, t) {
"object" == typeof exports && "undefined" != typeof module ? t(exports) : "function" == typeof define && define.amd ? define(["exports"], t) : t((e = e || self).WebStreamsPolyfill = {});
}(undefined, function (e) {
"use strict";
const t = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? Symbol : e => `Symbol(${e})`;const r = "undefined" != typeof self ? self : "undefined" != typeof window ? window : "undefined" != typeof global ? global : void 0,
o = Number.isNaN || function (e) {
return e != e;
};function n(e) {
return "object" == typeof e && null !== e || "function" == typeof e;
}function i(e, t, r) {
Object.defineProperty(e, t, { value: r, writable: !0, enumerable: !0, configurable: !0 });
}function a(e) {
return e.slice();
}function s(e, t, r, o, n) {
new Uint8Array(e).set(new Uint8Array(r, o, n), t);
}function l(e) {
return !1 !== function (e) {
if ("number" != typeof e) return !1;if (o(e)) return !1;if (e < 0) return !1;return !0;
}(e) && e !== 1 / 0;
}function c(e, t, r) {
if ("function" != typeof e) throw new TypeError("Argument is not a function");return Function.prototype.apply.call(e, t, r);
}function u(e, t, r, o) {
const n = e[t];if (void 0 !== n) {
if ("function" != typeof n) throw new TypeError(`${n} is not a method`);switch (r) {case 0:
return () => f(n, e, o);case 1:
return t => {
const r = [t].concat(o);return f(n, e, r);
};}
}return () => Promise.resolve();
}function d(e, t, r) {
const o = e[t];if (void 0 !== o) return c(o, e, r);
}function f(e, t, r) {
try {
return Promise.resolve(c(e, t, r));
} catch (e) {
return Promise.reject(e);
}
}function _(e) {
return e;
}function h(e) {
if (e = Number(e), o(e) || e < 0) throw new RangeError("highWaterMark property of a queuing strategy must be non-negative and non-NaN");return e;
}function b(e) {
if (void 0 === e) return () => 1;if ("function" != typeof e) throw new TypeError("size property of a queuing strategy must be a function");return t => e(t);
}function m(e, t, r) {
return Promise.prototype.then.call(e, t, r);
}function y(e, t, r) {
let o, n;const i = new Promise((e, t) => {
o = e, n = t;
});void 0 === r && (r = e => {
throw e;
});return function (e, t, r) {
let o = !1;const n = e => {
!1 === o && (o = !0, r(e));
};let i = 0,
a = 0;const s = e.length,
l = new Array(s);for (const r of e) {
const e = i;m(r, r => {
l[e] = r, ++a === s && t(l);
}, n), ++i;
}
}(e, e => {
try {
const r = t(e);o(r);
} catch (e) {
n(e);
}
}, e => {
try {
const t = r(e);o(t);
} catch (e) {
n(e);
}
}), i;
}function p(e) {}function w(e) {
e && e instanceof p.AssertionError && setTimeout(() => {
throw e;
}, 0);
}function g(e) {
const t = e._queue.shift();return e._queueTotalSize -= t.size, e._queueTotalSize < 0 && (e._queueTotalSize = 0), t.value;
}function S(e, t, r) {
if (!l(r = Number(r))) throw new RangeError("Size must be a finite, non-NaN, non-negative number.");e._queue.push({ value: t, size: r }), e._queueTotalSize += r;
}function v(e) {
e._queue = [], e._queueTotalSize = 0;
}p.AssertionError = function () {};const R = t("[[AbortSteps]]"),
P = t("[[ErrorSteps]]");class WritableStream {
constructor(e = {}, t = {}) {
q(this);const r = t.size;let o = t.highWaterMark;if (void 0 !== e.type) throw new RangeError("Invalid type is specified");const n = b(r);void 0 === o && (o = 1), function (e, t, r, o) {
const n = Object.create(WritableStreamDefaultController.prototype);const i = u(t, "write", 1, [n]),
a = u(t, "close", 0, []),
s = u(t, "abort", 1, []);$(e, n, function () {
return d(t, "start", [n]);
}, i, a, s, r, o);
}(this, e, o = h(o), n);
}get locked() {
if (!1 === E(this)) throw G("locked");return C(this);
}abort(e) {
return !1 === E(this) ? Promise.reject(G("abort")) : !0 === C(this) ? Promise.reject(new TypeError("Cannot abort a stream that already has a writer")) : j(this, e);
}getWriter() {
if (!1 === E(this)) throw G("getWriter");return T(this);
}
}function T(e) {
return new WritableStreamDefaultWriter(e);
}function q(e) {
e._state = "writable", e._storedError = void 0, e._writer = void 0, e._writableStreamController = void 0, e._writeRequests = [], e._inFlightWriteRequest = void 0, e._closeRequest = void 0, e._inFlightCloseRequest = void 0, e._pendingAbortRequest = void 0, e._backpressure = !1;
}function E(e) {
return !!n(e) && !!Object.prototype.hasOwnProperty.call(e, "_writableStreamController");
}function C(e) {
return void 0 !== e._writer;
}function j(e, t) {
const r = e._state;if ("closed" === r || "errored" === r) return Promise.resolve(void 0);if (void 0 !== e._pendingAbortRequest) return e._pendingAbortRequest._promise;let o = !1;"erroring" === r && (o = !0, t = void 0);const n = new Promise((r, n) => {
e._pendingAbortRequest = { _promise: void 0, _resolve: r, _reject: n, _reason: t, _wasAlreadyErroring: o };
});return e._pendingAbortRequest._promise = n, !1 === o && W(e, t), n;
}function A(e, t) {
"writable" !== e._state ? B(e) : W(e, t);
}function W(e, t) {
const r = e._writableStreamController;e._state = "erroring", e._storedError = t;const o = e._writer;void 0 !== o && D(o, t), !1 === function (e) {
if (void 0 === e._inFlightWriteRequest && void 0 === e._inFlightCloseRequest) return !1;return !0;
}(e) && !0 === r._started && B(e);
}function B(e) {
e._state = "errored", e._writableStreamController[P]();const t = e._storedError;for (const r of e._writeRequests) r._reject(t);if (e._writeRequests = [], void 0 === e._pendingAbortRequest) return void z(e);const r = e._pendingAbortRequest;if (e._pendingAbortRequest = void 0, !0 === r._wasAlreadyErroring) return r._reject(t), void z(e);e._writableStreamController[R](r._reason).then(() => {
r._resolve(), z(e);
}, t => {
r._reject(t), z(e);
});
}function O(e) {
return void 0 !== e._closeRequest || void 0 !== e._inFlightCloseRequest;
}function z(e) {
void 0 !== e._closeRequest && (e._closeRequest._reject(e._storedError), e._closeRequest = void 0);const t = e._writer;void 0 !== t && ee(t, e._storedError);
}function k(e, t) {
const r = e._writer;void 0 !== r && t !== e._backpressure && (!0 === t ? function (e) {
re(e);
}(r) : ae(r)), e._backpressure = t;
}class WritableStreamDefaultWriter {
constructor(e) {
if (!1 === E(e)) throw new TypeError("WritableStreamDefaultWriter can only be constructed with a WritableStream instance");if (!0 === C(e)) throw new TypeError("This stream has already been locked for exclusive writing by another writer");this._ownerWritableStream = e, e._writer = this;const t = e._state;if ("writable" === t) !1 === O(e) && !0 === e._backpressure ? re(this) : ne(this), X(this);else if ("erroring" === t) oe(this, e._storedError), X(this);else if ("closed" === t) ne(this), function (e) {
X(e), te(e);
}(this);else {
const t = e._storedError;oe(this, t), Z(this, t);
}
}get closed() {
return !1 === F(this) ? Promise.reject(J("closed")) : this._closedPromise;
}get desiredSize() {
if (!1 === F(this)) throw J("desiredSize");if (void 0 === this._ownerWritableStream) throw K("desiredSize");return function (e) {
const t = e._ownerWritableStream,
r = t._state;if ("errored" === r || "erroring" === r) return null;if ("closed" === r) return 0;return Q(t._writableStreamController);
}(this);
}get ready() {
return !1 === F(this) ? Promise.reject(J("ready")) : this._readyPromise;
}abort(e) {
return !1 === F(this) ? Promise.reject(J("abort")) : void 0 === this._ownerWritableStream ? Promise.reject(K("abort")) : function (e, t) {
return j(e._ownerWritableStream, t);
}(this, e);
}close() {
if (!1 === F(this)) return Promise.reject(J("close"));const e = this._ownerWritableStream;return void 0 === e ? Promise.reject(K("close")) : !0 === O(e) ? Promise.reject(new TypeError("cannot close an already-closing stream")) : L(this);
}releaseLock() {
if (!1 === F(this)) throw J("releaseLock");void 0 !== this._ownerWritableStream && M(this);
}write(e) {
return !1 === F(this) ? Promise.reject(J("write")) : void 0 === this._ownerWritableStream ? Promise.reject(K("write to")) : Y(this, e);
}
}function F(e) {
return !!n(e) && !!Object.prototype.hasOwnProperty.call(e, "_ownerWritableStream");
}function L(e) {
const t = e._ownerWritableStream,
r = t._state;if ("closed" === r || "errored" === r) return Promise.reject(new TypeError(`The stream (in ${r} state) is not in the writable state and cannot be closed`));const o = new Promise((e, r) => {
const o = { _resolve: e, _reject: r };t._closeRequest = o;
});return !0 === t._backpressure && "writable" === r && ae(e), function (e) {
S(e, "close", 0), x(e);
}(t._writableStreamController), o;
}function I(e, t) {
"pending" === e._closedPromiseState ? ee(e, t) : function (e, t) {
Z(e, t);
}(e, t);
}function D(e, t) {
"pending" === e._readyPromiseState ? ie(e, t) : function (e, t) {
oe(e, t);
}(e, t);
}function M(e) {
const t = e._ownerWritableStream,
r = new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");D(e, r), I(e, r), t._writer = void 0, e._ownerWritableStream = void 0;
}function Y(e, t) {
const r = e._ownerWritableStream,
o = r._writableStreamController,
n = function (e, t) {
try {
return e._strategySizeAlgorithm(t);
} catch (t) {
return H(e, t), 1;
}
}(o, t);if (r !== e._ownerWritableStream) return Promise.reject(K("write to"));const i = r._state;if ("errored" === i) return Promise.reject(r._storedError);if (!0 === O(r) || "closed" === i) return Promise.reject(new TypeError("The stream is closing or closed and cannot be written to"));if ("erroring" === i) return Promise.reject(r._storedError);const a = function (e) {
return new Promise((t, r) => {
const o = { _resolve: t, _reject: r };e._writeRequests.push(o);
});
}(r);return function (e, t, r) {
const o = { chunk: t };try {
S(e, o, r);
} catch (t) {
return void H(e, t);
}const n = e._controlledWritableStream;if (!1 === O(n) && "writable" === n._state) {
const t = U(e);k(n, t);
}x(e);
}(o, t, n), a;
}class WritableStreamDefaultController {
constructor() {
throw new TypeError("WritableStreamDefaultController cannot be constructed explicitly");
}error(e) {
if (!1 === function (e) {
if (!n(e)) return !1;if (!Object.prototype.hasOwnProperty.call(e, "_controlledWritableStream")) return !1;return !0;
}(this)) throw new TypeError("WritableStreamDefaultController.prototype.error can only be used on a WritableStreamDefaultController");"writable" === this._controlledWritableStream._state && V(this, e);
}[R](e) {
const t = this._abortAlgorithm(e);return N(this), t;
}[P]() {
v(this);
}
}function $(e, t, r, o, n, i, a, s) {
t._controlledWritableStream = e, e._writableStreamController = t, t._queue = void 0, t._queueTotalSize = void 0, v(t), t._started = !1, t._strategySizeAlgorithm = s, t._strategyHWM = a, t._writeAlgorithm = o, t._closeAlgorithm = n, t._abortAlgorithm = i;const l = U(t);k(e, l);const c = r();Promise.resolve(c).then(() => {
t._started = !0, x(t);
}, r => {
t._started = !0, A(e, r);
}).catch(w);
}function N(e) {
e._writeAlgorithm = void 0, e._closeAlgorithm = void 0, e._abortAlgorithm = void 0, e._strategySizeAlgorithm = void 0;
}function Q(e) {
return e._strategyHWM - e._queueTotalSize;
}function x(e) {
const t = e._controlledWritableStream;if (!1 === e._started) return;if (void 0 !== t._inFlightWriteRequest) return;const r = t._state;if ("closed" === r || "errored" === r) return;if ("erroring" === r) return void B(t);if (0 === e._queue.length) return;const o = function (e) {
return e._queue[0].value;
}(e);"close" === o ? function (e) {
const t = e._controlledWritableStream;(function (e) {
e._inFlightCloseRequest = e._closeRequest, e._closeRequest = void 0;
})(t), g(e);const r = e._closeAlgorithm();N(e), r.then(() => {
!function (e) {
e._inFlightCloseRequest._resolve(void 0), e._inFlightCloseRequest = void 0, "erroring" === e._state && (e._storedError = void 0, void 0 !== e._pendingAbortRequest && (e._pendingAbortRequest._resolve(), e._pendingAbortRequest = void 0)), e._state = "closed";const t = e._writer;void 0 !== t && te(t);
}(t);
}, e => {
!function (e, t) {
e._inFlightCloseRequest._reject(t), e._inFlightCloseRequest = void 0, void 0 !== e._pendingAbortRequest && (e._pendingAbortRequest._reject(t), e._pendingAbortRequest = void 0), A(e, t);
}(t, e);
}).catch(w);
}(e) : function (e, t) {
const r = e._controlledWritableStream;(function (e) {
e._inFlightWriteRequest = e._writeRequests.shift();
})(r), e._writeAlgorithm(t).then(() => {
!function (e) {
e._inFlightWriteRequest._resolve(void 0), e._inFlightWriteRequest = void 0;
}(r);const t = r._state;if (g(e), !1 === O(r) && "writable" === t) {
const t = U(e);k(r, t);
}x(e);
}, t => {
"writable" === r._state && N(e), function (e, t) {
e._inFlightWriteRequest._reject(t), e._inFlightWriteRequest = void 0, A(e, t);
}(r, t);
}).catch(w);
}(e, o.chunk);
}function H(e, t) {
"writable" === e._controlledWritableStream._state && V(e, t);
}function U(e) {
return Q(e) <= 0;
}function V(e, t) {
const r = e._controlledWritableStream;N(e), W(r, t);
}function G(e) {
return new TypeError(`WritableStream.prototype.${e} can only be used on a WritableStream`);
}function J(e) {
return new TypeError(`WritableStreamDefaultWriter.prototype.${e} can only be used on a WritableStreamDefaultWriter`);
}function K(e) {
return new TypeError("Cannot " + e + " a stream using a released writer");
}function X(e) {
e._closedPromise = new Promise((t, r) => {
e._closedPromise_resolve = t, e._closedPromise_reject = r, e._closedPromiseState = "pending";
});
}function Z(e, t) {
X(e), ee(e, t);
}function ee(e, t) {
e._closedPromise.catch(() => {}), e._closedPromise_reject(t), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0, e._closedPromiseState = "rejected";
}function te(e) {
e._closedPromise_resolve(void 0), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0, e._closedPromiseState = "resolved";
}function re(e) {
e._readyPromise = new Promise((t, r) => {
e._readyPromise_resolve = t, e._readyPromise_reject = r;
}), e._readyPromiseState = "pending";
}function oe(e, t) {
re(e), ie(e, t);
}function ne(e) {
re(e), ae(e);
}function ie(e, t) {
e._readyPromise.catch(() => {}), e._readyPromise_reject(t), e._readyPromise_resolve = void 0, e._readyPromise_reject = void 0, e._readyPromiseState = "rejected";
}function ae(e) {
e._readyPromise_resolve(void 0), e._readyPromise_resolve = void 0, e._readyPromise_reject = void 0, e._readyPromiseState = "fulfilled";
}const se = Number.isInteger || function (e) {
return "number" == typeof e && isFinite(e) && Math.floor(e) === e;
},
le = t("[[CancelSteps]]"),
ce = t("[[PullSteps]]");class ReadableStream {
constructor(e = {}, t = {}) {
fe(this);const r = t.size;let o = t.highWaterMark;const n = e.type;if ("bytes" === String(n)) {
if (void 0 !== r) throw new RangeError("The strategy for a byte stream cannot have a size function");void 0 === o && (o = 0), function (e, t, r) {
const o = Object.create(ReadableByteStreamController.prototype);const n = u(t, "pull", 0, [o]),
i = u(t, "cancel", 1, []);let a = t.autoAllocateChunkSize;if (void 0 !== a && (a = Number(a), !1 === se(a) || a <= 0)) throw new RangeError("autoAllocateChunkSize must be a positive integer");!function (e, t, r, o, n, i, a) {
t._controlledReadableByteStream = e, t._pullAgain = !1, t._pulling = !1, He(t), t._queue = t._queueTotalSize = void 0, v(t), t._closeRequested = !1, t._started = !1, t._strategyHWM = h(i), t._pullAlgorithm = o, t._cancelAlgorithm = n, t._autoAllocateChunkSize = a, t._pendingPullIntos = [], e._readableStreamController = t;const s = r();Promise.resolve(s).then(() => {
t._started = !0, xe(t);
}, e => {
nt(t, e);
}).catch(w);
}(e, o, function () {
return d(t, "start", [o]);
}, n, i, r, a);
}(this, e, o = h(o));
} else {
if (void 0 !== n) throw new RangeError("Invalid type is specified");{
const t = b(r);void 0 === o && (o = 1), function (e, t, r, o) {
const n = Object.create(ReadableStreamDefaultController.prototype);const i = u(t, "pull", 0, [n]),
a = u(t, "cancel", 1, []);$e(e, n, function () {
return d(t, "start", [n]);
}, i, a, r, o);
}(this, e, o = h(o), t);
}
}
}get locked() {
if (!1 === _e(this)) throw st("locked");return he(this);
}cancel(e) {
return !1 === _e(this) ? Promise.reject(st("cancel")) : !0 === he(this) ? Promise.reject(new TypeError("Cannot cancel a stream that already has a reader")) : pe(this, e);
}getReader({ mode: e } = {}) {
if (!1 === _e(this)) throw st("getReader");if (void 0 === e) return ue(this);if ("byob" === (e = String(e))) return function (e) {
return new ReadableStreamBYOBReader(e);
}(this);throw new RangeError("Invalid mode is specified");
}pipeThrough({ writable: e, readable: t }, { preventClose: r, preventAbort: o, preventCancel: n, signal: i } = {}) {
if (!1 === _e(this)) throw st("pipeThrough");if (!1 === E(e)) throw new TypeError("writable argument to pipeThrough must be a WritableStream");if (!1 === _e(t)) throw new TypeError("readable argument to pipeThrough must be a ReadableStream");if (r = Boolean(r), o = Boolean(o), n = Boolean(n), void 0 !== i && !at(i)) throw new TypeError("ReadableStream.prototype.pipeThrough's signal option must be an AbortSignal");if (!0 === he(this)) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");if (!0 === C(e)) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");return be(this, e, r, o, n, i).catch(() => {}), t;
}pipeTo(e, { preventClose: t, preventAbort: r, preventCancel: o, signal: n } = {}) {
return !1 === _e(this) ? Promise.reject(st("pipeTo")) : !1 === E(e) ? Promise.reject(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream")) : (t = Boolean(t), r = Boolean(r), o = Boolean(o), void 0 === n || at(n) ? !0 === he(this) ? Promise.reject(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")) : !0 === C(e) ? Promise.reject(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")) : be(this, e, t, r, o, n) : Promise.reject(new TypeError("ReadableStream.prototype.pipeTo's signal option must be an AbortSignal")));
}tee() {
if (!1 === _e(this)) throw st("tee");const e = function (e, t) {
const r = ue(e);let o,
n,
i,
s,
l,
c = !1,
u = !1,
d = !1;const f = new Promise(e => {
l = e;
});function _() {
return Be(r).then(e => {
const t = e.value,
r = e.done;if (!0 === r && !1 === c && (!1 === u && Le(i._readableStreamController), !1 === d && Le(s._readableStreamController), c = !0), !0 === c) return;const o = t,
n = t;!1 === u && Ie(i._readableStreamController, o), !1 === d && Ie(s._readableStreamController, n);
});
}function h() {}return i = de(h, _, function (t) {
if (u = !0, o = t, !0 === d) {
const t = a([o, n]),
r = pe(e, t);l(r);
}return f;
}), s = de(h, _, function (t) {
if (d = !0, n = t, !0 === u) {
const t = a([o, n]),
r = pe(e, t);l(r);
}return f;
}), r._closedPromise.catch(e => {
!0 !== c && (De(i._readableStreamController, e), De(s._readableStreamController, e), c = !0);
}), [i, s];
}(this);return a(e);
}
}function ue(e) {
return new ReadableStreamDefaultReader(e);
}function de(e, t, r, o = 1, n = () => 1) {
const i = Object.create(ReadableStream.prototype);return fe(i), $e(i, Object.create(ReadableStreamDefaultController.prototype), e, t, r, o, n), i;
}function fe(e) {
e._state = "readable", e._reader = void 0, e._storedError = void 0, e._disturbed = !1;
}function _e(e) {
return !!n(e) && !!Object.prototype.hasOwnProperty.call(e, "_readableStreamController");
}function he(e) {
return void 0 !== e._reader;
}function be(e, t, r, o, n, i) {
const a = ue(e),
s = T(t);let l = !1,
c = Promise.resolve();return new Promise((u, d) => {
let f;if (void 0 !== i) {
if (f = () => {
const r = new DOMException("Aborted", "AbortError"),
i = [];!1 === o && i.push(() => "writable" === t._state ? j(t, r) : Promise.resolve()), !1 === n && i.push(() => "readable" === e._state ? pe(e, r) : Promise.resolve()), b(() => y(i.map(e => e()), e => e), !0, r);
}, !0 === i.aborted) return void f();i.addEventListener("abort", f);
}if (h(e, a._closedPromise, e => {
!1 === o ? b(() => j(t, e), !0, e) : m(!0, e);
}), h(t, s._closedPromise, t => {
!1 === n ? b(() => pe(e, t), !0, t) : m(!0, t);
}), function (e, t, r) {
"closed" === e._state ? r() : t.then(r).catch(w);
}(e, a._closedPromise, () => {
!1 === r ? b(() => function (e) {
const t = e._ownerWritableStream,
r = t._state;return !0 === O(t) || "closed" === r ? Promise.resolve() : "errored" === r ? Promise.reject(t._storedError) : L(e);
}(s)) : m();
}), !0 === O(t) || "closed" === t._state) {
const t = new TypeError("the destination writable stream closed before all data could be piped to it");!1 === n ? b(() => pe(e, t), !0, t) : m(!0, t);
}function _() {
const e = c;return c.then(() => e !== c ? _() : void 0);
}function h(e, t, r) {
"errored" === e._state ? r(e._storedError) : t.catch(r).catch(w);
}function b(e, r, o) {
function n() {
e().then(() => p(r, o), e => p(!0, e)).catch(w);
}!0 !== l && (l = !0, "writable" === t._state && !1 === O(t) ? _().then(n) : n());
}function m(e, r) {
!0 !== l && (l = !0, "writable" === t._state && !1 === O(t) ? _().then(() => p(e, r)).catch(w) : p(e, r));
}function p(e, t) {
M(s), We(a), void 0 !== i && i.removeEventListener("abort", f), e ? d(t) : u(void 0);
}new Promise((e, t) => {
!function r(o) {
o ? e() : (!0 === l ? Promise.resolve(!0) : s._readyPromise.then(() => Be(a).then(({ value: e, done: t }) => !0 === t || (c = Y(s, e).catch(() => {}), !1)))).then(r, t);
}(!1);
}).catch(e => {
c = Promise.resolve(), w(e);
});
});
}function me(e, t) {
return new Promise((r, o) => {
const n = { _resolve: r, _reject: o, _forAuthorCode: t };e._reader._readIntoRequests.push(n);
});
}function ye(e, t) {
return new Promise((r, o) => {
const n = { _resolve: r, _reject: o, _forAuthorCode: t };e._reader._readRequests.push(n);
});
}function pe(e, t) {
if (e._disturbed = !0, "closed" === e._state) return Promise.resolve(void 0);if ("errored" === e._state) return Promise.reject(e._storedError);return we(e), e._readableStreamController[le](t).then(() => void 0);
}function we(e) {
e._state = "closed";const t = e._reader;if (void 0 !== t) {
if (Ce(t)) {
for (const _ref of t._readRequests) {
const e = _ref._resolve;
const r = _ref._forAuthorCode;
e(ge(void 0, !0, r));
}t._readRequests = [];
}_t(t);
}
}function ge(e, t, r) {
let o = null;!0 === r && (o = Object.prototype);const n = Object.create(o);return Object.defineProperty(n, "value", { value: e, enumerable: !0, writable: !0, configurable: !0 }), Object.defineProperty(n, "done", { value: t, enumerable: !0, writable: !0, configurable: !0 }), n;
}function Se(e, t) {
e._state = "errored", e._storedError = t;const r = e._reader;if (void 0 !== r) {
if (Ce(r)) {
for (const e of r._readRequests) e._reject(t);r._readRequests = [];
} else {
for (const e of r._readIntoRequests) e._reject(t);r._readIntoRequests = [];
}ft(r, t);
}
}function ve(e, t, r) {
const o = e._reader._readRequests.shift();o._resolve(ge(t, r, o._forAuthorCode));
}function Re(e) {
return e._reader._readIntoRequests.length;
}function Pe(e) {
return e._reader._readRequests.length;
}function Te(e) {
const t = e._reader;return void 0 !== t && !!Ee(t);
}function qe(e) {
const t = e._reader;return void 0 !== t && !!Ce(t);
}class ReadableStreamDefaultReader {
constructor(e) {
if (!1 === _e(e)) throw new TypeError("ReadableStreamDefaultReader can only be constructed with a ReadableStream instance");if (!0 === he(e)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");je(this, e), this._readRequests = [];
}get closed() {
return Ce(this) ? this._closedPromise : Promise.reject(ct("closed"));
}cancel(e) {
return Ce(this) ? void 0 === this._ownerReadableStream ? Promise.reject(lt("cancel")) : Ae(this, e) : Promise.reject(ct("cancel"));
}read() {
return Ce(this) ? void 0 === this._ownerReadableStream ? Promise.reject(lt("read from")) : Be(this, !0) : Promise.reject(ct("read"));
}releaseLock() {
if (!Ce(this)) throw ct("releaseLock");if (void 0 !== this._ownerReadableStream) {
if (this._readRequests.length > 0) throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled");We(this);
}
}
}class ReadableStreamBYOBReader {
constructor(e) {
if (!_e(e)) throw new TypeError("ReadableStreamBYOBReader can only be constructed with a ReadableStream instance given a byte source");if (!1 === Ne(e._readableStreamController)) throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");if (he(e)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");je(this, e), this._readIntoRequests = [];
}get closed() {
return Ee(this) ? this._closedPromise : Promise.reject(ht("closed"));
}cancel(e) {
return Ee(this) ? void 0 === this._ownerReadableStream ? Promise.reject(lt("cancel")) : Ae(this, e) : Promise.reject(ht("cancel"));
}read(e) {
return Ee(this) ? void 0 === this._ownerReadableStream ? Promise.reject(lt("read from")) : ArrayBuffer.isView(e) ? (e.buffer, 0 === e.byteLength ? Promise.reject(new TypeError("view must have non-zero byteLength")) : function (e, t, r = !1) {
const o = e._ownerReadableStream;if (o._disturbed = !0, "errored" === o._state) return Promise.reject(o._storedError);return function (e, t, r) {
const o = e._controlledReadableByteStream;let n = 1;t.constructor !== DataView && (n = t.constructor.BYTES_PER_ELEMENT);const i = t.constructor,
a = { buffer: _(t.buffer), byteOffset: t.byteOffset, byteLength: t.byteLength, bytesFilled: 0, elementSize: n, ctor: i, readerType: "byob" };if (e._pendingPullIntos.length > 0) return e._pendingPullIntos.push(a), me(o, r);if ("closed" === o._state) {
const e = new i(a.buffer, a.byteOffset, 0);return Promise.resolve(ge(e, !0, r));
}if (e._queueTotalSize > 0) {
if (!0 === Je(e, a)) {
const t = Ve(a);return Xe(e), Promise.resolve(ge(t, !1, r));
}if (!0 === e._closeRequested) {
const t = new TypeError("Insufficient bytes to fill elements in the given buffer");return nt(e, t), Promise.reject(t);
}
}e._pendingPullIntos.push(a);const s = me(o, r);return xe(e), s;
}(o._readableStreamController, t, r);
}(this, e, !0)) : Promise.reject(new TypeError("view must be an array buffer view")) : Promise.reject(ht("read"));
}releaseLock() {
if (!Ee(this)) throw ht("releaseLock");if (void 0 !== this._ownerReadableStream) {
if (this._readIntoRequests.length > 0) throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled");We(this);
}
}
}function Ee(e) {
return !!n(e) && !!Object.prototype.hasOwnProperty.call(e, "_readIntoRequests");
}function Ce(e) {
return !!n(e) && !!Object.prototype.hasOwnProperty.call(e, "_readRequests");
}function je(e, t) {
e._ownerReadableStream = t, t._reader = e, "readable" === t._state ? ut(e) : "closed" === t._state ? function (e) {
ut(e), _t(e);
}(e) : dt(e, t._storedError);
}function Ae(e, t) {
return pe(e._ownerReadableStream, t);
}function We(e) {
"readable" === e._ownerReadableStream._state ? ft(e, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")) : function (e, t) {
dt(e, t);
}(e, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")), e._ownerReadableStream._reader = void 0, e._ownerReadableStream = void 0;
}function Be(e, t = !1) {
const r = e._ownerReadableStream;return r._disturbed = !0, "closed" === r._state ? Promise.resolve(ge(void 0, !0, t)) : "errored" === r._state ? Promise.reject(r._storedError) : r._readableStreamController[ce](t);
}class ReadableStreamDefaultController {
constructor() {
throw new TypeError();
}get desiredSize() {
if (!1 === Oe(this)) throw bt("desiredSize");return Me(this);
}close() {
if (!1 === Oe(this)) throw bt("close");if (!1 === Ye(this)) throw new TypeError("The stream is not in a state that permits close");Le(this);
}enqueue(e) {
if (!1 === Oe(this)) throw bt("enqueue");if (!1 === Ye(this)) throw new TypeError("The stream is not in a state that permits enqueue");return Ie(this, e);
}error(e) {
if (!1 === Oe(this)) throw bt("error");De(this, e);
}[le](e) {
v(this);const t = this._cancelAlgorithm(e);return Fe(this), t;
}[ce](e) {
const t = this._controlledReadableStream;if (this._queue.length > 0) {
const r = g(this);return !0 === this._closeRequested && 0 === this._queue.length ? (Fe(this), we(t)) : ze(this), Promise.resolve(ge(r, !1, e));
}const r = ye(t, e);return ze(this), r;
}
}function Oe(e) {
return !!n(e) && !!Object.prototype.hasOwnProperty.call(e, "_controlledReadableStream");
}function ze(e) {
!1 !== ke(e) && (!0 !== e._pulling ? (e._pulling = !0, e._pullAlgorithm().then(() => {
if (e._pulling = !1, !0 === e._pullAgain) return e._pullAgain = !1, ze(e);
}, t => {
De(e, t);
}).catch(w)) : e._pullAgain = !0);
}function ke(e) {
const t = e._controlledReadableStream;return !1 !== Ye(e) && !1 !== e._started && (!0 === he(t) && Pe(t) > 0 || Me(e) > 0);
}function Fe(e) {
e._pullAlgorithm = void 0, e._cancelAlgorithm = void 0, e._strategySizeAlgorithm = void 0;
}function Le(e) {
const t = e._controlledReadableStream;e._closeRequested = !0, 0 === e._queue.length && (Fe(e), we(t));
}function Ie(e, t) {
const r = e._controlledReadableStream;if (!0 === he(r) && Pe(r) > 0) ve(r, t, !1);else {
let r;try {
r = e._strategySizeAlgorithm(t);
} catch (t) {
throw De(e, t), t;
}try {
S(e, t, r);
} catch (t) {
throw De(e, t), t;
}
}ze(e);
}function De(e, t) {
const r = e._controlledReadableStream;"readable" === r._state && (v(e), Fe(e), Se(r, t));
}function Me(e) {
const t = e._controlledReadableStream._state;return "errored" === t ? null : "closed" === t ? 0 : e._strategyHWM - e._queueTotalSize;
}function Ye(e) {
const t = e._controlledReadableStream._state;return !1 === e._closeRequested && "readable" === t;
}function $e(e, t, r, o, n, i, a) {
t._controlledReadableStream = e, t._queue = void 0, t._queueTotalSize = void 0, v(t), t._started = !1, t._closeRequested = !1, t._pullAgain = !1, t._pulling = !1, t._strategySizeAlgorithm = a, t._strategyHWM = i, t._pullAlgorithm = o, t._cancelAlgorithm = n, e._readableStreamController = t;const s = r();Promise.resolve(s).then(() => {
t._started = !0, ze(t);
}, e => {
De(t, e);
}).catch(w);
}class ReadableStreamBYOBRequest {
constructor() {
throw new TypeError("ReadableStreamBYOBRequest cannot be used directly");
}get view() {
if (!1 === Qe(this)) throw mt("view");return this._view;
}respond(e) {
if (!1 === Qe(this)) throw mt("respond");if (void 0 === this._associatedReadableByteStreamController) throw new TypeError("This BYOB request has been invalidated");this._view.buffer, function (e, t) {
if (!1 === l(t = Number(t))) throw new RangeError("bytesWritten must be a finite");tt(e, t);
}(this._associatedReadableByteStreamController, e);
}respondWithNewView(e) {
if (!1 === Qe(this)) throw mt("respond");if (void 0 === this._associatedReadableByteStreamController) throw new TypeError("This BYOB request has been invalidated");if (!ArrayBuffer.isView(e)) throw new TypeError("You can only respond with array buffer views");e.buffer, function (e, t) {
const r = e._pendingPullIntos[0];if (r.byteOffset + r.bytesFilled !== t.byteOffset) throw new RangeError("The region specified by view does not match byobRequest");if (r.byteLength !== t.byteLength) throw new RangeError("The buffer of view has different capacity than byobRequest");r.buffer = t.buffer, tt(e, t.byteLength);
}(this._associatedReadableByteStreamController, e);
}
}class ReadableByteStreamController {
constructor() {
throw new TypeError("ReadableByteStreamController constructor cannot be used directly");
}get byobRequest() {
if (!1 === Ne(this)) throw yt("byobRequest");if (void 0 === this._byobRequest && this._pendingPullIntos.length > 0) {
const e = this._pendingPullIntos[0],
t = new Uint8Array(e.buffer, e.byteOffset + e.bytesFilled, e.byteLength - e.bytesFilled),
r = Object.create(ReadableStreamBYOBRequest.prototype);!function (e, t, r) {
e._associatedReadableByteStreamController = t, e._view = r;
}(r, this, t), this._byobRequest = r;
}return this._byobRequest;
}get desiredSize() {
if (!1 === Ne(this)) throw yt("desiredSize");return it(this);
}close() {
if (!1 === Ne(this)) throw yt("close");if (!0 === this._closeRequested) throw new TypeError("The stream has already been closed; do not close it again!");const e = this._controlledReadableByteStream._state;if ("readable" !== e) throw new TypeError(`The stream (in ${e} state) is not in the readable state and cannot be closed`);!function (e) {
const t = e._controlledReadableByteStream;if (e._queueTotalSize > 0) return void (e._closeRequested = !0);if (e._pendingPullIntos.length > 0) {
const t = e._pendingPullIntos[0];if (t.bytesFilled > 0) {
const t = new TypeError("Insufficient bytes to fill elements in the given buffer");throw nt(e, t), t;
}
}ot(e), we(t);
}(this);
}enqueue(e) {
if (!1 === Ne(this)) throw yt("enqueue");if (!0 === this._closeRequested) throw new TypeError("stream is closed or draining");const t = this._controlledReadableByteStream._state;if ("readable" !== t) throw new TypeError(`The stream (in ${t} state) is not in the readable state and cannot be enqueued to`);if (!ArrayBuffer.isView(e)) throw new TypeError("You can only enqueue array buffer views when using a ReadableByteStreamController");e.buffer, function (e, t) {
const r = e._controlledReadableByteStream,
o = t.buffer,
n = t.byteOffset,
i = t.byteLength,
a = _(o);if (!0 === qe(r)) {
if (0 === Pe(r)) Ge(e, a, n, i);else {
const e = new Uint8Array(a, n, i);ve(r, e, !1);
}
} else !0 === Te(r) ? (Ge(e, a, n, i), et(e)) : Ge(e, a, n, i);xe(e);
}(this, e);
}error(e) {
if (!1 === Ne(this)) throw yt("error");nt(this, e);
}[le](e) {
if (this._pendingPullIntos.length > 0) {
this._pendingPullIntos[0].bytesFilled = 0;
}v(this);const t = this._cancelAlgorithm(e);return ot(this), t;
}[ce](e) {
const t = this._controlledReadableByteStream;if (this._queueTotalSize > 0) {
const t = this._queue.shift();let r;this._queueTotalSize -= t.byteLength, Xe(this);try {
r = new Uint8Array(t.buffer, t.byteOffset, t.byteLength);
} catch (e) {
return Promise.reject(e);
}return Promise.resolve(ge(r, !1, e));
}const r = this._autoAllocateChunkSize;if (void 0 !== r) {
let e;try {
e = new ArrayBuffer(r);
} catch (e) {
return Promise.reject(e);
}const t = { buffer: e, byteOffset: 0, byteLength: r, bytesFilled: 0, elementSize: 1, ctor: Uint8Array, readerType: "default" };this._pendingPullIntos.push(t);
}const o = ye(t, e);return xe(this), o;
}
}function Ne(e) {
return !!n(e) && !!Object.prototype.hasOwnProperty.call(e, "_controlledReadableByteStream");
}function Qe(e) {
return !!n(e) && !!Object.prototype.hasOwnProperty.call(e, "_associatedReadableByteStreamController");
}function xe(e) {
!1 !== function (e) {
const t = e._controlledReadableByteStream;if ("readable" !== t._state) return !1;if (!0 === e._closeRequested) return !1;if (!1 === e._started) return !1;if (!0 === qe(t) && Pe(t) > 0) return !0;if (!0 === Te(t) && Re(t) > 0) return !0;if (it(e) > 0) return !0;return !1;
}(e) && (!0 !== e._pulling ? (e._pulling = !0, e._pullAlgorithm().then(() => {
e._pulling = !1, !0 === e._pullAgain && (e._pullAgain = !1, xe(e));
}, t => {
nt(e, t);
}).catch(w)) : e._pullAgain = !0);
}function He(e) {
Ze(e), e._pendingPullIntos = [];
}function Ue(e, t) {
let r = !1;"closed" === e._state && (r = !0);const o = Ve(t);"default" === t.readerType ? ve(e, o, r) : function (e, t, r) {
const o = e._reader._readIntoRequests.shift();o._resolve(ge(t, r, o._forAuthorCode));
}(e, o, r);
}function Ve(e) {
const t = e.bytesFilled,
r = e.elementSize;return new e.ctor(e.buffer, e.byteOffset, t / r);
}function Ge(e, t, r, o) {
e._queue.push({ buffer: t, byteOffset: r, byteLength: o }), e._queueTotalSize += o;
}function Je(e, t) {
const r = t.elementSize,
o = t.bytesFilled - t.bytesFilled % r,
n = Math.min(e._queueTotalSize, t.byteLength - t.bytesFilled),
i = t.bytesFilled + n,
a = i - i % r;let l = n,
c = !1;a > o && (l = a - t.bytesFilled, c = !0);const u = e._queue;for (; l > 0;) {
const r = u[0],
o = Math.min(l, r.byteLength),
n = t.byteOffset + t.bytesFilled;s(t.buffer, n, r.buffer, r.byteOffset, o), r.byteLength === o ? u.shift() : (r.byteOffset += o, r.byteLength -= o), e._queueTotalSize -= o, Ke(e, o, t), l -= o;
}return c;
}function Ke(e, t, r) {
Ze(e), r.bytesFilled += t;
}function Xe(e) {
0 === e._queueTotalSize && !0 === e._closeRequested ? (ot(e), we(e._controlledReadableByteStream)) : xe(e);
}function Ze(e) {
void 0 !== e._byobRequest && (e._byobRequest._associatedReadableByteStreamController = void 0, e._byobRequest._view = void 0, e._byobRequest = void 0);
}function et(e) {
for (; e._pendingPullIntos.length > 0;) {
if (0 === e._queueTotalSize) return;const t = e._pendingPullIntos[0];!0 === Je(e, t) && (rt(e), Ue(e._controlledReadableByteStream, t));
}
}function tt(e, t) {
const r = e._pendingPullIntos[0];if ("closed" === e._controlledReadableByteStream._state) {
if (0 !== t) throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream");!function (e, t) {
t.buffer = _(t.buffer);const r = e._controlledReadableByteStream;if (!0 === Te(r)) for (; Re(r) > 0;) Ue(r, rt(e));
}(e, r);
} else !function (e, t, r) {
if (r.bytesFilled + t > r.byteLength) throw new RangeError("bytesWritten out of range");if (Ke(e, t, r), r.bytesFilled < r.elementSize) return;rt(e);const o = r.bytesFilled % r.elementSize;if (o > 0) {
const t = r.byteOffset + r.bytesFilled,
n = r.buffer.slice(t - o, t);Ge(e, n, 0, n.byteLength);
}r.buffer = _(r.buffer), r.bytesFilled -= o, Ue(e._controlledReadableByteStream, r), et(e);
}(e, t, r);xe(e);
}function rt(e) {
const t = e._pendingPullIntos.shift();return Ze(e), t;
}function ot(e) {
e._pullAlgorithm = void 0, e._cancelAlgorithm = void 0;
}function nt(e, t) {
const r = e._controlledReadableByteStream;"readable" === r._state && (He(e), v(e), ot(e), Se(r, t));
}function it(e) {
const t = e._controlledReadableByteStream._state;return "errored" === t ? null : "closed" === t ? 0 : e._strategyHWM - e._queueTotalSize;
}function at(e) {
if ("object" != typeof e || null === e) return !1;const t = Object.getOwnPropertyDescriptor(AbortSignal.prototype, "aborted").get;try {
return t.call(e), !0;
} catch (e) {
return !1;
}
}function st(e) {
return new TypeError(`ReadableStream.prototype.${e} can only be used on a ReadableStream`);
}function lt(e) {
return new TypeError("Cannot " + e + " a stream using a released reader");
}function ct(e) {
return new TypeError(`ReadableStreamDefaultReader.prototype.${e} can only be used on a ReadableStreamDefaultReader`);
}function ut(e) {
e._closedPromise = new Promise((t, r) => {
e._closedPromise_resolve = t, e._closedPromise_reject = r;
});
}function dt(e, t) {
ut(e), ft(e, t);
}function ft(e, t) {
e._closedPromise.catch(() => {}), e._closedPromise_reject(t), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0;
}function _t(e) {
e._closedPromise_resolve(void 0), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0;
}function ht(e) {
return new TypeError(`ReadableStreamBYOBReader.prototype.${e} can only be used on a ReadableStreamBYOBReader`);
}function bt(e) {
return new TypeError(`ReadableStreamDefaultController.prototype.${e} can only be used on a ReadableStreamDefaultController`);
}function mt(e) {
return new TypeError(`ReadableStreamBYOBRequest.prototype.${e} can only be used on a ReadableStreamBYOBRequest`);
}function yt(e) {
return new TypeError(`ReadableByteStreamController.prototype.${e} can only be used on a ReadableByteStreamController`);
}class ByteLengthQueuingStrategy {
constructor({ highWaterMark: e }) {
i(this, "highWaterMark", e);
}size(e) {
return e.byteLength;
}
}class CountQueuingStrategy {
constructor({ highWaterMark: e }) {
i(this, "highWaterMark", e);
}size() {
return 1;
}
}class TransformStream {
constructor(e = {}, t = {}, r = {}) {
const o = t.size;let n = t.highWaterMark;const i = r.size;let a = r.highWaterMark;if (void 0 !== e.writableType) throw new RangeError("Invalid writable type specified");const s = b(o);if (void 0 === n && (n = 1), n = h(n), void 0 !== e.readableType) throw new RangeError("Invalid readable type specified");const l = b(i);let c;void 0 === a && (a = 0), a = h(a), function (e, t, r, o, n, i) {
function a() {
return t;
}e._writable = function (e, t, r, o, n = 1, i = () => 1) {
const a = Object.create(WritableStream.prototype);return q(a), $(a, Object.create(WritableStreamDefaultController.prototype), e, t, r, o, n, i), a;
}(a, function (t) {
return function (e, t) {
const r = e._transformStreamController;if (!0 === e._backpressure) {
const o = e._backpressureChangePromise;return o.then(() => {
const o = e._writable,
n = o._state;if ("erroring" === n) throw o._storedError;return Tt(r, t);
});
}return Tt(r, t);
}(e, t);
}, function () {
return function (e) {
const t = e._readable,
r = e._transformStreamController,
o = r._flushAlgorithm();return Rt(r), o.then(() => {
if ("errored" === t._state) throw t._storedError;const e = t._readableStreamController;!0 === Ye(e) && Le(e);
}).catch(r => {
throw wt(e, r), t._storedError;
});
}(e);
}, function (t) {
return function (e, t) {
return wt(e, t), Promise.resolve();
}(e, t);
}, r, o), e._readable = de(a, function () {
return function (e) {
return St(e, !1), e._backpressureChangePromise;
}(e);
}, function (t) {
return gt(e, t), Promise.resolve();
}, n, i), e._backpressure = void 0, e._backpressureChangePromise = void 0, e._backpressureChangePromise_resolve = void 0, St(e, !0), e._transformStreamController = void 0;
}(this, new Promise(e => {
c = e;
}), n, s, a, l), function (e, t) {
const r = Object.create(TransformStreamDefaultController.prototype);let o = e => {
try {
return Pt(r, e), Promise.resolve();
} catch (e) {
return Promise.reject(e);
}
};const n = t.transform;if (void 0 !== n) {
if ("function" != typeof n) throw new TypeError("transform is not a method");o = e => f(n, t, [e, r]);
}const i = u(t, "flush", 0, [r]);!function (e, t, r, o) {
t._controlledTransformStream = e, e._transformStreamController = t, t._transformAlgorithm = r, t._flushAlgorithm = o;
}(e, r, o, i);
}(this, e);const _ = d(e, "start", [this._transformStreamController]);c(_);
}get readable() {
if (!1 === pt(this)) throw Et("readable");return this._readable;
}get writable() {
if (!1 === pt(this)) throw Et("writable");return this._writable;
}
}function pt(e) {
return !!n(e) && !!Object.prototype.hasOwnProperty.call(e, "_transformStreamController");
}function wt(e, t) {
De(e._readable._readableStreamController, t), gt(e, t);
}function gt(e, t) {
Rt(e._transformStreamController), H(e._writable._writableStreamController, t), !0 === e._backpressure && St(e, !1);
}function St(e, t) {
void 0 !== e._backpressureChangePromise && e._backpressureChangePromise_resolve(), e._backpressureChangePromise = new Promise(t => {
e._backpressureChangePromise_resolve = t;
}), e._backpressure = t;
}class TransformStreamDefaultController {
constructor() {
throw new TypeError("TransformStreamDefaultController instances cannot be created directly");
}get desiredSize() {
if (!1 === vt(this)) throw qt("desiredSize");return Me(this._controlledTransformStream._readable._readableStreamController);
}enqueue(e) {
if (!1 === vt(this)) throw qt("enqueue");Pt(this, e);
}error(e) {
if (!1 === vt(this)) throw qt("error");!function (e, t) {
wt(e._controlledTransformStream, t);
}(this, e);
}terminate() {
if (!1 === vt(this)) throw qt("terminate");!function (e) {
const t = e._controlledTransformStream,
r = t._readable._readableStreamController;!0 === Ye(r) && Le(r);const o = new TypeError("TransformStream terminated");gt(t, o);
}(this);
}
}function vt(e) {
return !!n(e) && !!Object.prototype.hasOwnProperty.call(e, "_controlledTransformStream");
}function Rt(e) {
e._transformAlgorithm = void 0, e._flushAlgorithm = void 0;
}function Pt(e, t) {
const r = e._controlledTransformStream,
o = r._readable._readableStreamController;if (!1 === Ye(o)) throw new TypeError("R