1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 | (function(e, a) { for(var i in a) e[i] = a[i]; }(exports, (function(modules) {
|
11 |
|
12 | var installedModules = {};
|
13 |
|
14 |
|
15 | function __webpack_require__(moduleId) {
|
16 |
|
17 |
|
18 | if(installedModules[moduleId])
|
19 | return installedModules[moduleId].exports;
|
20 |
|
21 |
|
22 | var module = installedModules[moduleId] = {
|
23 | i: moduleId,
|
24 | l: false,
|
25 | exports: {}
|
26 | };
|
27 |
|
28 |
|
29 | modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
30 |
|
31 |
|
32 | module.l = true;
|
33 |
|
34 |
|
35 | return module.exports;
|
36 | }
|
37 |
|
38 |
|
39 |
|
40 | __webpack_require__.m = modules;
|
41 |
|
42 |
|
43 | __webpack_require__.c = installedModules;
|
44 |
|
45 |
|
46 | __webpack_require__.i = function(value) { return value; };
|
47 |
|
48 |
|
49 | __webpack_require__.d = function(exports, name, getter) {
|
50 | if(!__webpack_require__.o(exports, name)) {
|
51 | Object.defineProperty(exports, name, {
|
52 | configurable: false,
|
53 | enumerable: true,
|
54 | get: getter
|
55 | /******/ });
|
56 | /******/ }
|
57 | /******/ };
|
58 | /******/
|
59 | /******/ // getDefaultExport function for compatibility with non-harmony modules
|
60 | /******/ __webpack_require__.n = function(module) {
|
61 | var getter = module && module.__esModule ?
|
62 | function getDefault() { return module['default']; } :
|
63 | function getModuleExports() { return module; };
|
64 | __webpack_require__.d(getter, 'a', getter);
|
65 | return getter;
|
66 | };
|
67 |
|
68 |
|
69 | __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
70 |
|
71 |
|
72 | __webpack_require__.p = "";
|
73 |
|
74 |
|
75 | return __webpack_require__(__webpack_require__.s = 7);
|
76 | })
|
77 |
|
78 | ([
|
79 |
|
80 | (function(module, exports, __webpack_require__) {
|
81 |
|
82 | "use strict";
|
83 |
|
84 |
|
85 | var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
86 |
|
87 | var _require = __webpack_require__(1),
|
88 | assert = _require.assert;
|
89 |
|
90 | function IsPropertyKey(argument) {
|
91 | return typeof argument === 'string' || (typeof argument === 'undefined' ? 'undefined' : _typeof(argument)) === 'symbol';
|
92 | }
|
93 |
|
94 | exports.typeIsObject = function (x) {
|
95 | return (typeof x === 'undefined' ? 'undefined' : _typeof(x)) === 'object' && x !== null || typeof x === 'function';
|
96 | };
|
97 |
|
98 | exports.createDataProperty = function (o, p, v) {
|
99 | assert(exports.typeIsObject(o));
|
100 | Object.defineProperty(o, p, { value: v, writable: true, enumerable: true, configurable: true });
|
101 | };
|
102 |
|
103 | exports.createArrayFromList = function (elements) {
|
104 |
|
105 |
|
106 | return elements.slice();
|
107 | };
|
108 |
|
109 | exports.ArrayBufferCopy = function (dest, destOffset, src, srcOffset, n) {
|
110 | new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
|
111 | };
|
112 |
|
113 | exports.CreateIterResultObject = function (value, done) {
|
114 | assert(typeof done === 'boolean');
|
115 | var obj = {};
|
116 | Object.defineProperty(obj, 'value', { value: value, enumerable: true, writable: true, configurable: true });
|
117 | Object.defineProperty(obj, 'done', { value: done, enumerable: true, writable: true, configurable: true });
|
118 | return obj;
|
119 | };
|
120 |
|
121 | exports.IsFiniteNonNegativeNumber = function (v) {
|
122 | if (Number.isNaN(v)) {
|
123 | return false;
|
124 | }
|
125 | if (v === Infinity) {
|
126 | return false;
|
127 | }
|
128 | if (v < 0) {
|
129 | return false;
|
130 | }
|
131 |
|
132 | return true;
|
133 | };
|
134 |
|
135 | function Call(F, V, args) {
|
136 | if (typeof F !== 'function') {
|
137 | throw new TypeError('Argument is not a function');
|
138 | }
|
139 |
|
140 | return Function.prototype.apply.call(F, V, args);
|
141 | }
|
142 |
|
143 | exports.InvokeOrNoop = function (O, P, args) {
|
144 | assert(O !== undefined);
|
145 | assert(IsPropertyKey(P));
|
146 | assert(Array.isArray(args));
|
147 |
|
148 | var method = O[P];
|
149 | if (method === undefined) {
|
150 | return undefined;
|
151 | }
|
152 |
|
153 | return Call(method, O, args);
|
154 | };
|
155 |
|
156 | exports.PromiseInvokeOrNoop = function (O, P, args) {
|
157 | assert(O !== undefined);
|
158 | assert(IsPropertyKey(P));
|
159 | assert(Array.isArray(args));
|
160 | try {
|
161 | return Promise.resolve(exports.InvokeOrNoop(O, P, args));
|
162 | } catch (returnValueE) {
|
163 | return Promise.reject(returnValueE);
|
164 | }
|
165 | };
|
166 |
|
167 | exports.PromiseInvokeOrPerformFallback = function (O, P, args, F, argsF) {
|
168 | assert(O !== undefined);
|
169 | assert(IsPropertyKey(P));
|
170 | assert(Array.isArray(args));
|
171 | assert(Array.isArray(argsF));
|
172 |
|
173 | var method = void 0;
|
174 | try {
|
175 | method = O[P];
|
176 | } catch (methodE) {
|
177 | return Promise.reject(methodE);
|
178 | }
|
179 |
|
180 | if (method === undefined) {
|
181 | return F.apply(null, argsF);
|
182 | }
|
183 |
|
184 | try {
|
185 | return Promise.resolve(Call(method, O, args));
|
186 | } catch (e) {
|
187 | return Promise.reject(e);
|
188 | }
|
189 | };
|
190 |
|
191 |
|
192 | exports.TransferArrayBuffer = function (O) {
|
193 | return O.slice();
|
194 | };
|
195 |
|
196 | exports.ValidateAndNormalizeHighWaterMark = function (highWaterMark) {
|
197 | highWaterMark = Number(highWaterMark);
|
198 | if (Number.isNaN(highWaterMark) || highWaterMark < 0) {
|
199 | throw new RangeError('highWaterMark property of a queuing strategy must be non-negative and non-NaN');
|
200 | }
|
201 |
|
202 | return highWaterMark;
|
203 | };
|
204 |
|
205 | exports.ValidateAndNormalizeQueuingStrategy = function (size, highWaterMark) {
|
206 | if (size !== undefined && typeof size !== 'function') {
|
207 | throw new TypeError('size property of a queuing strategy must be a function');
|
208 | }
|
209 |
|
210 | highWaterMark = exports.ValidateAndNormalizeHighWaterMark(highWaterMark);
|
211 |
|
212 | return { size: size, highWaterMark: highWaterMark };
|
213 | };
|
214 |
|
215 | }),
|
216 |
|
217 | (function(module, exports, __webpack_require__) {
|
218 |
|
219 | "use strict";
|
220 |
|
221 |
|
222 | function rethrowAssertionErrorRejection(e) {
|
223 |
|
224 |
|
225 |
|
226 | if (e && e.constructor === AssertionError) {
|
227 | setTimeout(function () {
|
228 | throw e;
|
229 | }, 0);
|
230 | }
|
231 | };
|
232 |
|
233 | function AssertionError(message) {
|
234 | this.name = 'AssertionError';
|
235 | this.message = message || '';
|
236 | this.stack = new Error().stack;
|
237 | }
|
238 | AssertionError.prototype = Object.create(Error.prototype);
|
239 | AssertionError.prototype.constructor = AssertionError;
|
240 |
|
241 | function assert(value, message) {
|
242 | if (!value) {
|
243 | throw new AssertionError(message);
|
244 | }
|
245 | }
|
246 |
|
247 | module.exports = {
|
248 | rethrowAssertionErrorRejection: rethrowAssertionErrorRejection,
|
249 | AssertionError: AssertionError,
|
250 | assert: assert
|
251 | };
|
252 |
|
253 | }),
|
254 |
|
255 | (function(module, exports, __webpack_require__) {
|
256 |
|
257 | "use strict";
|
258 |
|
259 |
|
260 | var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
261 |
|
262 | function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
263 |
|
264 | var _require = __webpack_require__(0),
|
265 | InvokeOrNoop = _require.InvokeOrNoop,
|
266 | PromiseInvokeOrNoop = _require.PromiseInvokeOrNoop,
|
267 | ValidateAndNormalizeQueuingStrategy = _require.ValidateAndNormalizeQueuingStrategy,
|
268 | typeIsObject = _require.typeIsObject;
|
269 |
|
270 | var _require2 = __webpack_require__(1),
|
271 | assert = _require2.assert,
|
272 | rethrowAssertionErrorRejection = _require2.rethrowAssertionErrorRejection;
|
273 |
|
274 | var _require3 = __webpack_require__(3),
|
275 | DequeueValue = _require3.DequeueValue,
|
276 | EnqueueValueWithSize = _require3.EnqueueValueWithSize,
|
277 | PeekQueueValue = _require3.PeekQueueValue,
|
278 | ResetQueue = _require3.ResetQueue;
|
279 |
|
280 | var WritableStream = function () {
|
281 | function WritableStream() {
|
282 | var underlyingSink = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
283 |
|
284 | var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
|
285 | size = _ref.size,
|
286 | _ref$highWaterMark = _ref.highWaterMark,
|
287 | highWaterMark = _ref$highWaterMark === undefined ? 1 : _ref$highWaterMark;
|
288 |
|
289 | _classCallCheck(this, WritableStream);
|
290 |
|
291 | this._state = 'writable';
|
292 |
|
293 |
|
294 |
|
295 | this._storedError = undefined;
|
296 |
|
297 | this._writer = undefined;
|
298 |
|
299 |
|
300 |
|
301 | this._writableStreamController = undefined;
|
302 |
|
303 |
|
304 |
|
305 | this._writeRequests = [];
|
306 |
|
307 |
|
308 |
|
309 | this._inFlightWriteRequest = undefined;
|
310 |
|
311 |
|
312 |
|
313 | this._closeRequest = undefined;
|
314 |
|
315 |
|
316 |
|
317 | this._inFlightCloseRequest = undefined;
|
318 |
|
319 |
|
320 | this._pendingAbortRequest = undefined;
|
321 |
|
322 |
|
323 | this._backpressure = false;
|
324 |
|
325 | var type = underlyingSink.type;
|
326 |
|
327 | if (type !== undefined) {
|
328 | throw new RangeError('Invalid type is specified');
|
329 | }
|
330 |
|
331 | this._writableStreamController = new WritableStreamDefaultController(this, underlyingSink, size, highWaterMark);
|
332 | this._writableStreamController.__startSteps();
|
333 | }
|
334 |
|
335 | _createClass(WritableStream, [{
|
336 | key: 'abort',
|
337 | value: function abort(reason) {
|
338 | if (IsWritableStream(this) === false) {
|
339 | return Promise.reject(streamBrandCheckException('abort'));
|
340 | }
|
341 |
|
342 | if (IsWritableStreamLocked(this) === true) {
|
343 | return Promise.reject(new TypeError('Cannot abort a stream that already has a writer'));
|
344 | }
|
345 |
|
346 | return WritableStreamAbort(this, reason);
|
347 | }
|
348 | }, {
|
349 | key: 'getWriter',
|
350 | value: function getWriter() {
|
351 | if (IsWritableStream(this) === false) {
|
352 | throw streamBrandCheckException('getWriter');
|
353 | }
|
354 |
|
355 | return AcquireWritableStreamDefaultWriter(this);
|
356 | }
|
357 | }, {
|
358 | key: 'locked',
|
359 | get: function get() {
|
360 | if (IsWritableStream(this) === false) {
|
361 | throw streamBrandCheckException('locked');
|
362 | }
|
363 |
|
364 | return IsWritableStreamLocked(this);
|
365 | }
|
366 | }]);
|
367 |
|
368 | return WritableStream;
|
369 | }();
|
370 |
|
371 | module.exports = {
|
372 | AcquireWritableStreamDefaultWriter: AcquireWritableStreamDefaultWriter,
|
373 | IsWritableStream: IsWritableStream,
|
374 | IsWritableStreamLocked: IsWritableStreamLocked,
|
375 | WritableStream: WritableStream,
|
376 | WritableStreamAbort: WritableStreamAbort,
|
377 | WritableStreamDefaultControllerError: WritableStreamDefaultControllerError,
|
378 | WritableStreamDefaultWriterCloseWithErrorPropagation: WritableStreamDefaultWriterCloseWithErrorPropagation,
|
379 | WritableStreamDefaultWriterRelease: WritableStreamDefaultWriterRelease,
|
380 | WritableStreamDefaultWriterWrite: WritableStreamDefaultWriterWrite,
|
381 | WritableStreamCloseQueuedOrInFlight: WritableStreamCloseQueuedOrInFlight
|
382 | };
|
383 |
|
384 |
|
385 |
|
386 | function AcquireWritableStreamDefaultWriter(stream) {
|
387 | return new WritableStreamDefaultWriter(stream);
|
388 | }
|
389 |
|
390 | function IsWritableStream(x) {
|
391 | if (!typeIsObject(x)) {
|
392 | return false;
|
393 | }
|
394 |
|
395 | if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) {
|
396 | return false;
|
397 | }
|
398 |
|
399 | return true;
|
400 | }
|
401 |
|
402 | function IsWritableStreamLocked(stream) {
|
403 | assert(IsWritableStream(stream) === true, 'IsWritableStreamLocked should only be used on known writable streams');
|
404 |
|
405 | if (stream._writer === undefined) {
|
406 | return false;
|
407 | }
|
408 |
|
409 | return true;
|
410 | }
|
411 |
|
412 | function WritableStreamAbort(stream, reason) {
|
413 | var state = stream._state;
|
414 | if (state === 'closed') {
|
415 | return Promise.resolve(undefined);
|
416 | }
|
417 | if (state === 'errored') {
|
418 | return Promise.reject(stream._storedError);
|
419 | }
|
420 | var error = new TypeError('Requested to abort');
|
421 | if (stream._pendingAbortRequest !== undefined) {
|
422 | return Promise.reject(error);
|
423 | }
|
424 |
|
425 | assert(state === 'writable' || state === 'erroring', 'state must be writable or erroring');
|
426 |
|
427 | var wasAlreadyErroring = false;
|
428 | if (state === 'erroring') {
|
429 | wasAlreadyErroring = true;
|
430 |
|
431 | reason = undefined;
|
432 | }
|
433 |
|
434 | var promise = new Promise(function (resolve, reject) {
|
435 | stream._pendingAbortRequest = {
|
436 | _resolve: resolve,
|
437 | _reject: reject,
|
438 | _reason: reason,
|
439 | _wasAlreadyErroring: wasAlreadyErroring
|
440 | };
|
441 | });
|
442 |
|
443 | if (wasAlreadyErroring === false) {
|
444 | WritableStreamStartErroring(stream, error);
|
445 | }
|
446 |
|
447 | return promise;
|
448 | }
|
449 |
|
450 |
|
451 |
|
452 | function WritableStreamAddWriteRequest(stream) {
|
453 | assert(IsWritableStreamLocked(stream) === true);
|
454 | assert(stream._state === 'writable');
|
455 |
|
456 | var promise = new Promise(function (resolve, reject) {
|
457 | var writeRequest = {
|
458 | _resolve: resolve,
|
459 | _reject: reject
|
460 | };
|
461 |
|
462 | stream._writeRequests.push(writeRequest);
|
463 | });
|
464 |
|
465 | return promise;
|
466 | }
|
467 |
|
468 | function WritableStreamDealWithRejection(stream, error) {
|
469 | var state = stream._state;
|
470 |
|
471 | if (state === 'writable') {
|
472 | WritableStreamStartErroring(stream, error);
|
473 | return;
|
474 | }
|
475 |
|
476 | assert(state === 'erroring');
|
477 | WritableStreamFinishErroring(stream);
|
478 | }
|
479 |
|
480 | function WritableStreamStartErroring(stream, reason) {
|
481 | assert(stream._storedError === undefined, 'stream._storedError === undefined');
|
482 | assert(stream._state === 'writable', 'state must be writable');
|
483 |
|
484 | var controller = stream._writableStreamController;
|
485 | assert(controller !== undefined, 'controller must not be undefined');
|
486 |
|
487 | stream._state = 'erroring';
|
488 | stream._storedError = reason;
|
489 | var writer = stream._writer;
|
490 | if (writer !== undefined) {
|
491 | WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);
|
492 | }
|
493 |
|
494 | if (WritableStreamHasOperationMarkedInFlight(stream) === false && controller._started === true) {
|
495 | WritableStreamFinishErroring(stream);
|
496 | }
|
497 | }
|
498 |
|
499 | function WritableStreamFinishErroring(stream) {
|
500 | assert(stream._state === 'erroring', 'stream._state === erroring');
|
501 | assert(WritableStreamHasOperationMarkedInFlight(stream) === false, 'WritableStreamHasOperationMarkedInFlight(stream) === false');
|
502 | stream._state = 'errored';
|
503 | stream._writableStreamController.__errorSteps();
|
504 |
|
505 | var storedError = stream._storedError;
|
506 | for (var i = 0; i < stream._writeRequests.length; i++) {
|
507 | var writeRequest = stream._writeRequests[i];
|
508 | writeRequest._reject(storedError);
|
509 | }
|
510 | stream._writeRequests = [];
|
511 |
|
512 | if (stream._pendingAbortRequest === undefined) {
|
513 | WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
|
514 | return;
|
515 | }
|
516 |
|
517 | var abortRequest = stream._pendingAbortRequest;
|
518 | stream._pendingAbortRequest = undefined;
|
519 |
|
520 | if (abortRequest._wasAlreadyErroring === true) {
|
521 | abortRequest._reject(storedError);
|
522 | WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
|
523 | return;
|
524 | }
|
525 |
|
526 | var promise = stream._writableStreamController.__abortSteps(abortRequest._reason);
|
527 | promise.then(function () {
|
528 | abortRequest._resolve();
|
529 | WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
|
530 | }, function (reason) {
|
531 | abortRequest._reject(reason);
|
532 | WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
|
533 | });
|
534 | }
|
535 |
|
536 | function WritableStreamFinishInFlightWrite(stream) {
|
537 | assert(stream._inFlightWriteRequest !== undefined);
|
538 | stream._inFlightWriteRequest._resolve(undefined);
|
539 | stream._inFlightWriteRequest = undefined;
|
540 | }
|
541 |
|
542 | function WritableStreamFinishInFlightWriteWithError(stream, error) {
|
543 | assert(stream._inFlightWriteRequest !== undefined);
|
544 | stream._inFlightWriteRequest._reject(error);
|
545 | stream._inFlightWriteRequest = undefined;
|
546 |
|
547 | assert(stream._state === 'writable' || stream._state === 'erroring');
|
548 |
|
549 | WritableStreamDealWithRejection(stream, error);
|
550 | }
|
551 |
|
552 | function WritableStreamFinishInFlightClose(stream) {
|
553 | assert(stream._inFlightCloseRequest !== undefined);
|
554 | stream._inFlightCloseRequest._resolve(undefined);
|
555 | stream._inFlightCloseRequest = undefined;
|
556 |
|
557 | var state = stream._state;
|
558 |
|
559 | assert(state === 'writable' || state === 'erroring');
|
560 |
|
561 | if (state === 'erroring') {
|
562 |
|
563 | stream._storedError = undefined;
|
564 | if (stream._pendingAbortRequest !== undefined) {
|
565 | stream._pendingAbortRequest._resolve();
|
566 | stream._pendingAbortRequest = undefined;
|
567 | }
|
568 | }
|
569 |
|
570 | stream._state = 'closed';
|
571 |
|
572 | var writer = stream._writer;
|
573 | if (writer !== undefined) {
|
574 | defaultWriterClosedPromiseResolve(writer);
|
575 | }
|
576 |
|
577 | assert(stream._pendingAbortRequest === undefined, 'stream._pendingAbortRequest === undefined');
|
578 | assert(stream._storedError === undefined, 'stream._storedError === undefined');
|
579 | }
|
580 |
|
581 | function WritableStreamFinishInFlightCloseWithError(stream, error) {
|
582 | assert(stream._inFlightCloseRequest !== undefined);
|
583 | stream._inFlightCloseRequest._reject(error);
|
584 | stream._inFlightCloseRequest = undefined;
|
585 |
|
586 | assert(stream._state === 'writable' || stream._state === 'erroring');
|
587 |
|
588 |
|
589 | if (stream._pendingAbortRequest !== undefined) {
|
590 | stream._pendingAbortRequest._reject(error);
|
591 | stream._pendingAbortRequest = undefined;
|
592 | }
|
593 | WritableStreamDealWithRejection(stream, error);
|
594 | }
|
595 |
|
596 |
|
597 | function WritableStreamCloseQueuedOrInFlight(stream) {
|
598 | if (stream._closeRequest === undefined && stream._inFlightCloseRequest === undefined) {
|
599 | return false;
|
600 | }
|
601 |
|
602 | return true;
|
603 | }
|
604 |
|
605 | function WritableStreamHasOperationMarkedInFlight(stream) {
|
606 | if (stream._inFlightWriteRequest === undefined && stream._inFlightCloseRequest === undefined) {
|
607 | return false;
|
608 | }
|
609 |
|
610 | return true;
|
611 | }
|
612 |
|
613 | function WritableStreamMarkCloseRequestInFlight(stream) {
|
614 | assert(stream._inFlightCloseRequest === undefined);
|
615 | assert(stream._closeRequest !== undefined);
|
616 | stream._inFlightCloseRequest = stream._closeRequest;
|
617 | stream._closeRequest = undefined;
|
618 | }
|
619 |
|
620 | function WritableStreamMarkFirstWriteRequestInFlight(stream) {
|
621 | assert(stream._inFlightWriteRequest === undefined, 'there must be no pending write request');
|
622 | assert(stream._writeRequests.length !== 0, 'writeRequests must not be empty');
|
623 | stream._inFlightWriteRequest = stream._writeRequests.shift();
|
624 | }
|
625 |
|
626 | function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
|
627 | assert(stream._state === 'errored', '_stream_.[[state]] is `"errored"`');
|
628 | if (stream._closeRequest !== undefined) {
|
629 | assert(stream._inFlightCloseRequest === undefined);
|
630 |
|
631 | stream._closeRequest._reject(stream._storedError);
|
632 | stream._closeRequest = undefined;
|
633 | }
|
634 | var writer = stream._writer;
|
635 | if (writer !== undefined) {
|
636 | defaultWriterClosedPromiseReject(writer, stream._storedError);
|
637 | writer._closedPromise.catch(function () {});
|
638 | }
|
639 | }
|
640 |
|
641 | function WritableStreamUpdateBackpressure(stream, backpressure) {
|
642 | assert(stream._state === 'writable');
|
643 | assert(WritableStreamCloseQueuedOrInFlight(stream) === false);
|
644 |
|
645 | var writer = stream._writer;
|
646 | if (writer !== undefined && backpressure !== stream._backpressure) {
|
647 | if (backpressure === true) {
|
648 | defaultWriterReadyPromiseReset(writer);
|
649 | } else {
|
650 | assert(backpressure === false);
|
651 |
|
652 | defaultWriterReadyPromiseResolve(writer);
|
653 | }
|
654 | }
|
655 |
|
656 | stream._backpressure = backpressure;
|
657 | }
|
658 |
|
659 | var WritableStreamDefaultWriter = function () {
|
660 | function WritableStreamDefaultWriter(stream) {
|
661 | _classCallCheck(this, WritableStreamDefaultWriter);
|
662 |
|
663 | if (IsWritableStream(stream) === false) {
|
664 | throw new TypeError('WritableStreamDefaultWriter can only be constructed with a WritableStream instance');
|
665 | }
|
666 | if (IsWritableStreamLocked(stream) === true) {
|
667 | throw new TypeError('This stream has already been locked for exclusive writing by another writer');
|
668 | }
|
669 |
|
670 | this._ownerWritableStream = stream;
|
671 | stream._writer = this;
|
672 |
|
673 | var state = stream._state;
|
674 |
|
675 | if (state === 'writable') {
|
676 | if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._backpressure === true) {
|
677 | defaultWriterReadyPromiseInitialize(this);
|
678 | } else {
|
679 | defaultWriterReadyPromiseInitializeAsResolved(this);
|
680 | }
|
681 |
|
682 | defaultWriterClosedPromiseInitialize(this);
|
683 | } else if (state === 'erroring') {
|
684 | defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError);
|
685 | this._readyPromise.catch(function () {});
|
686 | defaultWriterClosedPromiseInitialize(this);
|
687 | } else if (state === 'closed') {
|
688 | defaultWriterReadyPromiseInitializeAsResolved(this);
|
689 | defaultWriterClosedPromiseInitializeAsResolved(this);
|
690 | } else {
|
691 | assert(state === 'errored', 'state must be errored');
|
692 |
|
693 | var storedError = stream._storedError;
|
694 | defaultWriterReadyPromiseInitializeAsRejected(this, storedError);
|
695 | this._readyPromise.catch(function () {});
|
696 | defaultWriterClosedPromiseInitializeAsRejected(this, storedError);
|
697 | this._closedPromise.catch(function () {});
|
698 | }
|
699 | }
|
700 |
|
701 | _createClass(WritableStreamDefaultWriter, [{
|
702 | key: 'abort',
|
703 | value: function abort(reason) {
|
704 | if (IsWritableStreamDefaultWriter(this) === false) {
|
705 | return Promise.reject(defaultWriterBrandCheckException('abort'));
|
706 | }
|
707 |
|
708 | if (this._ownerWritableStream === undefined) {
|
709 | return Promise.reject(defaultWriterLockException('abort'));
|
710 | }
|
711 |
|
712 | return WritableStreamDefaultWriterAbort(this, reason);
|
713 | }
|
714 | }, {
|
715 | key: 'close',
|
716 | value: function close() {
|
717 | if (IsWritableStreamDefaultWriter(this) === false) {
|
718 | return Promise.reject(defaultWriterBrandCheckException('close'));
|
719 | }
|
720 |
|
721 | var stream = this._ownerWritableStream;
|
722 |
|
723 | if (stream === undefined) {
|
724 | return Promise.reject(defaultWriterLockException('close'));
|
725 | }
|
726 |
|
727 | if (WritableStreamCloseQueuedOrInFlight(stream) === true) {
|
728 | return Promise.reject(new TypeError('cannot close an already-closing stream'));
|
729 | }
|
730 |
|
731 | return WritableStreamDefaultWriterClose(this);
|
732 | }
|
733 | }, {
|
734 | key: 'releaseLock',
|
735 | value: function releaseLock() {
|
736 | if (IsWritableStreamDefaultWriter(this) === false) {
|
737 | throw defaultWriterBrandCheckException('releaseLock');
|
738 | }
|
739 |
|
740 | var stream = this._ownerWritableStream;
|
741 |
|
742 | if (stream === undefined) {
|
743 | return;
|
744 | }
|
745 |
|
746 | assert(stream._writer !== undefined);
|
747 |
|
748 | WritableStreamDefaultWriterRelease(this);
|
749 | }
|
750 | }, {
|
751 | key: 'write',
|
752 | value: function write(chunk) {
|
753 | if (IsWritableStreamDefaultWriter(this) === false) {
|
754 | return Promise.reject(defaultWriterBrandCheckException('write'));
|
755 | }
|
756 |
|
757 | if (this._ownerWritableStream === undefined) {
|
758 | return Promise.reject(defaultWriterLockException('write to'));
|
759 | }
|
760 |
|
761 | return WritableStreamDefaultWriterWrite(this, chunk);
|
762 | }
|
763 | }, {
|
764 | key: 'closed',
|
765 | get: function get() {
|
766 | if (IsWritableStreamDefaultWriter(this) === false) {
|
767 | return Promise.reject(defaultWriterBrandCheckException('closed'));
|
768 | }
|
769 |
|
770 | return this._closedPromise;
|
771 | }
|
772 | }, {
|
773 | key: 'desiredSize',
|
774 | get: function get() {
|
775 | if (IsWritableStreamDefaultWriter(this) === false) {
|
776 | throw defaultWriterBrandCheckException('desiredSize');
|
777 | }
|
778 |
|
779 | if (this._ownerWritableStream === undefined) {
|
780 | throw defaultWriterLockException('desiredSize');
|
781 | }
|
782 |
|
783 | return WritableStreamDefaultWriterGetDesiredSize(this);
|
784 | }
|
785 | }, {
|
786 | key: 'ready',
|
787 | get: function get() {
|
788 | if (IsWritableStreamDefaultWriter(this) === false) {
|
789 | return Promise.reject(defaultWriterBrandCheckException('ready'));
|
790 | }
|
791 |
|
792 | return this._readyPromise;
|
793 | }
|
794 | }]);
|
795 |
|
796 | return WritableStreamDefaultWriter;
|
797 | }();
|
798 |
|
799 |
|
800 |
|
801 | function IsWritableStreamDefaultWriter(x) {
|
802 | if (!typeIsObject(x)) {
|
803 | return false;
|
804 | }
|
805 |
|
806 | if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) {
|
807 | return false;
|
808 | }
|
809 |
|
810 | return true;
|
811 | }
|
812 |
|
813 |
|
814 |
|
815 | function WritableStreamDefaultWriterAbort(writer, reason) {
|
816 | var stream = writer._ownerWritableStream;
|
817 |
|
818 | assert(stream !== undefined);
|
819 |
|
820 | return WritableStreamAbort(stream, reason);
|
821 | }
|
822 |
|
823 | function WritableStreamDefaultWriterClose(writer) {
|
824 | var stream = writer._ownerWritableStream;
|
825 |
|
826 | assert(stream !== undefined);
|
827 |
|
828 | var state = stream._state;
|
829 | if (state === 'closed' || state === 'errored') {
|
830 | return Promise.reject(new TypeError('The stream (in ' + state + ' state) is not in the writable state and cannot be closed'));
|
831 | }
|
832 |
|
833 | assert(state === 'writable' || state === 'erroring');
|
834 | assert(WritableStreamCloseQueuedOrInFlight(stream) === false);
|
835 |
|
836 | var promise = new Promise(function (resolve, reject) {
|
837 | var closeRequest = {
|
838 | _resolve: resolve,
|
839 | _reject: reject
|
840 | };
|
841 |
|
842 | stream._closeRequest = closeRequest;
|
843 | });
|
844 |
|
845 | if (stream._backpressure === true && state === 'writable') {
|
846 | defaultWriterReadyPromiseResolve(writer);
|
847 | }
|
848 |
|
849 | WritableStreamDefaultControllerClose(stream._writableStreamController);
|
850 |
|
851 | return promise;
|
852 | }
|
853 |
|
854 | function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {
|
855 | var stream = writer._ownerWritableStream;
|
856 |
|
857 | assert(stream !== undefined);
|
858 |
|
859 | var state = stream._state;
|
860 | if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {
|
861 | return Promise.resolve();
|
862 | }
|
863 |
|
864 | if (state === 'errored') {
|
865 | return Promise.reject(stream._storedError);
|
866 | }
|
867 |
|
868 | assert(state === 'writable' || state === 'erroring');
|
869 |
|
870 | return WritableStreamDefaultWriterClose(writer);
|
871 | }
|
872 |
|
873 | function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {
|
874 | if (writer._closedPromiseState === 'pending') {
|
875 | defaultWriterClosedPromiseReject(writer, error);
|
876 | } else {
|
877 | defaultWriterClosedPromiseResetToRejected(writer, error);
|
878 | }
|
879 | writer._closedPromise.catch(function () {});
|
880 | }
|
881 |
|
882 | function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {
|
883 | if (writer._readyPromiseState === 'pending') {
|
884 | defaultWriterReadyPromiseReject(writer, error);
|
885 | } else {
|
886 | defaultWriterReadyPromiseResetToRejected(writer, error);
|
887 | }
|
888 | writer._readyPromise.catch(function () {});
|
889 | }
|
890 |
|
891 | function WritableStreamDefaultWriterGetDesiredSize(writer) {
|
892 | var stream = writer._ownerWritableStream;
|
893 | var state = stream._state;
|
894 |
|
895 | if (state === 'errored' || state === 'erroring') {
|
896 | return null;
|
897 | }
|
898 |
|
899 | if (state === 'closed') {
|
900 | return 0;
|
901 | }
|
902 |
|
903 | return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);
|
904 | }
|
905 |
|
906 | function WritableStreamDefaultWriterRelease(writer) {
|
907 | var stream = writer._ownerWritableStream;
|
908 | assert(stream !== undefined);
|
909 | assert(stream._writer === writer);
|
910 |
|
911 | var releasedError = new TypeError('Writer was released and can no longer be used to monitor the stream\'s closedness');
|
912 |
|
913 | WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);
|
914 |
|
915 |
|
916 |
|
917 | WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);
|
918 |
|
919 | stream._writer = undefined;
|
920 | writer._ownerWritableStream = undefined;
|
921 | }
|
922 |
|
923 | function WritableStreamDefaultWriterWrite(writer, chunk) {
|
924 | var stream = writer._ownerWritableStream;
|
925 |
|
926 | assert(stream !== undefined);
|
927 |
|
928 | var controller = stream._writableStreamController;
|
929 |
|
930 | var chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);
|
931 |
|
932 | if (stream !== writer._ownerWritableStream) {
|
933 | return Promise.reject(defaultWriterLockException('write to'));
|
934 | }
|
935 |
|
936 | var state = stream._state;
|
937 | if (state === 'errored') {
|
938 | return Promise.reject(stream._storedError);
|
939 | }
|
940 | if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {
|
941 | return Promise.reject(new TypeError('The stream is closing or closed and cannot be written to'));
|
942 | }
|
943 | if (state === 'erroring') {
|
944 | return Promise.reject(stream._storedError);
|
945 | }
|
946 |
|
947 | assert(state === 'writable');
|
948 |
|
949 | var promise = WritableStreamAddWriteRequest(stream);
|
950 |
|
951 | WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);
|
952 |
|
953 | return promise;
|
954 | }
|
955 |
|
956 | var WritableStreamDefaultController = function () {
|
957 | function WritableStreamDefaultController(stream, underlyingSink, size, highWaterMark) {
|
958 | _classCallCheck(this, WritableStreamDefaultController);
|
959 |
|
960 | if (IsWritableStream(stream) === false) {
|
961 | throw new TypeError('WritableStreamDefaultController can only be constructed with a WritableStream instance');
|
962 | }
|
963 |
|
964 | if (stream._writableStreamController !== undefined) {
|
965 | throw new TypeError('WritableStreamDefaultController instances can only be created by the WritableStream constructor');
|
966 | }
|
967 |
|
968 | this._controlledWritableStream = stream;
|
969 |
|
970 | this._underlyingSink = underlyingSink;
|
971 |
|
972 |
|
973 | this._queue = undefined;
|
974 | this._queueTotalSize = undefined;
|
975 | ResetQueue(this);
|
976 |
|
977 | this._started = false;
|
978 |
|
979 | var normalizedStrategy = ValidateAndNormalizeQueuingStrategy(size, highWaterMark);
|
980 | this._strategySize = normalizedStrategy.size;
|
981 | this._strategyHWM = normalizedStrategy.highWaterMark;
|
982 |
|
983 | var backpressure = WritableStreamDefaultControllerGetBackpressure(this);
|
984 | WritableStreamUpdateBackpressure(stream, backpressure);
|
985 | }
|
986 |
|
987 | _createClass(WritableStreamDefaultController, [{
|
988 | key: 'error',
|
989 | value: function error(e) {
|
990 | if (IsWritableStreamDefaultController(this) === false) {
|
991 | throw new TypeError('WritableStreamDefaultController.prototype.error can only be used on a WritableStreamDefaultController');
|
992 | }
|
993 | var state = this._controlledWritableStream._state;
|
994 | if (state !== 'writable') {
|
995 |
|
996 |
|
997 | return;
|
998 | }
|
999 |
|
1000 | WritableStreamDefaultControllerError(this, e);
|
1001 | }
|
1002 | }, {
|
1003 | key: '__abortSteps',
|
1004 | value: function __abortSteps(reason) {
|
1005 | return PromiseInvokeOrNoop(this._underlyingSink, 'abort', [reason]);
|
1006 | }
|
1007 | }, {
|
1008 | key: '__errorSteps',
|
1009 | value: function __errorSteps() {
|
1010 | ResetQueue(this);
|
1011 | }
|
1012 | }, {
|
1013 | key: '__startSteps',
|
1014 | value: function __startSteps() {
|
1015 | var _this = this;
|
1016 |
|
1017 | var startResult = InvokeOrNoop(this._underlyingSink, 'start', [this]);
|
1018 | var stream = this._controlledWritableStream;
|
1019 |
|
1020 | Promise.resolve(startResult).then(function () {
|
1021 | assert(stream._state === 'writable' || stream._state === 'erroring');
|
1022 | _this._started = true;
|
1023 | WritableStreamDefaultControllerAdvanceQueueIfNeeded(_this);
|
1024 | }, function (r) {
|
1025 | assert(stream._state === 'writable' || stream._state === 'erroring');
|
1026 | _this._started = true;
|
1027 | WritableStreamDealWithRejection(stream, r);
|
1028 | }).catch(rethrowAssertionErrorRejection);
|
1029 | }
|
1030 | }]);
|
1031 |
|
1032 | return WritableStreamDefaultController;
|
1033 | }();
|
1034 |
|
1035 |
|
1036 |
|
1037 | function WritableStreamDefaultControllerClose(controller) {
|
1038 | EnqueueValueWithSize(controller, 'close', 0);
|
1039 | WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
|
1040 | }
|
1041 |
|
1042 | function WritableStreamDefaultControllerGetChunkSize(controller, chunk) {
|
1043 | var strategySize = controller._strategySize;
|
1044 |
|
1045 | if (strategySize === undefined) {
|
1046 | return 1;
|
1047 | }
|
1048 |
|
1049 | try {
|
1050 | return strategySize(chunk);
|
1051 | } catch (chunkSizeE) {
|
1052 | WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
|
1053 | return 1;
|
1054 | }
|
1055 | }
|
1056 |
|
1057 | function WritableStreamDefaultControllerGetDesiredSize(controller) {
|
1058 | return controller._strategyHWM - controller._queueTotalSize;
|
1059 | }
|
1060 |
|
1061 | function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) {
|
1062 | var writeRecord = { chunk: chunk };
|
1063 |
|
1064 | try {
|
1065 | EnqueueValueWithSize(controller, writeRecord, chunkSize);
|
1066 | } catch (enqueueE) {
|
1067 | WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
|
1068 | return;
|
1069 | }
|
1070 |
|
1071 | var stream = controller._controlledWritableStream;
|
1072 | if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._state === 'writable') {
|
1073 | var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
|
1074 | WritableStreamUpdateBackpressure(stream, backpressure);
|
1075 | }
|
1076 |
|
1077 | WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
|
1078 | }
|
1079 |
|
1080 |
|
1081 |
|
1082 | function IsWritableStreamDefaultController(x) {
|
1083 | if (!typeIsObject(x)) {
|
1084 | return false;
|
1085 | }
|
1086 |
|
1087 | if (!Object.prototype.hasOwnProperty.call(x, '_underlyingSink')) {
|
1088 | return false;
|
1089 | }
|
1090 |
|
1091 | return true;
|
1092 | }
|
1093 |
|
1094 | function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
|
1095 | var stream = controller._controlledWritableStream;
|
1096 |
|
1097 | if (controller._started === false) {
|
1098 | return;
|
1099 | }
|
1100 |
|
1101 | if (stream._inFlightWriteRequest !== undefined) {
|
1102 | return;
|
1103 | }
|
1104 |
|
1105 | var state = stream._state;
|
1106 | if (state === 'closed' || state === 'errored') {
|
1107 | return;
|
1108 | }
|
1109 | if (state === 'erroring') {
|
1110 | WritableStreamFinishErroring(stream);
|
1111 | return;
|
1112 | }
|
1113 |
|
1114 | if (controller._queue.length === 0) {
|
1115 | return;
|
1116 | }
|
1117 |
|
1118 | var writeRecord = PeekQueueValue(controller);
|
1119 | if (writeRecord === 'close') {
|
1120 | WritableStreamDefaultControllerProcessClose(controller);
|
1121 | } else {
|
1122 | WritableStreamDefaultControllerProcessWrite(controller, writeRecord.chunk);
|
1123 | }
|
1124 | }
|
1125 |
|
1126 | function WritableStreamDefaultControllerErrorIfNeeded(controller, error) {
|
1127 | if (controller._controlledWritableStream._state === 'writable') {
|
1128 | WritableStreamDefaultControllerError(controller, error);
|
1129 | }
|
1130 | }
|
1131 |
|
1132 | function WritableStreamDefaultControllerProcessClose(controller) {
|
1133 | var stream = controller._controlledWritableStream;
|
1134 |
|
1135 | WritableStreamMarkCloseRequestInFlight(stream);
|
1136 |
|
1137 | DequeueValue(controller);
|
1138 | assert(controller._queue.length === 0, 'queue must be empty once the final write record is dequeued');
|
1139 |
|
1140 | var sinkClosePromise = PromiseInvokeOrNoop(controller._underlyingSink, 'close', []);
|
1141 | sinkClosePromise.then(function () {
|
1142 | WritableStreamFinishInFlightClose(stream);
|
1143 | }, function (reason) {
|
1144 | WritableStreamFinishInFlightCloseWithError(stream, reason);
|
1145 | }).catch(rethrowAssertionErrorRejection);
|
1146 | }
|
1147 |
|
1148 | function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
|
1149 | var stream = controller._controlledWritableStream;
|
1150 |
|
1151 | WritableStreamMarkFirstWriteRequestInFlight(stream);
|
1152 |
|
1153 | var sinkWritePromise = PromiseInvokeOrNoop(controller._underlyingSink, 'write', [chunk, controller]);
|
1154 | sinkWritePromise.then(function () {
|
1155 | WritableStreamFinishInFlightWrite(stream);
|
1156 |
|
1157 | var state = stream._state;
|
1158 | assert(state === 'writable' || state === 'erroring');
|
1159 |
|
1160 | DequeueValue(controller);
|
1161 |
|
1162 | if (WritableStreamCloseQueuedOrInFlight(stream) === false && state === 'writable') {
|
1163 | var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
|
1164 | WritableStreamUpdateBackpressure(stream, backpressure);
|
1165 | }
|
1166 |
|
1167 | WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
|
1168 | }, function (reason) {
|
1169 | WritableStreamFinishInFlightWriteWithError(stream, reason);
|
1170 | }).catch(rethrowAssertionErrorRejection);
|
1171 | }
|
1172 |
|
1173 | function WritableStreamDefaultControllerGetBackpressure(controller) {
|
1174 | var desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);
|
1175 | return desiredSize <= 0;
|
1176 | }
|
1177 |
|
1178 |
|
1179 |
|
1180 | function WritableStreamDefaultControllerError(controller, error) {
|
1181 | var stream = controller._controlledWritableStream;
|
1182 |
|
1183 | assert(stream._state === 'writable');
|
1184 |
|
1185 | WritableStreamStartErroring(stream, error);
|
1186 | }
|
1187 |
|
1188 |
|
1189 |
|
1190 | function streamBrandCheckException(name) {
|
1191 | return new TypeError('WritableStream.prototype.' + name + ' can only be used on a WritableStream');
|
1192 | }
|
1193 |
|
1194 |
|
1195 |
|
1196 | function defaultWriterBrandCheckException(name) {
|
1197 | return new TypeError('WritableStreamDefaultWriter.prototype.' + name + ' can only be used on a WritableStreamDefaultWriter');
|
1198 | }
|
1199 |
|
1200 | function defaultWriterLockException(name) {
|
1201 | return new TypeError('Cannot ' + name + ' a stream using a released writer');
|
1202 | }
|
1203 |
|
1204 | function defaultWriterClosedPromiseInitialize(writer) {
|
1205 | writer._closedPromise = new Promise(function (resolve, reject) {
|
1206 | writer._closedPromise_resolve = resolve;
|
1207 | writer._closedPromise_reject = reject;
|
1208 | writer._closedPromiseState = 'pending';
|
1209 | });
|
1210 | }
|
1211 |
|
1212 | function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) {
|
1213 | writer._closedPromise = Promise.reject(reason);
|
1214 | writer._closedPromise_resolve = undefined;
|
1215 | writer._closedPromise_reject = undefined;
|
1216 | writer._closedPromiseState = 'rejected';
|
1217 | }
|
1218 |
|
1219 | function defaultWriterClosedPromiseInitializeAsResolved(writer) {
|
1220 | writer._closedPromise = Promise.resolve(undefined);
|
1221 | writer._closedPromise_resolve = undefined;
|
1222 | writer._closedPromise_reject = undefined;
|
1223 | writer._closedPromiseState = 'resolved';
|
1224 | }
|
1225 |
|
1226 | function defaultWriterClosedPromiseReject(writer, reason) {
|
1227 | assert(writer._closedPromise_resolve !== undefined, 'writer._closedPromise_resolve !== undefined');
|
1228 | assert(writer._closedPromise_reject !== undefined, 'writer._closedPromise_reject !== undefined');
|
1229 | assert(writer._closedPromiseState === 'pending', 'writer._closedPromiseState is pending');
|
1230 |
|
1231 | writer._closedPromise_reject(reason);
|
1232 | writer._closedPromise_resolve = undefined;
|
1233 | writer._closedPromise_reject = undefined;
|
1234 | writer._closedPromiseState = 'rejected';
|
1235 | }
|
1236 |
|
1237 | function defaultWriterClosedPromiseResetToRejected(writer, reason) {
|
1238 | assert(writer._closedPromise_resolve === undefined, 'writer._closedPromise_resolve === undefined');
|
1239 | assert(writer._closedPromise_reject === undefined, 'writer._closedPromise_reject === undefined');
|
1240 | assert(writer._closedPromiseState !== 'pending', 'writer._closedPromiseState is not pending');
|
1241 |
|
1242 | writer._closedPromise = Promise.reject(reason);
|
1243 | writer._closedPromiseState = 'rejected';
|
1244 | }
|
1245 |
|
1246 | function defaultWriterClosedPromiseResolve(writer) {
|
1247 | assert(writer._closedPromise_resolve !== undefined, 'writer._closedPromise_resolve !== undefined');
|
1248 | assert(writer._closedPromise_reject !== undefined, 'writer._closedPromise_reject !== undefined');
|
1249 | assert(writer._closedPromiseState === 'pending', 'writer._closedPromiseState is pending');
|
1250 |
|
1251 | writer._closedPromise_resolve(undefined);
|
1252 | writer._closedPromise_resolve = undefined;
|
1253 | writer._closedPromise_reject = undefined;
|
1254 | writer._closedPromiseState = 'resolved';
|
1255 | }
|
1256 |
|
1257 | function defaultWriterReadyPromiseInitialize(writer) {
|
1258 | writer._readyPromise = new Promise(function (resolve, reject) {
|
1259 | writer._readyPromise_resolve = resolve;
|
1260 | writer._readyPromise_reject = reject;
|
1261 | });
|
1262 | writer._readyPromiseState = 'pending';
|
1263 | }
|
1264 |
|
1265 | function defaultWriterReadyPromiseInitializeAsRejected(writer, reason) {
|
1266 | writer._readyPromise = Promise.reject(reason);
|
1267 | writer._readyPromise_resolve = undefined;
|
1268 | writer._readyPromise_reject = undefined;
|
1269 | writer._readyPromiseState = 'rejected';
|
1270 | }
|
1271 |
|
1272 | function defaultWriterReadyPromiseInitializeAsResolved(writer) {
|
1273 | writer._readyPromise = Promise.resolve(undefined);
|
1274 | writer._readyPromise_resolve = undefined;
|
1275 | writer._readyPromise_reject = undefined;
|
1276 | writer._readyPromiseState = 'fulfilled';
|
1277 | }
|
1278 |
|
1279 | function defaultWriterReadyPromiseReject(writer, reason) {
|
1280 | assert(writer._readyPromise_resolve !== undefined, 'writer._readyPromise_resolve !== undefined');
|
1281 | assert(writer._readyPromise_reject !== undefined, 'writer._readyPromise_reject !== undefined');
|
1282 |
|
1283 | writer._readyPromise_reject(reason);
|
1284 | writer._readyPromise_resolve = undefined;
|
1285 | writer._readyPromise_reject = undefined;
|
1286 | writer._readyPromiseState = 'rejected';
|
1287 | }
|
1288 |
|
1289 | function defaultWriterReadyPromiseReset(writer) {
|
1290 | assert(writer._readyPromise_resolve === undefined, 'writer._readyPromise_resolve === undefined');
|
1291 | assert(writer._readyPromise_reject === undefined, 'writer._readyPromise_reject === undefined');
|
1292 |
|
1293 | writer._readyPromise = new Promise(function (resolve, reject) {
|
1294 | writer._readyPromise_resolve = resolve;
|
1295 | writer._readyPromise_reject = reject;
|
1296 | });
|
1297 | writer._readyPromiseState = 'pending';
|
1298 | }
|
1299 |
|
1300 | function defaultWriterReadyPromiseResetToRejected(writer, reason) {
|
1301 | assert(writer._readyPromise_resolve === undefined, 'writer._readyPromise_resolve === undefined');
|
1302 | assert(writer._readyPromise_reject === undefined, 'writer._readyPromise_reject === undefined');
|
1303 |
|
1304 | writer._readyPromise = Promise.reject(reason);
|
1305 | writer._readyPromiseState = 'rejected';
|
1306 | }
|
1307 |
|
1308 | function defaultWriterReadyPromiseResolve(writer) {
|
1309 | assert(writer._readyPromise_resolve !== undefined, 'writer._readyPromise_resolve !== undefined');
|
1310 | assert(writer._readyPromise_reject !== undefined, 'writer._readyPromise_reject !== undefined');
|
1311 |
|
1312 | writer._readyPromise_resolve(undefined);
|
1313 | writer._readyPromise_resolve = undefined;
|
1314 | writer._readyPromise_reject = undefined;
|
1315 | writer._readyPromiseState = 'fulfilled';
|
1316 | }
|
1317 |
|
1318 | }),
|
1319 |
|
1320 | (function(module, exports, __webpack_require__) {
|
1321 |
|
1322 | "use strict";
|
1323 |
|
1324 |
|
1325 | var _require = __webpack_require__(0),
|
1326 | IsFiniteNonNegativeNumber = _require.IsFiniteNonNegativeNumber;
|
1327 |
|
1328 | var _require2 = __webpack_require__(1),
|
1329 | assert = _require2.assert;
|
1330 |
|
1331 | exports.DequeueValue = function (container) {
|
1332 | assert('_queue' in container && '_queueTotalSize' in container, 'Spec-level failure: DequeueValue should only be used on containers with [[queue]] and [[queueTotalSize]].');
|
1333 | assert(container._queue.length > 0, 'Spec-level failure: should never dequeue from an empty queue.');
|
1334 |
|
1335 | var pair = container._queue.shift();
|
1336 | container._queueTotalSize -= pair.size;
|
1337 | if (container._queueTotalSize < 0) {
|
1338 | container._queueTotalSize = 0;
|
1339 | }
|
1340 |
|
1341 | return pair.value;
|
1342 | };
|
1343 |
|
1344 | exports.EnqueueValueWithSize = function (container, value, size) {
|
1345 | assert('_queue' in container && '_queueTotalSize' in container, 'Spec-level failure: EnqueueValueWithSize should only be used on containers with [[queue]] and ' + '[[queueTotalSize]].');
|
1346 |
|
1347 | size = Number(size);
|
1348 | if (!IsFiniteNonNegativeNumber(size)) {
|
1349 | throw new RangeError('Size must be a finite, non-NaN, non-negative number.');
|
1350 | }
|
1351 |
|
1352 | container._queue.push({ value: value, size: size });
|
1353 | container._queueTotalSize += size;
|
1354 | };
|
1355 |
|
1356 | exports.PeekQueueValue = function (container) {
|
1357 | assert('_queue' in container && '_queueTotalSize' in container, 'Spec-level failure: PeekQueueValue should only be used on containers with [[queue]] and [[queueTotalSize]].');
|
1358 | assert(container._queue.length > 0, 'Spec-level failure: should never peek at an empty queue.');
|
1359 |
|
1360 | var pair = container._queue[0];
|
1361 | return pair.value;
|
1362 | };
|
1363 |
|
1364 | exports.ResetQueue = function (container) {
|
1365 | assert('_queue' in container && '_queueTotalSize' in container, 'Spec-level failure: ResetQueue should only be used on containers with [[queue]] and [[queueTotalSize]].');
|
1366 |
|
1367 | container._queue = [];
|
1368 | container._queueTotalSize = 0;
|
1369 | };
|
1370 |
|
1371 | }),
|
1372 |
|
1373 | (function(module, exports, __webpack_require__) {
|
1374 |
|
1375 | "use strict";
|
1376 |
|
1377 |
|
1378 | var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
1379 |
|
1380 | function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
1381 |
|
1382 | var _require = __webpack_require__(0),
|
1383 | ArrayBufferCopy = _require.ArrayBufferCopy,
|
1384 | CreateIterResultObject = _require.CreateIterResultObject,
|
1385 | IsFiniteNonNegativeNumber = _require.IsFiniteNonNegativeNumber,
|
1386 | InvokeOrNoop = _require.InvokeOrNoop,
|
1387 | PromiseInvokeOrNoop = _require.PromiseInvokeOrNoop,
|
1388 | TransferArrayBuffer = _require.TransferArrayBuffer,
|
1389 | ValidateAndNormalizeQueuingStrategy = _require.ValidateAndNormalizeQueuingStrategy,
|
1390 | ValidateAndNormalizeHighWaterMark = _require.ValidateAndNormalizeHighWaterMark;
|
1391 |
|
1392 | var _require2 = __webpack_require__(0),
|
1393 | createArrayFromList = _require2.createArrayFromList,
|
1394 | createDataProperty = _require2.createDataProperty,
|
1395 | typeIsObject = _require2.typeIsObject;
|
1396 |
|
1397 | var _require3 = __webpack_require__(1),
|
1398 | assert = _require3.assert,
|
1399 | rethrowAssertionErrorRejection = _require3.rethrowAssertionErrorRejection;
|
1400 |
|
1401 | var _require4 = __webpack_require__(3),
|
1402 | DequeueValue = _require4.DequeueValue,
|
1403 | EnqueueValueWithSize = _require4.EnqueueValueWithSize,
|
1404 | ResetQueue = _require4.ResetQueue;
|
1405 |
|
1406 | var _require5 = __webpack_require__(2),
|
1407 | AcquireWritableStreamDefaultWriter = _require5.AcquireWritableStreamDefaultWriter,
|
1408 | IsWritableStream = _require5.IsWritableStream,
|
1409 | IsWritableStreamLocked = _require5.IsWritableStreamLocked,
|
1410 | WritableStreamAbort = _require5.WritableStreamAbort,
|
1411 | WritableStreamDefaultWriterCloseWithErrorPropagation = _require5.WritableStreamDefaultWriterCloseWithErrorPropagation,
|
1412 | WritableStreamDefaultWriterRelease = _require5.WritableStreamDefaultWriterRelease,
|
1413 | WritableStreamDefaultWriterWrite = _require5.WritableStreamDefaultWriterWrite,
|
1414 | WritableStreamCloseQueuedOrInFlight = _require5.WritableStreamCloseQueuedOrInFlight;
|
1415 |
|
1416 | var ReadableStream = function () {
|
1417 | function ReadableStream() {
|
1418 | var underlyingSource = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
1419 |
|
1420 | var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
|
1421 | size = _ref.size,
|
1422 | highWaterMark = _ref.highWaterMark;
|
1423 |
|
1424 | _classCallCheck(this, ReadableStream);
|
1425 |
|
1426 |
|
1427 | this._state = 'readable';
|
1428 |
|
1429 | this._reader = undefined;
|
1430 | this._storedError = undefined;
|
1431 |
|
1432 | this._disturbed = false;
|
1433 |
|
1434 |
|
1435 |
|
1436 | this._readableStreamController = undefined;
|
1437 | var type = underlyingSource.type;
|
1438 | var typeString = String(type);
|
1439 | if (typeString === 'bytes') {
|
1440 | if (highWaterMark === undefined) {
|
1441 | highWaterMark = 0;
|
1442 | }
|
1443 | this._readableStreamController = new ReadableByteStreamController(this, underlyingSource, highWaterMark);
|
1444 | } else if (type === undefined) {
|
1445 | if (highWaterMark === undefined) {
|
1446 | highWaterMark = 1;
|
1447 | }
|
1448 | this._readableStreamController = new ReadableStreamDefaultController(this, underlyingSource, size, highWaterMark);
|
1449 | } else {
|
1450 | throw new RangeError('Invalid type is specified');
|
1451 | }
|
1452 | }
|
1453 |
|
1454 | _createClass(ReadableStream, [{
|
1455 | key: 'cancel',
|
1456 | value: function cancel(reason) {
|
1457 | if (IsReadableStream(this) === false) {
|
1458 | return Promise.reject(streamBrandCheckException('cancel'));
|
1459 | }
|
1460 |
|
1461 | if (IsReadableStreamLocked(this) === true) {
|
1462 | return Promise.reject(new TypeError('Cannot cancel a stream that already has a reader'));
|
1463 | }
|
1464 |
|
1465 | return ReadableStreamCancel(this, reason);
|
1466 | }
|
1467 | }, {
|
1468 | key: 'getReader',
|
1469 | value: function getReader() {
|
1470 | var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
|
1471 | mode = _ref2.mode;
|
1472 |
|
1473 | if (IsReadableStream(this) === false) {
|
1474 | throw streamBrandCheckException('getReader');
|
1475 | }
|
1476 |
|
1477 | if (mode === undefined) {
|
1478 | return AcquireReadableStreamDefaultReader(this);
|
1479 | }
|
1480 |
|
1481 | mode = String(mode);
|
1482 |
|
1483 | if (mode === 'byob') {
|
1484 | return AcquireReadableStreamBYOBReader(this);
|
1485 | }
|
1486 |
|
1487 | throw new RangeError('Invalid mode is specified');
|
1488 | }
|
1489 | }, {
|
1490 | key: 'pipeThrough',
|
1491 | value: function pipeThrough(_ref3, options) {
|
1492 | var writable = _ref3.writable,
|
1493 | readable = _ref3.readable;
|
1494 |
|
1495 | var promise = this.pipeTo(writable, options);
|
1496 |
|
1497 | ifIsObjectAndHasAPromiseIsHandledInternalSlotSetPromiseIsHandledToTrue(promise);
|
1498 |
|
1499 | return readable;
|
1500 | }
|
1501 | }, {
|
1502 | key: 'pipeTo',
|
1503 | value: function pipeTo(dest) {
|
1504 | var _this = this;
|
1505 |
|
1506 | var _ref4 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
|
1507 | preventClose = _ref4.preventClose,
|
1508 | preventAbort = _ref4.preventAbort,
|
1509 | preventCancel = _ref4.preventCancel;
|
1510 |
|
1511 | if (IsReadableStream(this) === false) {
|
1512 | return Promise.reject(streamBrandCheckException('pipeTo'));
|
1513 | }
|
1514 | if (IsWritableStream(dest) === false) {
|
1515 | return Promise.reject(new TypeError('ReadableStream.prototype.pipeTo\'s first argument must be a WritableStream'));
|
1516 | }
|
1517 |
|
1518 | preventClose = Boolean(preventClose);
|
1519 | preventAbort = Boolean(preventAbort);
|
1520 | preventCancel = Boolean(preventCancel);
|
1521 |
|
1522 | if (IsReadableStreamLocked(this) === true) {
|
1523 | return Promise.reject(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream'));
|
1524 | }
|
1525 | if (IsWritableStreamLocked(dest) === true) {
|
1526 | return Promise.reject(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream'));
|
1527 | }
|
1528 |
|
1529 | var reader = AcquireReadableStreamDefaultReader(this);
|
1530 | var writer = AcquireWritableStreamDefaultWriter(dest);
|
1531 |
|
1532 | var shuttingDown = false;
|
1533 |
|
1534 |
|
1535 | var currentWrite = Promise.resolve();
|
1536 |
|
1537 | return new Promise(function (resolve, reject) {
|
1538 |
|
1539 |
|
1540 |
|
1541 | function pipeLoop() {
|
1542 | currentWrite = Promise.resolve();
|
1543 |
|
1544 | if (shuttingDown === true) {
|
1545 | return Promise.resolve();
|
1546 | }
|
1547 |
|
1548 | return writer._readyPromise.then(function () {
|
1549 | return ReadableStreamDefaultReaderRead(reader).then(function (_ref5) {
|
1550 | var value = _ref5.value,
|
1551 | done = _ref5.done;
|
1552 |
|
1553 | if (done === true) {
|
1554 | return;
|
1555 | }
|
1556 |
|
1557 | currentWrite = WritableStreamDefaultWriterWrite(writer, value).catch(function () {});
|
1558 | });
|
1559 | }).then(pipeLoop);
|
1560 | }
|
1561 |
|
1562 |
|
1563 | isOrBecomesErrored(_this, reader._closedPromise, function (storedError) {
|
1564 | if (preventAbort === false) {
|
1565 | shutdownWithAction(function () {
|
1566 | return WritableStreamAbort(dest, storedError);
|
1567 | }, true, storedError);
|
1568 | } else {
|
1569 | shutdown(true, storedError);
|
1570 | }
|
1571 | });
|
1572 |
|
1573 |
|
1574 | isOrBecomesErrored(dest, writer._closedPromise, function (storedError) {
|
1575 | if (preventCancel === false) {
|
1576 | shutdownWithAction(function () {
|
1577 | return ReadableStreamCancel(_this, storedError);
|
1578 | }, true, storedError);
|
1579 | } else {
|
1580 | shutdown(true, storedError);
|
1581 | }
|
1582 | });
|
1583 |
|
1584 |
|
1585 | isOrBecomesClosed(_this, reader._closedPromise, function () {
|
1586 | if (preventClose === false) {
|
1587 | shutdownWithAction(function () {
|
1588 | return WritableStreamDefaultWriterCloseWithErrorPropagation(writer);
|
1589 | });
|
1590 | } else {
|
1591 | shutdown();
|
1592 | }
|
1593 | });
|
1594 |
|
1595 |
|
1596 | if (WritableStreamCloseQueuedOrInFlight(dest) === true || dest._state === 'closed') {
|
1597 | var destClosed = new TypeError('the destination writable stream closed before all data could be piped to it');
|
1598 |
|
1599 | if (preventCancel === false) {
|
1600 | shutdownWithAction(function () {
|
1601 | return ReadableStreamCancel(_this, destClosed);
|
1602 | }, true, destClosed);
|
1603 | } else {
|
1604 | shutdown(true, destClosed);
|
1605 | }
|
1606 | }
|
1607 |
|
1608 | pipeLoop().catch(function (err) {
|
1609 | currentWrite = Promise.resolve();
|
1610 | rethrowAssertionErrorRejection(err);
|
1611 | });
|
1612 |
|
1613 | function waitForWritesToFinish() {
|
1614 |
|
1615 |
|
1616 | var oldCurrentWrite = currentWrite;
|
1617 | return currentWrite.then(function () {
|
1618 | return oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : undefined;
|
1619 | });
|
1620 | }
|
1621 |
|
1622 | function isOrBecomesErrored(stream, promise, action) {
|
1623 | if (stream._state === 'errored') {
|
1624 | action(stream._storedError);
|
1625 | } else {
|
1626 | promise.catch(action).catch(rethrowAssertionErrorRejection);
|
1627 | }
|
1628 | }
|
1629 |
|
1630 | function isOrBecomesClosed(stream, promise, action) {
|
1631 | if (stream._state === 'closed') {
|
1632 | action();
|
1633 | } else {
|
1634 | promise.then(action).catch(rethrowAssertionErrorRejection);
|
1635 | }
|
1636 | }
|
1637 |
|
1638 | function shutdownWithAction(action, originalIsError, originalError) {
|
1639 | if (shuttingDown === true) {
|
1640 | return;
|
1641 | }
|
1642 | shuttingDown = true;
|
1643 |
|
1644 | if (dest._state === 'writable' && WritableStreamCloseQueuedOrInFlight(dest) === false) {
|
1645 | waitForWritesToFinish().then(doTheRest);
|
1646 | } else {
|
1647 | doTheRest();
|
1648 | }
|
1649 |
|
1650 | function doTheRest() {
|
1651 | action().then(function () {
|
1652 | return finalize(originalIsError, originalError);
|
1653 | }, function (newError) {
|
1654 | return finalize(true, newError);
|
1655 | }).catch(rethrowAssertionErrorRejection);
|
1656 | }
|
1657 | }
|
1658 |
|
1659 | function shutdown(isError, error) {
|
1660 | if (shuttingDown === true) {
|
1661 | return;
|
1662 | }
|
1663 | shuttingDown = true;
|
1664 |
|
1665 | if (dest._state === 'writable' && WritableStreamCloseQueuedOrInFlight(dest) === false) {
|
1666 | waitForWritesToFinish().then(function () {
|
1667 | return finalize(isError, error);
|
1668 | }).catch(rethrowAssertionErrorRejection);
|
1669 | } else {
|
1670 | finalize(isError, error);
|
1671 | }
|
1672 | }
|
1673 |
|
1674 | function finalize(isError, error) {
|
1675 | WritableStreamDefaultWriterRelease(writer);
|
1676 | ReadableStreamReaderGenericRelease(reader);
|
1677 |
|
1678 | if (isError) {
|
1679 | reject(error);
|
1680 | } else {
|
1681 | resolve(undefined);
|
1682 | }
|
1683 | }
|
1684 | });
|
1685 | }
|
1686 | }, {
|
1687 | key: 'tee',
|
1688 | value: function tee() {
|
1689 | if (IsReadableStream(this) === false) {
|
1690 | throw streamBrandCheckException('tee');
|
1691 | }
|
1692 |
|
1693 | var branches = ReadableStreamTee(this, false);
|
1694 | return createArrayFromList(branches);
|
1695 | }
|
1696 | }, {
|
1697 | key: 'locked',
|
1698 | get: function get() {
|
1699 | if (IsReadableStream(this) === false) {
|
1700 | throw streamBrandCheckException('locked');
|
1701 | }
|
1702 |
|
1703 | return IsReadableStreamLocked(this);
|
1704 | }
|
1705 | }]);
|
1706 |
|
1707 | return ReadableStream;
|
1708 | }();
|
1709 |
|
1710 | module.exports = {
|
1711 | ReadableStream: ReadableStream,
|
1712 | IsReadableStreamDisturbed: IsReadableStreamDisturbed,
|
1713 | ReadableStreamDefaultControllerClose: ReadableStreamDefaultControllerClose,
|
1714 | ReadableStreamDefaultControllerEnqueue: ReadableStreamDefaultControllerEnqueue,
|
1715 | ReadableStreamDefaultControllerError: ReadableStreamDefaultControllerError,
|
1716 | ReadableStreamDefaultControllerGetDesiredSize: ReadableStreamDefaultControllerGetDesiredSize
|
1717 | };
|
1718 |
|
1719 |
|
1720 |
|
1721 | function AcquireReadableStreamBYOBReader(stream) {
|
1722 | return new ReadableStreamBYOBReader(stream);
|
1723 | }
|
1724 |
|
1725 | function AcquireReadableStreamDefaultReader(stream) {
|
1726 | return new ReadableStreamDefaultReader(stream);
|
1727 | }
|
1728 |
|
1729 | function IsReadableStream(x) {
|
1730 | if (!typeIsObject(x)) {
|
1731 | return false;
|
1732 | }
|
1733 |
|
1734 | if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {
|
1735 | return false;
|
1736 | }
|
1737 |
|
1738 | return true;
|
1739 | }
|
1740 |
|
1741 | function IsReadableStreamDisturbed(stream) {
|
1742 | assert(IsReadableStream(stream) === true, 'IsReadableStreamDisturbed should only be used on known readable streams');
|
1743 |
|
1744 | return stream._disturbed;
|
1745 | }
|
1746 |
|
1747 | function IsReadableStreamLocked(stream) {
|
1748 | assert(IsReadableStream(stream) === true, 'IsReadableStreamLocked should only be used on known readable streams');
|
1749 |
|
1750 | if (stream._reader === undefined) {
|
1751 | return false;
|
1752 | }
|
1753 |
|
1754 | return true;
|
1755 | }
|
1756 |
|
1757 | function ReadableStreamTee(stream, cloneForBranch2) {
|
1758 | assert(IsReadableStream(stream) === true);
|
1759 | assert(typeof cloneForBranch2 === 'boolean');
|
1760 |
|
1761 | var reader = AcquireReadableStreamDefaultReader(stream);
|
1762 |
|
1763 | var teeState = {
|
1764 | closedOrErrored: false,
|
1765 | canceled1: false,
|
1766 | canceled2: false,
|
1767 | reason1: undefined,
|
1768 | reason2: undefined
|
1769 | };
|
1770 | teeState.promise = new Promise(function (resolve) {
|
1771 | teeState._resolve = resolve;
|
1772 | });
|
1773 |
|
1774 | var pull = create_ReadableStreamTeePullFunction();
|
1775 | pull._reader = reader;
|
1776 | pull._teeState = teeState;
|
1777 | pull._cloneForBranch2 = cloneForBranch2;
|
1778 |
|
1779 | var cancel1 = create_ReadableStreamTeeBranch1CancelFunction();
|
1780 | cancel1._stream = stream;
|
1781 | cancel1._teeState = teeState;
|
1782 |
|
1783 | var cancel2 = create_ReadableStreamTeeBranch2CancelFunction();
|
1784 | cancel2._stream = stream;
|
1785 | cancel2._teeState = teeState;
|
1786 |
|
1787 | var underlyingSource1 = Object.create(Object.prototype);
|
1788 | createDataProperty(underlyingSource1, 'pull', pull);
|
1789 | createDataProperty(underlyingSource1, 'cancel', cancel1);
|
1790 | var branch1Stream = new ReadableStream(underlyingSource1);
|
1791 |
|
1792 | var underlyingSource2 = Object.create(Object.prototype);
|
1793 | createDataProperty(underlyingSource2, 'pull', pull);
|
1794 | createDataProperty(underlyingSource2, 'cancel', cancel2);
|
1795 | var branch2Stream = new ReadableStream(underlyingSource2);
|
1796 |
|
1797 | pull._branch1 = branch1Stream._readableStreamController;
|
1798 | pull._branch2 = branch2Stream._readableStreamController;
|
1799 |
|
1800 | reader._closedPromise.catch(function (r) {
|
1801 | if (teeState.closedOrErrored === true) {
|
1802 | return;
|
1803 | }
|
1804 |
|
1805 | ReadableStreamDefaultControllerError(pull._branch1, r);
|
1806 | ReadableStreamDefaultControllerError(pull._branch2, r);
|
1807 | teeState.closedOrErrored = true;
|
1808 | });
|
1809 |
|
1810 | return [branch1Stream, branch2Stream];
|
1811 | }
|
1812 |
|
1813 | function create_ReadableStreamTeePullFunction() {
|
1814 | function f() {
|
1815 | var reader = f._reader,
|
1816 | branch1 = f._branch1,
|
1817 | branch2 = f._branch2,
|
1818 | teeState = f._teeState;
|
1819 |
|
1820 |
|
1821 | return ReadableStreamDefaultReaderRead(reader).then(function (result) {
|
1822 | assert(typeIsObject(result));
|
1823 | var value = result.value;
|
1824 | var done = result.done;
|
1825 | assert(typeof done === 'boolean');
|
1826 |
|
1827 | if (done === true && teeState.closedOrErrored === false) {
|
1828 | if (teeState.canceled1 === false) {
|
1829 | ReadableStreamDefaultControllerClose(branch1);
|
1830 | }
|
1831 | if (teeState.canceled2 === false) {
|
1832 | ReadableStreamDefaultControllerClose(branch2);
|
1833 | }
|
1834 | teeState.closedOrErrored = true;
|
1835 | }
|
1836 |
|
1837 | if (teeState.closedOrErrored === true) {
|
1838 | return;
|
1839 | }
|
1840 |
|
1841 | var value1 = value;
|
1842 | var value2 = value;
|
1843 |
|
1844 |
|
1845 |
|
1846 |
|
1847 |
|
1848 |
|
1849 |
|
1850 | if (teeState.canceled1 === false) {
|
1851 | ReadableStreamDefaultControllerEnqueue(branch1, value1);
|
1852 | }
|
1853 |
|
1854 | if (teeState.canceled2 === false) {
|
1855 | ReadableStreamDefaultControllerEnqueue(branch2, value2);
|
1856 | }
|
1857 | });
|
1858 | }
|
1859 | return f;
|
1860 | }
|
1861 |
|
1862 | function create_ReadableStreamTeeBranch1CancelFunction() {
|
1863 | function f(reason) {
|
1864 | var stream = f._stream,
|
1865 | teeState = f._teeState;
|
1866 |
|
1867 |
|
1868 | teeState.canceled1 = true;
|
1869 | teeState.reason1 = reason;
|
1870 | if (teeState.canceled2 === true) {
|
1871 | var compositeReason = createArrayFromList([teeState.reason1, teeState.reason2]);
|
1872 | var cancelResult = ReadableStreamCancel(stream, compositeReason);
|
1873 | teeState._resolve(cancelResult);
|
1874 | }
|
1875 | return teeState.promise;
|
1876 | }
|
1877 | return f;
|
1878 | }
|
1879 |
|
1880 | function create_ReadableStreamTeeBranch2CancelFunction() {
|
1881 | function f(reason) {
|
1882 | var stream = f._stream,
|
1883 | teeState = f._teeState;
|
1884 |
|
1885 |
|
1886 | teeState.canceled2 = true;
|
1887 | teeState.reason2 = reason;
|
1888 | if (teeState.canceled1 === true) {
|
1889 | var compositeReason = createArrayFromList([teeState.reason1, teeState.reason2]);
|
1890 | var cancelResult = ReadableStreamCancel(stream, compositeReason);
|
1891 | teeState._resolve(cancelResult);
|
1892 | }
|
1893 | return teeState.promise;
|
1894 | }
|
1895 | return f;
|
1896 | }
|
1897 |
|
1898 |
|
1899 |
|
1900 | function ReadableStreamAddReadIntoRequest(stream) {
|
1901 | assert(IsReadableStreamBYOBReader(stream._reader) === true);
|
1902 | assert(stream._state === 'readable' || stream._state === 'closed');
|
1903 |
|
1904 | var promise = new Promise(function (resolve, reject) {
|
1905 | var readIntoRequest = {
|
1906 | _resolve: resolve,
|
1907 | _reject: reject
|
1908 | };
|
1909 |
|
1910 | stream._reader._readIntoRequests.push(readIntoRequest);
|
1911 | });
|
1912 |
|
1913 | return promise;
|
1914 | }
|
1915 |
|
1916 | function ReadableStreamAddReadRequest(stream) {
|
1917 | assert(IsReadableStreamDefaultReader(stream._reader) === true);
|
1918 | assert(stream._state === 'readable');
|
1919 |
|
1920 | var promise = new Promise(function (resolve, reject) {
|
1921 | var readRequest = {
|
1922 | _resolve: resolve,
|
1923 | _reject: reject
|
1924 | };
|
1925 |
|
1926 | stream._reader._readRequests.push(readRequest);
|
1927 | });
|
1928 |
|
1929 | return promise;
|
1930 | }
|
1931 |
|
1932 | function ReadableStreamCancel(stream, reason) {
|
1933 | stream._disturbed = true;
|
1934 |
|
1935 | if (stream._state === 'closed') {
|
1936 | return Promise.resolve(undefined);
|
1937 | }
|
1938 | if (stream._state === 'errored') {
|
1939 | return Promise.reject(stream._storedError);
|
1940 | }
|
1941 |
|
1942 | ReadableStreamClose(stream);
|
1943 |
|
1944 | var sourceCancelPromise = stream._readableStreamController.__cancelSteps(reason);
|
1945 | return sourceCancelPromise.then(function () {
|
1946 | return undefined;
|
1947 | });
|
1948 | }
|
1949 |
|
1950 | function ReadableStreamClose(stream) {
|
1951 | assert(stream._state === 'readable');
|
1952 |
|
1953 | stream._state = 'closed';
|
1954 |
|
1955 | var reader = stream._reader;
|
1956 |
|
1957 | if (reader === undefined) {
|
1958 | return undefined;
|
1959 | }
|
1960 |
|
1961 | if (IsReadableStreamDefaultReader(reader) === true) {
|
1962 | for (var i = 0; i < reader._readRequests.length; i++) {
|
1963 | var _resolve = reader._readRequests[i]._resolve;
|
1964 |
|
1965 | _resolve(CreateIterResultObject(undefined, true));
|
1966 | }
|
1967 | reader._readRequests = [];
|
1968 | }
|
1969 |
|
1970 | defaultReaderClosedPromiseResolve(reader);
|
1971 |
|
1972 | return undefined;
|
1973 | }
|
1974 |
|
1975 | function ReadableStreamError(stream, e) {
|
1976 | assert(IsReadableStream(stream) === true, 'stream must be ReadableStream');
|
1977 | assert(stream._state === 'readable', 'state must be readable');
|
1978 |
|
1979 | stream._state = 'errored';
|
1980 | stream._storedError = e;
|
1981 |
|
1982 | var reader = stream._reader;
|
1983 |
|
1984 | if (reader === undefined) {
|
1985 | return undefined;
|
1986 | }
|
1987 |
|
1988 | if (IsReadableStreamDefaultReader(reader) === true) {
|
1989 | for (var i = 0; i < reader._readRequests.length; i++) {
|
1990 | var readRequest = reader._readRequests[i];
|
1991 | readRequest._reject(e);
|
1992 | }
|
1993 |
|
1994 | reader._readRequests = [];
|
1995 | } else {
|
1996 | assert(IsReadableStreamBYOBReader(reader), 'reader must be ReadableStreamBYOBReader');
|
1997 |
|
1998 | for (var _i = 0; _i < reader._readIntoRequests.length; _i++) {
|
1999 | var readIntoRequest = reader._readIntoRequests[_i];
|
2000 | readIntoRequest._reject(e);
|
2001 | }
|
2002 |
|
2003 | reader._readIntoRequests = [];
|
2004 | }
|
2005 |
|
2006 | defaultReaderClosedPromiseReject(reader, e);
|
2007 | reader._closedPromise.catch(function () {});
|
2008 | }
|
2009 |
|
2010 | function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {
|
2011 | var reader = stream._reader;
|
2012 |
|
2013 | assert(reader._readIntoRequests.length > 0);
|
2014 |
|
2015 | var readIntoRequest = reader._readIntoRequests.shift();
|
2016 | readIntoRequest._resolve(CreateIterResultObject(chunk, done));
|
2017 | }
|
2018 |
|
2019 | function ReadableStreamFulfillReadRequest(stream, chunk, done) {
|
2020 | var reader = stream._reader;
|
2021 |
|
2022 | assert(reader._readRequests.length > 0);
|
2023 |
|
2024 | var readRequest = reader._readRequests.shift();
|
2025 | readRequest._resolve(CreateIterResultObject(chunk, done));
|
2026 | }
|
2027 |
|
2028 | function ReadableStreamGetNumReadIntoRequests(stream) {
|
2029 | return stream._reader._readIntoRequests.length;
|
2030 | }
|
2031 |
|
2032 | function ReadableStreamGetNumReadRequests(stream) {
|
2033 | return stream._reader._readRequests.length;
|
2034 | }
|
2035 |
|
2036 | function ReadableStreamHasBYOBReader(stream) {
|
2037 | var reader = stream._reader;
|
2038 |
|
2039 | if (reader === undefined) {
|
2040 | return false;
|
2041 | }
|
2042 |
|
2043 | if (IsReadableStreamBYOBReader(reader) === false) {
|
2044 | return false;
|
2045 | }
|
2046 |
|
2047 | return true;
|
2048 | }
|
2049 |
|
2050 | function ReadableStreamHasDefaultReader(stream) {
|
2051 | var reader = stream._reader;
|
2052 |
|
2053 | if (reader === undefined) {
|
2054 | return false;
|
2055 | }
|
2056 |
|
2057 | if (IsReadableStreamDefaultReader(reader) === false) {
|
2058 | return false;
|
2059 | }
|
2060 |
|
2061 | return true;
|
2062 | }
|
2063 |
|
2064 |
|
2065 |
|
2066 | var ReadableStreamDefaultReader = function () {
|
2067 | function ReadableStreamDefaultReader(stream) {
|
2068 | _classCallCheck(this, ReadableStreamDefaultReader);
|
2069 |
|
2070 | if (IsReadableStream(stream) === false) {
|
2071 | throw new TypeError('ReadableStreamDefaultReader can only be constructed with a ReadableStream instance');
|
2072 | }
|
2073 | if (IsReadableStreamLocked(stream) === true) {
|
2074 | throw new TypeError('This stream has already been locked for exclusive reading by another reader');
|
2075 | }
|
2076 |
|
2077 | ReadableStreamReaderGenericInitialize(this, stream);
|
2078 |
|
2079 | this._readRequests = [];
|
2080 | }
|
2081 |
|
2082 | _createClass(ReadableStreamDefaultReader, [{
|
2083 | key: 'cancel',
|
2084 | value: function cancel(reason) {
|
2085 | if (IsReadableStreamDefaultReader(this) === false) {
|
2086 | return Promise.reject(defaultReaderBrandCheckException('cancel'));
|
2087 | }
|
2088 |
|
2089 | if (this._ownerReadableStream === undefined) {
|
2090 | return Promise.reject(readerLockException('cancel'));
|
2091 | }
|
2092 |
|
2093 | return ReadableStreamReaderGenericCancel(this, reason);
|
2094 | }
|
2095 | }, {
|
2096 | key: 'read',
|
2097 | value: function read() {
|
2098 | if (IsReadableStreamDefaultReader(this) === false) {
|
2099 | return Promise.reject(defaultReaderBrandCheckException('read'));
|
2100 | }
|
2101 |
|
2102 | if (this._ownerReadableStream === undefined) {
|
2103 | return Promise.reject(readerLockException('read from'));
|
2104 | }
|
2105 |
|
2106 | return ReadableStreamDefaultReaderRead(this);
|
2107 | }
|
2108 | }, {
|
2109 | key: 'releaseLock',
|
2110 | value: function releaseLock() {
|
2111 | if (IsReadableStreamDefaultReader(this) === false) {
|
2112 | throw defaultReaderBrandCheckException('releaseLock');
|
2113 | }
|
2114 |
|
2115 | if (this._ownerReadableStream === undefined) {
|
2116 | return;
|
2117 | }
|
2118 |
|
2119 | if (this._readRequests.length > 0) {
|
2120 | throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');
|
2121 | }
|
2122 |
|
2123 | ReadableStreamReaderGenericRelease(this);
|
2124 | }
|
2125 | }, {
|
2126 | key: 'closed',
|
2127 | get: function get() {
|
2128 | if (IsReadableStreamDefaultReader(this) === false) {
|
2129 | return Promise.reject(defaultReaderBrandCheckException('closed'));
|
2130 | }
|
2131 |
|
2132 | return this._closedPromise;
|
2133 | }
|
2134 | }]);
|
2135 |
|
2136 | return ReadableStreamDefaultReader;
|
2137 | }();
|
2138 |
|
2139 | var ReadableStreamBYOBReader = function () {
|
2140 | function ReadableStreamBYOBReader(stream) {
|
2141 | _classCallCheck(this, ReadableStreamBYOBReader);
|
2142 |
|
2143 | if (!IsReadableStream(stream)) {
|
2144 | throw new TypeError('ReadableStreamBYOBReader can only be constructed with a ReadableStream instance given a ' + 'byte source');
|
2145 | }
|
2146 | if (IsReadableByteStreamController(stream._readableStreamController) === false) {
|
2147 | throw new TypeError('Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte ' + 'source');
|
2148 | }
|
2149 | if (IsReadableStreamLocked(stream)) {
|
2150 | throw new TypeError('This stream has already been locked for exclusive reading by another reader');
|
2151 | }
|
2152 |
|
2153 | ReadableStreamReaderGenericInitialize(this, stream);
|
2154 |
|
2155 | this._readIntoRequests = [];
|
2156 | }
|
2157 |
|
2158 | _createClass(ReadableStreamBYOBReader, [{
|
2159 | key: 'cancel',
|
2160 | value: function cancel(reason) {
|
2161 | if (!IsReadableStreamBYOBReader(this)) {
|
2162 | return Promise.reject(byobReaderBrandCheckException('cancel'));
|
2163 | }
|
2164 |
|
2165 | if (this._ownerReadableStream === undefined) {
|
2166 | return Promise.reject(readerLockException('cancel'));
|
2167 | }
|
2168 |
|
2169 | return ReadableStreamReaderGenericCancel(this, reason);
|
2170 | }
|
2171 | }, {
|
2172 | key: 'read',
|
2173 | value: function read(view) {
|
2174 | if (!IsReadableStreamBYOBReader(this)) {
|
2175 | return Promise.reject(byobReaderBrandCheckException('read'));
|
2176 | }
|
2177 |
|
2178 | if (this._ownerReadableStream === undefined) {
|
2179 | return Promise.reject(readerLockException('read from'));
|
2180 | }
|
2181 |
|
2182 | if (!ArrayBuffer.isView(view)) {
|
2183 | return Promise.reject(new TypeError('view must be an array buffer view'));
|
2184 | }
|
2185 |
|
2186 | if (view.byteLength === 0) {
|
2187 | return Promise.reject(new TypeError('view must have non-zero byteLength'));
|
2188 | }
|
2189 |
|
2190 | return ReadableStreamBYOBReaderRead(this, view);
|
2191 | }
|
2192 | }, {
|
2193 | key: 'releaseLock',
|
2194 | value: function releaseLock() {
|
2195 | if (!IsReadableStreamBYOBReader(this)) {
|
2196 | throw byobReaderBrandCheckException('releaseLock');
|
2197 | }
|
2198 |
|
2199 | if (this._ownerReadableStream === undefined) {
|
2200 | return;
|
2201 | }
|
2202 |
|
2203 | if (this._readIntoRequests.length > 0) {
|
2204 | throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');
|
2205 | }
|
2206 |
|
2207 | ReadableStreamReaderGenericRelease(this);
|
2208 | }
|
2209 | }, {
|
2210 | key: 'closed',
|
2211 | get: function get() {
|
2212 | if (!IsReadableStreamBYOBReader(this)) {
|
2213 | return Promise.reject(byobReaderBrandCheckException('closed'));
|
2214 | }
|
2215 |
|
2216 | return this._closedPromise;
|
2217 | }
|
2218 | }]);
|
2219 |
|
2220 | return ReadableStreamBYOBReader;
|
2221 | }();
|
2222 |
|
2223 |
|
2224 |
|
2225 | function IsReadableStreamBYOBReader(x) {
|
2226 | if (!typeIsObject(x)) {
|
2227 | return false;
|
2228 | }
|
2229 |
|
2230 | if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {
|
2231 | return false;
|
2232 | }
|
2233 |
|
2234 | return true;
|
2235 | }
|
2236 |
|
2237 | function IsReadableStreamDefaultReader(x) {
|
2238 | if (!typeIsObject(x)) {
|
2239 | return false;
|
2240 | }
|
2241 |
|
2242 | if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {
|
2243 | return false;
|
2244 | }
|
2245 |
|
2246 | return true;
|
2247 | }
|
2248 |
|
2249 | function ReadableStreamReaderGenericInitialize(reader, stream) {
|
2250 | reader._ownerReadableStream = stream;
|
2251 | stream._reader = reader;
|
2252 |
|
2253 | if (stream._state === 'readable') {
|
2254 | defaultReaderClosedPromiseInitialize(reader);
|
2255 | } else if (stream._state === 'closed') {
|
2256 | defaultReaderClosedPromiseInitializeAsResolved(reader);
|
2257 | } else {
|
2258 | assert(stream._state === 'errored', 'state must be errored');
|
2259 |
|
2260 | defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
|
2261 | reader._closedPromise.catch(function () {});
|
2262 | }
|
2263 | }
|
2264 |
|
2265 |
|
2266 |
|
2267 |
|
2268 | function ReadableStreamReaderGenericCancel(reader, reason) {
|
2269 | var stream = reader._ownerReadableStream;
|
2270 | assert(stream !== undefined);
|
2271 | return ReadableStreamCancel(stream, reason);
|
2272 | }
|
2273 |
|
2274 | function ReadableStreamReaderGenericRelease(reader) {
|
2275 | assert(reader._ownerReadableStream !== undefined);
|
2276 | assert(reader._ownerReadableStream._reader === reader);
|
2277 |
|
2278 | if (reader._ownerReadableStream._state === 'readable') {
|
2279 | defaultReaderClosedPromiseReject(reader, new TypeError('Reader was released and can no longer be used to monitor the stream\'s closedness'));
|
2280 | } else {
|
2281 | defaultReaderClosedPromiseResetToRejected(reader, new TypeError('Reader was released and can no longer be used to monitor the stream\'s closedness'));
|
2282 | }
|
2283 | reader._closedPromise.catch(function () {});
|
2284 |
|
2285 | reader._ownerReadableStream._reader = undefined;
|
2286 | reader._ownerReadableStream = undefined;
|
2287 | }
|
2288 |
|
2289 | function ReadableStreamBYOBReaderRead(reader, view) {
|
2290 | var stream = reader._ownerReadableStream;
|
2291 |
|
2292 | assert(stream !== undefined);
|
2293 |
|
2294 | stream._disturbed = true;
|
2295 |
|
2296 | if (stream._state === 'errored') {
|
2297 | return Promise.reject(stream._storedError);
|
2298 | }
|
2299 |
|
2300 |
|
2301 | return ReadableByteStreamControllerPullInto(stream._readableStreamController, view);
|
2302 | }
|
2303 |
|
2304 | function ReadableStreamDefaultReaderRead(reader) {
|
2305 | var stream = reader._ownerReadableStream;
|
2306 |
|
2307 | assert(stream !== undefined);
|
2308 |
|
2309 | stream._disturbed = true;
|
2310 |
|
2311 | if (stream._state === 'closed') {
|
2312 | return Promise.resolve(CreateIterResultObject(undefined, true));
|
2313 | }
|
2314 |
|
2315 | if (stream._state === 'errored') {
|
2316 | return Promise.reject(stream._storedError);
|
2317 | }
|
2318 |
|
2319 | assert(stream._state === 'readable');
|
2320 |
|
2321 | return stream._readableStreamController.__pullSteps();
|
2322 | }
|
2323 |
|
2324 |
|
2325 |
|
2326 | var ReadableStreamDefaultController = function () {
|
2327 | function ReadableStreamDefaultController(stream, underlyingSource, size, highWaterMark) {
|
2328 | _classCallCheck(this, ReadableStreamDefaultController);
|
2329 |
|
2330 | if (IsReadableStream(stream) === false) {
|
2331 | throw new TypeError('ReadableStreamDefaultController can only be constructed with a ReadableStream instance');
|
2332 | }
|
2333 |
|
2334 | if (stream._readableStreamController !== undefined) {
|
2335 | throw new TypeError('ReadableStreamDefaultController instances can only be created by the ReadableStream constructor');
|
2336 | }
|
2337 |
|
2338 | this._controlledReadableStream = stream;
|
2339 |
|
2340 | this._underlyingSource = underlyingSource;
|
2341 |
|
2342 |
|
2343 | this._queue = undefined;
|
2344 | this._queueTotalSize = undefined;
|
2345 | ResetQueue(this);
|
2346 |
|
2347 | this._started = false;
|
2348 | this._closeRequested = false;
|
2349 | this._pullAgain = false;
|
2350 | this._pulling = false;
|
2351 |
|
2352 | var normalizedStrategy = ValidateAndNormalizeQueuingStrategy(size, highWaterMark);
|
2353 | this._strategySize = normalizedStrategy.size;
|
2354 | this._strategyHWM = normalizedStrategy.highWaterMark;
|
2355 |
|
2356 | var controller = this;
|
2357 |
|
2358 | var startResult = InvokeOrNoop(underlyingSource, 'start', [this]);
|
2359 | Promise.resolve(startResult).then(function () {
|
2360 | controller._started = true;
|
2361 |
|
2362 | assert(controller._pulling === false);
|
2363 | assert(controller._pullAgain === false);
|
2364 |
|
2365 | ReadableStreamDefaultControllerCallPullIfNeeded(controller);
|
2366 | }, function (r) {
|
2367 | ReadableStreamDefaultControllerErrorIfNeeded(controller, r);
|
2368 | }).catch(rethrowAssertionErrorRejection);
|
2369 | }
|
2370 |
|
2371 | _createClass(ReadableStreamDefaultController, [{
|
2372 | key: 'close',
|
2373 | value: function close() {
|
2374 | if (IsReadableStreamDefaultController(this) === false) {
|
2375 | throw defaultControllerBrandCheckException('close');
|
2376 | }
|
2377 |
|
2378 | if (this._closeRequested === true) {
|
2379 | throw new TypeError('The stream has already been closed; do not close it again!');
|
2380 | }
|
2381 |
|
2382 | var state = this._controlledReadableStream._state;
|
2383 | if (state !== 'readable') {
|
2384 | throw new TypeError('The stream (in ' + state + ' state) is not in the readable state and cannot be closed');
|
2385 | }
|
2386 |
|
2387 | ReadableStreamDefaultControllerClose(this);
|
2388 | }
|
2389 | }, {
|
2390 | key: 'enqueue',
|
2391 | value: function enqueue(chunk) {
|
2392 | if (IsReadableStreamDefaultController(this) === false) {
|
2393 | throw defaultControllerBrandCheckException('enqueue');
|
2394 | }
|
2395 |
|
2396 | if (this._closeRequested === true) {
|
2397 | throw new TypeError('stream is closed or draining');
|
2398 | }
|
2399 |
|
2400 | var state = this._controlledReadableStream._state;
|
2401 | if (state !== 'readable') {
|
2402 | throw new TypeError('The stream (in ' + state + ' state) is not in the readable state and cannot be enqueued to');
|
2403 | }
|
2404 |
|
2405 | return ReadableStreamDefaultControllerEnqueue(this, chunk);
|
2406 | }
|
2407 | }, {
|
2408 | key: 'error',
|
2409 | value: function error(e) {
|
2410 | if (IsReadableStreamDefaultController(this) === false) {
|
2411 | throw defaultControllerBrandCheckException('error');
|
2412 | }
|
2413 |
|
2414 | var stream = this._controlledReadableStream;
|
2415 | if (stream._state !== 'readable') {
|
2416 | throw new TypeError('The stream is ' + stream._state + ' and so cannot be errored');
|
2417 | }
|
2418 |
|
2419 | ReadableStreamDefaultControllerError(this, e);
|
2420 | }
|
2421 | }, {
|
2422 | key: '__cancelSteps',
|
2423 | value: function __cancelSteps(reason) {
|
2424 | ResetQueue(this);
|
2425 | return PromiseInvokeOrNoop(this._underlyingSource, 'cancel', [reason]);
|
2426 | }
|
2427 | }, {
|
2428 | key: '__pullSteps',
|
2429 | value: function __pullSteps() {
|
2430 | var stream = this._controlledReadableStream;
|
2431 |
|
2432 | if (this._queue.length > 0) {
|
2433 | var chunk = DequeueValue(this);
|
2434 |
|
2435 | if (this._closeRequested === true && this._queue.length === 0) {
|
2436 | ReadableStreamClose(stream);
|
2437 | } else {
|
2438 | ReadableStreamDefaultControllerCallPullIfNeeded(this);
|
2439 | }
|
2440 |
|
2441 | return Promise.resolve(CreateIterResultObject(chunk, false));
|
2442 | }
|
2443 |
|
2444 | var pendingPromise = ReadableStreamAddReadRequest(stream);
|
2445 | ReadableStreamDefaultControllerCallPullIfNeeded(this);
|
2446 | return pendingPromise;
|
2447 | }
|
2448 | }, {
|
2449 | key: 'desiredSize',
|
2450 | get: function get() {
|
2451 | if (IsReadableStreamDefaultController(this) === false) {
|
2452 | throw defaultControllerBrandCheckException('desiredSize');
|
2453 | }
|
2454 |
|
2455 | return ReadableStreamDefaultControllerGetDesiredSize(this);
|
2456 | }
|
2457 | }]);
|
2458 |
|
2459 | return ReadableStreamDefaultController;
|
2460 | }();
|
2461 |
|
2462 |
|
2463 |
|
2464 | function IsReadableStreamDefaultController(x) {
|
2465 | if (!typeIsObject(x)) {
|
2466 | return false;
|
2467 | }
|
2468 |
|
2469 | if (!Object.prototype.hasOwnProperty.call(x, '_underlyingSource')) {
|
2470 | return false;
|
2471 | }
|
2472 |
|
2473 | return true;
|
2474 | }
|
2475 |
|
2476 | function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
|
2477 | var shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
|
2478 | if (shouldPull === false) {
|
2479 | return undefined;
|
2480 | }
|
2481 |
|
2482 | if (controller._pulling === true) {
|
2483 | controller._pullAgain = true;
|
2484 | return undefined;
|
2485 | }
|
2486 |
|
2487 | assert(controller._pullAgain === false);
|
2488 |
|
2489 | controller._pulling = true;
|
2490 |
|
2491 | var pullPromise = PromiseInvokeOrNoop(controller._underlyingSource, 'pull', [controller]);
|
2492 | pullPromise.then(function () {
|
2493 | controller._pulling = false;
|
2494 |
|
2495 | if (controller._pullAgain === true) {
|
2496 | controller._pullAgain = false;
|
2497 | return ReadableStreamDefaultControllerCallPullIfNeeded(controller);
|
2498 | }
|
2499 | return undefined;
|
2500 | }, function (e) {
|
2501 | ReadableStreamDefaultControllerErrorIfNeeded(controller, e);
|
2502 | }).catch(rethrowAssertionErrorRejection);
|
2503 |
|
2504 | return undefined;
|
2505 | }
|
2506 |
|
2507 | function ReadableStreamDefaultControllerShouldCallPull(controller) {
|
2508 | var stream = controller._controlledReadableStream;
|
2509 |
|
2510 | if (stream._state === 'closed' || stream._state === 'errored') {
|
2511 | return false;
|
2512 | }
|
2513 |
|
2514 | if (controller._closeRequested === true) {
|
2515 | return false;
|
2516 | }
|
2517 |
|
2518 | if (controller._started === false) {
|
2519 | return false;
|
2520 | }
|
2521 |
|
2522 | if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
|
2523 | return true;
|
2524 | }
|
2525 |
|
2526 | var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
|
2527 | if (desiredSize > 0) {
|
2528 | return true;
|
2529 | }
|
2530 |
|
2531 | return false;
|
2532 | }
|
2533 |
|
2534 |
|
2535 |
|
2536 | function ReadableStreamDefaultControllerClose(controller) {
|
2537 | var stream = controller._controlledReadableStream;
|
2538 |
|
2539 | assert(controller._closeRequested === false);
|
2540 | assert(stream._state === 'readable');
|
2541 |
|
2542 | controller._closeRequested = true;
|
2543 |
|
2544 | if (controller._queue.length === 0) {
|
2545 | ReadableStreamClose(stream);
|
2546 | }
|
2547 | }
|
2548 |
|
2549 | function ReadableStreamDefaultControllerEnqueue(controller, chunk) {
|
2550 | var stream = controller._controlledReadableStream;
|
2551 |
|
2552 | assert(controller._closeRequested === false);
|
2553 | assert(stream._state === 'readable');
|
2554 |
|
2555 | if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
|
2556 | ReadableStreamFulfillReadRequest(stream, chunk, false);
|
2557 | } else {
|
2558 | var chunkSize = 1;
|
2559 |
|
2560 | if (controller._strategySize !== undefined) {
|
2561 | var strategySize = controller._strategySize;
|
2562 | try {
|
2563 | chunkSize = strategySize(chunk);
|
2564 | } catch (chunkSizeE) {
|
2565 | ReadableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
|
2566 | throw chunkSizeE;
|
2567 | }
|
2568 | }
|
2569 |
|
2570 | try {
|
2571 | EnqueueValueWithSize(controller, chunk, chunkSize);
|
2572 | } catch (enqueueE) {
|
2573 | ReadableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
|
2574 | throw enqueueE;
|
2575 | }
|
2576 | }
|
2577 |
|
2578 | ReadableStreamDefaultControllerCallPullIfNeeded(controller);
|
2579 |
|
2580 | return undefined;
|
2581 | }
|
2582 |
|
2583 | function ReadableStreamDefaultControllerError(controller, e) {
|
2584 | var stream = controller._controlledReadableStream;
|
2585 |
|
2586 | assert(stream._state === 'readable');
|
2587 |
|
2588 | ResetQueue(controller);
|
2589 |
|
2590 | ReadableStreamError(stream, e);
|
2591 | }
|
2592 |
|
2593 | function ReadableStreamDefaultControllerErrorIfNeeded(controller, e) {
|
2594 | if (controller._controlledReadableStream._state === 'readable') {
|
2595 | ReadableStreamDefaultControllerError(controller, e);
|
2596 | }
|
2597 | }
|
2598 |
|
2599 | function ReadableStreamDefaultControllerGetDesiredSize(controller) {
|
2600 | var stream = controller._controlledReadableStream;
|
2601 | var state = stream._state;
|
2602 |
|
2603 | if (state === 'errored') {
|
2604 | return null;
|
2605 | }
|
2606 | if (state === 'closed') {
|
2607 | return 0;
|
2608 | }
|
2609 |
|
2610 | return controller._strategyHWM - controller._queueTotalSize;
|
2611 | }
|
2612 |
|
2613 | var ReadableStreamBYOBRequest = function () {
|
2614 | function ReadableStreamBYOBRequest(controller, view) {
|
2615 | _classCallCheck(this, ReadableStreamBYOBRequest);
|
2616 |
|
2617 | this._associatedReadableByteStreamController = controller;
|
2618 | this._view = view;
|
2619 | }
|
2620 |
|
2621 | _createClass(ReadableStreamBYOBRequest, [{
|
2622 | key: 'respond',
|
2623 | value: function respond(bytesWritten) {
|
2624 | if (IsReadableStreamBYOBRequest(this) === false) {
|
2625 | throw byobRequestBrandCheckException('respond');
|
2626 | }
|
2627 |
|
2628 | if (this._associatedReadableByteStreamController === undefined) {
|
2629 | throw new TypeError('This BYOB request has been invalidated');
|
2630 | }
|
2631 |
|
2632 | ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);
|
2633 | }
|
2634 | }, {
|
2635 | key: 'respondWithNewView',
|
2636 | value: function respondWithNewView(view) {
|
2637 | if (IsReadableStreamBYOBRequest(this) === false) {
|
2638 | throw byobRequestBrandCheckException('respond');
|
2639 | }
|
2640 |
|
2641 | if (this._associatedReadableByteStreamController === undefined) {
|
2642 | throw new TypeError('This BYOB request has been invalidated');
|
2643 | }
|
2644 |
|
2645 | if (!ArrayBuffer.isView(view)) {
|
2646 | throw new TypeError('You can only respond with array buffer views');
|
2647 | }
|
2648 |
|
2649 | ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
|
2650 | }
|
2651 | }, {
|
2652 | key: 'view',
|
2653 | get: function get() {
|
2654 | return this._view;
|
2655 | }
|
2656 | }]);
|
2657 |
|
2658 | return ReadableStreamBYOBRequest;
|
2659 | }();
|
2660 |
|
2661 | var ReadableByteStreamController = function () {
|
2662 | function ReadableByteStreamController(stream, underlyingByteSource, highWaterMark) {
|
2663 | _classCallCheck(this, ReadableByteStreamController);
|
2664 |
|
2665 | if (IsReadableStream(stream) === false) {
|
2666 | throw new TypeError('ReadableByteStreamController can only be constructed with a ReadableStream instance given ' + 'a byte source');
|
2667 | }
|
2668 |
|
2669 | if (stream._readableStreamController !== undefined) {
|
2670 | throw new TypeError('ReadableByteStreamController instances can only be created by the ReadableStream constructor given a byte ' + 'source');
|
2671 | }
|
2672 |
|
2673 | this._controlledReadableStream = stream;
|
2674 |
|
2675 | this._underlyingByteSource = underlyingByteSource;
|
2676 |
|
2677 | this._pullAgain = false;
|
2678 | this._pulling = false;
|
2679 |
|
2680 | ReadableByteStreamControllerClearPendingPullIntos(this);
|
2681 |
|
2682 |
|
2683 | this._queue = this._queueTotalSize = undefined;
|
2684 | ResetQueue(this);
|
2685 |
|
2686 | this._closeRequested = false;
|
2687 | this._started = false;
|
2688 |
|
2689 | this._strategyHWM = ValidateAndNormalizeHighWaterMark(highWaterMark);
|
2690 |
|
2691 | var autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
|
2692 | if (autoAllocateChunkSize !== undefined) {
|
2693 | if (Number.isInteger(autoAllocateChunkSize) === false || autoAllocateChunkSize <= 0) {
|
2694 | throw new RangeError('autoAllocateChunkSize must be a positive integer');
|
2695 | }
|
2696 | }
|
2697 | this._autoAllocateChunkSize = autoAllocateChunkSize;
|
2698 |
|
2699 | this._pendingPullIntos = [];
|
2700 |
|
2701 | var controller = this;
|
2702 |
|
2703 | var startResult = InvokeOrNoop(underlyingByteSource, 'start', [this]);
|
2704 | Promise.resolve(startResult).then(function () {
|
2705 | controller._started = true;
|
2706 |
|
2707 | assert(controller._pulling === false);
|
2708 | assert(controller._pullAgain === false);
|
2709 |
|
2710 | ReadableByteStreamControllerCallPullIfNeeded(controller);
|
2711 | }, function (r) {
|
2712 | if (stream._state === 'readable') {
|
2713 | ReadableByteStreamControllerError(controller, r);
|
2714 | }
|
2715 | }).catch(rethrowAssertionErrorRejection);
|
2716 | }
|
2717 |
|
2718 | _createClass(ReadableByteStreamController, [{
|
2719 | key: 'close',
|
2720 | value: function close() {
|
2721 | if (IsReadableByteStreamController(this) === false) {
|
2722 | throw byteStreamControllerBrandCheckException('close');
|
2723 | }
|
2724 |
|
2725 | if (this._closeRequested === true) {
|
2726 | throw new TypeError('The stream has already been closed; do not close it again!');
|
2727 | }
|
2728 |
|
2729 | var state = this._controlledReadableStream._state;
|
2730 | if (state !== 'readable') {
|
2731 | throw new TypeError('The stream (in ' + state + ' state) is not in the readable state and cannot be closed');
|
2732 | }
|
2733 |
|
2734 | ReadableByteStreamControllerClose(this);
|
2735 | }
|
2736 | }, {
|
2737 | key: 'enqueue',
|
2738 | value: function enqueue(chunk) {
|
2739 | if (IsReadableByteStreamController(this) === false) {
|
2740 | throw byteStreamControllerBrandCheckException('enqueue');
|
2741 | }
|
2742 |
|
2743 | if (this._closeRequested === true) {
|
2744 | throw new TypeError('stream is closed or draining');
|
2745 | }
|
2746 |
|
2747 | var state = this._controlledReadableStream._state;
|
2748 | if (state !== 'readable') {
|
2749 | throw new TypeError('The stream (in ' + state + ' state) is not in the readable state and cannot be enqueued to');
|
2750 | }
|
2751 |
|
2752 | if (!ArrayBuffer.isView(chunk)) {
|
2753 | throw new TypeError('You can only enqueue array buffer views when using a ReadableByteStreamController');
|
2754 | }
|
2755 |
|
2756 | ReadableByteStreamControllerEnqueue(this, chunk);
|
2757 | }
|
2758 | }, {
|
2759 | key: 'error',
|
2760 | value: function error(e) {
|
2761 | if (IsReadableByteStreamController(this) === false) {
|
2762 | throw byteStreamControllerBrandCheckException('error');
|
2763 | }
|
2764 |
|
2765 | var stream = this._controlledReadableStream;
|
2766 | if (stream._state !== 'readable') {
|
2767 | throw new TypeError('The stream is ' + stream._state + ' and so cannot be errored');
|
2768 | }
|
2769 |
|
2770 | ReadableByteStreamControllerError(this, e);
|
2771 | }
|
2772 | }, {
|
2773 | key: '__cancelSteps',
|
2774 | value: function __cancelSteps(reason) {
|
2775 | if (this._pendingPullIntos.length > 0) {
|
2776 | var firstDescriptor = this._pendingPullIntos[0];
|
2777 | firstDescriptor.bytesFilled = 0;
|
2778 | }
|
2779 |
|
2780 | ResetQueue(this);
|
2781 |
|
2782 | return PromiseInvokeOrNoop(this._underlyingByteSource, 'cancel', [reason]);
|
2783 | }
|
2784 | }, {
|
2785 | key: '__pullSteps',
|
2786 | value: function __pullSteps() {
|
2787 | var stream = this._controlledReadableStream;
|
2788 | assert(ReadableStreamHasDefaultReader(stream) === true);
|
2789 |
|
2790 | if (this._queueTotalSize > 0) {
|
2791 | assert(ReadableStreamGetNumReadRequests(stream) === 0);
|
2792 |
|
2793 | var entry = this._queue.shift();
|
2794 | this._queueTotalSize -= entry.byteLength;
|
2795 |
|
2796 | ReadableByteStreamControllerHandleQueueDrain(this);
|
2797 |
|
2798 | var view = void 0;
|
2799 | try {
|
2800 | view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
|
2801 | } catch (viewE) {
|
2802 | return Promise.reject(viewE);
|
2803 | }
|
2804 |
|
2805 | return Promise.resolve(CreateIterResultObject(view, false));
|
2806 | }
|
2807 |
|
2808 | var autoAllocateChunkSize = this._autoAllocateChunkSize;
|
2809 | if (autoAllocateChunkSize !== undefined) {
|
2810 | var buffer = void 0;
|
2811 | try {
|
2812 | buffer = new ArrayBuffer(autoAllocateChunkSize);
|
2813 | } catch (bufferE) {
|
2814 | return Promise.reject(bufferE);
|
2815 | }
|
2816 |
|
2817 | var pullIntoDescriptor = {
|
2818 | buffer: buffer,
|
2819 | byteOffset: 0,
|
2820 | byteLength: autoAllocateChunkSize,
|
2821 | bytesFilled: 0,
|
2822 | elementSize: 1,
|
2823 | ctor: Uint8Array,
|
2824 | readerType: 'default'
|
2825 | };
|
2826 |
|
2827 | this._pendingPullIntos.push(pullIntoDescriptor);
|
2828 | }
|
2829 |
|
2830 | var promise = ReadableStreamAddReadRequest(stream);
|
2831 |
|
2832 | ReadableByteStreamControllerCallPullIfNeeded(this);
|
2833 |
|
2834 | return promise;
|
2835 | }
|
2836 | }, {
|
2837 | key: 'byobRequest',
|
2838 | get: function get() {
|
2839 | if (IsReadableByteStreamController(this) === false) {
|
2840 | throw byteStreamControllerBrandCheckException('byobRequest');
|
2841 | }
|
2842 |
|
2843 | if (this._byobRequest === undefined && this._pendingPullIntos.length > 0) {
|
2844 | var firstDescriptor = this._pendingPullIntos[0];
|
2845 | var view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
|
2846 |
|
2847 | this._byobRequest = new ReadableStreamBYOBRequest(this, view);
|
2848 | }
|
2849 |
|
2850 | return this._byobRequest;
|
2851 | }
|
2852 | }, {
|
2853 | key: 'desiredSize',
|
2854 | get: function get() {
|
2855 | if (IsReadableByteStreamController(this) === false) {
|
2856 | throw byteStreamControllerBrandCheckException('desiredSize');
|
2857 | }
|
2858 |
|
2859 | return ReadableByteStreamControllerGetDesiredSize(this);
|
2860 | }
|
2861 | }]);
|
2862 |
|
2863 | return ReadableByteStreamController;
|
2864 | }();
|
2865 |
|
2866 |
|
2867 |
|
2868 | function IsReadableByteStreamController(x) {
|
2869 | if (!typeIsObject(x)) {
|
2870 | return false;
|
2871 | }
|
2872 |
|
2873 | if (!Object.prototype.hasOwnProperty.call(x, '_underlyingByteSource')) {
|
2874 | return false;
|
2875 | }
|
2876 |
|
2877 | return true;
|
2878 | }
|
2879 |
|
2880 | function IsReadableStreamBYOBRequest(x) {
|
2881 | if (!typeIsObject(x)) {
|
2882 | return false;
|
2883 | }
|
2884 |
|
2885 | if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {
|
2886 | return false;
|
2887 | }
|
2888 |
|
2889 | return true;
|
2890 | }
|
2891 |
|
2892 | function ReadableByteStreamControllerCallPullIfNeeded(controller) {
|
2893 | var shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
|
2894 | if (shouldPull === false) {
|
2895 | return undefined;
|
2896 | }
|
2897 |
|
2898 | if (controller._pulling === true) {
|
2899 | controller._pullAgain = true;
|
2900 | return undefined;
|
2901 | }
|
2902 |
|
2903 | assert(controller._pullAgain === false);
|
2904 |
|
2905 | controller._pulling = true;
|
2906 |
|
2907 |
|
2908 | var pullPromise = PromiseInvokeOrNoop(controller._underlyingByteSource, 'pull', [controller]);
|
2909 | pullPromise.then(function () {
|
2910 | controller._pulling = false;
|
2911 |
|
2912 | if (controller._pullAgain === true) {
|
2913 | controller._pullAgain = false;
|
2914 | ReadableByteStreamControllerCallPullIfNeeded(controller);
|
2915 | }
|
2916 | }, function (e) {
|
2917 | if (controller._controlledReadableStream._state === 'readable') {
|
2918 | ReadableByteStreamControllerError(controller, e);
|
2919 | }
|
2920 | }).catch(rethrowAssertionErrorRejection);
|
2921 |
|
2922 | return undefined;
|
2923 | }
|
2924 |
|
2925 | function ReadableByteStreamControllerClearPendingPullIntos(controller) {
|
2926 | ReadableByteStreamControllerInvalidateBYOBRequest(controller);
|
2927 | controller._pendingPullIntos = [];
|
2928 | }
|
2929 |
|
2930 | function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {
|
2931 | assert(stream._state !== 'errored', 'state must not be errored');
|
2932 |
|
2933 | var done = false;
|
2934 | if (stream._state === 'closed') {
|
2935 | assert(pullIntoDescriptor.bytesFilled === 0);
|
2936 | done = true;
|
2937 | }
|
2938 |
|
2939 | var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
|
2940 | if (pullIntoDescriptor.readerType === 'default') {
|
2941 | ReadableStreamFulfillReadRequest(stream, filledView, done);
|
2942 | } else {
|
2943 | assert(pullIntoDescriptor.readerType === 'byob');
|
2944 | ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
|
2945 | }
|
2946 | }
|
2947 |
|
2948 | function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {
|
2949 | var bytesFilled = pullIntoDescriptor.bytesFilled;
|
2950 | var elementSize = pullIntoDescriptor.elementSize;
|
2951 |
|
2952 | assert(bytesFilled <= pullIntoDescriptor.byteLength);
|
2953 | assert(bytesFilled % elementSize === 0);
|
2954 |
|
2955 | return new pullIntoDescriptor.ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize);
|
2956 | }
|
2957 |
|
2958 | function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) {
|
2959 | controller._queue.push({ buffer: buffer, byteOffset: byteOffset, byteLength: byteLength });
|
2960 | controller._queueTotalSize += byteLength;
|
2961 | }
|
2962 |
|
2963 | function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {
|
2964 | var elementSize = pullIntoDescriptor.elementSize;
|
2965 |
|
2966 | var currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize;
|
2967 |
|
2968 | var maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
|
2969 | var maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
|
2970 | var maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize;
|
2971 |
|
2972 | var totalBytesToCopyRemaining = maxBytesToCopy;
|
2973 | var ready = false;
|
2974 | if (maxAlignedBytes > currentAlignedBytes) {
|
2975 | totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
|
2976 | ready = true;
|
2977 | }
|
2978 |
|
2979 | var queue = controller._queue;
|
2980 |
|
2981 | while (totalBytesToCopyRemaining > 0) {
|
2982 | var headOfQueue = queue[0];
|
2983 |
|
2984 | var bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength);
|
2985 |
|
2986 | var destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
|
2987 | ArrayBufferCopy(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy);
|
2988 |
|
2989 | if (headOfQueue.byteLength === bytesToCopy) {
|
2990 | queue.shift();
|
2991 | } else {
|
2992 | headOfQueue.byteOffset += bytesToCopy;
|
2993 | headOfQueue.byteLength -= bytesToCopy;
|
2994 | }
|
2995 | controller._queueTotalSize -= bytesToCopy;
|
2996 |
|
2997 | ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor);
|
2998 |
|
2999 | totalBytesToCopyRemaining -= bytesToCopy;
|
3000 | }
|
3001 |
|
3002 | if (ready === false) {
|
3003 | assert(controller._queueTotalSize === 0, 'queue must be empty');
|
3004 | assert(pullIntoDescriptor.bytesFilled > 0);
|
3005 | assert(pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize);
|
3006 | }
|
3007 |
|
3008 | return ready;
|
3009 | }
|
3010 |
|
3011 | function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
|
3012 | assert(controller._pendingPullIntos.length === 0 || controller._pendingPullIntos[0] === pullIntoDescriptor);
|
3013 |
|
3014 | ReadableByteStreamControllerInvalidateBYOBRequest(controller);
|
3015 | pullIntoDescriptor.bytesFilled += size;
|
3016 | }
|
3017 |
|
3018 | function ReadableByteStreamControllerHandleQueueDrain(controller) {
|
3019 | assert(controller._controlledReadableStream._state === 'readable');
|
3020 |
|
3021 | if (controller._queueTotalSize === 0 && controller._closeRequested === true) {
|
3022 | ReadableStreamClose(controller._controlledReadableStream);
|
3023 | } else {
|
3024 | ReadableByteStreamControllerCallPullIfNeeded(controller);
|
3025 | }
|
3026 | }
|
3027 |
|
3028 | function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {
|
3029 | if (controller._byobRequest === undefined) {
|
3030 | return;
|
3031 | }
|
3032 |
|
3033 | controller._byobRequest._associatedReadableByteStreamController = undefined;
|
3034 | controller._byobRequest._view = undefined;
|
3035 | controller._byobRequest = undefined;
|
3036 | }
|
3037 |
|
3038 | function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {
|
3039 | assert(controller._closeRequested === false);
|
3040 |
|
3041 | while (controller._pendingPullIntos.length > 0) {
|
3042 | if (controller._queueTotalSize === 0) {
|
3043 | return;
|
3044 | }
|
3045 |
|
3046 | var pullIntoDescriptor = controller._pendingPullIntos[0];
|
3047 |
|
3048 | if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {
|
3049 | ReadableByteStreamControllerShiftPendingPullInto(controller);
|
3050 |
|
3051 | ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableStream, pullIntoDescriptor);
|
3052 | }
|
3053 | }
|
3054 | }
|
3055 |
|
3056 | function ReadableByteStreamControllerPullInto(controller, view) {
|
3057 | var stream = controller._controlledReadableStream;
|
3058 |
|
3059 | var elementSize = 1;
|
3060 | if (view.constructor !== DataView) {
|
3061 | elementSize = view.constructor.BYTES_PER_ELEMENT;
|
3062 | }
|
3063 |
|
3064 | var ctor = view.constructor;
|
3065 |
|
3066 | var pullIntoDescriptor = {
|
3067 | buffer: view.buffer,
|
3068 | byteOffset: view.byteOffset,
|
3069 | byteLength: view.byteLength,
|
3070 | bytesFilled: 0,
|
3071 | elementSize: elementSize,
|
3072 | ctor: ctor,
|
3073 | readerType: 'byob'
|
3074 | };
|
3075 |
|
3076 | if (controller._pendingPullIntos.length > 0) {
|
3077 | pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);
|
3078 | controller._pendingPullIntos.push(pullIntoDescriptor);
|
3079 |
|
3080 |
|
3081 |
|
3082 |
|
3083 |
|
3084 | return ReadableStreamAddReadIntoRequest(stream);
|
3085 | }
|
3086 |
|
3087 | if (stream._state === 'closed') {
|
3088 | var emptyView = new view.constructor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);
|
3089 | return Promise.resolve(CreateIterResultObject(emptyView, true));
|
3090 | }
|
3091 |
|
3092 | if (controller._queueTotalSize > 0) {
|
3093 | if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {
|
3094 | var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
|
3095 |
|
3096 | ReadableByteStreamControllerHandleQueueDrain(controller);
|
3097 |
|
3098 | return Promise.resolve(CreateIterResultObject(filledView, false));
|
3099 | }
|
3100 |
|
3101 | if (controller._closeRequested === true) {
|
3102 | var e = new TypeError('Insufficient bytes to fill elements in the given buffer');
|
3103 | ReadableByteStreamControllerError(controller, e);
|
3104 |
|
3105 | return Promise.reject(e);
|
3106 | }
|
3107 | }
|
3108 |
|
3109 | pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);
|
3110 | controller._pendingPullIntos.push(pullIntoDescriptor);
|
3111 |
|
3112 | var promise = ReadableStreamAddReadIntoRequest(stream);
|
3113 |
|
3114 | ReadableByteStreamControllerCallPullIfNeeded(controller);
|
3115 |
|
3116 | return promise;
|
3117 | }
|
3118 |
|
3119 | function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
|
3120 | firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
|
3121 |
|
3122 | assert(firstDescriptor.bytesFilled === 0, 'bytesFilled must be 0');
|
3123 |
|
3124 | var stream = controller._controlledReadableStream;
|
3125 | if (ReadableStreamHasBYOBReader(stream) === true) {
|
3126 | while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
|
3127 | var pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);
|
3128 | ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);
|
3129 | }
|
3130 | }
|
3131 | }
|
3132 |
|
3133 | function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
|
3134 | if (pullIntoDescriptor.bytesFilled + bytesWritten > pullIntoDescriptor.byteLength) {
|
3135 | throw new RangeError('bytesWritten out of range');
|
3136 | }
|
3137 |
|
3138 | ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
|
3139 |
|
3140 | if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {
|
3141 |
|
3142 | return;
|
3143 | }
|
3144 |
|
3145 | ReadableByteStreamControllerShiftPendingPullInto(controller);
|
3146 |
|
3147 | var remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
|
3148 | if (remainderSize > 0) {
|
3149 | var end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
|
3150 | var remainder = pullIntoDescriptor.buffer.slice(end - remainderSize, end);
|
3151 | ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);
|
3152 | }
|
3153 |
|
3154 | pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);
|
3155 | pullIntoDescriptor.bytesFilled -= remainderSize;
|
3156 | ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableStream, pullIntoDescriptor);
|
3157 |
|
3158 | ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
|
3159 | }
|
3160 |
|
3161 | function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
|
3162 | var firstDescriptor = controller._pendingPullIntos[0];
|
3163 |
|
3164 | var stream = controller._controlledReadableStream;
|
3165 |
|
3166 | if (stream._state === 'closed') {
|
3167 | if (bytesWritten !== 0) {
|
3168 | throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream');
|
3169 | }
|
3170 |
|
3171 | ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
|
3172 | } else {
|
3173 | assert(stream._state === 'readable');
|
3174 |
|
3175 | ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
|
3176 | }
|
3177 | }
|
3178 |
|
3179 | function ReadableByteStreamControllerShiftPendingPullInto(controller) {
|
3180 | var descriptor = controller._pendingPullIntos.shift();
|
3181 | ReadableByteStreamControllerInvalidateBYOBRequest(controller);
|
3182 | return descriptor;
|
3183 | }
|
3184 |
|
3185 | function ReadableByteStreamControllerShouldCallPull(controller) {
|
3186 | var stream = controller._controlledReadableStream;
|
3187 |
|
3188 | if (stream._state !== 'readable') {
|
3189 | return false;
|
3190 | }
|
3191 |
|
3192 | if (controller._closeRequested === true) {
|
3193 | return false;
|
3194 | }
|
3195 |
|
3196 | if (controller._started === false) {
|
3197 | return false;
|
3198 | }
|
3199 |
|
3200 | if (ReadableStreamHasDefaultReader(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
|
3201 | return true;
|
3202 | }
|
3203 |
|
3204 | if (ReadableStreamHasBYOBReader(stream) === true && ReadableStreamGetNumReadIntoRequests(stream) > 0) {
|
3205 | return true;
|
3206 | }
|
3207 |
|
3208 | if (ReadableByteStreamControllerGetDesiredSize(controller) > 0) {
|
3209 | return true;
|
3210 | }
|
3211 |
|
3212 | return false;
|
3213 | }
|
3214 |
|
3215 |
|
3216 |
|
3217 | function ReadableByteStreamControllerClose(controller) {
|
3218 | var stream = controller._controlledReadableStream;
|
3219 |
|
3220 | assert(controller._closeRequested === false);
|
3221 | assert(stream._state === 'readable');
|
3222 |
|
3223 | if (controller._queueTotalSize > 0) {
|
3224 | controller._closeRequested = true;
|
3225 |
|
3226 | return;
|
3227 | }
|
3228 |
|
3229 | if (controller._pendingPullIntos.length > 0) {
|
3230 | var firstPendingPullInto = controller._pendingPullIntos[0];
|
3231 | if (firstPendingPullInto.bytesFilled > 0) {
|
3232 | var e = new TypeError('Insufficient bytes to fill elements in the given buffer');
|
3233 | ReadableByteStreamControllerError(controller, e);
|
3234 |
|
3235 | throw e;
|
3236 | }
|
3237 | }
|
3238 |
|
3239 | ReadableStreamClose(stream);
|
3240 | }
|
3241 |
|
3242 | function ReadableByteStreamControllerEnqueue(controller, chunk) {
|
3243 | var stream = controller._controlledReadableStream;
|
3244 |
|
3245 | assert(controller._closeRequested === false);
|
3246 | assert(stream._state === 'readable');
|
3247 |
|
3248 | var buffer = chunk.buffer;
|
3249 | var byteOffset = chunk.byteOffset;
|
3250 | var byteLength = chunk.byteLength;
|
3251 | var transferredBuffer = TransferArrayBuffer(buffer);
|
3252 |
|
3253 | if (ReadableStreamHasDefaultReader(stream) === true) {
|
3254 | if (ReadableStreamGetNumReadRequests(stream) === 0) {
|
3255 | ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
|
3256 | } else {
|
3257 | assert(controller._queue.length === 0);
|
3258 |
|
3259 | var transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);
|
3260 | ReadableStreamFulfillReadRequest(stream, transferredView, false);
|
3261 | }
|
3262 | } else if (ReadableStreamHasBYOBReader(stream) === true) {
|
3263 |
|
3264 | ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
|
3265 | ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
|
3266 | } else {
|
3267 | assert(IsReadableStreamLocked(stream) === false, 'stream must not be locked');
|
3268 | ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
|
3269 | }
|
3270 | }
|
3271 |
|
3272 | function ReadableByteStreamControllerError(controller, e) {
|
3273 | var stream = controller._controlledReadableStream;
|
3274 |
|
3275 | assert(stream._state === 'readable');
|
3276 |
|
3277 | ReadableByteStreamControllerClearPendingPullIntos(controller);
|
3278 |
|
3279 | ResetQueue(controller);
|
3280 | ReadableStreamError(stream, e);
|
3281 | }
|
3282 |
|
3283 | function ReadableByteStreamControllerGetDesiredSize(controller) {
|
3284 | var stream = controller._controlledReadableStream;
|
3285 | var state = stream._state;
|
3286 |
|
3287 | if (state === 'errored') {
|
3288 | return null;
|
3289 | }
|
3290 | if (state === 'closed') {
|
3291 | return 0;
|
3292 | }
|
3293 |
|
3294 | return controller._strategyHWM - controller._queueTotalSize;
|
3295 | }
|
3296 |
|
3297 | function ReadableByteStreamControllerRespond(controller, bytesWritten) {
|
3298 | bytesWritten = Number(bytesWritten);
|
3299 | if (IsFiniteNonNegativeNumber(bytesWritten) === false) {
|
3300 | throw new RangeError('bytesWritten must be a finite');
|
3301 | }
|
3302 |
|
3303 | assert(controller._pendingPullIntos.length > 0);
|
3304 |
|
3305 | ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
|
3306 | }
|
3307 |
|
3308 | function ReadableByteStreamControllerRespondWithNewView(controller, view) {
|
3309 | assert(controller._pendingPullIntos.length > 0);
|
3310 |
|
3311 | var firstDescriptor = controller._pendingPullIntos[0];
|
3312 |
|
3313 | if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) {
|
3314 | throw new RangeError('The region specified by view does not match byobRequest');
|
3315 | }
|
3316 | if (firstDescriptor.byteLength !== view.byteLength) {
|
3317 | throw new RangeError('The buffer of view has different capacity than byobRequest');
|
3318 | }
|
3319 |
|
3320 | firstDescriptor.buffer = view.buffer;
|
3321 |
|
3322 | ReadableByteStreamControllerRespondInternal(controller, view.byteLength);
|
3323 | }
|
3324 |
|
3325 |
|
3326 |
|
3327 | function streamBrandCheckException(name) {
|
3328 | return new TypeError('ReadableStream.prototype.' + name + ' can only be used on a ReadableStream');
|
3329 | }
|
3330 |
|
3331 |
|
3332 |
|
3333 | function readerLockException(name) {
|
3334 | return new TypeError('Cannot ' + name + ' a stream using a released reader');
|
3335 | }
|
3336 |
|
3337 |
|
3338 |
|
3339 | function defaultReaderBrandCheckException(name) {
|
3340 | return new TypeError('ReadableStreamDefaultReader.prototype.' + name + ' can only be used on a ReadableStreamDefaultReader');
|
3341 | }
|
3342 |
|
3343 | function defaultReaderClosedPromiseInitialize(reader) {
|
3344 | reader._closedPromise = new Promise(function (resolve, reject) {
|
3345 | reader._closedPromise_resolve = resolve;
|
3346 | reader._closedPromise_reject = reject;
|
3347 | });
|
3348 | }
|
3349 |
|
3350 | function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
|
3351 | reader._closedPromise = Promise.reject(reason);
|
3352 | reader._closedPromise_resolve = undefined;
|
3353 | reader._closedPromise_reject = undefined;
|
3354 | }
|
3355 |
|
3356 | function defaultReaderClosedPromiseInitializeAsResolved(reader) {
|
3357 | reader._closedPromise = Promise.resolve(undefined);
|
3358 | reader._closedPromise_resolve = undefined;
|
3359 | reader._closedPromise_reject = undefined;
|
3360 | }
|
3361 |
|
3362 | function defaultReaderClosedPromiseReject(reader, reason) {
|
3363 | assert(reader._closedPromise_resolve !== undefined);
|
3364 | assert(reader._closedPromise_reject !== undefined);
|
3365 |
|
3366 | reader._closedPromise_reject(reason);
|
3367 | reader._closedPromise_resolve = undefined;
|
3368 | reader._closedPromise_reject = undefined;
|
3369 | }
|
3370 |
|
3371 | function defaultReaderClosedPromiseResetToRejected(reader, reason) {
|
3372 | assert(reader._closedPromise_resolve === undefined);
|
3373 | assert(reader._closedPromise_reject === undefined);
|
3374 |
|
3375 | reader._closedPromise = Promise.reject(reason);
|
3376 | }
|
3377 |
|
3378 | function defaultReaderClosedPromiseResolve(reader) {
|
3379 | assert(reader._closedPromise_resolve !== undefined);
|
3380 | assert(reader._closedPromise_reject !== undefined);
|
3381 |
|
3382 | reader._closedPromise_resolve(undefined);
|
3383 | reader._closedPromise_resolve = undefined;
|
3384 | reader._closedPromise_reject = undefined;
|
3385 | }
|
3386 |
|
3387 |
|
3388 |
|
3389 | function byobReaderBrandCheckException(name) {
|
3390 | return new TypeError('ReadableStreamBYOBReader.prototype.' + name + ' can only be used on a ReadableStreamBYOBReader');
|
3391 | }
|
3392 |
|
3393 |
|
3394 |
|
3395 | function defaultControllerBrandCheckException(name) {
|
3396 | return new TypeError('ReadableStreamDefaultController.prototype.' + name + ' can only be used on a ReadableStreamDefaultController');
|
3397 | }
|
3398 |
|
3399 |
|
3400 |
|
3401 | function byobRequestBrandCheckException(name) {
|
3402 | return new TypeError('ReadableStreamBYOBRequest.prototype.' + name + ' can only be used on a ReadableStreamBYOBRequest');
|
3403 | }
|
3404 |
|
3405 |
|
3406 |
|
3407 | function byteStreamControllerBrandCheckException(name) {
|
3408 | return new TypeError('ReadableByteStreamController.prototype.' + name + ' can only be used on a ReadableByteStreamController');
|
3409 | }
|
3410 |
|
3411 |
|
3412 |
|
3413 | function ifIsObjectAndHasAPromiseIsHandledInternalSlotSetPromiseIsHandledToTrue(promise) {
|
3414 | try {
|
3415 |
|
3416 |
|
3417 | Promise.prototype.then.call(promise, undefined, function () {});
|
3418 | } catch (e) {
|
3419 |
|
3420 | }
|
3421 | }
|
3422 |
|
3423 | }),
|
3424 |
|
3425 | (function(module, exports, __webpack_require__) {
|
3426 |
|
3427 | "use strict";
|
3428 |
|
3429 |
|
3430 | var transformStream = __webpack_require__(6);
|
3431 | var readableStream = __webpack_require__(4);
|
3432 | var writableStream = __webpack_require__(2);
|
3433 |
|
3434 | exports.TransformStream = transformStream.TransformStream;
|
3435 | exports.ReadableStream = readableStream.ReadableStream;
|
3436 | exports.IsReadableStreamDisturbed = readableStream.IsReadableStreamDisturbed;
|
3437 | exports.ReadableStreamDefaultControllerClose = readableStream.ReadableStreamDefaultControllerClose;
|
3438 | exports.ReadableStreamDefaultControllerEnqueue = readableStream.ReadableStreamDefaultControllerEnqueue;
|
3439 | exports.ReadableStreamDefaultControllerError = readableStream.ReadableStreamDefaultControllerError;
|
3440 | exports.ReadableStreamDefaultControllerGetDesiredSize = readableStream.ReadableStreamDefaultControllerGetDesiredSize;
|
3441 | exports.AcquireWritableStreamDefaultWriter = writableStream.AcquireWritableStreamDefaultWriter;
|
3442 | exports.IsWritableStream = writableStream.IsWritableStream;
|
3443 | exports.IsWritableStreamLocked = writableStream.IsWritableStreamLocked;
|
3444 | exports.WritableStream = writableStream.WritableStream;
|
3445 | exports.WritableStreamAbort = writableStream.WritableStreamAbort;
|
3446 | exports.WritableStreamDefaultControllerError = writableStream.WritableStreamDefaultControllerError;
|
3447 | exports.WritableStreamDefaultWriterCloseWithErrorPropagation = writableStream.WritableStreamDefaultWriterCloseWithErrorPropagation;
|
3448 | exports.WritableStreamDefaultWriterRelease = writableStream.WritableStreamDefaultWriterRelease;
|
3449 | exports.WritableStreamDefaultWriterWrite = writableStream.WritableStreamDefaultWriterWrite;
|
3450 |
|
3451 | }),
|
3452 |
|
3453 | (function(module, exports, __webpack_require__) {
|
3454 |
|
3455 | "use strict";
|
3456 |
|
3457 |
|
3458 | var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
3459 |
|
3460 | function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
3461 |
|
3462 | var _require = __webpack_require__(1),
|
3463 | assert = _require.assert;
|
3464 |
|
3465 | var _require2 = __webpack_require__(0),
|
3466 | InvokeOrNoop = _require2.InvokeOrNoop,
|
3467 | PromiseInvokeOrPerformFallback = _require2.PromiseInvokeOrPerformFallback,
|
3468 | PromiseInvokeOrNoop = _require2.PromiseInvokeOrNoop,
|
3469 | typeIsObject = _require2.typeIsObject;
|
3470 |
|
3471 | var _require3 = __webpack_require__(4),
|
3472 | ReadableStream = _require3.ReadableStream,
|
3473 | ReadableStreamDefaultControllerClose = _require3.ReadableStreamDefaultControllerClose,
|
3474 | ReadableStreamDefaultControllerEnqueue = _require3.ReadableStreamDefaultControllerEnqueue,
|
3475 | ReadableStreamDefaultControllerError = _require3.ReadableStreamDefaultControllerError,
|
3476 | ReadableStreamDefaultControllerGetDesiredSize = _require3.ReadableStreamDefaultControllerGetDesiredSize;
|
3477 |
|
3478 | var _require4 = __webpack_require__(2),
|
3479 | WritableStream = _require4.WritableStream,
|
3480 | WritableStreamDefaultControllerError = _require4.WritableStreamDefaultControllerError;
|
3481 |
|
3482 |
|
3483 |
|
3484 | function TransformStreamCloseReadable(transformStream) {
|
3485 |
|
3486 |
|
3487 | if (transformStream._errored === true) {
|
3488 | throw new TypeError('TransformStream is already errored');
|
3489 | }
|
3490 |
|
3491 | if (transformStream._readableClosed === true) {
|
3492 | throw new TypeError('Readable side is already closed');
|
3493 | }
|
3494 |
|
3495 | TransformStreamCloseReadableInternal(transformStream);
|
3496 | }
|
3497 |
|
3498 | function TransformStreamEnqueueToReadable(transformStream, chunk) {
|
3499 |
|
3500 |
|
3501 | if (transformStream._errored === true) {
|
3502 | throw new TypeError('TransformStream is already errored');
|
3503 | }
|
3504 |
|
3505 | if (transformStream._readableClosed === true) {
|
3506 | throw new TypeError('Readable side is already closed');
|
3507 | }
|
3508 |
|
3509 |
|
3510 |
|
3511 |
|
3512 | var controller = transformStream._readableController;
|
3513 |
|
3514 | try {
|
3515 | ReadableStreamDefaultControllerEnqueue(controller, chunk);
|
3516 | } catch (e) {
|
3517 |
|
3518 |
|
3519 | transformStream._readableClosed = true;
|
3520 | TransformStreamErrorIfNeeded(transformStream, e);
|
3521 |
|
3522 | throw transformStream._storedError;
|
3523 | }
|
3524 |
|
3525 | var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
|
3526 | var maybeBackpressure = desiredSize <= 0;
|
3527 |
|
3528 | if (maybeBackpressure === true && transformStream._backpressure === false) {
|
3529 |
|
3530 |
|
3531 |
|
3532 |
|
3533 |
|
3534 | TransformStreamSetBackpressure(transformStream, true);
|
3535 | }
|
3536 | }
|
3537 |
|
3538 | function TransformStreamError(transformStream, e) {
|
3539 | if (transformStream._errored === true) {
|
3540 | throw new TypeError('TransformStream is already errored');
|
3541 | }
|
3542 |
|
3543 | TransformStreamErrorInternal(transformStream, e);
|
3544 | }
|
3545 |
|
3546 |
|
3547 |
|
3548 | function TransformStreamCloseReadableInternal(transformStream) {
|
3549 | assert(transformStream._errored === false);
|
3550 | assert(transformStream._readableClosed === false);
|
3551 |
|
3552 | try {
|
3553 | ReadableStreamDefaultControllerClose(transformStream._readableController);
|
3554 | } catch (e) {
|
3555 | assert(false);
|
3556 | }
|
3557 |
|
3558 | transformStream._readableClosed = true;
|
3559 | }
|
3560 |
|
3561 | function TransformStreamErrorIfNeeded(transformStream, e) {
|
3562 | if (transformStream._errored === false) {
|
3563 | TransformStreamErrorInternal(transformStream, e);
|
3564 | }
|
3565 | }
|
3566 |
|
3567 | function TransformStreamErrorInternal(transformStream, e) {
|
3568 |
|
3569 |
|
3570 | assert(transformStream._errored === false);
|
3571 |
|
3572 | transformStream._errored = true;
|
3573 | transformStream._storedError = e;
|
3574 |
|
3575 | if (transformStream._writableDone === false) {
|
3576 | WritableStreamDefaultControllerError(transformStream._writableController, e);
|
3577 | }
|
3578 | if (transformStream._readableClosed === false) {
|
3579 | ReadableStreamDefaultControllerError(transformStream._readableController, e);
|
3580 | }
|
3581 | }
|
3582 |
|
3583 |
|
3584 |
|
3585 | function TransformStreamReadableReadyPromise(transformStream) {
|
3586 | assert(transformStream._backpressureChangePromise !== undefined, '_backpressureChangePromise should have been initialized');
|
3587 |
|
3588 | if (transformStream._backpressure === false) {
|
3589 | return Promise.resolve();
|
3590 | }
|
3591 |
|
3592 | assert(transformStream._backpressure === true, '_backpressure should have been initialized');
|
3593 |
|
3594 | return transformStream._backpressureChangePromise;
|
3595 | }
|
3596 |
|
3597 | function TransformStreamSetBackpressure(transformStream, backpressure) {
|
3598 |
|
3599 |
|
3600 |
|
3601 | assert(transformStream._backpressure !== backpressure, 'TransformStreamSetBackpressure() should be called only when backpressure is changed');
|
3602 |
|
3603 | if (transformStream._backpressureChangePromise !== undefined) {
|
3604 |
|
3605 | transformStream._backpressureChangePromise_resolve(backpressure);
|
3606 | }
|
3607 |
|
3608 | transformStream._backpressureChangePromise = new Promise(function (resolve) {
|
3609 | transformStream._backpressureChangePromise_resolve = resolve;
|
3610 | });
|
3611 |
|
3612 | transformStream._backpressureChangePromise.then(function (resolution) {
|
3613 | assert(resolution !== backpressure, '_backpressureChangePromise should be fulfilled only when backpressure is changed');
|
3614 | });
|
3615 |
|
3616 | transformStream._backpressure = backpressure;
|
3617 | }
|
3618 |
|
3619 | function TransformStreamDefaultTransform(chunk, transformStreamController) {
|
3620 | var transformStream = transformStreamController._controlledTransformStream;
|
3621 | TransformStreamEnqueueToReadable(transformStream, chunk);
|
3622 | return Promise.resolve();
|
3623 | }
|
3624 |
|
3625 | function TransformStreamTransform(transformStream, chunk) {
|
3626 |
|
3627 |
|
3628 | assert(transformStream._errored === false);
|
3629 | assert(transformStream._transforming === false);
|
3630 | assert(transformStream._backpressure === false);
|
3631 |
|
3632 | transformStream._transforming = true;
|
3633 |
|
3634 | var transformer = transformStream._transformer;
|
3635 | var controller = transformStream._transformStreamController;
|
3636 |
|
3637 | var transformPromise = PromiseInvokeOrPerformFallback(transformer, 'transform', [chunk, controller], TransformStreamDefaultTransform, [chunk, controller]);
|
3638 |
|
3639 | return transformPromise.then(function () {
|
3640 | transformStream._transforming = false;
|
3641 |
|
3642 | return TransformStreamReadableReadyPromise(transformStream);
|
3643 | }, function (e) {
|
3644 | TransformStreamErrorIfNeeded(transformStream, e);
|
3645 | return Promise.reject(e);
|
3646 | });
|
3647 | }
|
3648 |
|
3649 | function IsTransformStreamDefaultController(x) {
|
3650 | if (!typeIsObject(x)) {
|
3651 | return false;
|
3652 | }
|
3653 |
|
3654 | if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) {
|
3655 | return false;
|
3656 | }
|
3657 |
|
3658 | return true;
|
3659 | }
|
3660 |
|
3661 | function IsTransformStream(x) {
|
3662 | if (!typeIsObject(x)) {
|
3663 | return false;
|
3664 | }
|
3665 |
|
3666 | if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) {
|
3667 | return false;
|
3668 | }
|
3669 |
|
3670 | return true;
|
3671 | }
|
3672 |
|
3673 | var TransformStreamSink = function () {
|
3674 | function TransformStreamSink(transformStream, startPromise) {
|
3675 | _classCallCheck(this, TransformStreamSink);
|
3676 |
|
3677 | this._transformStream = transformStream;
|
3678 | this._startPromise = startPromise;
|
3679 | }
|
3680 |
|
3681 | _createClass(TransformStreamSink, [{
|
3682 | key: 'start',
|
3683 | value: function start(c) {
|
3684 | var transformStream = this._transformStream;
|
3685 |
|
3686 | transformStream._writableController = c;
|
3687 |
|
3688 | return this._startPromise.then(function () {
|
3689 | return TransformStreamReadableReadyPromise(transformStream);
|
3690 | });
|
3691 | }
|
3692 | }, {
|
3693 | key: 'write',
|
3694 | value: function write(chunk) {
|
3695 |
|
3696 |
|
3697 | var transformStream = this._transformStream;
|
3698 |
|
3699 | return TransformStreamTransform(transformStream, chunk);
|
3700 | }
|
3701 | }, {
|
3702 | key: 'abort',
|
3703 | value: function abort() {
|
3704 | var transformStream = this._transformStream;
|
3705 | transformStream._writableDone = true;
|
3706 | TransformStreamErrorInternal(transformStream, new TypeError('Writable side aborted'));
|
3707 | }
|
3708 | }, {
|
3709 | key: 'close',
|
3710 | value: function close() {
|
3711 |
|
3712 |
|
3713 | var transformStream = this._transformStream;
|
3714 |
|
3715 | assert(transformStream._transforming === false);
|
3716 |
|
3717 | transformStream._writableDone = true;
|
3718 |
|
3719 | var flushPromise = PromiseInvokeOrNoop(transformStream._transformer, 'flush', [transformStream._transformStreamController]);
|
3720 |
|
3721 | return flushPromise.then(function () {
|
3722 | if (transformStream._errored === true) {
|
3723 | return Promise.reject(transformStream._storedError);
|
3724 | }
|
3725 | if (transformStream._readableClosed === false) {
|
3726 | TransformStreamCloseReadableInternal(transformStream);
|
3727 | }
|
3728 | return Promise.resolve();
|
3729 | }).catch(function (r) {
|
3730 | TransformStreamErrorIfNeeded(transformStream, r);
|
3731 | return Promise.reject(transformStream._storedError);
|
3732 | });
|
3733 | }
|
3734 | }]);
|
3735 |
|
3736 | return TransformStreamSink;
|
3737 | }();
|
3738 |
|
3739 | var TransformStreamSource = function () {
|
3740 | function TransformStreamSource(transformStream, startPromise) {
|
3741 | _classCallCheck(this, TransformStreamSource);
|
3742 |
|
3743 | this._transformStream = transformStream;
|
3744 | this._startPromise = startPromise;
|
3745 | }
|
3746 |
|
3747 | _createClass(TransformStreamSource, [{
|
3748 | key: 'start',
|
3749 | value: function start(c) {
|
3750 | var transformStream = this._transformStream;
|
3751 |
|
3752 | transformStream._readableController = c;
|
3753 |
|
3754 | return this._startPromise.then(function () {
|
3755 |
|
3756 |
|
3757 | assert(transformStream._backpressureChangePromise !== undefined, '_backpressureChangePromise should have been initialized');
|
3758 |
|
3759 | if (transformStream._backpressure === true) {
|
3760 | return Promise.resolve();
|
3761 | }
|
3762 |
|
3763 | assert(transformStream._backpressure === false, '_backpressure should have been initialized');
|
3764 |
|
3765 | return transformStream._backpressureChangePromise;
|
3766 | });
|
3767 | }
|
3768 | }, {
|
3769 | key: 'pull',
|
3770 | value: function pull() {
|
3771 |
|
3772 |
|
3773 | var transformStream = this._transformStream;
|
3774 |
|
3775 |
|
3776 | assert(transformStream._backpressure === true, 'pull() should be never called while _backpressure is false');
|
3777 |
|
3778 | assert(transformStream._backpressureChangePromise !== undefined, '_backpressureChangePromise should have been initialized');
|
3779 |
|
3780 | TransformStreamSetBackpressure(transformStream, false);
|
3781 |
|
3782 |
|
3783 | return transformStream._backpressureChangePromise;
|
3784 | }
|
3785 | }, {
|
3786 | key: 'cancel',
|
3787 | value: function cancel() {
|
3788 | var transformStream = this._transformStream;
|
3789 | transformStream._readableClosed = true;
|
3790 | TransformStreamErrorInternal(transformStream, new TypeError('Readable side canceled'));
|
3791 | }
|
3792 | }]);
|
3793 |
|
3794 | return TransformStreamSource;
|
3795 | }();
|
3796 |
|
3797 | var TransformStreamDefaultController = function () {
|
3798 | function TransformStreamDefaultController(transformStream) {
|
3799 | _classCallCheck(this, TransformStreamDefaultController);
|
3800 |
|
3801 | if (IsTransformStream(transformStream) === false) {
|
3802 | throw new TypeError('TransformStreamDefaultController can only be ' + 'constructed with a TransformStream instance');
|
3803 | }
|
3804 |
|
3805 | if (transformStream._transformStreamController !== undefined) {
|
3806 | throw new TypeError('TransformStreamDefaultController instances can ' + 'only be created by the TransformStream constructor');
|
3807 | }
|
3808 |
|
3809 | this._controlledTransformStream = transformStream;
|
3810 | }
|
3811 |
|
3812 | _createClass(TransformStreamDefaultController, [{
|
3813 | key: 'enqueue',
|
3814 | value: function enqueue(chunk) {
|
3815 | if (IsTransformStreamDefaultController(this) === false) {
|
3816 | throw defaultControllerBrandCheckException('enqueue');
|
3817 | }
|
3818 |
|
3819 | TransformStreamEnqueueToReadable(this._controlledTransformStream, chunk);
|
3820 | }
|
3821 | }, {
|
3822 | key: 'close',
|
3823 | value: function close() {
|
3824 | if (IsTransformStreamDefaultController(this) === false) {
|
3825 | throw defaultControllerBrandCheckException('close');
|
3826 | }
|
3827 |
|
3828 | TransformStreamCloseReadable(this._controlledTransformStream);
|
3829 | }
|
3830 | }, {
|
3831 | key: 'error',
|
3832 | value: function error(reason) {
|
3833 | if (IsTransformStreamDefaultController(this) === false) {
|
3834 | throw defaultControllerBrandCheckException('error');
|
3835 | }
|
3836 |
|
3837 | TransformStreamError(this._controlledTransformStream, reason);
|
3838 | }
|
3839 | }, {
|
3840 | key: 'desiredSize',
|
3841 | get: function get() {
|
3842 | if (IsTransformStreamDefaultController(this) === false) {
|
3843 | throw defaultControllerBrandCheckException('desiredSize');
|
3844 | }
|
3845 |
|
3846 | var transformStream = this._controlledTransformStream;
|
3847 | var readableController = transformStream._readableController;
|
3848 |
|
3849 | return ReadableStreamDefaultControllerGetDesiredSize(readableController);
|
3850 | }
|
3851 | }]);
|
3852 |
|
3853 | return TransformStreamDefaultController;
|
3854 | }();
|
3855 |
|
3856 | var TransformStream = function () {
|
3857 | function TransformStream() {
|
3858 | var transformer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
3859 |
|
3860 | _classCallCheck(this, TransformStream);
|
3861 |
|
3862 | this._transformer = transformer;
|
3863 | var readableStrategy = transformer.readableStrategy,
|
3864 | writableStrategy = transformer.writableStrategy;
|
3865 |
|
3866 |
|
3867 | this._transforming = false;
|
3868 | this._errored = false;
|
3869 | this._storedError = undefined;
|
3870 |
|
3871 | this._writableController = undefined;
|
3872 | this._readableController = undefined;
|
3873 | this._transformStreamController = undefined;
|
3874 |
|
3875 | this._writableDone = false;
|
3876 | this._readableClosed = false;
|
3877 |
|
3878 | this._backpressure = undefined;
|
3879 | this._backpressureChangePromise = undefined;
|
3880 | this._backpressureChangePromise_resolve = undefined;
|
3881 |
|
3882 | this._transformStreamController = new TransformStreamDefaultController(this);
|
3883 |
|
3884 | var startPromise_resolve = void 0;
|
3885 | var startPromise = new Promise(function (resolve) {
|
3886 | startPromise_resolve = resolve;
|
3887 | });
|
3888 |
|
3889 | var source = new TransformStreamSource(this, startPromise);
|
3890 |
|
3891 | this._readable = new ReadableStream(source, readableStrategy);
|
3892 |
|
3893 | var sink = new TransformStreamSink(this, startPromise);
|
3894 |
|
3895 | this._writable = new WritableStream(sink, writableStrategy);
|
3896 |
|
3897 | assert(this._writableController !== undefined);
|
3898 | assert(this._readableController !== undefined);
|
3899 |
|
3900 | var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(this._readableController);
|
3901 |
|
3902 |
|
3903 | TransformStreamSetBackpressure(this, desiredSize <= 0);
|
3904 |
|
3905 | var transformStream = this;
|
3906 | var startResult = InvokeOrNoop(transformer, 'start', [transformStream._transformStreamController]);
|
3907 | startPromise_resolve(startResult);
|
3908 | startPromise.catch(function (e) {
|
3909 |
|
3910 | if (transformStream._errored === false) {
|
3911 | transformStream._errored = true;
|
3912 | transformStream._storedError = e;
|
3913 | }
|
3914 | });
|
3915 | }
|
3916 |
|
3917 | _createClass(TransformStream, [{
|
3918 | key: 'readable',
|
3919 | get: function get() {
|
3920 | if (IsTransformStream(this) === false) {
|
3921 | throw streamBrandCheckException('readable');
|
3922 | }
|
3923 |
|
3924 | return this._readable;
|
3925 | }
|
3926 | }, {
|
3927 | key: 'writable',
|
3928 | get: function get() {
|
3929 | if (IsTransformStream(this) === false) {
|
3930 | throw streamBrandCheckException('writable');
|
3931 | }
|
3932 |
|
3933 | return this._writable;
|
3934 | }
|
3935 | }]);
|
3936 |
|
3937 | return TransformStream;
|
3938 | }();
|
3939 |
|
3940 | module.exports = { TransformStream: TransformStream };
|
3941 |
|
3942 |
|
3943 |
|
3944 | function defaultControllerBrandCheckException(name) {
|
3945 | return new TypeError('TransformStreamDefaultController.prototype.' + name + ' can only be used on a TransformStreamDefaultController');
|
3946 | }
|
3947 |
|
3948 |
|
3949 |
|
3950 | function streamBrandCheckException(name) {
|
3951 | return new TypeError('TransformStream.prototype.' + name + ' can only be used on a TransformStream');
|
3952 | }
|
3953 |
|
3954 | }),
|
3955 |
|
3956 | (function(module, exports, __webpack_require__) {
|
3957 |
|
3958 | module.exports = __webpack_require__(5);
|
3959 |
|
3960 |
|
3961 | })
|
3962 | ]))); |
\ | No newline at end of file |