@sheetxl/studio-mui 0.4.20 → 0.4.22

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (98) hide show
  1. package/browser/cjs/2d2J6QkipnGWfI99.cjs +6 -0
  2. package/browser/cjs/BY09bxecVOSMwQA3.cjs +6 -0
  3. package/browser/cjs/BYJI3FMxQ-z5UGsU.cjs +6 -0
  4. package/browser/cjs/B_nvuo0kEXu5G0Gf.cjs +7 -0
  5. package/browser/cjs/BfnxiVEhzO5reOYH.cjs +42 -0
  6. package/browser/cjs/Bil3fXnJ3lk7aGF5.cjs +6 -0
  7. package/browser/cjs/{DItuuqkIamMzp7Im.cjs → BzbKSVugPof6dqQI.cjs} +1 -1
  8. package/browser/cjs/CU0utErelA1oX0n8.cjs +6 -0
  9. package/browser/cjs/CWp8_mrz0htdOXMM.cjs +20 -0
  10. package/browser/cjs/D2Cp7gwb6bRupSZY.cjs +6 -0
  11. package/browser/cjs/DC70SHoaPVkOUEHx.cjs +6 -0
  12. package/browser/cjs/DRUx3PLS_NrkJ6Yw.cjs +18 -0
  13. package/browser/cjs/index.cjs +2 -2
  14. package/browser/esm/-0XEuwqNVFTlDKEX.mjs +25 -0
  15. package/browser/esm/-AR3L_VjwMbtQVbL.mjs +62 -0
  16. package/browser/esm/BLhZj1SgWlsmeviw.mjs +4443 -0
  17. package/browser/esm/{BW3_mz5_8i9VLBYB.mjs → BXNl9EEQzO53Hoh5.mjs} +87 -85
  18. package/browser/esm/BqnVpwK0Q2fKGA2S.mjs +53 -0
  19. package/browser/esm/D4rFOqwrrtVMpgbc.mjs +49 -0
  20. package/browser/esm/DEbllEGmvtLkCug_.mjs +2156 -0
  21. package/browser/esm/{C60ZnLCvtztDLuoT.mjs → DXRFs7VZM4IShMju.mjs} +100 -98
  22. package/browser/esm/{C5xUbwpUPDeNua-i.mjs → DeGATuYv4-5bhQcD.mjs} +1 -1
  23. package/browser/esm/{5u-JEG1IfQBstjq0.mjs → EMqbYi0X_krk5yOL.mjs} +11 -10
  24. package/browser/esm/fWsCG2WBM3kCpC5p.mjs +46 -0
  25. package/browser/esm/index.mjs +29 -29
  26. package/browser/esm/{CxXpPYi4eOFhBNt2.mjs → pARZF2O230qNvxWd.mjs} +27 -26
  27. package/licenses/dependencies.txt +0 -271
  28. package/node/esm/{D6A_o47zvz5ITIJK.mjs → 0JTY0jNrXiIiOqWY.mjs} +79 -78
  29. package/node/esm/{Ds5dinNcyNdC8ta6.mjs → BqQ6JNhQ1K321g9U.mjs} +13 -11
  30. package/node/esm/{CrDbLKJh9omVo_TF.mjs → Bu58psaOsDy_zPOJ.mjs} +29 -28
  31. package/node/esm/BzBHqe1ThbCP-l_d.mjs +88 -0
  32. package/node/esm/CE_I2ijQF8MeexHD.mjs +63 -0
  33. package/node/esm/{Bv12-Yyv0C86Iquy.mjs → CuomeW-4DDc1ywFW.mjs} +7 -6
  34. package/node/esm/DRt8kMDuCJn53CIE.mjs +46 -0
  35. package/node/esm/{CH6p2H0CMCoz4NgJ.mjs → DgHCTCARk1Gv_msN.mjs} +23 -22
  36. package/node/esm/{Bn5TJPQAEMY-lGpF.mjs → Do7y7aKPA48-93AV.mjs} +4 -3
  37. package/node/esm/{rlqvGCJlj4a2UcSM.mjs → X11ONmg6R1Y6hfue.mjs} +11 -10
  38. package/node/esm/index.mjs +2381 -18514
  39. package/package.json +8 -8
  40. package/browser/cjs/-Z37a-mzY5SKXy--.cjs +0 -6
  41. package/browser/cjs/B384kb1_rsiCsdZG.cjs +0 -6
  42. package/browser/cjs/B8nWvy4zDv1CZsr_.cjs +0 -110
  43. package/browser/cjs/BBnMJiXp9lru0Rcq.cjs +0 -6
  44. package/browser/cjs/BFbHTu65n1oE-l0N.cjs +0 -6
  45. package/browser/cjs/BQMSHnQdWtqeakER.cjs +0 -6
  46. package/browser/cjs/BvjA0ybox6653eb5.cjs +0 -6
  47. package/browser/cjs/Cocgl4ghzWE9yVYS.cjs +0 -161
  48. package/browser/cjs/D21Q1NdM1zQ7uFlH.cjs +0 -6
  49. package/browser/cjs/D4LmaKqYiwjxp0Hs.cjs +0 -15
  50. package/browser/cjs/D6egUillMqBwTaEq.cjs +0 -6
  51. package/browser/cjs/D9lY6pd9tRxPeLKs.cjs +0 -18
  52. package/browser/cjs/DNqIYSqRYZkUpFxW.cjs +0 -7
  53. package/browser/cjs/DUImSlPsM-OipgBZ.cjs +0 -6
  54. package/browser/cjs/DUVLcBcwkTsuLb6q.cjs +0 -6
  55. package/browser/cjs/Db7IyKXFzo8IocDa.cjs +0 -145
  56. package/browser/cjs/DsHPj69dMFG09uD_.cjs +0 -16
  57. package/browser/cjs/DypblOPNMRx5Twgx.cjs +0 -12
  58. package/browser/cjs/QK7YNBstmN86K-xL.cjs +0 -6
  59. package/browser/cjs/VNWvn2kP6ZF0Snzw.cjs +0 -11
  60. package/browser/cjs/dc1YAArM3bSHvRcF.cjs +0 -7
  61. package/browser/cjs/mInXvB8P6r6q7pRY.cjs +0 -11
  62. package/browser/cjs/nop6N-Oi_LKy1Bpc.cjs +0 -42
  63. package/browser/cjs/s45oNHeIvJVeRjn5.cjs +0 -6
  64. package/browser/esm/1y10o01h14oGJtKG.mjs +0 -43
  65. package/browser/esm/BFpc8KBa-fb0nLSt.mjs +0 -46
  66. package/browser/esm/Bmjhrc6YMmfx_1Yi.mjs +0 -1703
  67. package/browser/esm/BnlJVFlQeWerd3KW.mjs +0 -3803
  68. package/browser/esm/BpuH_QvBidPOXgAR.mjs +0 -392
  69. package/browser/esm/CAiWSkkPRgUjk8CN.mjs +0 -424
  70. package/browser/esm/CW8taieVozHhyBOC.mjs +0 -1467
  71. package/browser/esm/CzyEerZmfWrW3i3U.mjs +0 -59
  72. package/browser/esm/D0FBHwm0Oz_wf0tR.mjs +0 -12
  73. package/browser/esm/DM9GPrZpbCcKOnyU.mjs +0 -1352
  74. package/browser/esm/DO1doKZhwYiL7vbF.mjs +0 -1672
  75. package/browser/esm/DS3anstzAV3EJBRw.mjs +0 -84
  76. package/browser/esm/DuEmdSQsXlkCWZIB.mjs +0 -1366
  77. package/browser/esm/FvK-pQsicRjtrKoS.mjs +0 -48
  78. package/browser/esm/KCTJzQeDChqf1yBO.mjs +0 -52
  79. package/browser/esm/P-3pIbidOtRCNsw3.mjs +0 -23
  80. package/browser/esm/W3EFMOPLR1aNXWvF.mjs +0 -2250
  81. package/browser/esm/Z_Sh-N3xHHWLCbEw.mjs +0 -23412
  82. package/browser/esm/mOmzoYDWAtgYndCA.mjs +0 -13391
  83. package/browser/esm/tnJECoiQzUzgUQZE.mjs +0 -44
  84. package/node/esm/54SjtcD6mOreKcCy.mjs +0 -1719
  85. package/node/esm/B2BlMiDOVpIp1FDQ.mjs +0 -1706
  86. package/node/esm/BNEvR1srnnwBgnrF.mjs +0 -1479
  87. package/node/esm/BZ20_F64yjZgn-_G.mjs +0 -1246
  88. package/node/esm/BfzRLuswtxg9uDsX.mjs +0 -78
  89. package/node/esm/C0ZBbkFa-24tJTnw.mjs +0 -60
  90. package/node/esm/CEVO60fX3MAPG0Hg.mjs +0 -1378
  91. package/node/esm/CdFmhVFplZFgBvTo.mjs +0 -44
  92. package/node/esm/Cx4mn0YEVkG-M1VL.mjs +0 -553
  93. package/node/esm/DDWek3aquTe_okr_.mjs +0 -392
  94. package/node/esm/DSLWcwr4qgHARs36.mjs +0 -13464
  95. package/node/esm/iXG86MN0JrtJkpqe.mjs +0 -44
  96. package/node/esm/m2teXjBzZLfLDFPx.mjs +0 -46
  97. package/node/esm/oykDy4erHC0NNHHq.mjs +0 -3776
  98. package/node/esm/sVOd1y3oNBREsKJ7.mjs +0 -86
@@ -1,1719 +0,0 @@
1
- /**
2
- * @license @sheetxl/studio-mui - Studio - Spreadsheet UI built with SheetXL SDK using React & MUI. - v0.4.20
3
- *
4
- * (C) 2025-present SheetXL Inc. & Michael T. Ford
5
- * License: The license can be found at https://www.sheetxl.com/license.
6
- */
7
- function e() {
8
- }
9
- function t(e2) {
10
- return "object" == typeof e2 && null !== e2 || "function" == typeof e2;
11
- }
12
- const r = e;
13
- function o(e2, t2) {
14
- try {
15
- Object.defineProperty(e2, "name", { value: t2, configurable: true });
16
- } catch (e3) {
17
- }
18
- }
19
- const n = Promise, i = Promise.resolve.bind(n), a = Promise.prototype.then, s = Promise.reject.bind(n), l = i;
20
- function u(e2) {
21
- return new n(e2);
22
- }
23
- function c(e2) {
24
- return u((t2) => t2(e2));
25
- }
26
- function d(e2) {
27
- return s(e2);
28
- }
29
- function f(e2, t2, r2) {
30
- return a.call(e2, t2, r2);
31
- }
32
- function b(e2, t2, o2) {
33
- f(f(e2, t2, o2), void 0, r);
34
- }
35
- function h(e2, t2) {
36
- b(e2, t2);
37
- }
38
- function _(e2, t2) {
39
- b(e2, void 0, t2);
40
- }
41
- function p(e2, t2, r2) {
42
- return f(e2, t2, r2);
43
- }
44
- function m(e2) {
45
- f(e2, void 0, r);
46
- }
47
- let y = (e2) => {
48
- if ("function" == typeof queueMicrotask) y = queueMicrotask;
49
- else {
50
- const e3 = c(void 0);
51
- y = (t2) => f(e3, t2);
52
- }
53
- return y(e2);
54
- };
55
- function v(e2, t2, r2) {
56
- if ("function" != typeof e2) throw new TypeError("Argument is not a function");
57
- return Function.prototype.apply.call(e2, t2, r2);
58
- }
59
- function w(e2, t2, r2) {
60
- try {
61
- return c(v(e2, t2, r2));
62
- } catch (e3) {
63
- return d(e3);
64
- }
65
- }
66
- class g {
67
- constructor() {
68
- this._cursor = 0, this._size = 0, this._front = { _elements: [], _next: void 0 }, this._back = this._front, this._cursor = 0, this._size = 0;
69
- }
70
- get length() {
71
- return this._size;
72
- }
73
- push(e2) {
74
- const t2 = this._back;
75
- let r2 = t2;
76
- 16383 === t2._elements.length && (r2 = { _elements: [], _next: void 0 }), t2._elements.push(e2), r2 !== t2 && (this._back = r2, t2._next = r2), ++this._size;
77
- }
78
- shift() {
79
- const e2 = this._front;
80
- let t2 = e2;
81
- const r2 = this._cursor;
82
- let o2 = r2 + 1;
83
- const n2 = e2._elements, i2 = n2[r2];
84
- return 16384 === o2 && (t2 = e2._next, o2 = 0), --this._size, this._cursor = o2, e2 !== t2 && (this._front = t2), n2[r2] = void 0, i2;
85
- }
86
- forEach(e2) {
87
- let t2 = this._cursor, r2 = this._front, o2 = r2._elements;
88
- for (; !(t2 === o2.length && void 0 === r2._next || t2 === o2.length && (r2 = r2._next, o2 = r2._elements, t2 = 0, 0 === o2.length)); ) e2(o2[t2]), ++t2;
89
- }
90
- peek() {
91
- const e2 = this._front, t2 = this._cursor;
92
- return e2._elements[t2];
93
- }
94
- }
95
- const S = Symbol("[[AbortSteps]]"), R = Symbol("[[ErrorSteps]]"), T = Symbol("[[CancelSteps]]"), q = Symbol("[[PullSteps]]"), E = Symbol("[[ReleaseSteps]]");
96
- function P(e2, t2) {
97
- e2._ownerReadableStream = t2, t2._reader = e2, "readable" === t2._state ? j(e2) : "closed" === t2._state ? function(e3) {
98
- j(e3), z(e3);
99
- }(e2) : k(e2, t2._storedError);
100
- }
101
- function C(e2, t2) {
102
- return zr(e2._ownerReadableStream, t2);
103
- }
104
- function O(e2) {
105
- const t2 = e2._ownerReadableStream;
106
- "readable" === t2._state ? W(e2, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")) : function(e3) {
107
- k(e3, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness"));
108
- }(e2), t2._readableStreamController[E](), t2._reader = void 0, e2._ownerReadableStream = void 0;
109
- }
110
- function A(e2) {
111
- return new TypeError("Cannot " + e2 + " a stream using a released reader");
112
- }
113
- function j(e2) {
114
- e2._closedPromise = u((t2, r2) => {
115
- e2._closedPromise_resolve = t2, e2._closedPromise_reject = r2;
116
- });
117
- }
118
- function k(e2, t2) {
119
- j(e2), W(e2, t2);
120
- }
121
- function W(e2, t2) {
122
- void 0 !== e2._closedPromise_reject && (m(e2._closedPromise), e2._closedPromise_reject(t2), e2._closedPromise_resolve = void 0, e2._closedPromise_reject = void 0);
123
- }
124
- function z(e2) {
125
- void 0 !== e2._closedPromise_resolve && (e2._closedPromise_resolve(void 0), e2._closedPromise_resolve = void 0, e2._closedPromise_reject = void 0);
126
- }
127
- const B = Number.isFinite || function(e2) {
128
- return "number" == typeof e2 && isFinite(e2);
129
- }, F = Math.trunc || function(e2) {
130
- return e2 < 0 ? Math.ceil(e2) : Math.floor(e2);
131
- };
132
- function I(e2, t2) {
133
- if (void 0 !== e2 && "object" != typeof (r2 = e2) && "function" != typeof r2) throw new TypeError(`${t2} is not an object.`);
134
- var r2;
135
- }
136
- function L(e2, t2) {
137
- if ("function" != typeof e2) throw new TypeError(`${t2} is not a function.`);
138
- }
139
- function $(e2, t2) {
140
- if (!/* @__PURE__ */ function(e3) {
141
- return "object" == typeof e3 && null !== e3 || "function" == typeof e3;
142
- }(e2)) throw new TypeError(`${t2} is not an object.`);
143
- }
144
- function x(e2, t2, r2) {
145
- if (void 0 === e2) throw new TypeError(`Parameter ${t2} is required in '${r2}'.`);
146
- }
147
- function M(e2, t2, r2) {
148
- if (void 0 === e2) throw new TypeError(`${t2} is required in '${r2}'.`);
149
- }
150
- function D(e2) {
151
- return Number(e2);
152
- }
153
- function N(e2) {
154
- return 0 === e2 ? 0 : e2;
155
- }
156
- function Y(e2, t2) {
157
- const r2 = Number.MAX_SAFE_INTEGER;
158
- let o2 = Number(e2);
159
- if (o2 = N(o2), !B(o2)) throw new TypeError(`${t2} is not a finite number`);
160
- if (o2 = function(e3) {
161
- return N(F(e3));
162
- }(o2), o2 < 0 || o2 > r2) throw new TypeError(`${t2} is outside the accepted range of 0 to ${r2}, inclusive`);
163
- return B(o2) && 0 !== o2 ? o2 : 0;
164
- }
165
- function V(e2, t2) {
166
- if (!kr(e2)) throw new TypeError(`${t2} is not a ReadableStream.`);
167
- }
168
- function U(e2) {
169
- return new K(e2);
170
- }
171
- function H(e2, t2) {
172
- e2._reader._readRequests.push(t2);
173
- }
174
- function G(e2, t2, r2) {
175
- const o2 = e2._reader._readRequests.shift();
176
- r2 ? o2._closeSteps() : o2._chunkSteps(t2);
177
- }
178
- function X(e2) {
179
- return e2._reader._readRequests.length;
180
- }
181
- function J(e2) {
182
- const t2 = e2._reader;
183
- return void 0 !== t2 && !!Q(t2);
184
- }
185
- class K {
186
- constructor(e2) {
187
- if (x(e2, 1, "ReadableStreamDefaultReader"), V(e2, "First parameter"), Wr(e2)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
188
- P(this, e2), this._readRequests = new g();
189
- }
190
- get closed() {
191
- return Q(this) ? this._closedPromise : d(te("closed"));
192
- }
193
- cancel(e2 = void 0) {
194
- return Q(this) ? void 0 === this._ownerReadableStream ? d(A("cancel")) : C(this, e2) : d(te("cancel"));
195
- }
196
- read() {
197
- if (!Q(this)) return d(te("read"));
198
- if (void 0 === this._ownerReadableStream) return d(A("read from"));
199
- let e2, t2;
200
- const r2 = u((r3, o2) => {
201
- e2 = r3, t2 = o2;
202
- });
203
- return Z(this, { _chunkSteps: (t3) => e2({ value: t3, done: false }), _closeSteps: () => e2({ value: void 0, done: true }), _errorSteps: (e3) => t2(e3) }), r2;
204
- }
205
- releaseLock() {
206
- if (!Q(this)) throw te("releaseLock");
207
- void 0 !== this._ownerReadableStream && function(e2) {
208
- O(e2);
209
- ee(e2, new TypeError("Reader was released"));
210
- }(this);
211
- }
212
- }
213
- function Q(e2) {
214
- return !!t(e2) && !!Object.prototype.hasOwnProperty.call(e2, "_readRequests") && e2 instanceof K;
215
- }
216
- function Z(e2, t2) {
217
- const r2 = e2._ownerReadableStream;
218
- r2._disturbed = true, "closed" === r2._state ? t2._closeSteps() : "errored" === r2._state ? t2._errorSteps(r2._storedError) : r2._readableStreamController[q](t2);
219
- }
220
- function ee(e2, t2) {
221
- const r2 = e2._readRequests;
222
- e2._readRequests = new g(), r2.forEach((e3) => {
223
- e3._errorSteps(t2);
224
- });
225
- }
226
- function te(e2) {
227
- return new TypeError(`ReadableStreamDefaultReader.prototype.${e2} can only be used on a ReadableStreamDefaultReader`);
228
- }
229
- var re, oe, ne;
230
- function ie(e2) {
231
- return e2.slice();
232
- }
233
- function ae(e2, t2, r2, o2, n2) {
234
- new Uint8Array(e2).set(new Uint8Array(r2, o2, n2), t2);
235
- }
236
- Object.defineProperties(K.prototype, { cancel: { enumerable: true }, read: { enumerable: true }, releaseLock: { enumerable: true }, closed: { enumerable: true } }), o(K.prototype.cancel, "cancel"), o(K.prototype.read, "read"), o(K.prototype.releaseLock, "releaseLock"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(K.prototype, Symbol.toStringTag, { value: "ReadableStreamDefaultReader", configurable: true });
237
- let se = (e2) => (se = "function" == typeof e2.transfer ? (e3) => e3.transfer() : "function" == typeof structuredClone ? (e3) => structuredClone(e3, { transfer: [e3] }) : (e3) => e3, se(e2)), le = (e2) => (le = "boolean" == typeof e2.detached ? (e3) => e3.detached : (e3) => 0 === e3.byteLength, le(e2));
238
- function ue(e2, t2, r2) {
239
- if (e2.slice) return e2.slice(t2, r2);
240
- const o2 = r2 - t2, n2 = new ArrayBuffer(o2);
241
- return ae(n2, 0, e2, t2, o2), n2;
242
- }
243
- function ce(e2, t2) {
244
- const r2 = e2[t2];
245
- if (null != r2) {
246
- if ("function" != typeof r2) throw new TypeError(`${String(t2)} is not a function`);
247
- return r2;
248
- }
249
- }
250
- function de(e2) {
251
- try {
252
- const t2 = e2.done, r2 = e2.value;
253
- return f(l(r2), (e3) => ({ done: t2, value: e3 }));
254
- } catch (e3) {
255
- return d(e3);
256
- }
257
- }
258
- const fe = null !== (ne = null !== (re = Symbol.asyncIterator) && void 0 !== re ? re : null === (oe = Symbol.for) || void 0 === oe ? void 0 : oe.call(Symbol, "Symbol.asyncIterator")) && void 0 !== ne ? ne : "@@asyncIterator";
259
- function be(e2, r2 = "sync", o2) {
260
- if (void 0 === o2) if ("async" === r2) {
261
- if (void 0 === (o2 = ce(e2, fe))) return function(e3) {
262
- const r3 = { next() {
263
- let t2;
264
- try {
265
- t2 = he(e3);
266
- } catch (e4) {
267
- return d(e4);
268
- }
269
- return de(t2);
270
- }, return(r4) {
271
- let o3;
272
- try {
273
- const t2 = ce(e3.iterator, "return");
274
- if (void 0 === t2) return c({ done: true, value: r4 });
275
- o3 = v(t2, e3.iterator, [r4]);
276
- } catch (e4) {
277
- return d(e4);
278
- }
279
- return t(o3) ? de(o3) : d(new TypeError("The iterator.return() method must return an object"));
280
- } };
281
- return { iterator: r3, nextMethod: r3.next, done: false };
282
- }(be(e2, "sync", ce(e2, Symbol.iterator)));
283
- } else o2 = ce(e2, Symbol.iterator);
284
- if (void 0 === o2) throw new TypeError("The object is not iterable");
285
- const n2 = v(o2, e2, []);
286
- if (!t(n2)) throw new TypeError("The iterator method must return an object");
287
- return { iterator: n2, nextMethod: n2.next, done: false };
288
- }
289
- function he(e2) {
290
- const r2 = v(e2.nextMethod, e2.iterator, []);
291
- if (!t(r2)) throw new TypeError("The iterator.next() method must return an object");
292
- return r2;
293
- }
294
- class _e {
295
- constructor(e2, t2) {
296
- this._ongoingPromise = void 0, this._isFinished = false, this._reader = e2, this._preventCancel = t2;
297
- }
298
- next() {
299
- const e2 = () => this._nextSteps();
300
- return this._ongoingPromise = this._ongoingPromise ? p(this._ongoingPromise, e2, e2) : e2(), this._ongoingPromise;
301
- }
302
- return(e2) {
303
- const t2 = () => this._returnSteps(e2);
304
- return this._ongoingPromise = this._ongoingPromise ? p(this._ongoingPromise, t2, t2) : t2(), this._ongoingPromise;
305
- }
306
- _nextSteps() {
307
- if (this._isFinished) return Promise.resolve({ value: void 0, done: true });
308
- const e2 = this._reader;
309
- let t2, r2;
310
- const o2 = u((e3, o3) => {
311
- t2 = e3, r2 = o3;
312
- });
313
- return Z(e2, { _chunkSteps: (e3) => {
314
- this._ongoingPromise = void 0, y(() => t2({ value: e3, done: false }));
315
- }, _closeSteps: () => {
316
- this._ongoingPromise = void 0, this._isFinished = true, O(e2), t2({ value: void 0, done: true });
317
- }, _errorSteps: (t3) => {
318
- this._ongoingPromise = void 0, this._isFinished = true, O(e2), r2(t3);
319
- } }), o2;
320
- }
321
- _returnSteps(e2) {
322
- if (this._isFinished) return Promise.resolve({ value: e2, done: true });
323
- this._isFinished = true;
324
- const t2 = this._reader;
325
- if (!this._preventCancel) {
326
- const r2 = C(t2, e2);
327
- return O(t2), p(r2, () => ({ value: e2, done: true }));
328
- }
329
- return O(t2), c({ value: e2, done: true });
330
- }
331
- }
332
- const pe = { next() {
333
- return me(this) ? this._asyncIteratorImpl.next() : d(ye("next"));
334
- }, return(e2) {
335
- return me(this) ? this._asyncIteratorImpl.return(e2) : d(ye("return"));
336
- }, [fe]() {
337
- return this;
338
- } };
339
- function me(e2) {
340
- if (!t(e2)) return false;
341
- if (!Object.prototype.hasOwnProperty.call(e2, "_asyncIteratorImpl")) return false;
342
- try {
343
- return e2._asyncIteratorImpl instanceof _e;
344
- } catch (e3) {
345
- return false;
346
- }
347
- }
348
- function ye(e2) {
349
- return new TypeError(`ReadableStreamAsyncIterator.${e2} can only be used on a ReadableSteamAsyncIterator`);
350
- }
351
- Object.defineProperty(pe, fe, { enumerable: false });
352
- const ve = Number.isNaN || function(e2) {
353
- return e2 != e2;
354
- };
355
- function we(e2) {
356
- const t2 = ue(e2.buffer, e2.byteOffset, e2.byteOffset + e2.byteLength);
357
- return new Uint8Array(t2);
358
- }
359
- function ge(e2) {
360
- const t2 = e2._queue.shift();
361
- return e2._queueTotalSize -= t2.size, e2._queueTotalSize < 0 && (e2._queueTotalSize = 0), t2.value;
362
- }
363
- function Se(e2, t2, r2) {
364
- if ("number" != typeof (o2 = r2) || ve(o2) || o2 < 0 || r2 === 1 / 0) throw new RangeError("Size must be a finite, non-NaN, non-negative number.");
365
- var o2;
366
- e2._queue.push({ value: t2, size: r2 }), e2._queueTotalSize += r2;
367
- }
368
- function Re(e2) {
369
- e2._queue = new g(), e2._queueTotalSize = 0;
370
- }
371
- function Te(e2) {
372
- return e2 === DataView;
373
- }
374
- class qe {
375
- constructor() {
376
- throw new TypeError("Illegal constructor");
377
- }
378
- get view() {
379
- if (!Ce(this)) throw et("view");
380
- return this._view;
381
- }
382
- respond(e2) {
383
- if (!Ce(this)) throw et("respond");
384
- if (x(e2, 1, "respond"), e2 = Y(e2, "First parameter"), void 0 === this._associatedReadableByteStreamController) throw new TypeError("This BYOB request has been invalidated");
385
- if (le(this._view.buffer)) throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");
386
- Ke(this._associatedReadableByteStreamController, e2);
387
- }
388
- respondWithNewView(e2) {
389
- if (!Ce(this)) throw et("respondWithNewView");
390
- if (x(e2, 1, "respondWithNewView"), !ArrayBuffer.isView(e2)) throw new TypeError("You can only respond with array buffer views");
391
- if (void 0 === this._associatedReadableByteStreamController) throw new TypeError("This BYOB request has been invalidated");
392
- if (le(e2.buffer)) throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");
393
- Qe(this._associatedReadableByteStreamController, e2);
394
- }
395
- }
396
- Object.defineProperties(qe.prototype, { respond: { enumerable: true }, respondWithNewView: { enumerable: true }, view: { enumerable: true } }), o(qe.prototype.respond, "respond"), o(qe.prototype.respondWithNewView, "respondWithNewView"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(qe.prototype, Symbol.toStringTag, { value: "ReadableStreamBYOBRequest", configurable: true });
397
- class Ee {
398
- constructor() {
399
- throw new TypeError("Illegal constructor");
400
- }
401
- get byobRequest() {
402
- if (!Pe(this)) throw tt("byobRequest");
403
- return Xe(this);
404
- }
405
- get desiredSize() {
406
- if (!Pe(this)) throw tt("desiredSize");
407
- return Je(this);
408
- }
409
- close() {
410
- if (!Pe(this)) throw tt("close");
411
- if (this._closeRequested) throw new TypeError("The stream has already been closed; do not close it again!");
412
- const e2 = this._controlledReadableByteStream._state;
413
- if ("readable" !== e2) throw new TypeError(`The stream (in ${e2} state) is not in the readable state and cannot be closed`);
414
- Ve(this);
415
- }
416
- enqueue(e2) {
417
- if (!Pe(this)) throw tt("enqueue");
418
- if (x(e2, 1, "enqueue"), !ArrayBuffer.isView(e2)) throw new TypeError("chunk must be an array buffer view");
419
- if (0 === e2.byteLength) throw new TypeError("chunk must have non-zero byteLength");
420
- if (0 === e2.buffer.byteLength) throw new TypeError("chunk's buffer must have non-zero byteLength");
421
- if (this._closeRequested) throw new TypeError("stream is closed or draining");
422
- const t2 = this._controlledReadableByteStream._state;
423
- if ("readable" !== t2) throw new TypeError(`The stream (in ${t2} state) is not in the readable state and cannot be enqueued to`);
424
- Ue(this, e2);
425
- }
426
- error(e2 = void 0) {
427
- if (!Pe(this)) throw tt("error");
428
- He(this, e2);
429
- }
430
- [T](e2) {
431
- Ae(this), Re(this);
432
- const t2 = this._cancelAlgorithm(e2);
433
- return Ye(this), t2;
434
- }
435
- [q](e2) {
436
- const t2 = this._controlledReadableByteStream;
437
- if (this._queueTotalSize > 0) return void Ge(this, e2);
438
- const r2 = this._autoAllocateChunkSize;
439
- if (void 0 !== r2) {
440
- let o2;
441
- try {
442
- o2 = new ArrayBuffer(r2);
443
- } catch (t3) {
444
- return void e2._errorSteps(t3);
445
- }
446
- const n2 = { buffer: o2, bufferByteLength: r2, byteOffset: 0, byteLength: r2, bytesFilled: 0, minimumFill: 1, elementSize: 1, viewConstructor: Uint8Array, readerType: "default" };
447
- this._pendingPullIntos.push(n2);
448
- }
449
- H(t2, e2), Oe(this);
450
- }
451
- [E]() {
452
- if (this._pendingPullIntos.length > 0) {
453
- const e2 = this._pendingPullIntos.peek();
454
- e2.readerType = "none", this._pendingPullIntos = new g(), this._pendingPullIntos.push(e2);
455
- }
456
- }
457
- }
458
- function Pe(e2) {
459
- return !!t(e2) && !!Object.prototype.hasOwnProperty.call(e2, "_controlledReadableByteStream") && e2 instanceof Ee;
460
- }
461
- function Ce(e2) {
462
- return !!t(e2) && !!Object.prototype.hasOwnProperty.call(e2, "_associatedReadableByteStreamController") && e2 instanceof qe;
463
- }
464
- function Oe(e2) {
465
- const t2 = function(e3) {
466
- const t3 = e3._controlledReadableByteStream;
467
- if ("readable" !== t3._state) return false;
468
- if (e3._closeRequested) return false;
469
- if (!e3._started) return false;
470
- if (J(t3) && X(t3) > 0) return true;
471
- if (at(t3) && it(t3) > 0) return true;
472
- return Je(e3) > 0;
473
- }(e2);
474
- t2 && (e2._pulling ? e2._pullAgain = true : (e2._pulling = true, b(e2._pullAlgorithm(), () => (e2._pulling = false, e2._pullAgain && (e2._pullAgain = false, Oe(e2)), null), (t3) => (He(e2, t3), null))));
475
- }
476
- function Ae(e2) {
477
- xe(e2), e2._pendingPullIntos = new g();
478
- }
479
- function je(e2, t2) {
480
- let r2 = false;
481
- "closed" === e2._state && (r2 = true);
482
- const o2 = We(t2);
483
- "default" === t2.readerType ? G(e2, o2, r2) : function(e3, t3, r3) {
484
- const o3 = e3._reader._readIntoRequests.shift();
485
- r3 ? o3._closeSteps(t3) : o3._chunkSteps(t3);
486
- }(e2, o2, r2);
487
- }
488
- function ke(e2, t2) {
489
- for (let r2 = 0; r2 < t2.length; ++r2) je(e2, t2[r2]);
490
- }
491
- function We(e2) {
492
- const t2 = e2.bytesFilled, r2 = e2.elementSize;
493
- return new e2.viewConstructor(e2.buffer, e2.byteOffset, t2 / r2);
494
- }
495
- function ze(e2, t2, r2, o2) {
496
- e2._queue.push({ buffer: t2, byteOffset: r2, byteLength: o2 }), e2._queueTotalSize += o2;
497
- }
498
- function Be(e2, t2, r2, o2) {
499
- let n2;
500
- try {
501
- n2 = ue(t2, r2, r2 + o2);
502
- } catch (t3) {
503
- throw He(e2, t3), t3;
504
- }
505
- ze(e2, n2, 0, o2);
506
- }
507
- function Fe(e2, t2) {
508
- t2.bytesFilled > 0 && Be(e2, t2.buffer, t2.byteOffset, t2.bytesFilled), Ne(e2);
509
- }
510
- function Ie(e2, t2) {
511
- const r2 = Math.min(e2._queueTotalSize, t2.byteLength - t2.bytesFilled), o2 = t2.bytesFilled + r2;
512
- let n2 = r2, i2 = false;
513
- const a2 = o2 - o2 % t2.elementSize;
514
- a2 >= t2.minimumFill && (n2 = a2 - t2.bytesFilled, i2 = true);
515
- const s2 = e2._queue;
516
- for (; n2 > 0; ) {
517
- const r3 = s2.peek(), o3 = Math.min(n2, r3.byteLength), i3 = t2.byteOffset + t2.bytesFilled;
518
- ae(t2.buffer, i3, r3.buffer, r3.byteOffset, o3), r3.byteLength === o3 ? s2.shift() : (r3.byteOffset += o3, r3.byteLength -= o3), e2._queueTotalSize -= o3, Le(e2, o3, t2), n2 -= o3;
519
- }
520
- return i2;
521
- }
522
- function Le(e2, t2, r2) {
523
- r2.bytesFilled += t2;
524
- }
525
- function $e(e2) {
526
- 0 === e2._queueTotalSize && e2._closeRequested ? (Ye(e2), Br(e2._controlledReadableByteStream)) : Oe(e2);
527
- }
528
- function xe(e2) {
529
- null !== e2._byobRequest && (e2._byobRequest._associatedReadableByteStreamController = void 0, e2._byobRequest._view = null, e2._byobRequest = null);
530
- }
531
- function Me(e2) {
532
- const t2 = [];
533
- for (; e2._pendingPullIntos.length > 0 && 0 !== e2._queueTotalSize; ) {
534
- const r2 = e2._pendingPullIntos.peek();
535
- Ie(e2, r2) && (Ne(e2), t2.push(r2));
536
- }
537
- return t2;
538
- }
539
- function De(e2, t2) {
540
- const r2 = e2._pendingPullIntos.peek();
541
- xe(e2), "closed" === e2._controlledReadableByteStream._state ? function(e3, t3) {
542
- "none" === t3.readerType && Ne(e3);
543
- const r3 = e3._controlledReadableByteStream;
544
- if (at(r3)) {
545
- const t4 = [];
546
- for (let o2 = 0; o2 < it(r3); ++o2) t4.push(Ne(e3));
547
- ke(r3, t4);
548
- }
549
- }(e2, r2) : function(e3, t3, r3) {
550
- if (Le(0, t3, r3), "none" === r3.readerType) {
551
- Fe(e3, r3);
552
- const t4 = Me(e3);
553
- return void ke(e3._controlledReadableByteStream, t4);
554
- }
555
- if (r3.bytesFilled < r3.minimumFill) return;
556
- Ne(e3);
557
- const o2 = r3.bytesFilled % r3.elementSize;
558
- if (o2 > 0) {
559
- const t4 = r3.byteOffset + r3.bytesFilled;
560
- Be(e3, r3.buffer, t4 - o2, o2);
561
- }
562
- r3.bytesFilled -= o2;
563
- const n2 = Me(e3);
564
- je(e3._controlledReadableByteStream, r3), ke(e3._controlledReadableByteStream, n2);
565
- }(e2, t2, r2), Oe(e2);
566
- }
567
- function Ne(e2) {
568
- return e2._pendingPullIntos.shift();
569
- }
570
- function Ye(e2) {
571
- e2._pullAlgorithm = void 0, e2._cancelAlgorithm = void 0;
572
- }
573
- function Ve(e2) {
574
- const t2 = e2._controlledReadableByteStream;
575
- if (!e2._closeRequested && "readable" === t2._state) if (e2._queueTotalSize > 0) e2._closeRequested = true;
576
- else {
577
- if (e2._pendingPullIntos.length > 0) {
578
- const t3 = e2._pendingPullIntos.peek();
579
- if (t3.bytesFilled % t3.elementSize != 0) {
580
- const t4 = new TypeError("Insufficient bytes to fill elements in the given buffer");
581
- throw He(e2, t4), t4;
582
- }
583
- }
584
- Ye(e2), Br(t2);
585
- }
586
- }
587
- function Ue(e2, t2) {
588
- const r2 = e2._controlledReadableByteStream;
589
- if (e2._closeRequested || "readable" !== r2._state) return;
590
- const { buffer: o2, byteOffset: n2, byteLength: i2 } = t2;
591
- if (le(o2)) throw new TypeError("chunk's buffer is detached and so cannot be enqueued");
592
- const a2 = se(o2);
593
- if (e2._pendingPullIntos.length > 0) {
594
- const t3 = e2._pendingPullIntos.peek();
595
- if (le(t3.buffer)) throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");
596
- xe(e2), t3.buffer = se(t3.buffer), "none" === t3.readerType && Fe(e2, t3);
597
- }
598
- if (J(r2)) (function(e3) {
599
- const t3 = e3._controlledReadableByteStream._reader;
600
- for (; t3._readRequests.length > 0; ) {
601
- if (0 === e3._queueTotalSize) return;
602
- Ge(e3, t3._readRequests.shift());
603
- }
604
- })(e2), 0 === X(r2) ? ze(e2, a2, n2, i2) : (e2._pendingPullIntos.length > 0 && Ne(e2), G(r2, new Uint8Array(a2, n2, i2), false));
605
- else if (at(r2)) {
606
- ze(e2, a2, n2, i2);
607
- const t3 = Me(e2);
608
- ke(e2._controlledReadableByteStream, t3);
609
- } else ze(e2, a2, n2, i2);
610
- Oe(e2);
611
- }
612
- function He(e2, t2) {
613
- const r2 = e2._controlledReadableByteStream;
614
- "readable" === r2._state && (Ae(e2), Re(e2), Ye(e2), Fr(r2, t2));
615
- }
616
- function Ge(e2, t2) {
617
- const r2 = e2._queue.shift();
618
- e2._queueTotalSize -= r2.byteLength, $e(e2);
619
- const o2 = new Uint8Array(r2.buffer, r2.byteOffset, r2.byteLength);
620
- t2._chunkSteps(o2);
621
- }
622
- function Xe(e2) {
623
- if (null === e2._byobRequest && e2._pendingPullIntos.length > 0) {
624
- const t2 = e2._pendingPullIntos.peek(), r2 = new Uint8Array(t2.buffer, t2.byteOffset + t2.bytesFilled, t2.byteLength - t2.bytesFilled), o2 = Object.create(qe.prototype);
625
- !function(e3, t3, r3) {
626
- e3._associatedReadableByteStreamController = t3, e3._view = r3;
627
- }(o2, e2, r2), e2._byobRequest = o2;
628
- }
629
- return e2._byobRequest;
630
- }
631
- function Je(e2) {
632
- const t2 = e2._controlledReadableByteStream._state;
633
- return "errored" === t2 ? null : "closed" === t2 ? 0 : e2._strategyHWM - e2._queueTotalSize;
634
- }
635
- function Ke(e2, t2) {
636
- const r2 = e2._pendingPullIntos.peek();
637
- if ("closed" === e2._controlledReadableByteStream._state) {
638
- if (0 !== t2) throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream");
639
- } else {
640
- if (0 === t2) throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");
641
- if (r2.bytesFilled + t2 > r2.byteLength) throw new RangeError("bytesWritten out of range");
642
- }
643
- r2.buffer = se(r2.buffer), De(e2, t2);
644
- }
645
- function Qe(e2, t2) {
646
- const r2 = e2._pendingPullIntos.peek();
647
- if ("closed" === e2._controlledReadableByteStream._state) {
648
- if (0 !== t2.byteLength) throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream");
649
- } else if (0 === t2.byteLength) throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");
650
- if (r2.byteOffset + r2.bytesFilled !== t2.byteOffset) throw new RangeError("The region specified by view does not match byobRequest");
651
- if (r2.bufferByteLength !== t2.buffer.byteLength) throw new RangeError("The buffer of view has different capacity than byobRequest");
652
- if (r2.bytesFilled + t2.byteLength > r2.byteLength) throw new RangeError("The region specified by view is larger than byobRequest");
653
- const o2 = t2.byteLength;
654
- r2.buffer = se(t2.buffer), De(e2, o2);
655
- }
656
- function Ze(e2, t2, r2, o2, n2, i2, a2) {
657
- t2._controlledReadableByteStream = e2, t2._pullAgain = false, t2._pulling = false, t2._byobRequest = null, t2._queue = t2._queueTotalSize = void 0, Re(t2), t2._closeRequested = false, t2._started = false, t2._strategyHWM = i2, t2._pullAlgorithm = o2, t2._cancelAlgorithm = n2, t2._autoAllocateChunkSize = a2, t2._pendingPullIntos = new g(), e2._readableStreamController = t2, b(c(r2()), () => (t2._started = true, Oe(t2), null), (e3) => (He(t2, e3), null));
658
- }
659
- function et(e2) {
660
- return new TypeError(`ReadableStreamBYOBRequest.prototype.${e2} can only be used on a ReadableStreamBYOBRequest`);
661
- }
662
- function tt(e2) {
663
- return new TypeError(`ReadableByteStreamController.prototype.${e2} can only be used on a ReadableByteStreamController`);
664
- }
665
- function rt(e2, t2) {
666
- if ("byob" != (e2 = `${e2}`)) throw new TypeError(`${t2} '${e2}' is not a valid enumeration value for ReadableStreamReaderMode`);
667
- return e2;
668
- }
669
- function ot(e2) {
670
- return new st(e2);
671
- }
672
- function nt(e2, t2) {
673
- e2._reader._readIntoRequests.push(t2);
674
- }
675
- function it(e2) {
676
- return e2._reader._readIntoRequests.length;
677
- }
678
- function at(e2) {
679
- const t2 = e2._reader;
680
- return void 0 !== t2 && !!lt(t2);
681
- }
682
- Object.defineProperties(Ee.prototype, { close: { enumerable: true }, enqueue: { enumerable: true }, error: { enumerable: true }, byobRequest: { enumerable: true }, desiredSize: { enumerable: true } }), o(Ee.prototype.close, "close"), o(Ee.prototype.enqueue, "enqueue"), o(Ee.prototype.error, "error"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(Ee.prototype, Symbol.toStringTag, { value: "ReadableByteStreamController", configurable: true });
683
- class st {
684
- constructor(e2) {
685
- if (x(e2, 1, "ReadableStreamBYOBReader"), V(e2, "First parameter"), Wr(e2)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
686
- if (!Pe(e2._readableStreamController)) throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");
687
- P(this, e2), this._readIntoRequests = new g();
688
- }
689
- get closed() {
690
- return lt(this) ? this._closedPromise : d(dt("closed"));
691
- }
692
- cancel(e2 = void 0) {
693
- return lt(this) ? void 0 === this._ownerReadableStream ? d(A("cancel")) : C(this, e2) : d(dt("cancel"));
694
- }
695
- read(e2, t2 = {}) {
696
- if (!lt(this)) return d(dt("read"));
697
- if (!ArrayBuffer.isView(e2)) return d(new TypeError("view must be an array buffer view"));
698
- if (0 === e2.byteLength) return d(new TypeError("view must have non-zero byteLength"));
699
- if (0 === e2.buffer.byteLength) return d(new TypeError("view's buffer must have non-zero byteLength"));
700
- if (le(e2.buffer)) return d(new TypeError("view's buffer has been detached"));
701
- let r2;
702
- try {
703
- r2 = function(e3, t3) {
704
- var r3;
705
- return I(e3, t3), { min: Y(null !== (r3 = null == e3 ? void 0 : e3.min) && void 0 !== r3 ? r3 : 1, `${t3} has member 'min' that`) };
706
- }(t2, "options");
707
- } catch (e3) {
708
- return d(e3);
709
- }
710
- const o2 = r2.min;
711
- if (0 === o2) return d(new TypeError("options.min must be greater than 0"));
712
- if (function(e3) {
713
- return Te(e3.constructor);
714
- }(e2)) {
715
- if (o2 > e2.byteLength) return d(new RangeError("options.min must be less than or equal to view's byteLength"));
716
- } else if (o2 > e2.length) return d(new RangeError("options.min must be less than or equal to view's length"));
717
- if (void 0 === this._ownerReadableStream) return d(A("read from"));
718
- let n2, i2;
719
- const a2 = u((e3, t3) => {
720
- n2 = e3, i2 = t3;
721
- });
722
- return ut(this, e2, o2, { _chunkSteps: (e3) => n2({ value: e3, done: false }), _closeSteps: (e3) => n2({ value: e3, done: true }), _errorSteps: (e3) => i2(e3) }), a2;
723
- }
724
- releaseLock() {
725
- if (!lt(this)) throw dt("releaseLock");
726
- void 0 !== this._ownerReadableStream && function(e2) {
727
- O(e2);
728
- ct(e2, new TypeError("Reader was released"));
729
- }(this);
730
- }
731
- }
732
- function lt(e2) {
733
- return !!t(e2) && !!Object.prototype.hasOwnProperty.call(e2, "_readIntoRequests") && e2 instanceof st;
734
- }
735
- function ut(e2, t2, r2, o2) {
736
- const n2 = e2._ownerReadableStream;
737
- n2._disturbed = true, "errored" === n2._state ? o2._errorSteps(n2._storedError) : function(e3, t3, r3, o3) {
738
- const n3 = e3._controlledReadableByteStream, i2 = t3.constructor, a2 = function(e4) {
739
- return Te(e4) ? 1 : e4.BYTES_PER_ELEMENT;
740
- }(i2), { byteOffset: s2, byteLength: l2 } = t3, u2 = r3 * a2;
741
- let c2;
742
- try {
743
- c2 = se(t3.buffer);
744
- } catch (e4) {
745
- return void o3._errorSteps(e4);
746
- }
747
- const d2 = { buffer: c2, bufferByteLength: c2.byteLength, byteOffset: s2, byteLength: l2, bytesFilled: 0, minimumFill: u2, elementSize: a2, viewConstructor: i2, readerType: "byob" };
748
- if (e3._pendingPullIntos.length > 0) return e3._pendingPullIntos.push(d2), void nt(n3, o3);
749
- if ("closed" !== n3._state) {
750
- if (e3._queueTotalSize > 0) {
751
- if (Ie(e3, d2)) {
752
- const t4 = We(d2);
753
- return $e(e3), void o3._chunkSteps(t4);
754
- }
755
- if (e3._closeRequested) {
756
- const t4 = new TypeError("Insufficient bytes to fill elements in the given buffer");
757
- return He(e3, t4), void o3._errorSteps(t4);
758
- }
759
- }
760
- e3._pendingPullIntos.push(d2), nt(n3, o3), Oe(e3);
761
- } else {
762
- const e4 = new i2(d2.buffer, d2.byteOffset, 0);
763
- o3._closeSteps(e4);
764
- }
765
- }(n2._readableStreamController, t2, r2, o2);
766
- }
767
- function ct(e2, t2) {
768
- const r2 = e2._readIntoRequests;
769
- e2._readIntoRequests = new g(), r2.forEach((e3) => {
770
- e3._errorSteps(t2);
771
- });
772
- }
773
- function dt(e2) {
774
- return new TypeError(`ReadableStreamBYOBReader.prototype.${e2} can only be used on a ReadableStreamBYOBReader`);
775
- }
776
- function ft(e2, t2) {
777
- const { highWaterMark: r2 } = e2;
778
- if (void 0 === r2) return t2;
779
- if (ve(r2) || r2 < 0) throw new RangeError("Invalid highWaterMark");
780
- return r2;
781
- }
782
- function bt(e2) {
783
- const { size: t2 } = e2;
784
- return t2 || (() => 1);
785
- }
786
- function ht(e2, t2) {
787
- I(e2, t2);
788
- const r2 = null == e2 ? void 0 : e2.highWaterMark, o2 = null == e2 ? void 0 : e2.size;
789
- return { highWaterMark: void 0 === r2 ? void 0 : D(r2), size: void 0 === o2 ? void 0 : _t(o2, `${t2} has member 'size' that`) };
790
- }
791
- function _t(e2, t2) {
792
- return L(e2, t2), (t3) => D(e2(t3));
793
- }
794
- function pt(e2, t2, r2) {
795
- return L(e2, r2), (r3) => w(e2, t2, [r3]);
796
- }
797
- function mt(e2, t2, r2) {
798
- return L(e2, r2), () => w(e2, t2, []);
799
- }
800
- function yt(e2, t2, r2) {
801
- return L(e2, r2), (r3) => v(e2, t2, [r3]);
802
- }
803
- function vt(e2, t2, r2) {
804
- return L(e2, r2), (r3, o2) => w(e2, t2, [r3, o2]);
805
- }
806
- function wt(e2, t2) {
807
- if (!Rt(e2)) throw new TypeError(`${t2} is not a WritableStream.`);
808
- }
809
- Object.defineProperties(st.prototype, { cancel: { enumerable: true }, read: { enumerable: true }, releaseLock: { enumerable: true }, closed: { enumerable: true } }), o(st.prototype.cancel, "cancel"), o(st.prototype.read, "read"), o(st.prototype.releaseLock, "releaseLock"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(st.prototype, Symbol.toStringTag, { value: "ReadableStreamBYOBReader", configurable: true });
810
- class gt {
811
- constructor(e2 = {}, t2 = {}) {
812
- void 0 === e2 ? e2 = null : $(e2, "First parameter");
813
- const r2 = ht(t2, "Second parameter"), o2 = function(e3, t3) {
814
- I(e3, t3);
815
- const r3 = null == e3 ? void 0 : e3.abort, o3 = null == e3 ? void 0 : e3.close, n3 = null == e3 ? void 0 : e3.start, i2 = null == e3 ? void 0 : e3.type, a2 = null == e3 ? void 0 : e3.write;
816
- return { abort: void 0 === r3 ? void 0 : pt(r3, e3, `${t3} has member 'abort' that`), close: void 0 === o3 ? void 0 : mt(o3, e3, `${t3} has member 'close' that`), start: void 0 === n3 ? void 0 : yt(n3, e3, `${t3} has member 'start' that`), write: void 0 === a2 ? void 0 : vt(a2, e3, `${t3} has member 'write' that`), type: i2 };
817
- }(e2, "First parameter");
818
- if (function(e3) {
819
- e3._state = "writable", e3._storedError = void 0, e3._writer = void 0, e3._writableStreamController = void 0, e3._writeRequests = new g(), e3._inFlightWriteRequest = void 0, e3._closeRequest = void 0, e3._inFlightCloseRequest = void 0, e3._pendingAbortRequest = void 0, e3._backpressure = false;
820
- }(this), void 0 !== o2.type) throw new RangeError("Invalid type is specified");
821
- const n2 = bt(r2);
822
- !function(e3, t3, r3, o3) {
823
- const n3 = Object.create(xt.prototype);
824
- let i2, a2, s2, l2;
825
- i2 = void 0 !== t3.start ? () => t3.start(n3) : () => {
826
- }, a2 = void 0 !== t3.write ? (e4) => t3.write(e4, n3) : () => c(void 0), s2 = void 0 !== t3.close ? () => t3.close() : () => c(void 0), l2 = void 0 !== t3.abort ? (e4) => t3.abort(e4) : () => c(void 0), function(e4, t4, r4, o4, n4, i3, a3, s3) {
827
- t4._controlledWritableStream = e4, e4._writableStreamController = t4, t4._queue = void 0, t4._queueTotalSize = void 0, Re(t4), t4._abortReason = void 0, t4._abortController = function() {
828
- if ("function" == typeof AbortController) return new AbortController();
829
- }(), t4._started = false, t4._strategySizeAlgorithm = s3, t4._strategyHWM = a3, t4._writeAlgorithm = o4, t4._closeAlgorithm = n4, t4._abortAlgorithm = i3;
830
- const l3 = Ut(t4);
831
- kt(e4, l3), b(c(r4()), () => (t4._started = true, Yt(t4), null), (r5) => (t4._started = true, Pt(e4, r5), null));
832
- }(e3, n3, i2, a2, s2, l2, r3, o3);
833
- }(this, o2, ft(r2, 1), n2);
834
- }
835
- get locked() {
836
- if (!Rt(this)) throw Gt("locked");
837
- return Tt(this);
838
- }
839
- abort(e2 = void 0) {
840
- return Rt(this) ? Tt(this) ? d(new TypeError("Cannot abort a stream that already has a writer")) : qt(this, e2) : d(Gt("abort"));
841
- }
842
- close() {
843
- return Rt(this) ? Tt(this) ? d(new TypeError("Cannot close a stream that already has a writer")) : At(this) ? d(new TypeError("Cannot close an already-closing stream")) : Et(this) : d(Gt("close"));
844
- }
845
- getWriter() {
846
- if (!Rt(this)) throw Gt("getWriter");
847
- return St(this);
848
- }
849
- }
850
- function St(e2) {
851
- return new Wt(e2);
852
- }
853
- function Rt(e2) {
854
- return !!t(e2) && !!Object.prototype.hasOwnProperty.call(e2, "_writableStreamController") && e2 instanceof gt;
855
- }
856
- function Tt(e2) {
857
- return void 0 !== e2._writer;
858
- }
859
- function qt(e2, t2) {
860
- var r2;
861
- if ("closed" === e2._state || "errored" === e2._state) return c(void 0);
862
- e2._writableStreamController._abortReason = t2, null === (r2 = e2._writableStreamController._abortController) || void 0 === r2 || r2.abort(t2);
863
- const o2 = e2._state;
864
- if ("closed" === o2 || "errored" === o2) return c(void 0);
865
- if (void 0 !== e2._pendingAbortRequest) return e2._pendingAbortRequest._promise;
866
- let n2 = false;
867
- "erroring" === o2 && (n2 = true, t2 = void 0);
868
- const i2 = u((r3, o3) => {
869
- e2._pendingAbortRequest = { _promise: void 0, _resolve: r3, _reject: o3, _reason: t2, _wasAlreadyErroring: n2 };
870
- });
871
- return e2._pendingAbortRequest._promise = i2, n2 || Ct(e2, t2), i2;
872
- }
873
- function Et(e2) {
874
- const t2 = e2._state;
875
- if ("closed" === t2 || "errored" === t2) return d(new TypeError(`The stream (in ${t2} state) is not in the writable state and cannot be closed`));
876
- const r2 = u((t3, r3) => {
877
- const o3 = { _resolve: t3, _reject: r3 };
878
- e2._closeRequest = o3;
879
- }), o2 = e2._writer;
880
- var n2;
881
- return void 0 !== o2 && e2._backpressure && "writable" === t2 && ar(o2), Se(n2 = e2._writableStreamController, $t, 0), Yt(n2), r2;
882
- }
883
- function Pt(e2, t2) {
884
- "writable" !== e2._state ? Ot(e2) : Ct(e2, t2);
885
- }
886
- function Ct(e2, t2) {
887
- const r2 = e2._writableStreamController;
888
- e2._state = "erroring", e2._storedError = t2;
889
- const o2 = e2._writer;
890
- void 0 !== o2 && Ft(o2, t2), !function(e3) {
891
- return void 0 !== e3._inFlightWriteRequest || void 0 !== e3._inFlightCloseRequest;
892
- }(e2) && r2._started && Ot(e2);
893
- }
894
- function Ot(e2) {
895
- e2._state = "errored", e2._writableStreamController[R]();
896
- const t2 = e2._storedError;
897
- if (e2._writeRequests.forEach((e3) => {
898
- e3._reject(t2);
899
- }), e2._writeRequests = new g(), void 0 === e2._pendingAbortRequest) return void jt(e2);
900
- const r2 = e2._pendingAbortRequest;
901
- if (e2._pendingAbortRequest = void 0, r2._wasAlreadyErroring) return r2._reject(t2), void jt(e2);
902
- b(e2._writableStreamController[S](r2._reason), () => (r2._resolve(), jt(e2), null), (t3) => (r2._reject(t3), jt(e2), null));
903
- }
904
- function At(e2) {
905
- return void 0 !== e2._closeRequest || void 0 !== e2._inFlightCloseRequest;
906
- }
907
- function jt(e2) {
908
- void 0 !== e2._closeRequest && (e2._closeRequest._reject(e2._storedError), e2._closeRequest = void 0);
909
- const t2 = e2._writer;
910
- void 0 !== t2 && er(t2, e2._storedError);
911
- }
912
- function kt(e2, t2) {
913
- const r2 = e2._writer;
914
- void 0 !== r2 && t2 !== e2._backpressure && (t2 ? function(e3) {
915
- rr(e3);
916
- }(r2) : ar(r2)), e2._backpressure = t2;
917
- }
918
- Object.defineProperties(gt.prototype, { abort: { enumerable: true }, close: { enumerable: true }, getWriter: { enumerable: true }, locked: { enumerable: true } }), o(gt.prototype.abort, "abort"), o(gt.prototype.close, "close"), o(gt.prototype.getWriter, "getWriter"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(gt.prototype, Symbol.toStringTag, { value: "WritableStream", configurable: true });
919
- class Wt {
920
- constructor(e2) {
921
- if (x(e2, 1, "WritableStreamDefaultWriter"), wt(e2, "First parameter"), Tt(e2)) throw new TypeError("This stream has already been locked for exclusive writing by another writer");
922
- this._ownerWritableStream = e2, e2._writer = this;
923
- const t2 = e2._state;
924
- if ("writable" === t2) !At(e2) && e2._backpressure ? rr(this) : nr(this), Qt(this);
925
- else if ("erroring" === t2) or(this, e2._storedError), Qt(this);
926
- else if ("closed" === t2) nr(this), Qt(this), tr(this);
927
- else {
928
- const t3 = e2._storedError;
929
- or(this, t3), Zt(this, t3);
930
- }
931
- }
932
- get closed() {
933
- return zt(this) ? this._closedPromise : d(Jt("closed"));
934
- }
935
- get desiredSize() {
936
- if (!zt(this)) throw Jt("desiredSize");
937
- if (void 0 === this._ownerWritableStream) throw Kt("desiredSize");
938
- return function(e2) {
939
- const t2 = e2._ownerWritableStream, r2 = t2._state;
940
- return "errored" === r2 || "erroring" === r2 ? null : "closed" === r2 ? 0 : Nt(t2._writableStreamController);
941
- }(this);
942
- }
943
- get ready() {
944
- return zt(this) ? this._readyPromise : d(Jt("ready"));
945
- }
946
- abort(e2 = void 0) {
947
- return zt(this) ? void 0 === this._ownerWritableStream ? d(Kt("abort")) : function(e3, t2) {
948
- return qt(e3._ownerWritableStream, t2);
949
- }(this, e2) : d(Jt("abort"));
950
- }
951
- close() {
952
- if (!zt(this)) return d(Jt("close"));
953
- const e2 = this._ownerWritableStream;
954
- return void 0 === e2 ? d(Kt("close")) : At(e2) ? d(new TypeError("Cannot close an already-closing stream")) : Bt(this);
955
- }
956
- releaseLock() {
957
- if (!zt(this)) throw Jt("releaseLock");
958
- void 0 !== this._ownerWritableStream && It(this);
959
- }
960
- write(e2 = void 0) {
961
- return zt(this) ? void 0 === this._ownerWritableStream ? d(Kt("write to")) : Lt(this, e2) : d(Jt("write"));
962
- }
963
- }
964
- function zt(e2) {
965
- return !!t(e2) && !!Object.prototype.hasOwnProperty.call(e2, "_ownerWritableStream") && e2 instanceof Wt;
966
- }
967
- function Bt(e2) {
968
- return Et(e2._ownerWritableStream);
969
- }
970
- function Ft(e2, t2) {
971
- "pending" === e2._readyPromiseState ? ir(e2, t2) : function(e3, t3) {
972
- or(e3, t3);
973
- }(e2, t2);
974
- }
975
- function It(e2) {
976
- const t2 = e2._ownerWritableStream, r2 = new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");
977
- Ft(e2, r2), function(e3, t3) {
978
- "pending" === e3._closedPromiseState ? er(e3, t3) : function(e4, t4) {
979
- Zt(e4, t4);
980
- }(e3, t3);
981
- }(e2, r2), t2._writer = void 0, e2._ownerWritableStream = void 0;
982
- }
983
- function Lt(e2, t2) {
984
- const r2 = e2._ownerWritableStream, o2 = r2._writableStreamController, n2 = function(e3, t3) {
985
- if (void 0 === e3._strategySizeAlgorithm) return 1;
986
- try {
987
- return e3._strategySizeAlgorithm(t3);
988
- } catch (t4) {
989
- return Vt(e3, t4), 1;
990
- }
991
- }(o2, t2);
992
- if (r2 !== e2._ownerWritableStream) return d(Kt("write to"));
993
- const i2 = r2._state;
994
- if ("errored" === i2) return d(r2._storedError);
995
- if (At(r2) || "closed" === i2) return d(new TypeError("The stream is closing or closed and cannot be written to"));
996
- if ("erroring" === i2) return d(r2._storedError);
997
- const a2 = function(e3) {
998
- return u((t3, r3) => {
999
- const o3 = { _resolve: t3, _reject: r3 };
1000
- e3._writeRequests.push(o3);
1001
- });
1002
- }(r2);
1003
- return function(e3, t3, r3) {
1004
- try {
1005
- Se(e3, t3, r3);
1006
- } catch (t4) {
1007
- return void Vt(e3, t4);
1008
- }
1009
- const o3 = e3._controlledWritableStream;
1010
- At(o3) || "writable" !== o3._state || kt(o3, Ut(e3)), Yt(e3);
1011
- }(o2, t2, n2), a2;
1012
- }
1013
- Object.defineProperties(Wt.prototype, { abort: { enumerable: true }, close: { enumerable: true }, releaseLock: { enumerable: true }, write: { enumerable: true }, closed: { enumerable: true }, desiredSize: { enumerable: true }, ready: { enumerable: true } }), o(Wt.prototype.abort, "abort"), o(Wt.prototype.close, "close"), o(Wt.prototype.releaseLock, "releaseLock"), o(Wt.prototype.write, "write"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(Wt.prototype, Symbol.toStringTag, { value: "WritableStreamDefaultWriter", configurable: true });
1014
- const $t = {};
1015
- class xt {
1016
- constructor() {
1017
- throw new TypeError("Illegal constructor");
1018
- }
1019
- get abortReason() {
1020
- if (!Mt(this)) throw Xt("abortReason");
1021
- return this._abortReason;
1022
- }
1023
- get signal() {
1024
- if (!Mt(this)) throw Xt("signal");
1025
- if (void 0 === this._abortController) throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");
1026
- return this._abortController.signal;
1027
- }
1028
- error(e2 = void 0) {
1029
- if (!Mt(this)) throw Xt("error");
1030
- "writable" === this._controlledWritableStream._state && Ht(this, e2);
1031
- }
1032
- [S](e2) {
1033
- const t2 = this._abortAlgorithm(e2);
1034
- return Dt(this), t2;
1035
- }
1036
- [R]() {
1037
- Re(this);
1038
- }
1039
- }
1040
- function Mt(e2) {
1041
- return !!t(e2) && !!Object.prototype.hasOwnProperty.call(e2, "_controlledWritableStream") && e2 instanceof xt;
1042
- }
1043
- function Dt(e2) {
1044
- e2._writeAlgorithm = void 0, e2._closeAlgorithm = void 0, e2._abortAlgorithm = void 0, e2._strategySizeAlgorithm = void 0;
1045
- }
1046
- function Nt(e2) {
1047
- return e2._strategyHWM - e2._queueTotalSize;
1048
- }
1049
- function Yt(e2) {
1050
- const t2 = e2._controlledWritableStream;
1051
- if (!e2._started) return;
1052
- if (void 0 !== t2._inFlightWriteRequest) return;
1053
- if ("erroring" === t2._state) return void Ot(t2);
1054
- if (0 === e2._queue.length) return;
1055
- const r2 = e2._queue.peek().value;
1056
- r2 === $t ? function(e3) {
1057
- const t3 = e3._controlledWritableStream;
1058
- (function(e4) {
1059
- e4._inFlightCloseRequest = e4._closeRequest, e4._closeRequest = void 0;
1060
- })(t3), ge(e3);
1061
- const r3 = e3._closeAlgorithm();
1062
- Dt(e3), b(r3, () => (function(e4) {
1063
- e4._inFlightCloseRequest._resolve(void 0), e4._inFlightCloseRequest = void 0, "erroring" === e4._state && (e4._storedError = void 0, void 0 !== e4._pendingAbortRequest && (e4._pendingAbortRequest._resolve(), e4._pendingAbortRequest = void 0)), e4._state = "closed";
1064
- const t4 = e4._writer;
1065
- void 0 !== t4 && tr(t4);
1066
- }(t3), null), (e4) => (function(e5, t4) {
1067
- e5._inFlightCloseRequest._reject(t4), e5._inFlightCloseRequest = void 0, void 0 !== e5._pendingAbortRequest && (e5._pendingAbortRequest._reject(t4), e5._pendingAbortRequest = void 0), Pt(e5, t4);
1068
- }(t3, e4), null));
1069
- }(e2) : function(e3, t3) {
1070
- const r3 = e3._controlledWritableStream;
1071
- !function(e4) {
1072
- e4._inFlightWriteRequest = e4._writeRequests.shift();
1073
- }(r3);
1074
- b(e3._writeAlgorithm(t3), () => {
1075
- !function(e4) {
1076
- e4._inFlightWriteRequest._resolve(void 0), e4._inFlightWriteRequest = void 0;
1077
- }(r3);
1078
- const t4 = r3._state;
1079
- if (ge(e3), !At(r3) && "writable" === t4) {
1080
- const t5 = Ut(e3);
1081
- kt(r3, t5);
1082
- }
1083
- return Yt(e3), null;
1084
- }, (t4) => ("writable" === r3._state && Dt(e3), function(e4, t5) {
1085
- e4._inFlightWriteRequest._reject(t5), e4._inFlightWriteRequest = void 0, Pt(e4, t5);
1086
- }(r3, t4), null));
1087
- }(e2, r2);
1088
- }
1089
- function Vt(e2, t2) {
1090
- "writable" === e2._controlledWritableStream._state && Ht(e2, t2);
1091
- }
1092
- function Ut(e2) {
1093
- return Nt(e2) <= 0;
1094
- }
1095
- function Ht(e2, t2) {
1096
- const r2 = e2._controlledWritableStream;
1097
- Dt(e2), Ct(r2, t2);
1098
- }
1099
- function Gt(e2) {
1100
- return new TypeError(`WritableStream.prototype.${e2} can only be used on a WritableStream`);
1101
- }
1102
- function Xt(e2) {
1103
- return new TypeError(`WritableStreamDefaultController.prototype.${e2} can only be used on a WritableStreamDefaultController`);
1104
- }
1105
- function Jt(e2) {
1106
- return new TypeError(`WritableStreamDefaultWriter.prototype.${e2} can only be used on a WritableStreamDefaultWriter`);
1107
- }
1108
- function Kt(e2) {
1109
- return new TypeError("Cannot " + e2 + " a stream using a released writer");
1110
- }
1111
- function Qt(e2) {
1112
- e2._closedPromise = u((t2, r2) => {
1113
- e2._closedPromise_resolve = t2, e2._closedPromise_reject = r2, e2._closedPromiseState = "pending";
1114
- });
1115
- }
1116
- function Zt(e2, t2) {
1117
- Qt(e2), er(e2, t2);
1118
- }
1119
- function er(e2, t2) {
1120
- void 0 !== e2._closedPromise_reject && (m(e2._closedPromise), e2._closedPromise_reject(t2), e2._closedPromise_resolve = void 0, e2._closedPromise_reject = void 0, e2._closedPromiseState = "rejected");
1121
- }
1122
- function tr(e2) {
1123
- void 0 !== e2._closedPromise_resolve && (e2._closedPromise_resolve(void 0), e2._closedPromise_resolve = void 0, e2._closedPromise_reject = void 0, e2._closedPromiseState = "resolved");
1124
- }
1125
- function rr(e2) {
1126
- e2._readyPromise = u((t2, r2) => {
1127
- e2._readyPromise_resolve = t2, e2._readyPromise_reject = r2;
1128
- }), e2._readyPromiseState = "pending";
1129
- }
1130
- function or(e2, t2) {
1131
- rr(e2), ir(e2, t2);
1132
- }
1133
- function nr(e2) {
1134
- rr(e2), ar(e2);
1135
- }
1136
- function ir(e2, t2) {
1137
- void 0 !== e2._readyPromise_reject && (m(e2._readyPromise), e2._readyPromise_reject(t2), e2._readyPromise_resolve = void 0, e2._readyPromise_reject = void 0, e2._readyPromiseState = "rejected");
1138
- }
1139
- function ar(e2) {
1140
- void 0 !== e2._readyPromise_resolve && (e2._readyPromise_resolve(void 0), e2._readyPromise_resolve = void 0, e2._readyPromise_reject = void 0, e2._readyPromiseState = "fulfilled");
1141
- }
1142
- Object.defineProperties(xt.prototype, { abortReason: { enumerable: true }, signal: { enumerable: true }, error: { enumerable: true } }), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(xt.prototype, Symbol.toStringTag, { value: "WritableStreamDefaultController", configurable: true });
1143
- const sr = "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : "undefined" != typeof global ? global : void 0, lr = function() {
1144
- const e2 = null == sr ? void 0 : sr.DOMException;
1145
- return function(e3) {
1146
- if ("function" != typeof e3 && "object" != typeof e3) return false;
1147
- if ("DOMException" !== e3.name) return false;
1148
- try {
1149
- return new e3(), true;
1150
- } catch (e4) {
1151
- return false;
1152
- }
1153
- }(e2) ? e2 : void 0;
1154
- }() || function() {
1155
- const e2 = function(e3, t2) {
1156
- this.message = e3 || "", this.name = t2 || "Error", Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
1157
- };
1158
- return o(e2, "DOMException"), e2.prototype = Object.create(Error.prototype), Object.defineProperty(e2.prototype, "constructor", { value: e2, writable: true, configurable: true }), e2;
1159
- }();
1160
- function ur(t2, r2, o2, n2, i2, a2) {
1161
- const s2 = U(t2), l2 = St(r2);
1162
- t2._disturbed = true;
1163
- let p2 = false, y2 = c(void 0);
1164
- return u((v2, w2) => {
1165
- let g2;
1166
- if (void 0 !== a2) {
1167
- if (g2 = () => {
1168
- const e2 = void 0 !== a2.reason ? a2.reason : new lr("Aborted", "AbortError"), o3 = [];
1169
- n2 || o3.push(() => "writable" === r2._state ? qt(r2, e2) : c(void 0)), i2 || o3.push(() => "readable" === t2._state ? zr(t2, e2) : c(void 0)), P2(() => Promise.all(o3.map((e3) => e3())), true, e2);
1170
- }, a2.aborted) return void g2();
1171
- a2.addEventListener("abort", g2);
1172
- }
1173
- var S2, R2, T2;
1174
- if (E2(t2, s2._closedPromise, (e2) => (n2 ? C2(true, e2) : P2(() => qt(r2, e2), true, e2), null)), E2(r2, l2._closedPromise, (e2) => (i2 ? C2(true, e2) : P2(() => zr(t2, e2), true, e2), null)), S2 = t2, R2 = s2._closedPromise, T2 = () => (o2 ? C2() : P2(() => function(e2) {
1175
- const t3 = e2._ownerWritableStream, r3 = t3._state;
1176
- return At(t3) || "closed" === r3 ? c(void 0) : "errored" === r3 ? d(t3._storedError) : Bt(e2);
1177
- }(l2)), null), "closed" === S2._state ? T2() : h(R2, T2), At(r2) || "closed" === r2._state) {
1178
- const e2 = new TypeError("the destination writable stream closed before all data could be piped to it");
1179
- i2 ? C2(true, e2) : P2(() => zr(t2, e2), true, e2);
1180
- }
1181
- function q2() {
1182
- const e2 = y2;
1183
- return f(y2, () => e2 !== y2 ? q2() : void 0);
1184
- }
1185
- function E2(e2, t3, r3) {
1186
- "errored" === e2._state ? r3(e2._storedError) : _(t3, r3);
1187
- }
1188
- function P2(e2, t3, o3) {
1189
- function n3() {
1190
- return b(e2(), () => A2(t3, o3), (e3) => A2(true, e3)), null;
1191
- }
1192
- p2 || (p2 = true, "writable" !== r2._state || At(r2) ? n3() : h(q2(), n3));
1193
- }
1194
- function C2(e2, t3) {
1195
- p2 || (p2 = true, "writable" !== r2._state || At(r2) ? A2(e2, t3) : h(q2(), () => A2(e2, t3)));
1196
- }
1197
- function A2(e2, t3) {
1198
- return It(l2), O(s2), void 0 !== a2 && a2.removeEventListener("abort", g2), e2 ? w2(t3) : v2(void 0), null;
1199
- }
1200
- m(u((t3, r3) => {
1201
- !function o3(n3) {
1202
- n3 ? t3() : f(p2 ? c(true) : f(l2._readyPromise, () => u((t4, r4) => {
1203
- Z(s2, { _chunkSteps: (r5) => {
1204
- y2 = f(Lt(l2, r5), void 0, e), t4(false);
1205
- }, _closeSteps: () => t4(true), _errorSteps: r4 });
1206
- })), o3, r3);
1207
- }(false);
1208
- }));
1209
- });
1210
- }
1211
- class cr {
1212
- constructor() {
1213
- throw new TypeError("Illegal constructor");
1214
- }
1215
- get desiredSize() {
1216
- if (!dr(this)) throw gr("desiredSize");
1217
- return yr(this);
1218
- }
1219
- close() {
1220
- if (!dr(this)) throw gr("close");
1221
- if (!vr(this)) throw new TypeError("The stream is not in a state that permits close");
1222
- _r(this);
1223
- }
1224
- enqueue(e2 = void 0) {
1225
- if (!dr(this)) throw gr("enqueue");
1226
- if (!vr(this)) throw new TypeError("The stream is not in a state that permits enqueue");
1227
- return pr(this, e2);
1228
- }
1229
- error(e2 = void 0) {
1230
- if (!dr(this)) throw gr("error");
1231
- mr(this, e2);
1232
- }
1233
- [T](e2) {
1234
- Re(this);
1235
- const t2 = this._cancelAlgorithm(e2);
1236
- return hr(this), t2;
1237
- }
1238
- [q](e2) {
1239
- const t2 = this._controlledReadableStream;
1240
- if (this._queue.length > 0) {
1241
- const r2 = ge(this);
1242
- this._closeRequested && 0 === this._queue.length ? (hr(this), Br(t2)) : fr(this), e2._chunkSteps(r2);
1243
- } else H(t2, e2), fr(this);
1244
- }
1245
- [E]() {
1246
- }
1247
- }
1248
- function dr(e2) {
1249
- return !!t(e2) && !!Object.prototype.hasOwnProperty.call(e2, "_controlledReadableStream") && e2 instanceof cr;
1250
- }
1251
- function fr(e2) {
1252
- br(e2) && (e2._pulling ? e2._pullAgain = true : (e2._pulling = true, b(e2._pullAlgorithm(), () => (e2._pulling = false, e2._pullAgain && (e2._pullAgain = false, fr(e2)), null), (t2) => (mr(e2, t2), null))));
1253
- }
1254
- function br(e2) {
1255
- const t2 = e2._controlledReadableStream;
1256
- return !!vr(e2) && (!!e2._started && (!!(Wr(t2) && X(t2) > 0) || yr(e2) > 0));
1257
- }
1258
- function hr(e2) {
1259
- e2._pullAlgorithm = void 0, e2._cancelAlgorithm = void 0, e2._strategySizeAlgorithm = void 0;
1260
- }
1261
- function _r(e2) {
1262
- if (!vr(e2)) return;
1263
- const t2 = e2._controlledReadableStream;
1264
- e2._closeRequested = true, 0 === e2._queue.length && (hr(e2), Br(t2));
1265
- }
1266
- function pr(e2, t2) {
1267
- if (!vr(e2)) return;
1268
- const r2 = e2._controlledReadableStream;
1269
- if (Wr(r2) && X(r2) > 0) G(r2, t2, false);
1270
- else {
1271
- let r3;
1272
- try {
1273
- r3 = e2._strategySizeAlgorithm(t2);
1274
- } catch (t3) {
1275
- throw mr(e2, t3), t3;
1276
- }
1277
- try {
1278
- Se(e2, t2, r3);
1279
- } catch (t3) {
1280
- throw mr(e2, t3), t3;
1281
- }
1282
- }
1283
- fr(e2);
1284
- }
1285
- function mr(e2, t2) {
1286
- const r2 = e2._controlledReadableStream;
1287
- "readable" === r2._state && (Re(e2), hr(e2), Fr(r2, t2));
1288
- }
1289
- function yr(e2) {
1290
- const t2 = e2._controlledReadableStream._state;
1291
- return "errored" === t2 ? null : "closed" === t2 ? 0 : e2._strategyHWM - e2._queueTotalSize;
1292
- }
1293
- function vr(e2) {
1294
- const t2 = e2._controlledReadableStream._state;
1295
- return !e2._closeRequested && "readable" === t2;
1296
- }
1297
- function wr(e2, t2, r2, o2, n2, i2, a2) {
1298
- t2._controlledReadableStream = e2, t2._queue = void 0, t2._queueTotalSize = void 0, Re(t2), t2._started = false, t2._closeRequested = false, t2._pullAgain = false, t2._pulling = false, t2._strategySizeAlgorithm = a2, t2._strategyHWM = i2, t2._pullAlgorithm = o2, t2._cancelAlgorithm = n2, e2._readableStreamController = t2, b(c(r2()), () => (t2._started = true, fr(t2), null), (e3) => (mr(t2, e3), null));
1299
- }
1300
- function gr(e2) {
1301
- return new TypeError(`ReadableStreamDefaultController.prototype.${e2} can only be used on a ReadableStreamDefaultController`);
1302
- }
1303
- function Sr(r2) {
1304
- return t(o2 = r2) && void 0 !== o2.getReader ? function(r3) {
1305
- let o3;
1306
- return o3 = Or(e, function() {
1307
- let e2;
1308
- try {
1309
- e2 = r3.read();
1310
- } catch (e3) {
1311
- return d(e3);
1312
- }
1313
- return p(e2, (e3) => {
1314
- if (!t(e3)) throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");
1315
- if (e3.done) _r(o3._readableStreamController);
1316
- else {
1317
- const t2 = e3.value;
1318
- pr(o3._readableStreamController, t2);
1319
- }
1320
- });
1321
- }, function(e2) {
1322
- try {
1323
- return c(r3.cancel(e2));
1324
- } catch (e3) {
1325
- return d(e3);
1326
- }
1327
- }, 0), o3;
1328
- }(r2.getReader()) : function(r3) {
1329
- let o3;
1330
- const n2 = be(r3, "async");
1331
- return o3 = Or(e, function() {
1332
- let e2;
1333
- try {
1334
- e2 = he(n2);
1335
- } catch (e3) {
1336
- return d(e3);
1337
- }
1338
- return p(c(e2), (e3) => {
1339
- if (!t(e3)) throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");
1340
- if (e3.done) _r(o3._readableStreamController);
1341
- else {
1342
- const t2 = e3.value;
1343
- pr(o3._readableStreamController, t2);
1344
- }
1345
- });
1346
- }, function(e2) {
1347
- const r4 = n2.iterator;
1348
- let o4;
1349
- try {
1350
- o4 = ce(r4, "return");
1351
- } catch (e3) {
1352
- return d(e3);
1353
- }
1354
- return void 0 === o4 ? c(void 0) : p(w(o4, r4, [e2]), (e3) => {
1355
- if (!t(e3)) throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object");
1356
- });
1357
- }, 0), o3;
1358
- }(r2);
1359
- var o2;
1360
- }
1361
- function Rr(e2, t2, r2) {
1362
- return L(e2, r2), (r3) => w(e2, t2, [r3]);
1363
- }
1364
- function Tr(e2, t2, r2) {
1365
- return L(e2, r2), (r3) => w(e2, t2, [r3]);
1366
- }
1367
- function qr(e2, t2, r2) {
1368
- return L(e2, r2), (r3) => v(e2, t2, [r3]);
1369
- }
1370
- function Er(e2, t2) {
1371
- if ("bytes" != (e2 = `${e2}`)) throw new TypeError(`${t2} '${e2}' is not a valid enumeration value for ReadableStreamType`);
1372
- return e2;
1373
- }
1374
- function Pr(e2, t2) {
1375
- I(e2, t2);
1376
- const r2 = null == e2 ? void 0 : e2.preventAbort, o2 = null == e2 ? void 0 : e2.preventCancel, n2 = null == e2 ? void 0 : e2.preventClose, i2 = null == e2 ? void 0 : e2.signal;
1377
- return void 0 !== i2 && function(e3, t3) {
1378
- if (!function(e4) {
1379
- if ("object" != typeof e4 || null === e4) return false;
1380
- try {
1381
- return "boolean" == typeof e4.aborted;
1382
- } catch (e5) {
1383
- return false;
1384
- }
1385
- }(e3)) throw new TypeError(`${t3} is not an AbortSignal.`);
1386
- }(i2, `${t2} has member 'signal' that`), { preventAbort: Boolean(r2), preventCancel: Boolean(o2), preventClose: Boolean(n2), signal: i2 };
1387
- }
1388
- Object.defineProperties(cr.prototype, { close: { enumerable: true }, enqueue: { enumerable: true }, error: { enumerable: true }, desiredSize: { enumerable: true } }), o(cr.prototype.close, "close"), o(cr.prototype.enqueue, "enqueue"), o(cr.prototype.error, "error"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(cr.prototype, Symbol.toStringTag, { value: "ReadableStreamDefaultController", configurable: true });
1389
- class Cr {
1390
- constructor(e2 = {}, t2 = {}) {
1391
- void 0 === e2 ? e2 = null : $(e2, "First parameter");
1392
- const r2 = ht(t2, "Second parameter"), o2 = function(e3, t3) {
1393
- I(e3, t3);
1394
- const r3 = e3, o3 = null == r3 ? void 0 : r3.autoAllocateChunkSize, n2 = null == r3 ? void 0 : r3.cancel, i2 = null == r3 ? void 0 : r3.pull, a2 = null == r3 ? void 0 : r3.start, s2 = null == r3 ? void 0 : r3.type;
1395
- return { autoAllocateChunkSize: void 0 === o3 ? void 0 : Y(o3, `${t3} has member 'autoAllocateChunkSize' that`), cancel: void 0 === n2 ? void 0 : Rr(n2, r3, `${t3} has member 'cancel' that`), pull: void 0 === i2 ? void 0 : Tr(i2, r3, `${t3} has member 'pull' that`), start: void 0 === a2 ? void 0 : qr(a2, r3, `${t3} has member 'start' that`), type: void 0 === s2 ? void 0 : Er(s2, `${t3} has member 'type' that`) };
1396
- }(e2, "First parameter");
1397
- if (jr(this), "bytes" === o2.type) {
1398
- if (void 0 !== r2.size) throw new RangeError("The strategy for a byte stream cannot have a size function");
1399
- !function(e3, t3, r3) {
1400
- const o3 = Object.create(Ee.prototype);
1401
- let n2, i2, a2;
1402
- n2 = void 0 !== t3.start ? () => t3.start(o3) : () => {
1403
- }, i2 = void 0 !== t3.pull ? () => t3.pull(o3) : () => c(void 0), a2 = void 0 !== t3.cancel ? (e4) => t3.cancel(e4) : () => c(void 0);
1404
- const s2 = t3.autoAllocateChunkSize;
1405
- if (0 === s2) throw new TypeError("autoAllocateChunkSize must be greater than 0");
1406
- Ze(e3, o3, n2, i2, a2, r3, s2);
1407
- }(this, o2, ft(r2, 0));
1408
- } else {
1409
- const e3 = bt(r2);
1410
- !function(e4, t3, r3, o3) {
1411
- const n2 = Object.create(cr.prototype);
1412
- let i2, a2, s2;
1413
- i2 = void 0 !== t3.start ? () => t3.start(n2) : () => {
1414
- }, a2 = void 0 !== t3.pull ? () => t3.pull(n2) : () => c(void 0), s2 = void 0 !== t3.cancel ? (e5) => t3.cancel(e5) : () => c(void 0), wr(e4, n2, i2, a2, s2, r3, o3);
1415
- }(this, o2, ft(r2, 1), e3);
1416
- }
1417
- }
1418
- get locked() {
1419
- if (!kr(this)) throw Ir("locked");
1420
- return Wr(this);
1421
- }
1422
- cancel(e2 = void 0) {
1423
- return kr(this) ? Wr(this) ? d(new TypeError("Cannot cancel a stream that already has a reader")) : zr(this, e2) : d(Ir("cancel"));
1424
- }
1425
- getReader(e2 = void 0) {
1426
- if (!kr(this)) throw Ir("getReader");
1427
- return void 0 === function(e3, t2) {
1428
- I(e3, t2);
1429
- const r2 = null == e3 ? void 0 : e3.mode;
1430
- return { mode: void 0 === r2 ? void 0 : rt(r2, `${t2} has member 'mode' that`) };
1431
- }(e2, "First parameter").mode ? U(this) : ot(this);
1432
- }
1433
- pipeThrough(e2, t2 = {}) {
1434
- if (!kr(this)) throw Ir("pipeThrough");
1435
- x(e2, 1, "pipeThrough");
1436
- const r2 = function(e3, t3) {
1437
- I(e3, t3);
1438
- const r3 = null == e3 ? void 0 : e3.readable;
1439
- M(r3, "readable", "ReadableWritablePair"), V(r3, `${t3} has member 'readable' that`);
1440
- const o3 = null == e3 ? void 0 : e3.writable;
1441
- return M(o3, "writable", "ReadableWritablePair"), wt(o3, `${t3} has member 'writable' that`), { readable: r3, writable: o3 };
1442
- }(e2, "First parameter"), o2 = Pr(t2, "Second parameter");
1443
- if (Wr(this)) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");
1444
- if (Tt(r2.writable)) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");
1445
- return m(ur(this, r2.writable, o2.preventClose, o2.preventAbort, o2.preventCancel, o2.signal)), r2.readable;
1446
- }
1447
- pipeTo(e2, t2 = {}) {
1448
- if (!kr(this)) return d(Ir("pipeTo"));
1449
- if (void 0 === e2) return d("Parameter 1 is required in 'pipeTo'.");
1450
- if (!Rt(e2)) return d(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));
1451
- let r2;
1452
- try {
1453
- r2 = Pr(t2, "Second parameter");
1454
- } catch (e3) {
1455
- return d(e3);
1456
- }
1457
- return Wr(this) ? d(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")) : Tt(e2) ? d(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")) : ur(this, e2, r2.preventClose, r2.preventAbort, r2.preventCancel, r2.signal);
1458
- }
1459
- tee() {
1460
- if (!kr(this)) throw Ir("tee");
1461
- return ie(function(e2) {
1462
- return Pe(e2._readableStreamController) ? function(e3) {
1463
- let t2, r2, o2, n2, i2, a2 = U(e3), s2 = false, l2 = false, d2 = false, f2 = false, b2 = false;
1464
- const h2 = u((e4) => {
1465
- i2 = e4;
1466
- });
1467
- function p2(e4) {
1468
- _(e4._closedPromise, (t3) => (e4 !== a2 || (He(o2._readableStreamController, t3), He(n2._readableStreamController, t3), f2 && b2 || i2(void 0)), null));
1469
- }
1470
- function m2() {
1471
- lt(a2) && (O(a2), a2 = U(e3), p2(a2)), Z(a2, { _chunkSteps: (t3) => {
1472
- y(() => {
1473
- l2 = false, d2 = false;
1474
- const r3 = t3;
1475
- let a3 = t3;
1476
- if (!f2 && !b2) try {
1477
- a3 = we(t3);
1478
- } catch (t4) {
1479
- return He(o2._readableStreamController, t4), He(n2._readableStreamController, t4), void i2(zr(e3, t4));
1480
- }
1481
- f2 || Ue(o2._readableStreamController, r3), b2 || Ue(n2._readableStreamController, a3), s2 = false, l2 ? w2() : d2 && g2();
1482
- });
1483
- }, _closeSteps: () => {
1484
- s2 = false, f2 || Ve(o2._readableStreamController), b2 || Ve(n2._readableStreamController), o2._readableStreamController._pendingPullIntos.length > 0 && Ke(o2._readableStreamController, 0), n2._readableStreamController._pendingPullIntos.length > 0 && Ke(n2._readableStreamController, 0), f2 && b2 || i2(void 0);
1485
- }, _errorSteps: () => {
1486
- s2 = false;
1487
- } });
1488
- }
1489
- function v2(t3, r3) {
1490
- Q(a2) && (O(a2), a2 = ot(e3), p2(a2));
1491
- const u2 = r3 ? n2 : o2, c2 = r3 ? o2 : n2;
1492
- ut(a2, t3, 1, { _chunkSteps: (t4) => {
1493
- y(() => {
1494
- l2 = false, d2 = false;
1495
- const o3 = r3 ? b2 : f2;
1496
- if (r3 ? f2 : b2) o3 || Qe(u2._readableStreamController, t4);
1497
- else {
1498
- let r4;
1499
- try {
1500
- r4 = we(t4);
1501
- } catch (t5) {
1502
- return He(u2._readableStreamController, t5), He(c2._readableStreamController, t5), void i2(zr(e3, t5));
1503
- }
1504
- o3 || Qe(u2._readableStreamController, t4), Ue(c2._readableStreamController, r4);
1505
- }
1506
- s2 = false, l2 ? w2() : d2 && g2();
1507
- });
1508
- }, _closeSteps: (e4) => {
1509
- s2 = false;
1510
- const t4 = r3 ? b2 : f2, o3 = r3 ? f2 : b2;
1511
- t4 || Ve(u2._readableStreamController), o3 || Ve(c2._readableStreamController), void 0 !== e4 && (t4 || Qe(u2._readableStreamController, e4), !o3 && c2._readableStreamController._pendingPullIntos.length > 0 && Ke(c2._readableStreamController, 0)), t4 && o3 || i2(void 0);
1512
- }, _errorSteps: () => {
1513
- s2 = false;
1514
- } });
1515
- }
1516
- function w2() {
1517
- if (s2) return l2 = true, c(void 0);
1518
- s2 = true;
1519
- const e4 = Xe(o2._readableStreamController);
1520
- return null === e4 ? m2() : v2(e4._view, false), c(void 0);
1521
- }
1522
- function g2() {
1523
- if (s2) return d2 = true, c(void 0);
1524
- s2 = true;
1525
- const e4 = Xe(n2._readableStreamController);
1526
- return null === e4 ? m2() : v2(e4._view, true), c(void 0);
1527
- }
1528
- function S2() {
1529
- }
1530
- return o2 = Ar(S2, w2, function(o3) {
1531
- if (f2 = true, t2 = o3, b2) {
1532
- const o4 = ie([t2, r2]), n3 = zr(e3, o4);
1533
- i2(n3);
1534
- }
1535
- return h2;
1536
- }), n2 = Ar(S2, g2, function(o3) {
1537
- if (b2 = true, r2 = o3, f2) {
1538
- const o4 = ie([t2, r2]), n3 = zr(e3, o4);
1539
- i2(n3);
1540
- }
1541
- return h2;
1542
- }), p2(a2), [o2, n2];
1543
- }(e2) : function(e3) {
1544
- const t2 = U(e3);
1545
- let r2, o2, n2, i2, a2, s2 = false, l2 = false, d2 = false, f2 = false;
1546
- const b2 = u((e4) => {
1547
- a2 = e4;
1548
- });
1549
- function h2() {
1550
- return s2 ? (l2 = true, c(void 0)) : (s2 = true, Z(t2, { _chunkSteps: (e4) => {
1551
- y(() => {
1552
- l2 = false;
1553
- const t3 = e4, r3 = e4;
1554
- d2 || pr(n2._readableStreamController, t3), f2 || pr(i2._readableStreamController, r3), s2 = false, l2 && h2();
1555
- });
1556
- }, _closeSteps: () => {
1557
- s2 = false, d2 || _r(n2._readableStreamController), f2 || _r(i2._readableStreamController), d2 && f2 || a2(void 0);
1558
- }, _errorSteps: () => {
1559
- s2 = false;
1560
- } }), c(void 0));
1561
- }
1562
- function p2() {
1563
- }
1564
- return n2 = Or(p2, h2, function(t3) {
1565
- if (d2 = true, r2 = t3, f2) {
1566
- const t4 = ie([r2, o2]), n3 = zr(e3, t4);
1567
- a2(n3);
1568
- }
1569
- return b2;
1570
- }), i2 = Or(p2, h2, function(t3) {
1571
- if (f2 = true, o2 = t3, d2) {
1572
- const t4 = ie([r2, o2]), n3 = zr(e3, t4);
1573
- a2(n3);
1574
- }
1575
- return b2;
1576
- }), _(t2._closedPromise, (e4) => (mr(n2._readableStreamController, e4), mr(i2._readableStreamController, e4), d2 && f2 || a2(void 0), null)), [n2, i2];
1577
- }(e2);
1578
- }(this));
1579
- }
1580
- values(e2 = void 0) {
1581
- if (!kr(this)) throw Ir("values");
1582
- return function(e3, t2) {
1583
- const r2 = U(e3), o2 = new _e(r2, t2), n2 = Object.create(pe);
1584
- return n2._asyncIteratorImpl = o2, n2;
1585
- }(this, function(e3) {
1586
- I(e3, "First parameter");
1587
- const t2 = null == e3 ? void 0 : e3.preventCancel;
1588
- return { preventCancel: Boolean(t2) };
1589
- }(e2).preventCancel);
1590
- }
1591
- [fe](e2) {
1592
- return this.values(e2);
1593
- }
1594
- static from(e2) {
1595
- return Sr(e2);
1596
- }
1597
- }
1598
- function Or(e2, t2, r2, o2 = 1, n2 = () => 1) {
1599
- const i2 = Object.create(Cr.prototype);
1600
- return jr(i2), wr(i2, Object.create(cr.prototype), e2, t2, r2, o2, n2), i2;
1601
- }
1602
- function Ar(e2, t2, r2) {
1603
- const o2 = Object.create(Cr.prototype);
1604
- return jr(o2), Ze(o2, Object.create(Ee.prototype), e2, t2, r2, 0, void 0), o2;
1605
- }
1606
- function jr(e2) {
1607
- e2._state = "readable", e2._reader = void 0, e2._storedError = void 0, e2._disturbed = false;
1608
- }
1609
- function kr(e2) {
1610
- return !!t(e2) && !!Object.prototype.hasOwnProperty.call(e2, "_readableStreamController") && e2 instanceof Cr;
1611
- }
1612
- function Wr(e2) {
1613
- return void 0 !== e2._reader;
1614
- }
1615
- function zr(t2, r2) {
1616
- if (t2._disturbed = true, "closed" === t2._state) return c(void 0);
1617
- if ("errored" === t2._state) return d(t2._storedError);
1618
- Br(t2);
1619
- const o2 = t2._reader;
1620
- if (void 0 !== o2 && lt(o2)) {
1621
- const e2 = o2._readIntoRequests;
1622
- o2._readIntoRequests = new g(), e2.forEach((e3) => {
1623
- e3._closeSteps(void 0);
1624
- });
1625
- }
1626
- return p(t2._readableStreamController[T](r2), e);
1627
- }
1628
- function Br(e2) {
1629
- e2._state = "closed";
1630
- const t2 = e2._reader;
1631
- if (void 0 !== t2 && (z(t2), Q(t2))) {
1632
- const e3 = t2._readRequests;
1633
- t2._readRequests = new g(), e3.forEach((e4) => {
1634
- e4._closeSteps();
1635
- });
1636
- }
1637
- }
1638
- function Fr(e2, t2) {
1639
- e2._state = "errored", e2._storedError = t2;
1640
- const r2 = e2._reader;
1641
- void 0 !== r2 && (W(r2, t2), Q(r2) ? ee(r2, t2) : ct(r2, t2));
1642
- }
1643
- function Ir(e2) {
1644
- return new TypeError(`ReadableStream.prototype.${e2} can only be used on a ReadableStream`);
1645
- }
1646
- Object.defineProperties(Cr, { from: { enumerable: true } }), Object.defineProperties(Cr.prototype, { cancel: { enumerable: true }, getReader: { enumerable: true }, pipeThrough: { enumerable: true }, pipeTo: { enumerable: true }, tee: { enumerable: true }, values: { enumerable: true }, locked: { enumerable: true } }), o(Cr.from, "from"), o(Cr.prototype.cancel, "cancel"), o(Cr.prototype.getReader, "getReader"), o(Cr.prototype.pipeThrough, "pipeThrough"), o(Cr.prototype.pipeTo, "pipeTo"), o(Cr.prototype.tee, "tee"), o(Cr.prototype.values, "values"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(Cr.prototype, Symbol.toStringTag, { value: "ReadableStream", configurable: true }), Object.defineProperty(Cr.prototype, fe, { value: Cr.prototype.values, writable: true, configurable: true });
1647
- o((e2) => e2.byteLength, "size");
1648
- function Lr(e2, t2) {
1649
- (function(e3) {
1650
- e3._transformAlgorithm = void 0, e3._flushAlgorithm = void 0, e3._cancelAlgorithm = void 0;
1651
- })(e2._transformStreamController), Vt(e2._writable._writableStreamController, t2), function(e3) {
1652
- e3._backpressure && $r(e3, false);
1653
- }(e2);
1654
- }
1655
- function $r(e2, t2) {
1656
- void 0 !== e2._backpressureChangePromise && e2._backpressureChangePromise_resolve(), e2._backpressureChangePromise = u((t3) => {
1657
- e2._backpressureChangePromise_resolve = t3;
1658
- }), e2._backpressure = t2;
1659
- }
1660
- o(() => 1, "size");
1661
- class xr {
1662
- constructor() {
1663
- throw new TypeError("Illegal constructor");
1664
- }
1665
- get desiredSize() {
1666
- if (!Mr(this)) throw Dr("desiredSize");
1667
- return yr(this._controlledTransformStream._readable._readableStreamController);
1668
- }
1669
- enqueue(e2 = void 0) {
1670
- if (!Mr(this)) throw Dr("enqueue");
1671
- !function(e3, t2) {
1672
- const r2 = e3._controlledTransformStream, o2 = r2._readable._readableStreamController;
1673
- if (!vr(o2)) throw new TypeError("Readable side is not in a state that permits enqueue");
1674
- try {
1675
- pr(o2, t2);
1676
- } catch (e4) {
1677
- throw Lr(r2, e4), r2._readable._storedError;
1678
- }
1679
- const n2 = function(e4) {
1680
- return !br(e4);
1681
- }(o2);
1682
- n2 !== r2._backpressure && $r(r2, true);
1683
- }(this, e2);
1684
- }
1685
- error(e2 = void 0) {
1686
- if (!Mr(this)) throw Dr("error");
1687
- var t2;
1688
- t2 = e2, function(e3, t3) {
1689
- mr(e3._readable._readableStreamController, t3), Lr(e3, t3);
1690
- }(this._controlledTransformStream, t2);
1691
- }
1692
- terminate() {
1693
- if (!Mr(this)) throw Dr("terminate");
1694
- !function(e2) {
1695
- const t2 = e2._controlledTransformStream;
1696
- _r(t2._readable._readableStreamController);
1697
- Lr(t2, new TypeError("TransformStream terminated"));
1698
- }(this);
1699
- }
1700
- }
1701
- function Mr(e2) {
1702
- return !!t(e2) && !!Object.prototype.hasOwnProperty.call(e2, "_controlledTransformStream") && e2 instanceof xr;
1703
- }
1704
- function Dr(e2) {
1705
- return new TypeError(`TransformStreamDefaultController.prototype.${e2} can only be used on a TransformStreamDefaultController`);
1706
- }
1707
- Object.defineProperties(xr.prototype, { enqueue: { enumerable: true }, error: { enumerable: true }, terminate: { enumerable: true }, desiredSize: { enumerable: true } }), o(xr.prototype.enqueue, "enqueue"), o(xr.prototype.error, "error"), o(xr.prototype.terminate, "terminate"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(xr.prototype, Symbol.toStringTag, { value: "TransformStreamDefaultController", configurable: true });
1708
- export {
1709
- Ee as ReadableByteStreamController,
1710
- Cr as ReadableStream,
1711
- st as ReadableStreamBYOBReader,
1712
- qe as ReadableStreamBYOBRequest,
1713
- cr as ReadableStreamDefaultController,
1714
- K as ReadableStreamDefaultReader,
1715
- xr as TransformStreamDefaultController,
1716
- gt as WritableStream,
1717
- xt as WritableStreamDefaultController,
1718
- Wt as WritableStreamDefaultWriter
1719
- };