@gjsify/web-streams 0.3.13 → 0.3.14

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 (14) hide show
  1. package/lib/esm/index.js +22 -87
  2. package/lib/esm/queuing-strategies.js +47 -55
  3. package/lib/esm/readable-stream.js +836 -989
  4. package/lib/esm/register/queuing.js +7 -3
  5. package/lib/esm/register/readable.js +12 -8
  6. package/lib/esm/register/text-streams.js +7 -3
  7. package/lib/esm/register/transform.js +12 -8
  8. package/lib/esm/register/writable.js +12 -8
  9. package/lib/esm/text-decoder-stream.js +133 -118
  10. package/lib/esm/text-encoder-stream.js +58 -44
  11. package/lib/esm/transform-stream.js +242 -298
  12. package/lib/esm/util.js +106 -129
  13. package/lib/esm/writable-stream.js +588 -588
  14. package/package.json +4 -4
package/lib/esm/writable-stream.js CHANGED
@@ -1,676 +1,676 @@
1
- import {
2
- kState,
3
- kType,
4
- isBrandCheck,
5
- createPromiseCallback,
6
- dequeueValue,
7
- enqueueValueWithSize,
8
- extractHighWaterMark,
9
- extractSizeAlgorithm,
10
- peekQueueValue,
11
- resetQueue,
12
- setPromiseHandled,
13
- nonOpCancel,
14
- nonOpStart,
15
- nonOpWrite
16
- } from "./util.js";
1
+ import { createPromiseCallback, dequeueValue, enqueueValueWithSize, extractHighWaterMark, extractSizeAlgorithm, isBrandCheck, kState, kType, nonOpCancel, nonOpStart, nonOpWrite, peekQueueValue, resetQueue, setPromiseHandled } from "./util.js";
2
+
3
+ //#region src/writable-stream.ts
17
4
  const _AbortController = typeof globalThis.AbortController === "function" ? globalThis.AbortController : class AbortControllerShim {
18
- signal = { aborted: false, reason: void 0, addEventListener() {
19
- }, removeEventListener() {
20
- } };
21
- abort(reason) {
22
- this.signal.aborted = true;
23
- this.signal.reason = reason;
24
- }
5
+ signal = {
6
+ aborted: false,
7
+ reason: undefined,
8
+ addEventListener() {},
9
+ removeEventListener() {}
10
+ };
11
+ abort(reason) {
12
+ this.signal.aborted = true;
13
+ this.signal.reason = reason;
14
+ }
15
+ };
16
+ const kAbort = Symbol("kAbort");
17
+ const kCloseSentinel = Symbol("kCloseSentinel");
18
+ const kError = Symbol("kError");
19
+ const kSkipThrow = Symbol("kSkipThrow");
20
+ var WritableStream = class {
21
+ [kType] = "WritableStream";
22
+ [kState];
23
+ constructor(sink = {}, strategy = {}) {
24
+ if (sink != null && typeof sink !== "object") {
25
+ throw new TypeError("sink must be an object");
26
+ }
27
+ if (strategy != null && typeof strategy !== "object") {
28
+ throw new TypeError("strategy must be an object");
29
+ }
30
+ const type = sink?.type;
31
+ if (type !== undefined) {
32
+ throw new RangeError(`Invalid type: ${type}`);
33
+ }
34
+ this[kState] = createWritableStreamState();
35
+ const size = extractSizeAlgorithm(strategy?.size);
36
+ const highWaterMark = extractHighWaterMark(strategy?.highWaterMark, 1);
37
+ setupWritableStreamDefaultControllerFromSink(this, sink, highWaterMark, size);
38
+ }
39
+ get locked() {
40
+ if (!isWritableStream(this)) throw new TypeError("Invalid this");
41
+ return isWritableStreamLocked(this);
42
+ }
43
+ abort(reason) {
44
+ if (!isWritableStream(this)) return Promise.reject(new TypeError("Invalid this"));
45
+ if (isWritableStreamLocked(this)) {
46
+ return Promise.reject(new TypeError("WritableStream is locked"));
47
+ }
48
+ return writableStreamAbort(this, reason);
49
+ }
50
+ close() {
51
+ if (!isWritableStream(this)) return Promise.reject(new TypeError("Invalid this"));
52
+ if (isWritableStreamLocked(this)) {
53
+ return Promise.reject(new TypeError("WritableStream is locked"));
54
+ }
55
+ if (writableStreamCloseQueuedOrInFlight(this)) {
56
+ return Promise.reject(new TypeError("Failure closing WritableStream"));
57
+ }
58
+ return writableStreamClose(this);
59
+ }
60
+ getWriter() {
61
+ if (!isWritableStream(this)) throw new TypeError("Invalid this");
62
+ return new WritableStreamDefaultWriter(this);
63
+ }
64
+ get [Symbol.toStringTag]() {
65
+ return "WritableStream";
66
+ }
67
+ };
68
+ var WritableStreamDefaultWriter = class {
69
+ [kType] = "WritableStreamDefaultWriter";
70
+ [kState];
71
+ constructor(stream) {
72
+ if (!isWritableStream(stream)) {
73
+ throw new TypeError("Expected a WritableStream");
74
+ }
75
+ this[kState] = {
76
+ stream: undefined,
77
+ close: {
78
+ promise: undefined,
79
+ resolve: undefined,
80
+ reject: undefined
81
+ },
82
+ ready: {
83
+ promise: undefined,
84
+ resolve: undefined,
85
+ reject: undefined
86
+ }
87
+ };
88
+ setupWritableStreamDefaultWriter(this, stream);
89
+ }
90
+ get closed() {
91
+ if (!isWritableStreamDefaultWriter(this)) return Promise.reject(new TypeError("Invalid this"));
92
+ return this[kState].close.promise;
93
+ }
94
+ get desiredSize() {
95
+ if (!isWritableStreamDefaultWriter(this)) throw new TypeError("Invalid this");
96
+ if (this[kState].stream === undefined) {
97
+ throw new TypeError("Writer is not bound to a WritableStream");
98
+ }
99
+ return writableStreamDefaultWriterGetDesiredSize(this);
100
+ }
101
+ get ready() {
102
+ if (!isWritableStreamDefaultWriter(this)) return Promise.reject(new TypeError("Invalid this"));
103
+ return this[kState].ready.promise;
104
+ }
105
+ abort(reason) {
106
+ if (!isWritableStreamDefaultWriter(this)) return Promise.reject(new TypeError("Invalid this"));
107
+ if (this[kState].stream === undefined) {
108
+ return Promise.reject(new TypeError("Writer is not bound to a WritableStream"));
109
+ }
110
+ return writableStreamDefaultWriterAbort(this, reason);
111
+ }
112
+ close() {
113
+ if (!isWritableStreamDefaultWriter(this)) return Promise.reject(new TypeError("Invalid this"));
114
+ const { stream } = this[kState];
115
+ if (stream === undefined) {
116
+ return Promise.reject(new TypeError("Writer is not bound to a WritableStream"));
117
+ }
118
+ if (writableStreamCloseQueuedOrInFlight(stream)) {
119
+ return Promise.reject(new TypeError("Failure to close WritableStream"));
120
+ }
121
+ return writableStreamDefaultWriterClose(this);
122
+ }
123
+ releaseLock() {
124
+ if (!isWritableStreamDefaultWriter(this)) throw new TypeError("Invalid this");
125
+ const { stream } = this[kState];
126
+ if (stream === undefined) return;
127
+ writableStreamDefaultWriterRelease(this);
128
+ }
129
+ write(chunk) {
130
+ if (!isWritableStreamDefaultWriter(this)) return Promise.reject(new TypeError("Invalid this"));
131
+ if (this[kState].stream === undefined) {
132
+ return Promise.reject(new TypeError("Writer is not bound to a WritableStream"));
133
+ }
134
+ return writableStreamDefaultWriterWrite(this, chunk);
135
+ }
136
+ get [Symbol.toStringTag]() {
137
+ return "WritableStreamDefaultWriter";
138
+ }
139
+ };
140
+ var WritableStreamDefaultController = class {
141
+ [kType] = "WritableStreamDefaultController";
142
+ [kState];
143
+ constructor(skipThrowSymbol) {
144
+ if (skipThrowSymbol !== kSkipThrow) {
145
+ throw new TypeError("Illegal constructor");
146
+ }
147
+ }
148
+ [kAbort](reason) {
149
+ const result = this[kState].abortAlgorithm(reason);
150
+ writableStreamDefaultControllerClearAlgorithms(this);
151
+ return result;
152
+ }
153
+ [kError]() {
154
+ resetQueue(this);
155
+ }
156
+ get signal() {
157
+ if (!isWritableStreamDefaultController(this)) throw new TypeError("Invalid this");
158
+ return this[kState].abortController.signal;
159
+ }
160
+ error(error) {
161
+ if (!isWritableStreamDefaultController(this)) throw new TypeError("Invalid this");
162
+ if (this[kState].stream[kState].state !== "writable") return;
163
+ writableStreamDefaultControllerError(this, error);
164
+ }
165
+ get [Symbol.toStringTag]() {
166
+ return "WritableStreamDefaultController";
167
+ }
25
168
  };
26
- const kAbort = /* @__PURE__ */ Symbol("kAbort");
27
- const kCloseSentinel = /* @__PURE__ */ Symbol("kCloseSentinel");
28
- const kError = /* @__PURE__ */ Symbol("kError");
29
- const kSkipThrow = /* @__PURE__ */ Symbol("kSkipThrow");
30
- class WritableStream {
31
- [kType] = "WritableStream";
32
- [kState];
33
- constructor(sink = {}, strategy = {}) {
34
- if (sink != null && typeof sink !== "object") {
35
- throw new TypeError("sink must be an object");
36
- }
37
- if (strategy != null && typeof strategy !== "object") {
38
- throw new TypeError("strategy must be an object");
39
- }
40
- const type = sink?.type;
41
- if (type !== void 0) {
42
- throw new RangeError(`Invalid type: ${type}`);
43
- }
44
- this[kState] = createWritableStreamState();
45
- const size = extractSizeAlgorithm(strategy?.size);
46
- const highWaterMark = extractHighWaterMark(strategy?.highWaterMark, 1);
47
- setupWritableStreamDefaultControllerFromSink(this, sink, highWaterMark, size);
48
- }
49
- get locked() {
50
- if (!isWritableStream(this)) throw new TypeError("Invalid this");
51
- return isWritableStreamLocked(this);
52
- }
53
- abort(reason) {
54
- if (!isWritableStream(this)) return Promise.reject(new TypeError("Invalid this"));
55
- if (isWritableStreamLocked(this)) {
56
- return Promise.reject(new TypeError("WritableStream is locked"));
57
- }
58
- return writableStreamAbort(this, reason);
59
- }
60
- close() {
61
- if (!isWritableStream(this)) return Promise.reject(new TypeError("Invalid this"));
62
- if (isWritableStreamLocked(this)) {
63
- return Promise.reject(new TypeError("WritableStream is locked"));
64
- }
65
- if (writableStreamCloseQueuedOrInFlight(this)) {
66
- return Promise.reject(new TypeError("Failure closing WritableStream"));
67
- }
68
- return writableStreamClose(this);
69
- }
70
- getWriter() {
71
- if (!isWritableStream(this)) throw new TypeError("Invalid this");
72
- return new WritableStreamDefaultWriter(this);
73
- }
74
- get [Symbol.toStringTag]() {
75
- return "WritableStream";
76
- }
77
- }
78
- class WritableStreamDefaultWriter {
79
- [kType] = "WritableStreamDefaultWriter";
80
- [kState];
81
- constructor(stream) {
82
- if (!isWritableStream(stream)) {
83
- throw new TypeError("Expected a WritableStream");
84
- }
85
- this[kState] = {
86
- stream: void 0,
87
- close: { promise: void 0, resolve: void 0, reject: void 0 },
88
- ready: { promise: void 0, resolve: void 0, reject: void 0 }
89
- };
90
- setupWritableStreamDefaultWriter(this, stream);
91
- }
92
- get closed() {
93
- if (!isWritableStreamDefaultWriter(this)) return Promise.reject(new TypeError("Invalid this"));
94
- return this[kState].close.promise;
95
- }
96
- get desiredSize() {
97
- if (!isWritableStreamDefaultWriter(this)) throw new TypeError("Invalid this");
98
- if (this[kState].stream === void 0) {
99
- throw new TypeError("Writer is not bound to a WritableStream");
100
- }
101
- return writableStreamDefaultWriterGetDesiredSize(this);
102
- }
103
- get ready() {
104
- if (!isWritableStreamDefaultWriter(this)) return Promise.reject(new TypeError("Invalid this"));
105
- return this[kState].ready.promise;
106
- }
107
- abort(reason) {
108
- if (!isWritableStreamDefaultWriter(this)) return Promise.reject(new TypeError("Invalid this"));
109
- if (this[kState].stream === void 0) {
110
- return Promise.reject(new TypeError("Writer is not bound to a WritableStream"));
111
- }
112
- return writableStreamDefaultWriterAbort(this, reason);
113
- }
114
- close() {
115
- if (!isWritableStreamDefaultWriter(this)) return Promise.reject(new TypeError("Invalid this"));
116
- const { stream } = this[kState];
117
- if (stream === void 0) {
118
- return Promise.reject(new TypeError("Writer is not bound to a WritableStream"));
119
- }
120
- if (writableStreamCloseQueuedOrInFlight(stream)) {
121
- return Promise.reject(new TypeError("Failure to close WritableStream"));
122
- }
123
- return writableStreamDefaultWriterClose(this);
124
- }
125
- releaseLock() {
126
- if (!isWritableStreamDefaultWriter(this)) throw new TypeError("Invalid this");
127
- const { stream } = this[kState];
128
- if (stream === void 0) return;
129
- writableStreamDefaultWriterRelease(this);
130
- }
131
- write(chunk) {
132
- if (!isWritableStreamDefaultWriter(this)) return Promise.reject(new TypeError("Invalid this"));
133
- if (this[kState].stream === void 0) {
134
- return Promise.reject(new TypeError("Writer is not bound to a WritableStream"));
135
- }
136
- return writableStreamDefaultWriterWrite(this, chunk);
137
- }
138
- get [Symbol.toStringTag]() {
139
- return "WritableStreamDefaultWriter";
140
- }
141
- }
142
- class WritableStreamDefaultController {
143
- [kType] = "WritableStreamDefaultController";
144
- [kState];
145
- constructor(skipThrowSymbol) {
146
- if (skipThrowSymbol !== kSkipThrow) {
147
- throw new TypeError("Illegal constructor");
148
- }
149
- }
150
- [kAbort](reason) {
151
- const result = this[kState].abortAlgorithm(reason);
152
- writableStreamDefaultControllerClearAlgorithms(this);
153
- return result;
154
- }
155
- [kError]() {
156
- resetQueue(this);
157
- }
158
- get signal() {
159
- if (!isWritableStreamDefaultController(this)) throw new TypeError("Invalid this");
160
- return this[kState].abortController.signal;
161
- }
162
- error(error) {
163
- if (!isWritableStreamDefaultController(this)) throw new TypeError("Invalid this");
164
- if (this[kState].stream[kState].state !== "writable") return;
165
- writableStreamDefaultControllerError(this, error);
166
- }
167
- get [Symbol.toStringTag]() {
168
- return "WritableStreamDefaultController";
169
- }
170
- }
171
169
  const isWritableStream = isBrandCheck("WritableStream");
172
170
  const isWritableStreamDefaultWriter = isBrandCheck("WritableStreamDefaultWriter");
173
171
  const isWritableStreamDefaultController = isBrandCheck("WritableStreamDefaultController");
174
172
  function createEmptyPromiseRecord() {
175
- return { promise: void 0, resolve: void 0, reject: void 0 };
173
+ return {
174
+ promise: undefined,
175
+ resolve: undefined,
176
+ reject: undefined
177
+ };
176
178
  }
177
179
  function createWritableStreamState() {
178
- return {
179
- close: Promise.withResolvers(),
180
- closeRequest: createEmptyPromiseRecord(),
181
- inFlightWriteRequest: createEmptyPromiseRecord(),
182
- inFlightCloseRequest: createEmptyPromiseRecord(),
183
- pendingAbortRequest: {
184
- abort: createEmptyPromiseRecord(),
185
- reason: void 0,
186
- wasAlreadyErroring: false
187
- },
188
- backpressure: false,
189
- controller: void 0,
190
- state: "writable",
191
- storedError: void 0,
192
- writeRequests: [],
193
- writer: void 0
194
- };
180
+ return {
181
+ close: Promise.withResolvers(),
182
+ closeRequest: createEmptyPromiseRecord(),
183
+ inFlightWriteRequest: createEmptyPromiseRecord(),
184
+ inFlightCloseRequest: createEmptyPromiseRecord(),
185
+ pendingAbortRequest: {
186
+ abort: createEmptyPromiseRecord(),
187
+ reason: undefined,
188
+ wasAlreadyErroring: false
189
+ },
190
+ backpressure: false,
191
+ controller: undefined,
192
+ state: "writable",
193
+ storedError: undefined,
194
+ writeRequests: [],
195
+ writer: undefined
196
+ };
195
197
  }
196
198
  function isWritableStreamLocked(stream) {
197
- return stream[kState].writer !== void 0;
199
+ return stream[kState].writer !== undefined;
198
200
  }
199
201
  function setupWritableStreamDefaultWriter(writer, stream) {
200
- if (isWritableStreamLocked(stream)) {
201
- throw new TypeError("WritableStream is locked");
202
- }
203
- writer[kState].stream = stream;
204
- stream[kState].writer = writer;
205
- switch (stream[kState].state) {
206
- case "writable":
207
- if (!writableStreamCloseQueuedOrInFlight(stream) && stream[kState].backpressure) {
208
- writer[kState].ready = Promise.withResolvers();
209
- } else {
210
- writer[kState].ready = {
211
- promise: Promise.resolve(),
212
- resolve: void 0,
213
- reject: void 0
214
- };
215
- }
216
- writer[kState].close = Promise.withResolvers();
217
- break;
218
- case "erroring":
219
- writer[kState].ready = {
220
- promise: Promise.reject(stream[kState].storedError),
221
- resolve: void 0,
222
- reject: void 0
223
- };
224
- setPromiseHandled(writer[kState].ready.promise);
225
- writer[kState].close = Promise.withResolvers();
226
- break;
227
- case "closed":
228
- writer[kState].ready = {
229
- promise: Promise.resolve(),
230
- resolve: void 0,
231
- reject: void 0
232
- };
233
- writer[kState].close = {
234
- promise: Promise.resolve(),
235
- resolve: void 0,
236
- reject: void 0
237
- };
238
- break;
239
- default:
240
- writer[kState].ready = {
241
- promise: Promise.reject(stream[kState].storedError),
242
- resolve: void 0,
243
- reject: void 0
244
- };
245
- writer[kState].close = {
246
- promise: Promise.reject(stream[kState].storedError),
247
- resolve: void 0,
248
- reject: void 0
249
- };
250
- setPromiseHandled(writer[kState].ready.promise);
251
- setPromiseHandled(writer[kState].close.promise);
252
- }
202
+ if (isWritableStreamLocked(stream)) {
203
+ throw new TypeError("WritableStream is locked");
204
+ }
205
+ writer[kState].stream = stream;
206
+ stream[kState].writer = writer;
207
+ switch (stream[kState].state) {
208
+ case "writable":
209
+ if (!writableStreamCloseQueuedOrInFlight(stream) && stream[kState].backpressure) {
210
+ writer[kState].ready = Promise.withResolvers();
211
+ } else {
212
+ writer[kState].ready = {
213
+ promise: Promise.resolve(),
214
+ resolve: undefined,
215
+ reject: undefined
216
+ };
217
+ }
218
+ writer[kState].close = Promise.withResolvers();
219
+ break;
220
+ case "erroring":
221
+ writer[kState].ready = {
222
+ promise: Promise.reject(stream[kState].storedError),
223
+ resolve: undefined,
224
+ reject: undefined
225
+ };
226
+ setPromiseHandled(writer[kState].ready.promise);
227
+ writer[kState].close = Promise.withResolvers();
228
+ break;
229
+ case "closed":
230
+ writer[kState].ready = {
231
+ promise: Promise.resolve(),
232
+ resolve: undefined,
233
+ reject: undefined
234
+ };
235
+ writer[kState].close = {
236
+ promise: Promise.resolve(),
237
+ resolve: undefined,
238
+ reject: undefined
239
+ };
240
+ break;
241
+ default:
242
+ writer[kState].ready = {
243
+ promise: Promise.reject(stream[kState].storedError),
244
+ resolve: undefined,
245
+ reject: undefined
246
+ };
247
+ writer[kState].close = {
248
+ promise: Promise.reject(stream[kState].storedError),
249
+ resolve: undefined,
250
+ reject: undefined
251
+ };
252
+ setPromiseHandled(writer[kState].ready.promise);
253
+ setPromiseHandled(writer[kState].close.promise);
254
+ }
253
255
  }
254
256
  function writableStreamAbort(stream, reason) {
255
- const { state, controller } = stream[kState];
256
- if (state === "closed" || state === "errored") return Promise.resolve();
257
- controller[kState].abortController.abort(reason);
258
- if (stream[kState].pendingAbortRequest.abort.promise !== void 0) {
259
- return stream[kState].pendingAbortRequest.abort.promise;
260
- }
261
- let wasAlreadyErroring = false;
262
- if (state === "erroring") {
263
- wasAlreadyErroring = true;
264
- reason = void 0;
265
- }
266
- const abort = Promise.withResolvers();
267
- stream[kState].pendingAbortRequest = { abort, reason, wasAlreadyErroring };
268
- if (!wasAlreadyErroring) writableStreamStartErroring(stream, reason);
269
- return abort.promise;
257
+ const { state, controller } = stream[kState];
258
+ if (state === "closed" || state === "errored") return Promise.resolve();
259
+ controller[kState].abortController.abort(reason);
260
+ if (stream[kState].pendingAbortRequest.abort.promise !== undefined) {
261
+ return stream[kState].pendingAbortRequest.abort.promise;
262
+ }
263
+ let wasAlreadyErroring = false;
264
+ if (state === "erroring") {
265
+ wasAlreadyErroring = true;
266
+ reason = undefined;
267
+ }
268
+ const abort = Promise.withResolvers();
269
+ stream[kState].pendingAbortRequest = {
270
+ abort,
271
+ reason,
272
+ wasAlreadyErroring
273
+ };
274
+ if (!wasAlreadyErroring) writableStreamStartErroring(stream, reason);
275
+ return abort.promise;
270
276
  }
271
277
  function writableStreamClose(stream) {
272
- const { state, writer, backpressure, controller } = stream[kState];
273
- if (state === "closed" || state === "errored") {
274
- return Promise.reject(new TypeError("WritableStream is closed"));
275
- }
276
- stream[kState].closeRequest = Promise.withResolvers();
277
- const { promise } = stream[kState].closeRequest;
278
- if (writer !== void 0 && backpressure && state === "writable") {
279
- writer[kState].ready.resolve?.();
280
- }
281
- writableStreamDefaultControllerClose(controller);
282
- return promise;
278
+ const { state, writer, backpressure, controller } = stream[kState];
279
+ if (state === "closed" || state === "errored") {
280
+ return Promise.reject(new TypeError("WritableStream is closed"));
281
+ }
282
+ stream[kState].closeRequest = Promise.withResolvers();
283
+ const { promise } = stream[kState].closeRequest;
284
+ if (writer !== undefined && backpressure && state === "writable") {
285
+ writer[kState].ready.resolve?.();
286
+ }
287
+ writableStreamDefaultControllerClose(controller);
288
+ return promise;
283
289
  }
284
290
  function writableStreamUpdateBackpressure(stream, backpressure) {
285
- const { writer } = stream[kState];
286
- if (writer !== void 0 && stream[kState].backpressure !== backpressure) {
287
- if (backpressure) {
288
- writer[kState].ready = Promise.withResolvers();
289
- } else {
290
- writer[kState].ready.resolve?.();
291
- }
292
- }
293
- stream[kState].backpressure = backpressure;
291
+ const { writer } = stream[kState];
292
+ if (writer !== undefined && stream[kState].backpressure !== backpressure) {
293
+ if (backpressure) {
294
+ writer[kState].ready = Promise.withResolvers();
295
+ } else {
296
+ writer[kState].ready.resolve?.();
297
+ }
298
+ }
299
+ stream[kState].backpressure = backpressure;
294
300
  }
295
301
  function writableStreamStartErroring(stream, reason) {
296
- const { controller, writer } = stream[kState];
297
- stream[kState].state = "erroring";
298
- stream[kState].storedError = reason;
299
- if (writer !== void 0) {
300
- writableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);
301
- }
302
- if (!writableStreamHasOperationMarkedInFlight(stream) && controller[kState].started) {
303
- writableStreamFinishErroring(stream);
304
- }
302
+ const { controller, writer } = stream[kState];
303
+ stream[kState].state = "erroring";
304
+ stream[kState].storedError = reason;
305
+ if (writer !== undefined) {
306
+ writableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);
307
+ }
308
+ if (!writableStreamHasOperationMarkedInFlight(stream) && controller[kState].started) {
309
+ writableStreamFinishErroring(stream);
310
+ }
305
311
  }
306
312
  function writableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
307
- if (stream[kState].closeRequest.promise !== void 0) {
308
- stream[kState].closeRequest.reject?.(stream[kState].storedError);
309
- stream[kState].closeRequest = { promise: void 0, resolve: void 0, reject: void 0 };
310
- }
311
- setPromiseHandled(stream[kState].close.promise);
312
- stream[kState].close.reject?.(stream[kState].storedError);
313
- const { writer } = stream[kState];
314
- if (writer !== void 0) {
315
- setPromiseHandled(writer[kState].close.promise);
316
- writer[kState].close.reject?.(stream[kState].storedError);
317
- }
313
+ if (stream[kState].closeRequest.promise !== undefined) {
314
+ stream[kState].closeRequest.reject?.(stream[kState].storedError);
315
+ stream[kState].closeRequest = {
316
+ promise: undefined,
317
+ resolve: undefined,
318
+ reject: undefined
319
+ };
320
+ }
321
+ setPromiseHandled(stream[kState].close.promise);
322
+ stream[kState].close.reject?.(stream[kState].storedError);
323
+ const { writer } = stream[kState];
324
+ if (writer !== undefined) {
325
+ setPromiseHandled(writer[kState].close.promise);
326
+ writer[kState].close.reject?.(stream[kState].storedError);
327
+ }
318
328
  }
319
329
  function writableStreamMarkFirstWriteRequestInFlight(stream) {
320
- const writeRequest = stream[kState].writeRequests.shift();
321
- stream[kState].inFlightWriteRequest = writeRequest;
330
+ const writeRequest = stream[kState].writeRequests.shift();
331
+ stream[kState].inFlightWriteRequest = writeRequest;
322
332
  }
323
333
  function writableStreamMarkCloseRequestInFlight(stream) {
324
- stream[kState].inFlightCloseRequest = stream[kState].closeRequest;
325
- stream[kState].closeRequest = { promise: void 0, resolve: void 0, reject: void 0 };
334
+ stream[kState].inFlightCloseRequest = stream[kState].closeRequest;
335
+ stream[kState].closeRequest = {
336
+ promise: undefined,
337
+ resolve: undefined,
338
+ reject: undefined
339
+ };
326
340
  }
327
341
  function writableStreamHasOperationMarkedInFlight(stream) {
328
- return stream[kState].inFlightWriteRequest.promise !== void 0 || stream[kState].inFlightCloseRequest.promise !== void 0;
342
+ return stream[kState].inFlightWriteRequest.promise !== undefined || stream[kState].inFlightCloseRequest.promise !== undefined;
329
343
  }
330
344
  function writableStreamFinishInFlightWriteWithError(stream, error) {
331
- stream[kState].inFlightWriteRequest.reject?.(error);
332
- stream[kState].inFlightWriteRequest = { promise: void 0, resolve: void 0, reject: void 0 };
333
- writableStreamDealWithRejection(stream, error);
345
+ stream[kState].inFlightWriteRequest.reject?.(error);
346
+ stream[kState].inFlightWriteRequest = {
347
+ promise: undefined,
348
+ resolve: undefined,
349
+ reject: undefined
350
+ };
351
+ writableStreamDealWithRejection(stream, error);
334
352
  }
335
353
  function writableStreamFinishInFlightWrite(stream) {
336
- stream[kState].inFlightWriteRequest.resolve?.();
337
- stream[kState].inFlightWriteRequest = { promise: void 0, resolve: void 0, reject: void 0 };
354
+ stream[kState].inFlightWriteRequest.resolve?.();
355
+ stream[kState].inFlightWriteRequest = {
356
+ promise: undefined,
357
+ resolve: undefined,
358
+ reject: undefined
359
+ };
338
360
  }
339
361
  function writableStreamFinishInFlightCloseWithError(stream, error) {
340
- stream[kState].inFlightCloseRequest.reject?.(error);
341
- stream[kState].inFlightCloseRequest = { promise: void 0, resolve: void 0, reject: void 0 };
342
- if (stream[kState].pendingAbortRequest.abort.promise !== void 0) {
343
- stream[kState].pendingAbortRequest.abort.reject?.(error);
344
- stream[kState].pendingAbortRequest = {
345
- abort: { promise: void 0, resolve: void 0, reject: void 0 },
346
- reason: void 0,
347
- wasAlreadyErroring: false
348
- };
349
- }
350
- writableStreamDealWithRejection(stream, error);
362
+ stream[kState].inFlightCloseRequest.reject?.(error);
363
+ stream[kState].inFlightCloseRequest = {
364
+ promise: undefined,
365
+ resolve: undefined,
366
+ reject: undefined
367
+ };
368
+ if (stream[kState].pendingAbortRequest.abort.promise !== undefined) {
369
+ stream[kState].pendingAbortRequest.abort.reject?.(error);
370
+ stream[kState].pendingAbortRequest = {
371
+ abort: {
372
+ promise: undefined,
373
+ resolve: undefined,
374
+ reject: undefined
375
+ },
376
+ reason: undefined,
377
+ wasAlreadyErroring: false
378
+ };
379
+ }
380
+ writableStreamDealWithRejection(stream, error);
351
381
  }
352
382
  function writableStreamFinishInFlightClose(stream) {
353
- stream[kState].inFlightCloseRequest.resolve?.();
354
- stream[kState].inFlightCloseRequest = { promise: void 0, resolve: void 0, reject: void 0 };
355
- if (stream[kState].state === "erroring") {
356
- stream[kState].storedError = void 0;
357
- if (stream[kState].pendingAbortRequest.abort.promise !== void 0) {
358
- stream[kState].pendingAbortRequest.abort.resolve?.();
359
- stream[kState].pendingAbortRequest = {
360
- abort: { promise: void 0, resolve: void 0, reject: void 0 },
361
- reason: void 0,
362
- wasAlreadyErroring: false
363
- };
364
- }
365
- }
366
- stream[kState].state = "closed";
367
- if (stream[kState].writer !== void 0) {
368
- stream[kState].writer[kState].close.resolve?.();
369
- }
370
- stream[kState].close.resolve?.();
383
+ stream[kState].inFlightCloseRequest.resolve?.();
384
+ stream[kState].inFlightCloseRequest = {
385
+ promise: undefined,
386
+ resolve: undefined,
387
+ reject: undefined
388
+ };
389
+ if (stream[kState].state === "erroring") {
390
+ stream[kState].storedError = undefined;
391
+ if (stream[kState].pendingAbortRequest.abort.promise !== undefined) {
392
+ stream[kState].pendingAbortRequest.abort.resolve?.();
393
+ stream[kState].pendingAbortRequest = {
394
+ abort: {
395
+ promise: undefined,
396
+ resolve: undefined,
397
+ reject: undefined
398
+ },
399
+ reason: undefined,
400
+ wasAlreadyErroring: false
401
+ };
402
+ }
403
+ }
404
+ stream[kState].state = "closed";
405
+ if (stream[kState].writer !== undefined) {
406
+ stream[kState].writer[kState].close.resolve?.();
407
+ }
408
+ stream[kState].close.resolve?.();
371
409
  }
372
410
  function writableStreamFinishErroring(stream) {
373
- stream[kState].state = "errored";
374
- stream[kState].controller[kError]();
375
- const storedError = stream[kState].storedError;
376
- for (const req of stream[kState].writeRequests) {
377
- req.reject?.(storedError);
378
- }
379
- stream[kState].writeRequests = [];
380
- if (stream[kState].pendingAbortRequest.abort.promise === void 0) {
381
- writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
382
- return;
383
- }
384
- const abortRequest = stream[kState].pendingAbortRequest;
385
- stream[kState].pendingAbortRequest = {
386
- abort: { promise: void 0, resolve: void 0, reject: void 0 },
387
- reason: void 0,
388
- wasAlreadyErroring: false
389
- };
390
- if (abortRequest.wasAlreadyErroring) {
391
- abortRequest.abort.reject?.(storedError);
392
- writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
393
- return;
394
- }
395
- stream[kState].controller[kAbort](abortRequest.reason).then(
396
- () => {
397
- abortRequest.abort.resolve?.();
398
- writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
399
- },
400
- (error) => {
401
- abortRequest.abort.reject?.(error);
402
- writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
403
- }
404
- );
411
+ stream[kState].state = "errored";
412
+ stream[kState].controller[kError]();
413
+ const storedError = stream[kState].storedError;
414
+ for (const req of stream[kState].writeRequests) {
415
+ req.reject?.(storedError);
416
+ }
417
+ stream[kState].writeRequests = [];
418
+ if (stream[kState].pendingAbortRequest.abort.promise === undefined) {
419
+ writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
420
+ return;
421
+ }
422
+ const abortRequest = stream[kState].pendingAbortRequest;
423
+ stream[kState].pendingAbortRequest = {
424
+ abort: {
425
+ promise: undefined,
426
+ resolve: undefined,
427
+ reject: undefined
428
+ },
429
+ reason: undefined,
430
+ wasAlreadyErroring: false
431
+ };
432
+ if (abortRequest.wasAlreadyErroring) {
433
+ abortRequest.abort.reject?.(storedError);
434
+ writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
435
+ return;
436
+ }
437
+ stream[kState].controller[kAbort](abortRequest.reason).then(() => {
438
+ abortRequest.abort.resolve?.();
439
+ writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
440
+ }, (error) => {
441
+ abortRequest.abort.reject?.(error);
442
+ writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
443
+ });
405
444
  }
406
445
  function writableStreamDealWithRejection(stream, error) {
407
- if (stream[kState].state === "writable") {
408
- writableStreamStartErroring(stream, error);
409
- return;
410
- }
411
- writableStreamFinishErroring(stream);
446
+ if (stream[kState].state === "writable") {
447
+ writableStreamStartErroring(stream, error);
448
+ return;
449
+ }
450
+ writableStreamFinishErroring(stream);
412
451
  }
413
452
  function writableStreamCloseQueuedOrInFlight(stream) {
414
- return stream[kState].closeRequest.promise !== void 0 || stream[kState].inFlightCloseRequest.promise !== void 0;
453
+ return stream[kState].closeRequest.promise !== undefined || stream[kState].inFlightCloseRequest.promise !== undefined;
415
454
  }
416
455
  function writableStreamAddWriteRequest(stream) {
417
- const { promise, resolve, reject } = Promise.withResolvers();
418
- stream[kState].writeRequests.push({ promise, resolve, reject });
419
- return promise;
456
+ const { promise, resolve, reject } = Promise.withResolvers();
457
+ stream[kState].writeRequests.push({
458
+ promise,
459
+ resolve,
460
+ reject
461
+ });
462
+ return promise;
420
463
  }
421
464
  function writableStreamDefaultWriterWrite(writer, chunk) {
422
- const { stream } = writer[kState];
423
- const { controller } = stream[kState];
424
- const chunkSize = writableStreamDefaultControllerGetChunkSize(controller, chunk);
425
- if (stream !== writer[kState].stream) {
426
- return Promise.reject(new TypeError("Mismatched WritableStreams"));
427
- }
428
- const { state } = stream[kState];
429
- if (state === "errored") return Promise.reject(stream[kState].storedError);
430
- if (writableStreamCloseQueuedOrInFlight(stream) || state === "closed") {
431
- return Promise.reject(new TypeError("WritableStream is closed"));
432
- }
433
- if (state === "erroring") return Promise.reject(stream[kState].storedError);
434
- const promise = writableStreamAddWriteRequest(stream);
435
- writableStreamDefaultControllerWrite(controller, chunk, chunkSize);
436
- return promise;
465
+ const { stream } = writer[kState];
466
+ const { controller } = stream[kState];
467
+ const chunkSize = writableStreamDefaultControllerGetChunkSize(controller, chunk);
468
+ if (stream !== writer[kState].stream) {
469
+ return Promise.reject(new TypeError("Mismatched WritableStreams"));
470
+ }
471
+ const { state } = stream[kState];
472
+ if (state === "errored") return Promise.reject(stream[kState].storedError);
473
+ if (writableStreamCloseQueuedOrInFlight(stream) || state === "closed") {
474
+ return Promise.reject(new TypeError("WritableStream is closed"));
475
+ }
476
+ if (state === "erroring") return Promise.reject(stream[kState].storedError);
477
+ const promise = writableStreamAddWriteRequest(stream);
478
+ writableStreamDefaultControllerWrite(controller, chunk, chunkSize);
479
+ return promise;
437
480
  }
438
481
  function writableStreamDefaultWriterRelease(writer) {
439
- const { stream } = writer[kState];
440
- const releasedError = new TypeError("Writer has been released");
441
- writableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);
442
- writableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);
443
- stream[kState].writer = void 0;
444
- writer[kState].stream = void 0;
482
+ const { stream } = writer[kState];
483
+ const releasedError = new TypeError("Writer has been released");
484
+ writableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);
485
+ writableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);
486
+ stream[kState].writer = undefined;
487
+ writer[kState].stream = undefined;
445
488
  }
446
489
  function writableStreamDefaultWriterGetDesiredSize(writer) {
447
- const { stream } = writer[kState];
448
- switch (stream[kState].state) {
449
- case "errored":
450
- case "erroring":
451
- return null;
452
- case "closed":
453
- return 0;
454
- }
455
- return writableStreamDefaultControllerGetDesiredSize(stream[kState].controller);
490
+ const { stream } = writer[kState];
491
+ switch (stream[kState].state) {
492
+ case "errored":
493
+ case "erroring": return null;
494
+ case "closed": return 0;
495
+ }
496
+ return writableStreamDefaultControllerGetDesiredSize(stream[kState].controller);
456
497
  }
457
498
  function writableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {
458
- if (writer[kState].ready.reject) {
459
- writer[kState].ready.reject(error);
460
- writer[kState].ready.resolve = void 0;
461
- writer[kState].ready.reject = void 0;
462
- } else {
463
- writer[kState].ready = {
464
- promise: Promise.reject(error),
465
- resolve: void 0,
466
- reject: void 0
467
- };
468
- }
469
- setPromiseHandled(writer[kState].ready.promise);
499
+ if (writer[kState].ready.reject) {
500
+ writer[kState].ready.reject(error);
501
+ writer[kState].ready.resolve = undefined;
502
+ writer[kState].ready.reject = undefined;
503
+ } else {
504
+ writer[kState].ready = {
505
+ promise: Promise.reject(error),
506
+ resolve: undefined,
507
+ reject: undefined
508
+ };
509
+ }
510
+ setPromiseHandled(writer[kState].ready.promise);
470
511
  }
471
512
  function writableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {
472
- if (writer[kState].close.reject) {
473
- writer[kState].close.reject(error);
474
- writer[kState].close.resolve = void 0;
475
- writer[kState].close.reject = void 0;
476
- } else {
477
- writer[kState].close = {
478
- promise: Promise.reject(error),
479
- resolve: void 0,
480
- reject: void 0
481
- };
482
- }
483
- setPromiseHandled(writer[kState].close.promise);
513
+ if (writer[kState].close.reject) {
514
+ writer[kState].close.reject(error);
515
+ writer[kState].close.resolve = undefined;
516
+ writer[kState].close.reject = undefined;
517
+ } else {
518
+ writer[kState].close = {
519
+ promise: Promise.reject(error),
520
+ resolve: undefined,
521
+ reject: undefined
522
+ };
523
+ }
524
+ setPromiseHandled(writer[kState].close.promise);
484
525
  }
485
526
  function writableStreamDefaultWriterCloseWithErrorPropagation(writer) {
486
- const { stream } = writer[kState];
487
- const { state } = stream[kState];
488
- if (writableStreamCloseQueuedOrInFlight(stream) || state === "closed") {
489
- return Promise.resolve();
490
- }
491
- if (state === "errored") return Promise.reject(stream[kState].storedError);
492
- return writableStreamDefaultWriterClose(writer);
527
+ const { stream } = writer[kState];
528
+ const { state } = stream[kState];
529
+ if (writableStreamCloseQueuedOrInFlight(stream) || state === "closed") {
530
+ return Promise.resolve();
531
+ }
532
+ if (state === "errored") return Promise.reject(stream[kState].storedError);
533
+ return writableStreamDefaultWriterClose(writer);
493
534
  }
494
535
  function writableStreamDefaultWriterClose(writer) {
495
- return writableStreamClose(writer[kState].stream);
536
+ return writableStreamClose(writer[kState].stream);
496
537
  }
497
538
  function writableStreamDefaultWriterAbort(writer, reason) {
498
- return writableStreamAbort(writer[kState].stream, reason);
539
+ return writableStreamAbort(writer[kState].stream, reason);
499
540
  }
500
541
  function writableStreamDefaultControllerWrite(controller, chunk, chunkSize) {
501
- try {
502
- enqueueValueWithSize(controller, chunk, chunkSize);
503
- } catch (error) {
504
- writableStreamDefaultControllerErrorIfNeeded(controller, error);
505
- return;
506
- }
507
- const { stream } = controller[kState];
508
- if (!writableStreamCloseQueuedOrInFlight(stream) && stream[kState].state === "writable") {
509
- writableStreamUpdateBackpressure(stream, writableStreamDefaultControllerGetBackpressure(controller));
510
- }
511
- writableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
542
+ try {
543
+ enqueueValueWithSize(controller, chunk, chunkSize);
544
+ } catch (error) {
545
+ writableStreamDefaultControllerErrorIfNeeded(controller, error);
546
+ return;
547
+ }
548
+ const { stream } = controller[kState];
549
+ if (!writableStreamCloseQueuedOrInFlight(stream) && stream[kState].state === "writable") {
550
+ writableStreamUpdateBackpressure(stream, writableStreamDefaultControllerGetBackpressure(controller));
551
+ }
552
+ writableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
512
553
  }
513
554
  function writableStreamDefaultControllerProcessWrite(controller, chunk) {
514
- const { stream, writeAlgorithm } = controller[kState];
515
- writableStreamMarkFirstWriteRequestInFlight(stream);
516
- writeAlgorithm(chunk, controller).then(
517
- () => {
518
- writableStreamFinishInFlightWrite(stream);
519
- const { state } = stream[kState];
520
- dequeueValue(controller);
521
- if (!writableStreamCloseQueuedOrInFlight(stream) && state === "writable") {
522
- writableStreamUpdateBackpressure(stream, writableStreamDefaultControllerGetBackpressure(controller));
523
- }
524
- writableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
525
- },
526
- (error) => {
527
- if (stream[kState].state === "writable") {
528
- writableStreamDefaultControllerClearAlgorithms(controller);
529
- }
530
- writableStreamFinishInFlightWriteWithError(stream, error);
531
- }
532
- );
555
+ const { stream, writeAlgorithm } = controller[kState];
556
+ writableStreamMarkFirstWriteRequestInFlight(stream);
557
+ writeAlgorithm(chunk, controller).then(() => {
558
+ writableStreamFinishInFlightWrite(stream);
559
+ const { state } = stream[kState];
560
+ dequeueValue(controller);
561
+ if (!writableStreamCloseQueuedOrInFlight(stream) && state === "writable") {
562
+ writableStreamUpdateBackpressure(stream, writableStreamDefaultControllerGetBackpressure(controller));
563
+ }
564
+ writableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
565
+ }, (error) => {
566
+ if (stream[kState].state === "writable") {
567
+ writableStreamDefaultControllerClearAlgorithms(controller);
568
+ }
569
+ writableStreamFinishInFlightWriteWithError(stream, error);
570
+ });
533
571
  }
534
572
  function writableStreamDefaultControllerProcessClose(controller) {
535
- const { closeAlgorithm, queue, stream } = controller[kState];
536
- writableStreamMarkCloseRequestInFlight(stream);
537
- dequeueValue(controller);
538
- const sinkClosePromise = closeAlgorithm();
539
- writableStreamDefaultControllerClearAlgorithms(controller);
540
- sinkClosePromise.then(
541
- () => writableStreamFinishInFlightClose(stream),
542
- (error) => writableStreamFinishInFlightCloseWithError(stream, error)
543
- );
573
+ const { closeAlgorithm, queue, stream } = controller[kState];
574
+ writableStreamMarkCloseRequestInFlight(stream);
575
+ dequeueValue(controller);
576
+ const sinkClosePromise = closeAlgorithm();
577
+ writableStreamDefaultControllerClearAlgorithms(controller);
578
+ sinkClosePromise.then(() => writableStreamFinishInFlightClose(stream), (error) => writableStreamFinishInFlightCloseWithError(stream, error));
544
579
  }
545
580
  function writableStreamDefaultControllerGetDesiredSize(controller) {
546
- return controller[kState].highWaterMark - controller[kState].queueTotalSize;
581
+ return controller[kState].highWaterMark - controller[kState].queueTotalSize;
547
582
  }
548
583
  function writableStreamDefaultControllerGetChunkSize(controller, chunk) {
549
- const { stream, sizeAlgorithm } = controller[kState];
550
- if (sizeAlgorithm === void 0) return 1;
551
- try {
552
- return sizeAlgorithm(chunk);
553
- } catch (error) {
554
- writableStreamDefaultControllerErrorIfNeeded(controller, error);
555
- return 1;
556
- }
584
+ const { stream, sizeAlgorithm } = controller[kState];
585
+ if (sizeAlgorithm === undefined) return 1;
586
+ try {
587
+ return sizeAlgorithm(chunk);
588
+ } catch (error) {
589
+ writableStreamDefaultControllerErrorIfNeeded(controller, error);
590
+ return 1;
591
+ }
557
592
  }
558
593
  function writableStreamDefaultControllerErrorIfNeeded(controller, error) {
559
- if (controller[kState].stream[kState].state === "writable") {
560
- writableStreamDefaultControllerError(controller, error);
561
- }
594
+ if (controller[kState].stream[kState].state === "writable") {
595
+ writableStreamDefaultControllerError(controller, error);
596
+ }
562
597
  }
563
598
  function writableStreamDefaultControllerError(controller, error) {
564
- writableStreamDefaultControllerClearAlgorithms(controller);
565
- writableStreamStartErroring(controller[kState].stream, error);
599
+ writableStreamDefaultControllerClearAlgorithms(controller);
600
+ writableStreamStartErroring(controller[kState].stream, error);
566
601
  }
567
602
  function writableStreamDefaultControllerClose(controller) {
568
- enqueueValueWithSize(controller, kCloseSentinel, 0);
569
- writableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
603
+ enqueueValueWithSize(controller, kCloseSentinel, 0);
604
+ writableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
570
605
  }
571
606
  function writableStreamDefaultControllerClearAlgorithms(controller) {
572
- controller[kState].writeAlgorithm = void 0;
573
- controller[kState].closeAlgorithm = void 0;
574
- controller[kState].abortAlgorithm = void 0;
575
- controller[kState].sizeAlgorithm = void 0;
607
+ controller[kState].writeAlgorithm = undefined;
608
+ controller[kState].closeAlgorithm = undefined;
609
+ controller[kState].abortAlgorithm = undefined;
610
+ controller[kState].sizeAlgorithm = undefined;
576
611
  }
577
612
  function writableStreamDefaultControllerGetBackpressure(controller) {
578
- return writableStreamDefaultControllerGetDesiredSize(controller) <= 0;
613
+ return writableStreamDefaultControllerGetDesiredSize(controller) <= 0;
579
614
  }
580
615
  function writableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
581
- const { queue, started, stream } = controller[kState];
582
- if (!started || stream[kState].inFlightWriteRequest.promise !== void 0) return;
583
- if (stream[kState].state === "erroring") {
584
- writableStreamFinishErroring(stream);
585
- return;
586
- }
587
- if (!queue.length) return;
588
- const value = peekQueueValue(controller);
589
- if (value === kCloseSentinel) {
590
- writableStreamDefaultControllerProcessClose(controller);
591
- } else {
592
- writableStreamDefaultControllerProcessWrite(controller, value);
593
- }
616
+ const { queue, started, stream } = controller[kState];
617
+ if (!started || stream[kState].inFlightWriteRequest.promise !== undefined) return;
618
+ if (stream[kState].state === "erroring") {
619
+ writableStreamFinishErroring(stream);
620
+ return;
621
+ }
622
+ if (!queue.length) return;
623
+ const value = peekQueueValue(controller);
624
+ if (value === kCloseSentinel) {
625
+ writableStreamDefaultControllerProcessClose(controller);
626
+ } else {
627
+ writableStreamDefaultControllerProcessWrite(controller, value);
628
+ }
594
629
  }
595
630
  function setupWritableStreamDefaultControllerFromSink(stream, sink, highWaterMark, sizeAlgorithm) {
596
- const controller = new WritableStreamDefaultController(kSkipThrow);
597
- const start = sink?.start;
598
- const write = sink?.write;
599
- const close = sink?.close;
600
- const abort = sink?.abort;
601
- const startAlgorithm = start ? start.bind(sink, controller) : nonOpStart;
602
- const writeAlgorithm = write ? createPromiseCallback("sink.write", write, sink) : nonOpWrite;
603
- const closeAlgorithm = close ? createPromiseCallback("sink.close", close, sink) : nonOpCancel;
604
- const abortAlgorithm = abort ? createPromiseCallback("sink.abort", abort, sink) : nonOpCancel;
605
- setupWritableStreamDefaultController(
606
- stream,
607
- controller,
608
- startAlgorithm,
609
- writeAlgorithm,
610
- closeAlgorithm,
611
- abortAlgorithm,
612
- highWaterMark,
613
- sizeAlgorithm
614
- );
631
+ const controller = new WritableStreamDefaultController(kSkipThrow);
632
+ const start = sink?.start;
633
+ const write = sink?.write;
634
+ const close = sink?.close;
635
+ const abort = sink?.abort;
636
+ const startAlgorithm = start ? start.bind(sink, controller) : nonOpStart;
637
+ const writeAlgorithm = write ? createPromiseCallback("sink.write", write, sink) : nonOpWrite;
638
+ const closeAlgorithm = close ? createPromiseCallback("sink.close", close, sink) : nonOpCancel;
639
+ const abortAlgorithm = abort ? createPromiseCallback("sink.abort", abort, sink) : nonOpCancel;
640
+ setupWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
615
641
  }
616
642
  function setupWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {
617
- controller[kState] = {
618
- abortAlgorithm,
619
- closeAlgorithm,
620
- highWaterMark,
621
- queue: [],
622
- queueTotalSize: 0,
623
- abortController: new _AbortController(),
624
- sizeAlgorithm,
625
- started: false,
626
- stream,
627
- writeAlgorithm
628
- };
629
- stream[kState].controller = controller;
630
- writableStreamUpdateBackpressure(stream, writableStreamDefaultControllerGetBackpressure(controller));
631
- const startResult = startAlgorithm();
632
- new Promise((r) => r(startResult)).then(
633
- () => {
634
- controller[kState].started = true;
635
- writableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
636
- },
637
- (error) => {
638
- controller[kState].started = true;
639
- writableStreamDealWithRejection(stream, error);
640
- }
641
- );
643
+ controller[kState] = {
644
+ abortAlgorithm,
645
+ closeAlgorithm,
646
+ highWaterMark,
647
+ queue: [],
648
+ queueTotalSize: 0,
649
+ abortController: new _AbortController(),
650
+ sizeAlgorithm,
651
+ started: false,
652
+ stream,
653
+ writeAlgorithm
654
+ };
655
+ stream[kState].controller = controller;
656
+ writableStreamUpdateBackpressure(stream, writableStreamDefaultControllerGetBackpressure(controller));
657
+ const startResult = startAlgorithm();
658
+ new Promise((r) => r(startResult)).then(() => {
659
+ controller[kState].started = true;
660
+ writableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
661
+ }, (error) => {
662
+ controller[kState].started = true;
663
+ writableStreamDealWithRejection(stream, error);
664
+ });
642
665
  }
643
666
  function createWritableStream(start, write, close, abort, highWaterMark = 1, size = () => 1) {
644
- const stream = Object.create(WritableStream.prototype);
645
- stream[kType] = "WritableStream";
646
- stream[kState] = createWritableStreamState();
647
- const controller = new WritableStreamDefaultController(kSkipThrow);
648
- setupWritableStreamDefaultController(
649
- stream,
650
- controller,
651
- start,
652
- write,
653
- close,
654
- abort,
655
- highWaterMark,
656
- size
657
- );
658
- return stream;
659
- }
660
- export {
661
- WritableStream,
662
- WritableStreamDefaultController,
663
- WritableStreamDefaultWriter,
664
- createWritableStream,
665
- isWritableStream,
666
- isWritableStreamDefaultController,
667
- isWritableStreamDefaultWriter,
668
- isWritableStreamLocked,
669
- writableStreamAbort,
670
- writableStreamClose,
671
- writableStreamCloseQueuedOrInFlight,
672
- writableStreamDefaultControllerErrorIfNeeded,
673
- writableStreamDefaultWriterCloseWithErrorPropagation,
674
- writableStreamDefaultWriterRelease,
675
- writableStreamDefaultWriterWrite
676
- };
667
+ const stream = Object.create(WritableStream.prototype);
668
+ stream[kType] = "WritableStream";
669
+ stream[kState] = createWritableStreamState();
670
+ const controller = new WritableStreamDefaultController(kSkipThrow);
671
+ setupWritableStreamDefaultController(stream, controller, start, write, close, abort, highWaterMark, size);
672
+ return stream;
673
+ }
674
+
675
+ //#endregion
676
+ export { WritableStream, WritableStreamDefaultController, WritableStreamDefaultWriter, createWritableStream, isWritableStream, isWritableStreamDefaultController, isWritableStreamDefaultWriter, isWritableStreamLocked, writableStreamAbort, writableStreamClose, writableStreamCloseQueuedOrInFlight, writableStreamDefaultControllerErrorIfNeeded, writableStreamDefaultWriterCloseWithErrorPropagation, writableStreamDefaultWriterRelease, writableStreamDefaultWriterWrite };