@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/transform-stream.js CHANGED
@@ -1,336 +1,280 @@
1
- import {
2
- kState,
3
- kType,
4
- isBrandCheck,
5
- createPromiseCallback,
6
- extractHighWaterMark,
7
- extractSizeAlgorithm,
8
- nonOpFlush,
9
- nonOpCancel
10
- } from "./util.js";
11
- import {
12
- createReadableStream,
13
- readableStreamDefaultControllerCanCloseOrEnqueue,
14
- readableStreamDefaultControllerClose,
15
- readableStreamDefaultControllerEnqueue,
16
- readableStreamDefaultControllerError,
17
- readableStreamDefaultControllerGetDesiredSize,
18
- readableStreamDefaultControllerHasBackpressure
19
- } from "./readable-stream.js";
20
- import {
21
- createWritableStream,
22
- writableStreamDefaultControllerErrorIfNeeded
23
- } from "./writable-stream.js";
24
- const kSkipThrow = /* @__PURE__ */ Symbol("kSkipThrow");
25
- class TransformStream {
26
- [kType] = "TransformStream";
27
- [kState];
28
- constructor(transformer = {}, writableStrategy = {}, readableStrategy = {}) {
29
- if (transformer != null && typeof transformer !== "object") {
30
- throw new TypeError("transformer must be an object");
31
- }
32
- if (writableStrategy != null && typeof writableStrategy !== "object") {
33
- throw new TypeError("writableStrategy must be an object");
34
- }
35
- if (readableStrategy != null && typeof readableStrategy !== "object") {
36
- throw new TypeError("readableStrategy must be an object");
37
- }
38
- const readableType = transformer?.readableType;
39
- const writableType = transformer?.writableType;
40
- const start = transformer?.start;
41
- if (readableType !== void 0) {
42
- throw new RangeError(`Invalid readableType: ${readableType}`);
43
- }
44
- if (writableType !== void 0) {
45
- throw new RangeError(`Invalid writableType: ${writableType}`);
46
- }
47
- const readableHighWaterMark = extractHighWaterMark(readableStrategy?.highWaterMark, 0);
48
- const readableSize = extractSizeAlgorithm(readableStrategy?.size);
49
- const writableHighWaterMark = extractHighWaterMark(writableStrategy?.highWaterMark, 1);
50
- const writableSize = extractSizeAlgorithm(writableStrategy?.size);
51
- const startPromise = Promise.withResolvers();
52
- initializeTransformStream(
53
- this,
54
- startPromise,
55
- writableHighWaterMark,
56
- writableSize,
57
- readableHighWaterMark,
58
- readableSize
59
- );
60
- setupTransformStreamDefaultControllerFromTransformer(this, transformer);
61
- if (start !== void 0) {
62
- startPromise.resolve(start.call(transformer, this[kState].controller));
63
- } else {
64
- startPromise.resolve();
65
- }
66
- }
67
- get readable() {
68
- if (!isTransformStream(this)) throw new TypeError("Invalid this");
69
- return this[kState].readable;
70
- }
71
- get writable() {
72
- if (!isTransformStream(this)) throw new TypeError("Invalid this");
73
- return this[kState].writable;
74
- }
75
- get [Symbol.toStringTag]() {
76
- return "TransformStream";
77
- }
78
- }
79
- class TransformStreamDefaultController {
80
- [kType] = "TransformStreamDefaultController";
81
- [kState];
82
- constructor(skipThrowSymbol) {
83
- if (skipThrowSymbol !== kSkipThrow) {
84
- throw new TypeError("Illegal constructor");
85
- }
86
- }
87
- get desiredSize() {
88
- if (!isTransformStreamDefaultController(this)) throw new TypeError("Invalid this");
89
- const { stream } = this[kState];
90
- const { readable } = stream[kState];
91
- const readableController = readable[kState].controller;
92
- return readableStreamDefaultControllerGetDesiredSize(readableController);
93
- }
94
- enqueue(chunk) {
95
- if (!isTransformStreamDefaultController(this)) throw new TypeError("Invalid this");
96
- transformStreamDefaultControllerEnqueue(this, chunk);
97
- }
98
- error(reason) {
99
- if (!isTransformStreamDefaultController(this)) throw new TypeError("Invalid this");
100
- transformStreamDefaultControllerError(this, reason);
101
- }
102
- terminate() {
103
- if (!isTransformStreamDefaultController(this)) throw new TypeError("Invalid this");
104
- transformStreamDefaultControllerTerminate(this);
105
- }
106
- get [Symbol.toStringTag]() {
107
- return "TransformStreamDefaultController";
108
- }
109
- }
1
+ import { createPromiseCallback, extractHighWaterMark, extractSizeAlgorithm, isBrandCheck, kState, kType, nonOpCancel, nonOpFlush } from "./util.js";
2
+ import { createWritableStream, writableStreamDefaultControllerErrorIfNeeded } from "./writable-stream.js";
3
+ import { createReadableStream, readableStreamDefaultControllerCanCloseOrEnqueue, readableStreamDefaultControllerClose, readableStreamDefaultControllerEnqueue, readableStreamDefaultControllerError, readableStreamDefaultControllerGetDesiredSize, readableStreamDefaultControllerHasBackpressure } from "./readable-stream.js";
4
+
5
+ //#region src/transform-stream.ts
6
+ const kSkipThrow = Symbol("kSkipThrow");
7
+ var TransformStream = class {
8
+ [kType] = "TransformStream";
9
+ [kState];
10
+ constructor(transformer = {}, writableStrategy = {}, readableStrategy = {}) {
11
+ if (transformer != null && typeof transformer !== "object") {
12
+ throw new TypeError("transformer must be an object");
13
+ }
14
+ if (writableStrategy != null && typeof writableStrategy !== "object") {
15
+ throw new TypeError("writableStrategy must be an object");
16
+ }
17
+ if (readableStrategy != null && typeof readableStrategy !== "object") {
18
+ throw new TypeError("readableStrategy must be an object");
19
+ }
20
+ const readableType = transformer?.readableType;
21
+ const writableType = transformer?.writableType;
22
+ const start = transformer?.start;
23
+ if (readableType !== undefined) {
24
+ throw new RangeError(`Invalid readableType: ${readableType}`);
25
+ }
26
+ if (writableType !== undefined) {
27
+ throw new RangeError(`Invalid writableType: ${writableType}`);
28
+ }
29
+ const readableHighWaterMark = extractHighWaterMark(readableStrategy?.highWaterMark, 0);
30
+ const readableSize = extractSizeAlgorithm(readableStrategy?.size);
31
+ const writableHighWaterMark = extractHighWaterMark(writableStrategy?.highWaterMark, 1);
32
+ const writableSize = extractSizeAlgorithm(writableStrategy?.size);
33
+ const startPromise = Promise.withResolvers();
34
+ initializeTransformStream(this, startPromise, writableHighWaterMark, writableSize, readableHighWaterMark, readableSize);
35
+ setupTransformStreamDefaultControllerFromTransformer(this, transformer);
36
+ if (start !== undefined) {
37
+ startPromise.resolve(start.call(transformer, this[kState].controller));
38
+ } else {
39
+ startPromise.resolve();
40
+ }
41
+ }
42
+ get readable() {
43
+ if (!isTransformStream(this)) throw new TypeError("Invalid this");
44
+ return this[kState].readable;
45
+ }
46
+ get writable() {
47
+ if (!isTransformStream(this)) throw new TypeError("Invalid this");
48
+ return this[kState].writable;
49
+ }
50
+ get [Symbol.toStringTag]() {
51
+ return "TransformStream";
52
+ }
53
+ };
54
+ var TransformStreamDefaultController = class {
55
+ [kType] = "TransformStreamDefaultController";
56
+ [kState];
57
+ constructor(skipThrowSymbol) {
58
+ if (skipThrowSymbol !== kSkipThrow) {
59
+ throw new TypeError("Illegal constructor");
60
+ }
61
+ }
62
+ get desiredSize() {
63
+ if (!isTransformStreamDefaultController(this)) throw new TypeError("Invalid this");
64
+ const { stream } = this[kState];
65
+ const { readable } = stream[kState];
66
+ const readableController = readable[kState].controller;
67
+ return readableStreamDefaultControllerGetDesiredSize(readableController);
68
+ }
69
+ enqueue(chunk) {
70
+ if (!isTransformStreamDefaultController(this)) throw new TypeError("Invalid this");
71
+ transformStreamDefaultControllerEnqueue(this, chunk);
72
+ }
73
+ error(reason) {
74
+ if (!isTransformStreamDefaultController(this)) throw new TypeError("Invalid this");
75
+ transformStreamDefaultControllerError(this, reason);
76
+ }
77
+ terminate() {
78
+ if (!isTransformStreamDefaultController(this)) throw new TypeError("Invalid this");
79
+ transformStreamDefaultControllerTerminate(this);
80
+ }
81
+ get [Symbol.toStringTag]() {
82
+ return "TransformStreamDefaultController";
83
+ }
84
+ };
110
85
  const isTransformStream = isBrandCheck("TransformStream");
111
86
  const isTransformStreamDefaultController = isBrandCheck("TransformStreamDefaultController");
112
87
  async function defaultTransformAlgorithm(chunk, controller) {
113
- transformStreamDefaultControllerEnqueue(controller, chunk);
88
+ transformStreamDefaultControllerEnqueue(controller, chunk);
114
89
  }
115
90
  function initializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) {
116
- const startAlgorithm = () => startPromise.promise;
117
- const writable = createWritableStream(
118
- startAlgorithm,
119
- (chunk) => transformStreamDefaultSinkWriteAlgorithm(stream, chunk),
120
- () => transformStreamDefaultSinkCloseAlgorithm(stream),
121
- (reason) => transformStreamDefaultSinkAbortAlgorithm(stream, reason),
122
- writableHighWaterMark,
123
- writableSizeAlgorithm
124
- );
125
- const readable = createReadableStream(
126
- startAlgorithm,
127
- () => transformStreamDefaultSourcePullAlgorithm(stream),
128
- (reason) => transformStreamDefaultSourceCancelAlgorithm(stream, reason),
129
- readableHighWaterMark,
130
- readableSizeAlgorithm
131
- );
132
- stream[kState] = {
133
- readable,
134
- writable,
135
- controller: void 0,
136
- backpressure: void 0,
137
- backpressureChange: {
138
- promise: void 0,
139
- resolve: void 0,
140
- reject: void 0
141
- }
142
- };
143
- transformStreamSetBackpressure(stream, true);
91
+ const startAlgorithm = () => startPromise.promise;
92
+ const writable = createWritableStream(startAlgorithm, (chunk) => transformStreamDefaultSinkWriteAlgorithm(stream, chunk), () => transformStreamDefaultSinkCloseAlgorithm(stream), (reason) => transformStreamDefaultSinkAbortAlgorithm(stream, reason), writableHighWaterMark, writableSizeAlgorithm);
93
+ const readable = createReadableStream(startAlgorithm, () => transformStreamDefaultSourcePullAlgorithm(stream), (reason) => transformStreamDefaultSourceCancelAlgorithm(stream, reason), readableHighWaterMark, readableSizeAlgorithm);
94
+ stream[kState] = {
95
+ readable,
96
+ writable,
97
+ controller: undefined,
98
+ backpressure: undefined,
99
+ backpressureChange: {
100
+ promise: undefined,
101
+ resolve: undefined,
102
+ reject: undefined
103
+ }
104
+ };
105
+ transformStreamSetBackpressure(stream, true);
144
106
  }
145
107
  function transformStreamError(stream, error) {
146
- const { readable } = stream[kState];
147
- readableStreamDefaultControllerError(readable[kState].controller, error);
148
- transformStreamErrorWritableAndUnblockWrite(stream, error);
108
+ const { readable } = stream[kState];
109
+ readableStreamDefaultControllerError(readable[kState].controller, error);
110
+ transformStreamErrorWritableAndUnblockWrite(stream, error);
149
111
  }
150
112
  function transformStreamErrorWritableAndUnblockWrite(stream, error) {
151
- const { controller, writable } = stream[kState];
152
- transformStreamDefaultControllerClearAlgorithms(controller);
153
- writableStreamDefaultControllerErrorIfNeeded(writable[kState].controller, error);
154
- transformStreamUnblockWrite(stream);
113
+ const { controller, writable } = stream[kState];
114
+ transformStreamDefaultControllerClearAlgorithms(controller);
115
+ writableStreamDefaultControllerErrorIfNeeded(writable[kState].controller, error);
116
+ transformStreamUnblockWrite(stream);
155
117
  }
156
118
  function transformStreamUnblockWrite(stream) {
157
- if (stream[kState].backpressure) {
158
- transformStreamSetBackpressure(stream, false);
159
- }
119
+ if (stream[kState].backpressure) {
120
+ transformStreamSetBackpressure(stream, false);
121
+ }
160
122
  }
161
123
  function transformStreamSetBackpressure(stream, backpressure) {
162
- if (stream[kState].backpressureChange.promise !== void 0) {
163
- stream[kState].backpressureChange.resolve?.();
164
- }
165
- stream[kState].backpressureChange = Promise.withResolvers();
166
- stream[kState].backpressure = backpressure;
124
+ if (stream[kState].backpressureChange.promise !== undefined) {
125
+ stream[kState].backpressureChange.resolve?.();
126
+ }
127
+ stream[kState].backpressureChange = Promise.withResolvers();
128
+ stream[kState].backpressure = backpressure;
167
129
  }
168
130
  function setupTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm) {
169
- controller[kState] = {
170
- stream,
171
- transformAlgorithm,
172
- flushAlgorithm,
173
- cancelAlgorithm,
174
- finishPromise: void 0
175
- };
176
- stream[kState].controller = controller;
131
+ controller[kState] = {
132
+ stream,
133
+ transformAlgorithm,
134
+ flushAlgorithm,
135
+ cancelAlgorithm,
136
+ finishPromise: undefined
137
+ };
138
+ stream[kState].controller = controller;
177
139
  }
178
140
  function setupTransformStreamDefaultControllerFromTransformer(stream, transformer) {
179
- const controller = new TransformStreamDefaultController(kSkipThrow);
180
- const transform = transformer?.transform;
181
- const flush = transformer?.flush;
182
- const cancel = transformer?.cancel;
183
- const transformAlgorithm = transform ? createPromiseCallback("transformer.transform", transform, transformer) : defaultTransformAlgorithm;
184
- const flushAlgorithm = flush ? createPromiseCallback("transformer.flush", flush, transformer) : nonOpFlush;
185
- const cancelAlgorithm = cancel ? createPromiseCallback("transformer.cancel", cancel, transformer) : nonOpCancel;
186
- setupTransformStreamDefaultController(
187
- stream,
188
- controller,
189
- transformAlgorithm,
190
- flushAlgorithm,
191
- cancelAlgorithm
192
- );
141
+ const controller = new TransformStreamDefaultController(kSkipThrow);
142
+ const transform = transformer?.transform;
143
+ const flush = transformer?.flush;
144
+ const cancel = transformer?.cancel;
145
+ const transformAlgorithm = transform ? createPromiseCallback("transformer.transform", transform, transformer) : defaultTransformAlgorithm;
146
+ const flushAlgorithm = flush ? createPromiseCallback("transformer.flush", flush, transformer) : nonOpFlush;
147
+ const cancelAlgorithm = cancel ? createPromiseCallback("transformer.cancel", cancel, transformer) : nonOpCancel;
148
+ setupTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm);
193
149
  }
194
150
  function transformStreamDefaultControllerClearAlgorithms(controller) {
195
- controller[kState].transformAlgorithm = void 0;
196
- controller[kState].flushAlgorithm = void 0;
197
- controller[kState].cancelAlgorithm = void 0;
151
+ controller[kState].transformAlgorithm = undefined;
152
+ controller[kState].flushAlgorithm = undefined;
153
+ controller[kState].cancelAlgorithm = undefined;
198
154
  }
199
155
  function transformStreamDefaultControllerEnqueue(controller, chunk) {
200
- const { stream } = controller[kState];
201
- const { readable } = stream[kState];
202
- const readableController = readable[kState].controller;
203
- if (!readableStreamDefaultControllerCanCloseOrEnqueue(readableController)) {
204
- throw new TypeError("Unable to enqueue");
205
- }
206
- try {
207
- readableStreamDefaultControllerEnqueue(readableController, chunk);
208
- } catch (error) {
209
- transformStreamErrorWritableAndUnblockWrite(stream, error);
210
- throw readable[kState].storedError;
211
- }
212
- const backpressure = readableStreamDefaultControllerHasBackpressure(readableController);
213
- if (backpressure !== stream[kState].backpressure) {
214
- transformStreamSetBackpressure(stream, true);
215
- }
156
+ const { stream } = controller[kState];
157
+ const { readable } = stream[kState];
158
+ const readableController = readable[kState].controller;
159
+ if (!readableStreamDefaultControllerCanCloseOrEnqueue(readableController)) {
160
+ throw new TypeError("Unable to enqueue");
161
+ }
162
+ try {
163
+ readableStreamDefaultControllerEnqueue(readableController, chunk);
164
+ } catch (error) {
165
+ transformStreamErrorWritableAndUnblockWrite(stream, error);
166
+ throw readable[kState].storedError;
167
+ }
168
+ const backpressure = readableStreamDefaultControllerHasBackpressure(readableController);
169
+ if (backpressure !== stream[kState].backpressure) {
170
+ transformStreamSetBackpressure(stream, true);
171
+ }
216
172
  }
217
173
  function transformStreamDefaultControllerError(controller, error) {
218
- transformStreamError(controller[kState].stream, error);
174
+ transformStreamError(controller[kState].stream, error);
219
175
  }
220
176
  async function transformStreamDefaultControllerPerformTransform(controller, chunk) {
221
- try {
222
- const transformAlgorithm = controller[kState].transformAlgorithm;
223
- if (transformAlgorithm === void 0) return;
224
- return await transformAlgorithm(chunk, controller);
225
- } catch (error) {
226
- transformStreamError(controller[kState].stream, error);
227
- throw error;
228
- }
177
+ try {
178
+ const transformAlgorithm = controller[kState].transformAlgorithm;
179
+ if (transformAlgorithm === undefined) return;
180
+ return await transformAlgorithm(chunk, controller);
181
+ } catch (error) {
182
+ transformStreamError(controller[kState].stream, error);
183
+ throw error;
184
+ }
229
185
  }
230
186
  function transformStreamDefaultControllerTerminate(controller) {
231
- const { stream } = controller[kState];
232
- const { readable } = stream[kState];
233
- readableStreamDefaultControllerClose(readable[kState].controller);
234
- transformStreamErrorWritableAndUnblockWrite(stream, new TypeError("TransformStream has been terminated"));
187
+ const { stream } = controller[kState];
188
+ const { readable } = stream[kState];
189
+ readableStreamDefaultControllerClose(readable[kState].controller);
190
+ transformStreamErrorWritableAndUnblockWrite(stream, new TypeError("TransformStream has been terminated"));
235
191
  }
236
192
  function transformStreamDefaultSinkWriteAlgorithm(stream, chunk) {
237
- const { controller } = stream[kState];
238
- if (stream[kState].backpressure) {
239
- const backpressureChange = stream[kState].backpressureChange.promise;
240
- return backpressureChange.then(() => {
241
- const { writable } = stream[kState];
242
- if (writable[kState].state === "erroring") {
243
- throw writable[kState].storedError;
244
- }
245
- return transformStreamDefaultControllerPerformTransform(controller, chunk);
246
- });
247
- }
248
- return transformStreamDefaultControllerPerformTransform(controller, chunk);
193
+ const { controller } = stream[kState];
194
+ if (stream[kState].backpressure) {
195
+ const backpressureChange = stream[kState].backpressureChange.promise;
196
+ return backpressureChange.then(() => {
197
+ const { writable } = stream[kState];
198
+ if (writable[kState].state === "erroring") {
199
+ throw writable[kState].storedError;
200
+ }
201
+ return transformStreamDefaultControllerPerformTransform(controller, chunk);
202
+ });
203
+ }
204
+ return transformStreamDefaultControllerPerformTransform(controller, chunk);
249
205
  }
250
206
  async function transformStreamDefaultSinkAbortAlgorithm(stream, reason) {
251
- const { controller, readable } = stream[kState];
252
- if (controller[kState].finishPromise !== void 0) {
253
- return controller[kState].finishPromise;
254
- }
255
- const { promise, resolve, reject } = Promise.withResolvers();
256
- controller[kState].finishPromise = promise;
257
- const cancelPromise = controller[kState].cancelAlgorithm(reason);
258
- transformStreamDefaultControllerClearAlgorithms(controller);
259
- cancelPromise.then(
260
- () => {
261
- if (readable[kState].state === "errored") {
262
- reject(readable[kState].storedError);
263
- } else {
264
- readableStreamDefaultControllerError(readable[kState].controller, reason);
265
- resolve();
266
- }
267
- },
268
- (error) => {
269
- readableStreamDefaultControllerError(readable[kState].controller, error);
270
- reject(error);
271
- }
272
- );
273
- return controller[kState].finishPromise;
207
+ const { controller, readable } = stream[kState];
208
+ if (controller[kState].finishPromise !== undefined) {
209
+ return controller[kState].finishPromise;
210
+ }
211
+ const { promise, resolve, reject } = Promise.withResolvers();
212
+ controller[kState].finishPromise = promise;
213
+ const cancelPromise = controller[kState].cancelAlgorithm(reason);
214
+ transformStreamDefaultControllerClearAlgorithms(controller);
215
+ cancelPromise.then(() => {
216
+ if (readable[kState].state === "errored") {
217
+ reject(readable[kState].storedError);
218
+ } else {
219
+ readableStreamDefaultControllerError(readable[kState].controller, reason);
220
+ resolve();
221
+ }
222
+ }, (error) => {
223
+ readableStreamDefaultControllerError(readable[kState].controller, error);
224
+ reject(error);
225
+ });
226
+ return controller[kState].finishPromise;
274
227
  }
275
228
  function transformStreamDefaultSinkCloseAlgorithm(stream) {
276
- const { readable, controller } = stream[kState];
277
- if (controller[kState].finishPromise !== void 0) {
278
- return controller[kState].finishPromise;
279
- }
280
- const { promise, resolve, reject } = Promise.withResolvers();
281
- controller[kState].finishPromise = promise;
282
- const flushPromise = controller[kState].flushAlgorithm(controller);
283
- transformStreamDefaultControllerClearAlgorithms(controller);
284
- flushPromise.then(
285
- () => {
286
- if (readable[kState].state === "errored") {
287
- reject(readable[kState].storedError);
288
- } else {
289
- readableStreamDefaultControllerClose(readable[kState].controller);
290
- resolve();
291
- }
292
- },
293
- (error) => {
294
- readableStreamDefaultControllerError(readable[kState].controller, error);
295
- reject(error);
296
- }
297
- );
298
- return controller[kState].finishPromise;
229
+ const { readable, controller } = stream[kState];
230
+ if (controller[kState].finishPromise !== undefined) {
231
+ return controller[kState].finishPromise;
232
+ }
233
+ const { promise, resolve, reject } = Promise.withResolvers();
234
+ controller[kState].finishPromise = promise;
235
+ const flushPromise = controller[kState].flushAlgorithm(controller);
236
+ transformStreamDefaultControllerClearAlgorithms(controller);
237
+ flushPromise.then(() => {
238
+ if (readable[kState].state === "errored") {
239
+ reject(readable[kState].storedError);
240
+ } else {
241
+ readableStreamDefaultControllerClose(readable[kState].controller);
242
+ resolve();
243
+ }
244
+ }, (error) => {
245
+ readableStreamDefaultControllerError(readable[kState].controller, error);
246
+ reject(error);
247
+ });
248
+ return controller[kState].finishPromise;
299
249
  }
300
250
  function transformStreamDefaultSourcePullAlgorithm(stream) {
301
- transformStreamSetBackpressure(stream, false);
302
- return stream[kState].backpressureChange.promise;
251
+ transformStreamSetBackpressure(stream, false);
252
+ return stream[kState].backpressureChange.promise;
303
253
  }
304
254
  function transformStreamDefaultSourceCancelAlgorithm(stream, reason) {
305
- const { controller, writable } = stream[kState];
306
- if (controller[kState].finishPromise !== void 0) {
307
- return controller[kState].finishPromise;
308
- }
309
- const { promise, resolve, reject } = Promise.withResolvers();
310
- controller[kState].finishPromise = promise;
311
- const cancelPromise = controller[kState].cancelAlgorithm(reason);
312
- transformStreamDefaultControllerClearAlgorithms(controller);
313
- cancelPromise.then(
314
- () => {
315
- if (writable[kState].state === "errored") {
316
- reject(writable[kState].storedError);
317
- } else {
318
- writableStreamDefaultControllerErrorIfNeeded(writable[kState].controller, reason);
319
- transformStreamUnblockWrite(stream);
320
- resolve();
321
- }
322
- },
323
- (error) => {
324
- writableStreamDefaultControllerErrorIfNeeded(writable[kState].controller, error);
325
- transformStreamUnblockWrite(stream);
326
- reject(error);
327
- }
328
- );
329
- return controller[kState].finishPromise;
255
+ const { controller, writable } = stream[kState];
256
+ if (controller[kState].finishPromise !== undefined) {
257
+ return controller[kState].finishPromise;
258
+ }
259
+ const { promise, resolve, reject } = Promise.withResolvers();
260
+ controller[kState].finishPromise = promise;
261
+ const cancelPromise = controller[kState].cancelAlgorithm(reason);
262
+ transformStreamDefaultControllerClearAlgorithms(controller);
263
+ cancelPromise.then(() => {
264
+ if (writable[kState].state === "errored") {
265
+ reject(writable[kState].storedError);
266
+ } else {
267
+ writableStreamDefaultControllerErrorIfNeeded(writable[kState].controller, reason);
268
+ transformStreamUnblockWrite(stream);
269
+ resolve();
270
+ }
271
+ }, (error) => {
272
+ writableStreamDefaultControllerErrorIfNeeded(writable[kState].controller, error);
273
+ transformStreamUnblockWrite(stream);
274
+ reject(error);
275
+ });
276
+ return controller[kState].finishPromise;
330
277
  }
331
- export {
332
- TransformStream,
333
- TransformStreamDefaultController,
334
- isTransformStream,
335
- isTransformStreamDefaultController
336
- };
278
+
279
+ //#endregion
280
+ export { TransformStream, TransformStreamDefaultController, isTransformStream, isTransformStreamDefaultController };