☰

web-streams-polyfill

Web Streams, based on the WHATWG spec reference implementation

This script should not be not be installed directly. It is a library for other scripts to include with the meta directive // @require https://update.greatest.deepsurf.us/scripts/29319/191261/web-streams-polyfill.js 

  1. (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.default = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
  2. 'use strict';
  3.  
  4. Object.defineProperty(exports, "__esModule", {
  5.   value: true
  6. });
  7.  
  8. var _require = _dereq_('./spec/reference-implementation/lib/readable-stream');
  9.  
  10. var ReadableStream = _require.ReadableStream;
  11.  
  12. var _require2 = _dereq_('./spec/reference-implementation/lib/writable-stream');
  13.  
  14. var WritableStream = _require2.WritableStream,
  15.     ByteLengthQueuingStrategy = _dereq_('./spec/reference-implementation/lib/byte-length-queuing-strategy'),
  16.     CountQueuingStrategy = _dereq_('./spec/reference-implementation/lib/count-queuing-strategy'),
  17.     TransformStream = _dereq_('./spec/reference-implementation/lib/transform-stream').TransformStream;
  18. exports.ByteLengthQueuingStrategy = ByteLengthQueuingStrategy;
  19. exports.CountQueuingStrategy = CountQueuingStrategy;
  20. exports.TransformStream = TransformStream;
  21. exports.ReadableStream = ReadableStream;
  22. exports.WritableStream = WritableStream;
  23.  
  24.  
  25. var interfaces = {
  26.   ReadableStream: ReadableStream,
  27.   WritableStream: WritableStream,
  28.   ByteLengthQueuingStrategy: ByteLengthQueuingStrategy,
  29.   CountQueuingStrategy: CountQueuingStrategy,
  30.   TransformStream: TransformStream
  31. };
  32.  
  33. // Export
  34. exports.default = interfaces;
  35.  
  36. // Add classes to window
  37.  
  38. if (typeof window !== "undefined") Object.assign(window, interfaces);
  39.  
  40. },{"./spec/reference-implementation/lib/byte-length-queuing-strategy":7,"./spec/reference-implementation/lib/count-queuing-strategy":8,"./spec/reference-implementation/lib/readable-stream":11,"./spec/reference-implementation/lib/transform-stream":12,"./spec/reference-implementation/lib/writable-stream":14}],2:[function(_dereq_,module,exports){
  41. // http://wiki.commonjs.org/wiki/Unit_Testing/1.0
  42. //
  43. // THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
  44. //
  45. // Originally from narwhal.js (http://narwhaljs.org)
  46. // Copyright (c) 2009 Thomas Robinson <280north.com>
  47. //
  48. // Permission is hereby granted, free of charge, to any person obtaining a copy
  49. // of this software and associated documentation files (the 'Software'), to
  50. // deal in the Software without restriction, including without limitation the
  51. // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  52. // sell copies of the Software, and to permit persons to whom the Software is
  53. // furnished to do so, subject to the following conditions:
  54. //
  55. // The above copyright notice and this permission notice shall be included in
  56. // all copies or substantial portions of the Software.
  57. //
  58. // THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  59. // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  60. // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  61. // AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  62. // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  63. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  64.  
  65. // when used in node, this will actually load the util module we depend on
  66. // versus loading the builtin util module as happens otherwise
  67. // this is a bug in node module loading as far as I am concerned
  68. var util = _dereq_('util/');
  69.  
  70. var pSlice = Array.prototype.slice;
  71. var hasOwn = Object.prototype.hasOwnProperty;
  72.  
  73. // 1. The assert module provides functions that throw
  74. // AssertionError's when particular conditions are not met. The
  75. // assert module must conform to the following interface.
  76.  
  77. var assert = module.exports = ok;
  78.  
  79. // 2. The AssertionError is defined in assert.
  80. // new assert.AssertionError({ message: message,
  81. //                             actual: actual,
  82. //                             expected: expected })
  83.  
  84. assert.AssertionError = function AssertionError(options) {
  85.   this.name = 'AssertionError';
  86.   this.actual = options.actual;
  87.   this.expected = options.expected;
  88.   this.operator = options.operator;
  89.   if (options.message) {
  90.     this.message = options.message;
  91.     this.generatedMessage = false;
  92.   } else {
  93.     this.message = getMessage(this);
  94.     this.generatedMessage = true;
  95.   }
  96.   var stackStartFunction = options.stackStartFunction || fail;
  97.  
  98.   if (Error.captureStackTrace) {
  99.     Error.captureStackTrace(this, stackStartFunction);
  100.   }
  101.   else {
  102.     // non v8 browsers so we can have a stacktrace
  103.     var err = new Error();
  104.     if (err.stack) {
  105.       var out = err.stack;
  106.  
  107.       // try to strip useless frames
  108.       var fn_name = stackStartFunction.name;
  109.       var idx = out.indexOf('\n' + fn_name);
  110.       if (idx >= 0) {
  111.         // once we have located the function frame
  112.         // we need to strip out everything before it (and its line)
  113.         var next_line = out.indexOf('\n', idx + 1);
  114.         out = out.substring(next_line + 1);
  115.       }
  116.  
  117.       this.stack = out;
  118.     }
  119.   }
  120. };
  121.  
  122. // assert.AssertionError instanceof Error
  123. util.inherits(assert.AssertionError, Error);
  124.  
  125. function replacer(key, value) {
  126.   if (util.isUndefined(value)) {
  127.     return '' + value;
  128.   }
  129.   if (util.isNumber(value) && !isFinite(value)) {
  130.     return value.toString();
  131.   }
  132.   if (util.isFunction(value) || util.isRegExp(value)) {
  133.     return value.toString();
  134.   }
  135.   return value;
  136. }
  137.  
  138. function truncate(s, n) {
  139.   if (util.isString(s)) {
  140.     return s.length < n ? s : s.slice(0, n);
  141.   } else {
  142.     return s;
  143.   }
  144. }
  145.  
  146. function getMessage(self) {
  147.   return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +
  148.          self.operator + ' ' +
  149.          truncate(JSON.stringify(self.expected, replacer), 128);
  150. }
  151.  
  152. // At present only the three keys mentioned above are used and
  153. // understood by the spec. Implementations or sub modules can pass
  154. // other keys to the AssertionError's constructor - they will be
  155. // ignored.
  156.  
  157. // 3. All of the following functions must throw an AssertionError
  158. // when a corresponding condition is not met, with a message that
  159. // may be undefined if not provided.  All assertion methods provide
  160. // both the actual and expected values to the assertion error for
  161. // display purposes.
  162.  
  163. function fail(actual, expected, message, operator, stackStartFunction) {
  164.   throw new assert.AssertionError({
  165.     message: message,
  166.     actual: actual,
  167.     expected: expected,
  168.     operator: operator,
  169.     stackStartFunction: stackStartFunction
  170.   });
  171. }
  172.  
  173. // EXTENSION! allows for well behaved errors defined elsewhere.
  174. assert.fail = fail;
  175.  
  176. // 4. Pure assertion tests whether a value is truthy, as determined
  177. // by !!guard.
  178. // assert.ok(guard, message_opt);
  179. // This statement is equivalent to assert.equal(true, !!guard,
  180. // message_opt);. To test strictly for the value true, use
  181. // assert.strictEqual(true, guard, message_opt);.
  182.  
  183. function ok(value, message) {
  184.   if (!value) fail(value, true, message, '==', assert.ok);
  185. }
  186. assert.ok = ok;
  187.  
  188. // 5. The equality assertion tests shallow, coercive equality with
  189. // ==.
  190. // assert.equal(actual, expected, message_opt);
  191.  
  192. assert.equal = function equal(actual, expected, message) {
  193.   if (actual != expected) fail(actual, expected, message, '==', assert.equal);
  194. };
  195.  
  196. // 6. The non-equality assertion tests for whether two objects are not equal
  197. // with != assert.notEqual(actual, expected, message_opt);
  198.  
  199. assert.notEqual = function notEqual(actual, expected, message) {
  200.   if (actual == expected) {
  201.     fail(actual, expected, message, '!=', assert.notEqual);
  202.   }
  203. };
  204.  
  205. // 7. The equivalence assertion tests a deep equality relation.
  206. // assert.deepEqual(actual, expected, message_opt);
  207.  
  208. assert.deepEqual = function deepEqual(actual, expected, message) {
  209.   if (!_deepEqual(actual, expected)) {
  210.     fail(actual, expected, message, 'deepEqual', assert.deepEqual);
  211.   }
  212. };
  213.  
  214. function _deepEqual(actual, expected) {
  215.   // 7.1. All identical values are equivalent, as determined by ===.
  216.   if (actual === expected) {
  217.     return true;
  218.  
  219.   } else if (util.isBuffer(actual) && util.isBuffer(expected)) {
  220.     if (actual.length != expected.length) return false;
  221.  
  222.     for (var i = 0; i < actual.length; i++) {
  223.       if (actual[i] !== expected[i]) return false;
  224.     }
  225.  
  226.     return true;
  227.  
  228.   // 7.2. If the expected value is a Date object, the actual value is
  229.   // equivalent if it is also a Date object that refers to the same time.
  230.   } else if (util.isDate(actual) && util.isDate(expected)) {
  231.     return actual.getTime() === expected.getTime();
  232.  
  233.   // 7.3 If the expected value is a RegExp object, the actual value is
  234.   // equivalent if it is also a RegExp object with the same source and
  235.   // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
  236.   } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
  237.     return actual.source === expected.source &&
  238.            actual.global === expected.global &&
  239.            actual.multiline === expected.multiline &&
  240.            actual.lastIndex === expected.lastIndex &&
  241.            actual.ignoreCase === expected.ignoreCase;
  242.  
  243.   // 7.4. Other pairs that do not both pass typeof value == 'object',
  244.   // equivalence is determined by ==.
  245.   } else if (!util.isObject(actual) && !util.isObject(expected)) {
  246.     return actual == expected;
  247.  
  248.   // 7.5 For all other Object pairs, including Array objects, equivalence is
  249.   // determined by having the same number of owned properties (as verified
  250.   // with Object.prototype.hasOwnProperty.call), the same set of keys
  251.   // (although not necessarily the same order), equivalent values for every
  252.   // corresponding key, and an identical 'prototype' property. Note: this
  253.   // accounts for both named and indexed properties on Arrays.
  254.   } else {
  255.     return objEquiv(actual, expected);
  256.   }
  257. }
  258.  
  259. function isArguments(object) {
  260.   return Object.prototype.toString.call(object) == '[object Arguments]';
  261. }
  262.  
  263. function objEquiv(a, b) {
  264.   if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))
  265.     return false;
  266.   // an identical 'prototype' property.
  267.   if (a.prototype !== b.prototype) return false;
  268.   // if one is a primitive, the other must be same
  269.   if (util.isPrimitive(a) || util.isPrimitive(b)) {
  270.     return a === b;
  271.   }
  272.   var aIsArgs = isArguments(a),
  273.       bIsArgs = isArguments(b);
  274.   if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
  275.     return false;
  276.   if (aIsArgs) {
  277.     a = pSlice.call(a);
  278.     b = pSlice.call(b);
  279.     return _deepEqual(a, b);
  280.   }
  281.   var ka = objectKeys(a),
  282.       kb = objectKeys(b),
  283.       key, i;
  284.   // having the same number of owned properties (keys incorporates
  285.   // hasOwnProperty)
  286.   if (ka.length != kb.length)
  287.     return false;
  288.   //the same set of keys (although not necessarily the same order),
  289.   ka.sort();
  290.   kb.sort();
  291.   //~~~cheap key test
  292.   for (i = ka.length - 1; i >= 0; i--) {
  293.     if (ka[i] != kb[i])
  294.       return false;
  295.   }
  296.   //equivalent values for every corresponding key, and
  297.   //~~~possibly expensive deep test
  298.   for (i = ka.length - 1; i >= 0; i--) {
  299.     key = ka[i];
  300.     if (!_deepEqual(a[key], b[key])) return false;
  301.   }
  302.   return true;
  303. }
  304.  
  305. // 8. The non-equivalence assertion tests for any deep inequality.
  306. // assert.notDeepEqual(actual, expected, message_opt);
  307.  
  308. assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
  309.   if (_deepEqual(actual, expected)) {
  310.     fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
  311.   }
  312. };
  313.  
  314. // 9. The strict equality assertion tests strict equality, as determined by ===.
  315. // assert.strictEqual(actual, expected, message_opt);
  316.  
  317. assert.strictEqual = function strictEqual(actual, expected, message) {
  318.   if (actual !== expected) {
  319.     fail(actual, expected, message, '===', assert.strictEqual);
  320.   }
  321. };
  322.  
  323. // 10. The strict non-equality assertion tests for strict inequality, as
  324. // determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
  325.  
  326. assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
  327.   if (actual === expected) {
  328.     fail(actual, expected, message, '!==', assert.notStrictEqual);
  329.   }
  330. };
  331.  
  332. function expectedException(actual, expected) {
  333.   if (!actual || !expected) {
  334.     return false;
  335.   }
  336.  
  337.   if (Object.prototype.toString.call(expected) == '[object RegExp]') {
  338.     return expected.test(actual);
  339.   } else if (actual instanceof expected) {
  340.     return true;
  341.   } else if (expected.call({}, actual) === true) {
  342.     return true;
  343.   }
  344.  
  345.   return false;
  346. }
  347.  
  348. function _throws(shouldThrow, block, expected, message) {
  349.   var actual;
  350.  
  351.   if (util.isString(expected)) {
  352.     message = expected;
  353.     expected = null;
  354.   }
  355.  
  356.   try {
  357.     block();
  358.   } catch (e) {
  359.     actual = e;
  360.   }
  361.  
  362.   message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
  363.             (message ? ' ' + message : '.');
  364.  
  365.   if (shouldThrow && !actual) {
  366.     fail(actual, expected, 'Missing expected exception' + message);
  367.   }
  368.  
  369.   if (!shouldThrow && expectedException(actual, expected)) {
  370.     fail(actual, expected, 'Got unwanted exception' + message);
  371.   }
  372.  
  373.   if ((shouldThrow && actual && expected &&
  374.       !expectedException(actual, expected)) || (!shouldThrow && actual)) {
  375.     throw actual;
  376.   }
  377. }
  378.  
  379. // 11. Expected to throw an error:
  380. // assert.throws(block, Error_opt, message_opt);
  381.  
  382. assert.throws = function(block, /*optional*/error, /*optional*/message) {
  383.   _throws.apply(this, [true].concat(pSlice.call(arguments)));
  384. };
  385.  
  386. // EXTENSION! This is annoying to write outside this module.
  387. assert.doesNotThrow = function(block, /*optional*/message) {
  388.   _throws.apply(this, [false].concat(pSlice.call(arguments)));
  389. };
  390.  
  391. assert.ifError = function(err) { if (err) {throw err;}};
  392.  
  393. var objectKeys = Object.keys || function (obj) {
  394.   var keys = [];
  395.   for (var key in obj) {
  396.     if (hasOwn.call(obj, key)) keys.push(key);
  397.   }
  398.   return keys;
  399. };
  400.  
  401. },{"util/":6}],3:[function(_dereq_,module,exports){
  402. // shim for using process in browser
  403. var process = module.exports = {};
  404.  
  405. // cached from whatever global is present so that test runners that stub it
  406. // don't break things.  But we need to wrap it in a try catch in case it is
  407. // wrapped in strict mode code which doesn't define any globals.  It's inside a
  408. // function because try/catches deoptimize in certain engines.
  409.  
  410. var cachedSetTimeout;
  411. var cachedClearTimeout;
  412.  
  413. function defaultSetTimout() {
  414.     throw new Error('setTimeout has not been defined');
  415. }
  416. function defaultClearTimeout () {
  417.     throw new Error('clearTimeout has not been defined');
  418. }
  419. (function () {
  420.     try {
  421.         if (typeof setTimeout === 'function') {
  422.             cachedSetTimeout = setTimeout;
  423.         } else {
  424.             cachedSetTimeout = defaultSetTimout;
  425.         }
  426.     } catch (e) {
  427.         cachedSetTimeout = defaultSetTimout;
  428.     }
  429.     try {
  430.         if (typeof clearTimeout === 'function') {
  431.             cachedClearTimeout = clearTimeout;
  432.         } else {
  433.             cachedClearTimeout = defaultClearTimeout;
  434.         }
  435.     } catch (e) {
  436.         cachedClearTimeout = defaultClearTimeout;
  437.     }
  438. } ())
  439. function runTimeout(fun) {
  440.     if (cachedSetTimeout === setTimeout) {
  441.         //normal enviroments in sane situations
  442.         return setTimeout(fun, 0);
  443.     }
  444.     // if setTimeout wasn't available but was latter defined
  445.     if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
  446.         cachedSetTimeout = setTimeout;
  447.         return setTimeout(fun, 0);
  448.     }
  449.     try {
  450.         // when when somebody has screwed with setTimeout but no I.E. maddness
  451.         return cachedSetTimeout(fun, 0);
  452.     } catch(e){
  453.         try {
  454.             // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
  455.             return cachedSetTimeout.call(null, fun, 0);
  456.         } catch(e){
  457.             // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
  458.             return cachedSetTimeout.call(this, fun, 0);
  459.         }
  460.     }
  461.  
  462.  
  463. }
  464. function runClearTimeout(marker) {
  465.     if (cachedClearTimeout === clearTimeout) {
  466.         //normal enviroments in sane situations
  467.         return clearTimeout(marker);
  468.     }
  469.     // if clearTimeout wasn't available but was latter defined
  470.     if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
  471.         cachedClearTimeout = clearTimeout;
  472.         return clearTimeout(marker);
  473.     }
  474.     try {
  475.         // when when somebody has screwed with setTimeout but no I.E. maddness
  476.         return cachedClearTimeout(marker);
  477.     } catch (e){
  478.         try {
  479.             // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
  480.             return cachedClearTimeout.call(null, marker);
  481.         } catch (e){
  482.             // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
  483.             // Some versions of I.E. have different rules for clearTimeout vs setTimeout
  484.             return cachedClearTimeout.call(this, marker);
  485.         }
  486.     }
  487.  
  488.  
  489.  
  490. }
  491. var queue = [];
  492. var draining = false;
  493. var currentQueue;
  494. var queueIndex = -1;
  495.  
  496. function cleanUpNextTick() {
  497.     if (!draining || !currentQueue) {
  498.         return;
  499.     }
  500.     draining = false;
  501.     if (currentQueue.length) {
  502.         queue = currentQueue.concat(queue);
  503.     } else {
  504.         queueIndex = -1;
  505.     }
  506.     if (queue.length) {
  507.         drainQueue();
  508.     }
  509. }
  510.  
  511. function drainQueue() {
  512.     if (draining) {
  513.         return;
  514.     }
  515.     var timeout = runTimeout(cleanUpNextTick);
  516.     draining = true;
  517.  
  518.     var len = queue.length;
  519.     while(len) {
  520.         currentQueue = queue;
  521.         queue = [];
  522.         while (++queueIndex < len) {
  523.             if (currentQueue) {
  524.                 currentQueue[queueIndex].run();
  525.             }
  526.         }
  527.         queueIndex = -1;
  528.         len = queue.length;
  529.     }
  530.     currentQueue = null;
  531.     draining = false;
  532.     runClearTimeout(timeout);
  533. }
  534.  
  535. process.nextTick = function (fun) {
  536.     var args = new Array(arguments.length - 1);
  537.     if (arguments.length > 1) {
  538.         for (var i = 1; i < arguments.length; i++) {
  539.             args[i - 1] = arguments[i];
  540.         }
  541.     }
  542.     queue.push(new Item(fun, args));
  543.     if (queue.length === 1 && !draining) {
  544.         runTimeout(drainQueue);
  545.     }
  546. };
  547.  
  548. // v8 likes predictible objects
  549. function Item(fun, array) {
  550.     this.fun = fun;
  551.     this.array = array;
  552. }
  553. Item.prototype.run = function () {
  554.     this.fun.apply(null, this.array);
  555. };
  556. process.title = 'browser';
  557. process.browser = true;
  558. process.env = {};
  559. process.argv = [];
  560. process.version = ''; // empty string to avoid regexp issues
  561. process.versions = {};
  562.  
  563. function noop() {}
  564.  
  565. process.on = noop;
  566. process.addListener = noop;
  567. process.once = noop;
  568. process.off = noop;
  569. process.removeListener = noop;
  570. process.removeAllListeners = noop;
  571. process.emit = noop;
  572.  
  573. process.binding = function (name) {
  574.     throw new Error('process.binding is not supported');
  575. };
  576.  
  577. process.cwd = function () { return '/' };
  578. process.chdir = function (dir) {
  579.     throw new Error('process.chdir is not supported');
  580. };
  581. process.umask = function() { return 0; };
  582.  
  583. },{}],4:[function(_dereq_,module,exports){
  584. if (typeof Object.create === 'function') {
  585.   // implementation from standard node.js 'util' module
  586.   module.exports = function inherits(ctor, superCtor) {
  587.     ctor.super_ = superCtor
  588.     ctor.prototype = Object.create(superCtor.prototype, {
  589.       constructor: {
  590.         value: ctor,
  591.         enumerable: false,
  592.         writable: true,
  593.         configurable: true
  594.       }
  595.     });
  596.   };
  597. } else {
  598.   // old school shim for old browsers
  599.   module.exports = function inherits(ctor, superCtor) {
  600.     ctor.super_ = superCtor
  601.     var TempCtor = function () {}
  602.     TempCtor.prototype = superCtor.prototype
  603.     ctor.prototype = new TempCtor()
  604.     ctor.prototype.constructor = ctor
  605.   }
  606. }
  607.  
  608. },{}],5:[function(_dereq_,module,exports){
  609. module.exports = function isBuffer(arg) {
  610.   return arg && typeof arg === 'object'
  611.     && typeof arg.copy === 'function'
  612.     && typeof arg.fill === 'function'
  613.     && typeof arg.readUInt8 === 'function';
  614. }
  615. },{}],6:[function(_dereq_,module,exports){
  616. (function (process,global){
  617. // Copyright Joyent, Inc. and other Node contributors.
  618. //
  619. // Permission is hereby granted, free of charge, to any person obtaining a
  620. // copy of this software and associated documentation files (the
  621. // "Software"), to deal in the Software without restriction, including
  622. // without limitation the rights to use, copy, modify, merge, publish,
  623. // distribute, sublicense, and/or sell copies of the Software, and to permit
  624. // persons to whom the Software is furnished to do so, subject to the
  625. // following conditions:
  626. //
  627. // The above copyright notice and this permission notice shall be included
  628. // in all copies or substantial portions of the Software.
  629. //
  630. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  631. // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  632. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  633. // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  634. // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  635. // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  636. // USE OR OTHER DEALINGS IN THE SOFTWARE.
  637.  
  638. var formatRegExp = /%[sdj%]/g;
  639. exports.format = function(f) {
  640.   if (!isString(f)) {
  641.     var objects = [];
  642.     for (var i = 0; i < arguments.length; i++) {
  643.       objects.push(inspect(arguments[i]));
  644.     }
  645.     return objects.join(' ');
  646.   }
  647.  
  648.   var i = 1;
  649.   var args = arguments;
  650.   var len = args.length;
  651.   var str = String(f).replace(formatRegExp, function(x) {
  652.     if (x === '%%') return '%';
  653.     if (i >= len) return x;
  654.     switch (x) {
  655.       case '%s': return String(args[i++]);
  656.       case '%d': return Number(args[i++]);
  657.       case '%j':
  658.         try {
  659.           return JSON.stringify(args[i++]);
  660.         } catch (_) {
  661.           return '[Circular]';
  662.         }
  663.       default:
  664.         return x;
  665.     }
  666.   });
  667.   for (var x = args[i]; i < len; x = args[++i]) {
  668.     if (isNull(x) || !isObject(x)) {
  669.       str += ' ' + x;
  670.     } else {
  671.       str += ' ' + inspect(x);
  672.     }
  673.   }
  674.   return str;
  675. };
  676.  
  677.  
  678. // Mark that a method should not be used.
  679. // Returns a modified function which warns once by default.
  680. // If --no-deprecation is set, then it is a no-op.
  681. exports.deprecate = function(fn, msg) {
  682.   // Allow for deprecating things in the process of starting up.
  683.   if (isUndefined(global.process)) {
  684.     return function() {
  685.       return exports.deprecate(fn, msg).apply(this, arguments);
  686.     };
  687.   }
  688.  
  689.   if (process.noDeprecation === true) {
  690.     return fn;
  691.   }
  692.  
  693.   var warned = false;
  694.   function deprecated() {
  695.     if (!warned) {
  696.       if (process.throwDeprecation) {
  697.         throw new Error(msg);
  698.       } else if (process.traceDeprecation) {
  699.         console.trace(msg);
  700.       } else {
  701.         console.error(msg);
  702.       }
  703.       warned = true;
  704.     }
  705.     return fn.apply(this, arguments);
  706.   }
  707.  
  708.   return deprecated;
  709. };
  710.  
  711.  
  712. var debugs = {};
  713. var debugEnviron;
  714. exports.debuglog = function(set) {
  715.   if (isUndefined(debugEnviron))
  716.     debugEnviron = process.env.NODE_DEBUG || '';
  717.   set = set.toUpperCase();
  718.   if (!debugs[set]) {
  719.     if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
  720.       var pid = process.pid;
  721.       debugs[set] = function() {
  722.         var msg = exports.format.apply(exports, arguments);
  723.         console.error('%s %d: %s', set, pid, msg);
  724.       };
  725.     } else {
  726.       debugs[set] = function() {};
  727.     }
  728.   }
  729.   return debugs[set];
  730. };
  731.  
  732.  
  733. /**
  734.  * Echos the value of a value. Trys to print the value out
  735.  * in the best way possible given the different types.
  736.  *
  737.  * @param {Object} obj The object to print out.
  738.  * @param {Object} opts Optional options object that alters the output.
  739.  */
  740. /* legacy: obj, showHidden, depth, colors*/
  741. function inspect(obj, opts) {
  742.   // default options
  743.   var ctx = {
  744.     seen: [],
  745.     stylize: stylizeNoColor
  746.   };
  747.   // legacy...
  748.   if (arguments.length >= 3) ctx.depth = arguments[2];
  749.   if (arguments.length >= 4) ctx.colors = arguments[3];
  750.   if (isBoolean(opts)) {
  751.     // legacy...
  752.     ctx.showHidden = opts;
  753.   } else if (opts) {
  754.     // got an "options" object
  755.     exports._extend(ctx, opts);
  756.   }
  757.   // set default options
  758.   if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
  759.   if (isUndefined(ctx.depth)) ctx.depth = 2;
  760.   if (isUndefined(ctx.colors)) ctx.colors = false;
  761.   if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
  762.   if (ctx.colors) ctx.stylize = stylizeWithColor;
  763.   return formatValue(ctx, obj, ctx.depth);
  764. }
  765. exports.inspect = inspect;
  766.  
  767.  
  768. // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
  769. inspect.colors = {
  770.   'bold' : [1, 22],
  771.   'italic' : [3, 23],
  772.   'underline' : [4, 24],
  773.   'inverse' : [7, 27],
  774.   'white' : [37, 39],
  775.   'grey' : [90, 39],
  776.   'black' : [30, 39],
  777.   'blue' : [34, 39],
  778.   'cyan' : [36, 39],
  779.   'green' : [32, 39],
  780.   'magenta' : [35, 39],
  781.   'red' : [31, 39],
  782.   'yellow' : [33, 39]
  783. };
  784.  
  785. // Don't use 'blue' not visible on cmd.exe
  786. inspect.styles = {
  787.   'special': 'cyan',
  788.   'number': 'yellow',
  789.   'boolean': 'yellow',
  790.   'undefined': 'grey',
  791.   'null': 'bold',
  792.   'string': 'green',
  793.   'date': 'magenta',
  794.   // "name": intentionally not styling
  795.   'regexp': 'red'
  796. };
  797.  
  798.  
  799. function stylizeWithColor(str, styleType) {
  800.   var style = inspect.styles[styleType];
  801.  
  802.   if (style) {
  803.     return '\u001b[' + inspect.colors[style][0] + 'm' + str +
  804.            '\u001b[' + inspect.colors[style][1] + 'm';
  805.   } else {
  806.     return str;
  807.   }
  808. }
  809.  
  810.  
  811. function stylizeNoColor(str, styleType) {
  812.   return str;
  813. }
  814.  
  815.  
  816. function arrayToHash(array) {
  817.   var hash = {};
  818.  
  819.   array.forEach(function(val, idx) {
  820.     hash[val] = true;
  821.   });
  822.  
  823.   return hash;
  824. }
  825.  
  826.  
  827. function formatValue(ctx, value, recurseTimes) {
  828.   // Provide a hook for user-specified inspect functions.
  829.   // Check that value is an object with an inspect function on it
  830.   if (ctx.customInspect &&
  831.       value &&
  832.       isFunction(value.inspect) &&
  833.       // Filter out the util module, it's inspect function is special
  834.       value.inspect !== exports.inspect &&
  835.       // Also filter out any prototype objects using the circular check.
  836.       !(value.constructor && value.constructor.prototype === value)) {
  837.     var ret = value.inspect(recurseTimes, ctx);
  838.     if (!isString(ret)) {
  839.       ret = formatValue(ctx, ret, recurseTimes);
  840.     }
  841.     return ret;
  842.   }
  843.  
  844.   // Primitive types cannot have properties
  845.   var primitive = formatPrimitive(ctx, value);
  846.   if (primitive) {
  847.     return primitive;
  848.   }
  849.  
  850.   // Look up the keys of the object.
  851.   var keys = Object.keys(value);
  852.   var visibleKeys = arrayToHash(keys);
  853.  
  854.   if (ctx.showHidden) {
  855.     keys = Object.getOwnPropertyNames(value);
  856.   }
  857.  
  858.   // IE doesn't make error fields non-enumerable
  859.   // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
  860.   if (isError(value)
  861.       && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
  862.     return formatError(value);
  863.   }
  864.  
  865.   // Some type of object without properties can be shortcutted.
  866.   if (keys.length === 0) {
  867.     if (isFunction(value)) {
  868.       var name = value.name ? ': ' + value.name : '';
  869.       return ctx.stylize('[Function' + name + ']', 'special');
  870.     }
  871.     if (isRegExp(value)) {
  872.       return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
  873.     }
  874.     if (isDate(value)) {
  875.       return ctx.stylize(Date.prototype.toString.call(value), 'date');
  876.     }
  877.     if (isError(value)) {
  878.       return formatError(value);
  879.     }
  880.   }
  881.  
  882.   var base = '', array = false, braces = ['{', '}'];
  883.  
  884.   // Make Array say that they are Array
  885.   if (isArray(value)) {
  886.     array = true;
  887.     braces = ['[', ']'];
  888.   }
  889.  
  890.   // Make functions say that they are functions
  891.   if (isFunction(value)) {
  892.     var n = value.name ? ': ' + value.name : '';
  893.     base = ' [Function' + n + ']';
  894.   }
  895.  
  896.   // Make RegExps say that they are RegExps
  897.   if (isRegExp(value)) {
  898.     base = ' ' + RegExp.prototype.toString.call(value);
  899.   }
  900.  
  901.   // Make dates with properties first say the date
  902.   if (isDate(value)) {
  903.     base = ' ' + Date.prototype.toUTCString.call(value);
  904.   }
  905.  
  906.   // Make error with message first say the error
  907.   if (isError(value)) {
  908.     base = ' ' + formatError(value);
  909.   }
  910.  
  911.   if (keys.length === 0 && (!array || value.length == 0)) {
  912.     return braces[0] + base + braces[1];
  913.   }
  914.  
  915.   if (recurseTimes < 0) {
  916.     if (isRegExp(value)) {
  917.       return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
  918.     } else {
  919.       return ctx.stylize('[Object]', 'special');
  920.     }
  921.   }
  922.  
  923.   ctx.seen.push(value);
  924.  
  925.   var output;
  926.   if (array) {
  927.     output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
  928.   } else {
  929.     output = keys.map(function(key) {
  930.       return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
  931.     });
  932.   }
  933.  
  934.   ctx.seen.pop();
  935.  
  936.   return reduceToSingleString(output, base, braces);
  937. }
  938.  
  939.  
  940. function formatPrimitive(ctx, value) {
  941.   if (isUndefined(value))
  942.     return ctx.stylize('undefined', 'undefined');
  943.   if (isString(value)) {
  944.     var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
  945.                                              .replace(/'/g, "\\'")
  946.                                              .replace(/\\"/g, '"') + '\'';
  947.     return ctx.stylize(simple, 'string');
  948.   }
  949.   if (isNumber(value))
  950.     return ctx.stylize('' + value, 'number');
  951.   if (isBoolean(value))
  952.     return ctx.stylize('' + value, 'boolean');
  953.   // For some reason typeof null is "object", so special case here.
  954.   if (isNull(value))
  955.     return ctx.stylize('null', 'null');
  956. }
  957.  
  958.  
  959. function formatError(value) {
  960.   return '[' + Error.prototype.toString.call(value) + ']';
  961. }
  962.  
  963.  
  964. function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
  965.   var output = [];
  966.   for (var i = 0, l = value.length; i < l; ++i) {
  967.     if (hasOwnProperty(value, String(i))) {
  968.       output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
  969.           String(i), true));
  970.     } else {
  971.       output.push('');
  972.     }
  973.   }
  974.   keys.forEach(function(key) {
  975.     if (!key.match(/^\d+$/)) {
  976.       output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
  977.           key, true));
  978.     }
  979.   });
  980.   return output;
  981. }
  982.  
  983.  
  984. function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
  985.   var name, str, desc;
  986.   desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
  987.   if (desc.get) {
  988.     if (desc.set) {
  989.       str = ctx.stylize('[Getter/Setter]', 'special');
  990.     } else {
  991.       str = ctx.stylize('[Getter]', 'special');
  992.     }
  993.   } else {
  994.     if (desc.set) {
  995.       str = ctx.stylize('[Setter]', 'special');
  996.     }
  997.   }
  998.   if (!hasOwnProperty(visibleKeys, key)) {
  999.     name = '[' + key + ']';
  1000.   }
  1001.   if (!str) {
  1002.     if (ctx.seen.indexOf(desc.value) < 0) {
  1003.       if (isNull(recurseTimes)) {
  1004.         str = formatValue(ctx, desc.value, null);
  1005.       } else {
  1006.         str = formatValue(ctx, desc.value, recurseTimes - 1);
  1007.       }
  1008.       if (str.indexOf('\n') > -1) {
  1009.         if (array) {
  1010.           str = str.split('\n').map(function(line) {
  1011.             return '  ' + line;
  1012.           }).join('\n').substr(2);
  1013.         } else {
  1014.           str = '\n' + str.split('\n').map(function(line) {
  1015.             return '   ' + line;
  1016.           }).join('\n');
  1017.         }
  1018.       }
  1019.     } else {
  1020.       str = ctx.stylize('[Circular]', 'special');
  1021.     }
  1022.   }
  1023.   if (isUndefined(name)) {
  1024.     if (array && key.match(/^\d+$/)) {
  1025.       return str;
  1026.     }
  1027.     name = JSON.stringify('' + key);
  1028.     if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
  1029.       name = name.substr(1, name.length - 2);
  1030.       name = ctx.stylize(name, 'name');
  1031.     } else {
  1032.       name = name.replace(/'/g, "\\'")
  1033.                  .replace(/\\"/g, '"')
  1034.                  .replace(/(^"|"$)/g, "'");
  1035.       name = ctx.stylize(name, 'string');
  1036.     }
  1037.   }
  1038.  
  1039.   return name + ': ' + str;
  1040. }
  1041.  
  1042.  
  1043. function reduceToSingleString(output, base, braces) {
  1044.   var numLinesEst = 0;
  1045.   var length = output.reduce(function(prev, cur) {
  1046.     numLinesEst++;
  1047.     if (cur.indexOf('\n') >= 0) numLinesEst++;
  1048.     return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
  1049.   }, 0);
  1050.  
  1051.   if (length > 60) {
  1052.     return braces[0] +
  1053.            (base === '' ? '' : base + '\n ') +
  1054.            ' ' +
  1055.            output.join(',\n  ') +
  1056.            ' ' +
  1057.            braces[1];
  1058.   }
  1059.  
  1060.   return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
  1061. }
  1062.  
  1063.  
  1064. // NOTE: These type checking functions intentionally don't use `instanceof`
  1065. // because it is fragile and can be easily faked with `Object.create()`.
  1066. function isArray(ar) {
  1067.   return Array.isArray(ar);
  1068. }
  1069. exports.isArray = isArray;
  1070.  
  1071. function isBoolean(arg) {
  1072.   return typeof arg === 'boolean';
  1073. }
  1074. exports.isBoolean = isBoolean;
  1075.  
  1076. function isNull(arg) {
  1077.   return arg === null;
  1078. }
  1079. exports.isNull = isNull;
  1080.  
  1081. function isNullOrUndefined(arg) {
  1082.   return arg == null;
  1083. }
  1084. exports.isNullOrUndefined = isNullOrUndefined;
  1085.  
  1086. function isNumber(arg) {
  1087.   return typeof arg === 'number';
  1088. }
  1089. exports.isNumber = isNumber;
  1090.  
  1091. function isString(arg) {
  1092.   return typeof arg === 'string';
  1093. }
  1094. exports.isString = isString;
  1095.  
  1096. function isSymbol(arg) {
  1097.   return typeof arg === 'symbol';
  1098. }
  1099. exports.isSymbol = isSymbol;
  1100.  
  1101. function isUndefined(arg) {
  1102.   return arg === void 0;
  1103. }
  1104. exports.isUndefined = isUndefined;
  1105.  
  1106. function isRegExp(re) {
  1107.   return isObject(re) && objectToString(re) === '[object RegExp]';
  1108. }
  1109. exports.isRegExp = isRegExp;
  1110.  
  1111. function isObject(arg) {
  1112.   return typeof arg === 'object' && arg !== null;
  1113. }
  1114. exports.isObject = isObject;
  1115.  
  1116. function isDate(d) {
  1117.   return isObject(d) && objectToString(d) === '[object Date]';
  1118. }
  1119. exports.isDate = isDate;
  1120.  
  1121. function isError(e) {
  1122.   return isObject(e) &&
  1123.       (objectToString(e) === '[object Error]' || e instanceof Error);
  1124. }
  1125. exports.isError = isError;
  1126.  
  1127. function isFunction(arg) {
  1128.   return typeof arg === 'function';
  1129. }
  1130. exports.isFunction = isFunction;
  1131.  
  1132. function isPrimitive(arg) {
  1133.   return arg === null ||
  1134.          typeof arg === 'boolean' ||
  1135.          typeof arg === 'number' ||
  1136.          typeof arg === 'string' ||
  1137.          typeof arg === 'symbol' ||  // ES6 symbol
  1138.          typeof arg === 'undefined';
  1139. }
  1140. exports.isPrimitive = isPrimitive;
  1141.  
  1142. exports.isBuffer = _dereq_('./support/isBuffer');
  1143.  
  1144. function objectToString(o) {
  1145.   return Object.prototype.toString.call(o);
  1146. }
  1147.  
  1148.  
  1149. function pad(n) {
  1150.   return n < 10 ? '0' + n.toString(10) : n.toString(10);
  1151. }
  1152.  
  1153.  
  1154. var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
  1155.               'Oct', 'Nov', 'Dec'];
  1156.  
  1157. // 26 Feb 16:19:34
  1158. function timestamp() {
  1159.   var d = new Date();
  1160.   var time = [pad(d.getHours()),
  1161.               pad(d.getMinutes()),
  1162.               pad(d.getSeconds())].join(':');
  1163.   return [d.getDate(), months[d.getMonth()], time].join(' ');
  1164. }
  1165.  
  1166.  
  1167. // log is just a thin wrapper to console.log that prepends a timestamp
  1168. exports.log = function() {
  1169.   console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
  1170. };
  1171.  
  1172.  
  1173. /**
  1174.  * Inherit the prototype methods from one constructor into another.
  1175.  *
  1176.  * The Function.prototype.inherits from lang.js rewritten as a standalone
  1177.  * function (not on Function.prototype). NOTE: If this file is to be loaded
  1178.  * during bootstrapping this function needs to be rewritten using some native
  1179.  * functions as prototype setup using normal JavaScript does not work as
  1180.  * expected during bootstrapping (see mirror.js in r114903).
  1181.  *
  1182.  * @param {function} ctor Constructor function which needs to inherit the
  1183.  *     prototype.
  1184.  * @param {function} superCtor Constructor function to inherit prototype from.
  1185.  */
  1186. exports.inherits = _dereq_('inherits');
  1187.  
  1188. exports._extend = function(origin, add) {
  1189.   // Don't do anything if add isn't an object
  1190.   if (!add || !isObject(add)) return origin;
  1191.  
  1192.   var keys = Object.keys(add);
  1193.   var i = keys.length;
  1194.   while (i--) {
  1195.     origin[keys[i]] = add[keys[i]];
  1196.   }
  1197.   return origin;
  1198. };
  1199.  
  1200. function hasOwnProperty(obj, prop) {
  1201.   return Object.prototype.hasOwnProperty.call(obj, prop);
  1202. }
  1203.  
  1204. }).call(this,_dereq_('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  1205.  
  1206. },{"./support/isBuffer":5,"_process":3,"inherits":4}],7:[function(_dereq_,module,exports){
  1207. 'use strict';
  1208.  
  1209. 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; }; }();
  1210.  
  1211. function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  1212.  
  1213. var _require = _dereq_('./helpers.js'),
  1214.     createDataProperty = _require.createDataProperty;
  1215.  
  1216. module.exports = function () {
  1217.   function ByteLengthQueuingStrategy(_ref) {
  1218.     var highWaterMark = _ref.highWaterMark;
  1219.  
  1220.     _classCallCheck(this, ByteLengthQueuingStrategy);
  1221.  
  1222.     createDataProperty(this, 'highWaterMark', highWaterMark);
  1223.   }
  1224.  
  1225.   _createClass(ByteLengthQueuingStrategy, [{
  1226.     key: 'size',
  1227.     value: function size(chunk) {
  1228.       return chunk.byteLength;
  1229.     }
  1230.   }]);
  1231.  
  1232.   return ByteLengthQueuingStrategy;
  1233. }();
  1234.  
  1235. },{"./helpers.js":9}],8:[function(_dereq_,module,exports){
  1236. 'use strict';
  1237.  
  1238. 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; }; }();
  1239.  
  1240. function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  1241.  
  1242. var _require = _dereq_('./helpers.js'),
  1243.     createDataProperty = _require.createDataProperty;
  1244.  
  1245. module.exports = function () {
  1246.   function CountQueuingStrategy(_ref) {
  1247.     var highWaterMark = _ref.highWaterMark;
  1248.  
  1249.     _classCallCheck(this, CountQueuingStrategy);
  1250.  
  1251.     createDataProperty(this, 'highWaterMark', highWaterMark);
  1252.   }
  1253.  
  1254.   _createClass(CountQueuingStrategy, [{
  1255.     key: 'size',
  1256.     value: function size() {
  1257.       return 1;
  1258.     }
  1259.   }]);
  1260.  
  1261.   return CountQueuingStrategy;
  1262. }();
  1263.  
  1264. },{"./helpers.js":9}],9:[function(_dereq_,module,exports){
  1265. 'use strict';
  1266.  
  1267. 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; };
  1268.  
  1269. function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
  1270.  
  1271. var assert = _dereq_('assert');
  1272.  
  1273. function IsPropertyKey(argument) {
  1274.   return typeof argument === 'string' || (typeof argument === 'undefined' ? 'undefined' : _typeof(argument)) === 'symbol';
  1275. }
  1276.  
  1277. exports.typeIsObject = function (x) {
  1278.   return (typeof x === 'undefined' ? 'undefined' : _typeof(x)) === 'object' && x !== null || typeof x === 'function';
  1279. };
  1280.  
  1281. exports.createDataProperty = function (o, p, v) {
  1282.   assert(exports.typeIsObject(o));
  1283.   Object.defineProperty(o, p, { value: v, writable: true, enumerable: true, configurable: true });
  1284. };
  1285.  
  1286. exports.createArrayFromList = function (elements) {
  1287.   // We use arrays to represent lists, so this is basically a no-op.
  1288.   // Do a slice though just in case we happen to depend on the unique-ness.
  1289.   return elements.slice();
  1290. };
  1291.  
  1292. exports.ArrayBufferCopy = function (dest, destOffset, src, srcOffset, n) {
  1293.   new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
  1294. };
  1295.  
  1296. exports.CreateIterResultObject = function (value, done) {
  1297.   assert(typeof done === 'boolean');
  1298.   var obj = {};
  1299.   Object.defineProperty(obj, 'value', { value: value, enumerable: true, writable: true, configurable: true });
  1300.   Object.defineProperty(obj, 'done', { value: done, enumerable: true, writable: true, configurable: true });
  1301.   return obj;
  1302. };
  1303.  
  1304. exports.IsFiniteNonNegativeNumber = function (v) {
  1305.   if (Number.isNaN(v)) {
  1306.     return false;
  1307.   }
  1308.   if (v === Infinity) {
  1309.     return false;
  1310.   }
  1311.   if (v < 0) {
  1312.     return false;
  1313.   }
  1314.  
  1315.   return true;
  1316. };
  1317.  
  1318. function Call(F, V, args) {
  1319.   if (typeof F !== 'function') {
  1320.     throw new TypeError('Argument is not a function');
  1321.   }
  1322.  
  1323.   return Function.prototype.apply.call(F, V, args);
  1324. }
  1325.  
  1326. exports.InvokeOrNoop = function (O, P, args) {
  1327.   assert(O !== undefined);
  1328.   assert(IsPropertyKey(P));
  1329.   assert(Array.isArray(args));
  1330.  
  1331.   var method = O[P];
  1332.   if (method === undefined) {
  1333.     return undefined;
  1334.   }
  1335.  
  1336.   return Call(method, O, args);
  1337. };
  1338.  
  1339. exports.PromiseInvokeOrNoop = function (O, P, args) {
  1340.   assert(O !== undefined);
  1341.   assert(IsPropertyKey(P));
  1342.   assert(Array.isArray(args));
  1343.   try {
  1344.     return Promise.resolve(exports.InvokeOrNoop(O, P, args));
  1345.   } catch (returnValueE) {
  1346.     return Promise.reject(returnValueE);
  1347.   }
  1348. };
  1349.  
  1350. exports.PromiseInvokeOrPerformFallback = function (O, P, args, F, argsF) {
  1351.   assert(O !== undefined);
  1352.   assert(IsPropertyKey(P));
  1353.   assert(Array.isArray(args));
  1354.   assert(Array.isArray(argsF));
  1355.  
  1356.   var method = void 0;
  1357.   try {
  1358.     method = O[P];
  1359.   } catch (methodE) {
  1360.     return Promise.reject(methodE);
  1361.   }
  1362.  
  1363.   if (method === undefined) {
  1364.     return F.apply(undefined, _toConsumableArray(argsF));
  1365.   }
  1366.  
  1367.   try {
  1368.     return Promise.resolve(Call(method, O, args));
  1369.   } catch (e) {
  1370.     return Promise.reject(e);
  1371.   }
  1372. };
  1373.  
  1374. exports.PromiseInvokeOrFallbackOrNoop = function (O, P1, args1, P2, args2) {
  1375.   assert(O !== undefined);
  1376.   assert(IsPropertyKey(P1));
  1377.   assert(Array.isArray(args1));
  1378.   assert(IsPropertyKey(P2));
  1379.   assert(Array.isArray(args2));
  1380.  
  1381.   return exports.PromiseInvokeOrPerformFallback(O, P1, args1, exports.PromiseInvokeOrNoop, [O, P2, args2]);
  1382. };
  1383.  
  1384. // Not implemented correctly
  1385. exports.SameRealmTransfer = function (O) {
  1386.   return O;
  1387. };
  1388.  
  1389. exports.ValidateAndNormalizeHighWaterMark = function (highWaterMark) {
  1390.   highWaterMark = Number(highWaterMark);
  1391.   if (Number.isNaN(highWaterMark) || highWaterMark < 0) {
  1392.     throw new RangeError('highWaterMark property of a queuing strategy must be non-negative and non-NaN');
  1393.   }
  1394.  
  1395.   return highWaterMark;
  1396. };
  1397.  
  1398. exports.ValidateAndNormalizeQueuingStrategy = function (size, highWaterMark) {
  1399.   if (size !== undefined && typeof size !== 'function') {
  1400.     throw new TypeError('size property of a queuing strategy must be a function');
  1401.   }
  1402.  
  1403.   highWaterMark = exports.ValidateAndNormalizeHighWaterMark(highWaterMark);
  1404.  
  1405.   return { size: size, highWaterMark: highWaterMark };
  1406. };
  1407.  
  1408. },{"assert":2}],10:[function(_dereq_,module,exports){
  1409. 'use strict';
  1410.  
  1411. var assert = _dereq_('assert');
  1412.  
  1413. var _require = _dereq_('./helpers.js'),
  1414.     IsFiniteNonNegativeNumber = _require.IsFiniteNonNegativeNumber;
  1415.  
  1416. exports.DequeueValue = function (queue) {
  1417.   assert(queue.length > 0, 'Spec-level failure: should never dequeue from an empty queue.');
  1418.   var pair = queue.shift();
  1419.  
  1420.   queue._totalSize -= pair.size;
  1421.  
  1422.   return pair.value;
  1423. };
  1424.  
  1425. exports.EnqueueValueWithSize = function (queue, value, size) {
  1426.   size = Number(size);
  1427.   if (!IsFiniteNonNegativeNumber(size)) {
  1428.     throw new RangeError('Size must be a finite, non-NaN, non-negative number.');
  1429.   }
  1430.  
  1431.   queue.push({ value: value, size: size });
  1432.  
  1433.   if (queue._totalSize === undefined) {
  1434.     queue._totalSize = 0;
  1435.   }
  1436.   queue._totalSize += size;
  1437. };
  1438.  
  1439. // This implementation is not per-spec. Total size is cached for speed.
  1440. exports.GetTotalQueueSize = function (queue) {
  1441.   if (queue._totalSize === undefined) {
  1442.     queue._totalSize = 0;
  1443.   }
  1444.   return queue._totalSize;
  1445. };
  1446.  
  1447. exports.PeekQueueValue = function (queue) {
  1448.   assert(queue.length > 0, 'Spec-level failure: should never peek at an empty queue.');
  1449.   var pair = queue[0];
  1450.   return pair.value;
  1451. };
  1452.  
  1453. },{"./helpers.js":9,"assert":2}],11:[function(_dereq_,module,exports){
  1454. 'use strict';
  1455.  
  1456. 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; }; }();
  1457.  
  1458. function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  1459.  
  1460. var assert = _dereq_('assert');
  1461.  
  1462. var _require = _dereq_('./helpers.js'),
  1463.     ArrayBufferCopy = _require.ArrayBufferCopy,
  1464.     CreateIterResultObject = _require.CreateIterResultObject,
  1465.     IsFiniteNonNegativeNumber = _require.IsFiniteNonNegativeNumber,
  1466.     InvokeOrNoop = _require.InvokeOrNoop,
  1467.     PromiseInvokeOrNoop = _require.PromiseInvokeOrNoop,
  1468.     SameRealmTransfer = _require.SameRealmTransfer,
  1469.     ValidateAndNormalizeQueuingStrategy = _require.ValidateAndNormalizeQueuingStrategy,
  1470.     ValidateAndNormalizeHighWaterMark = _require.ValidateAndNormalizeHighWaterMark;
  1471.  
  1472. var _require2 = _dereq_('./helpers.js'),
  1473.     createArrayFromList = _require2.createArrayFromList,
  1474.     createDataProperty = _require2.createDataProperty,
  1475.     typeIsObject = _require2.typeIsObject;
  1476.  
  1477. var _require3 = _dereq_('./utils.js'),
  1478.     rethrowAssertionErrorRejection = _require3.rethrowAssertionErrorRejection;
  1479.  
  1480. var _require4 = _dereq_('./queue-with-sizes.js'),
  1481.     DequeueValue = _require4.DequeueValue,
  1482.     EnqueueValueWithSize = _require4.EnqueueValueWithSize,
  1483.     GetTotalQueueSize = _require4.GetTotalQueueSize;
  1484.  
  1485. var _require5 = _dereq_('./writable-stream.js'),
  1486.     AcquireWritableStreamDefaultWriter = _require5.AcquireWritableStreamDefaultWriter,
  1487.     IsWritableStream = _require5.IsWritableStream,
  1488.     IsWritableStreamLocked = _require5.IsWritableStreamLocked,
  1489.     WritableStreamAbort = _require5.WritableStreamAbort,
  1490.     WritableStreamDefaultWriterCloseWithErrorPropagation = _require5.WritableStreamDefaultWriterCloseWithErrorPropagation,
  1491.     WritableStreamDefaultWriterRelease = _require5.WritableStreamDefaultWriterRelease,
  1492.     WritableStreamDefaultWriterWrite = _require5.WritableStreamDefaultWriterWrite;
  1493.  
  1494. var InternalCancel = Symbol('[[Cancel]]');
  1495. var InternalPull = Symbol('[[Pull]]');
  1496.  
  1497. var ReadableStream = function () {
  1498.   function ReadableStream() {
  1499.     var underlyingSource = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  1500.  
  1501.     var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
  1502.         size = _ref.size,
  1503.         highWaterMark = _ref.highWaterMark;
  1504.  
  1505.     _classCallCheck(this, ReadableStream);
  1506.  
  1507.     // Exposed to controllers.
  1508.     this._state = 'readable';
  1509.  
  1510.     this._reader = undefined;
  1511.     this._storedError = undefined;
  1512.  
  1513.     this._disturbed = false;
  1514.  
  1515.     // Initialize to undefined first because the constructor of the controller checks this
  1516.     // variable to validate the caller.
  1517.     this._readableStreamController = undefined;
  1518.     var type = underlyingSource.type;
  1519.     var typeString = String(type);
  1520.     if (typeString === 'bytes') {
  1521.       if (highWaterMark === undefined) {
  1522.         highWaterMark = 0;
  1523.       }
  1524.       this._readableStreamController = new ReadableByteStreamController(this, underlyingSource, highWaterMark);
  1525.     } else if (type === undefined) {
  1526.       if (highWaterMark === undefined) {
  1527.         highWaterMark = 1;
  1528.       }
  1529.       this._readableStreamController = new ReadableStreamDefaultController(this, underlyingSource, size, highWaterMark);
  1530.     } else {
  1531.       throw new RangeError('Invalid type is specified');
  1532.     }
  1533.   }
  1534.  
  1535.   _createClass(ReadableStream, [{
  1536.     key: 'cancel',
  1537.     value: function cancel(reason) {
  1538.       if (IsReadableStream(this) === false) {
  1539.         return Promise.reject(streamBrandCheckException('cancel'));
  1540.       }
  1541.  
  1542.       if (IsReadableStreamLocked(this) === true) {
  1543.         return Promise.reject(new TypeError('Cannot cancel a stream that already has a reader'));
  1544.       }
  1545.  
  1546.       return ReadableStreamCancel(this, reason);
  1547.     }
  1548.   }, {
  1549.     key: 'getReader',
  1550.     value: function getReader() {
  1551.       var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
  1552.           mode = _ref2.mode;
  1553.  
  1554.       if (IsReadableStream(this) === false) {
  1555.         throw streamBrandCheckException('getReader');
  1556.       }
  1557.  
  1558.       if (mode === 'byob') {
  1559.         if (IsReadableByteStreamController(this._readableStreamController) === false) {
  1560.           throw new TypeError('Cannot get a ReadableStreamBYOBReader for a stream not constructed with a byte source');
  1561.         }
  1562.  
  1563.         return AcquireReadableStreamBYOBReader(this);
  1564.       }
  1565.  
  1566.       if (mode === undefined) {
  1567.         return AcquireReadableStreamDefaultReader(this);
  1568.       }
  1569.  
  1570.       throw new RangeError('Invalid mode is specified');
  1571.     }
  1572.   }, {
  1573.     key: 'pipeThrough',
  1574.     value: function pipeThrough(_ref3, options) {
  1575.       var writable = _ref3.writable,
  1576.           readable = _ref3.readable;
  1577.  
  1578.       this.pipeTo(writable, options);
  1579.       return readable;
  1580.     }
  1581.   }, {
  1582.     key: 'pipeTo',
  1583.     value: function pipeTo(dest) {
  1584.       var _this = this;
  1585.  
  1586.       var _ref4 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
  1587.           preventClose = _ref4.preventClose,
  1588.           preventAbort = _ref4.preventAbort,
  1589.           preventCancel = _ref4.preventCancel;
  1590.  
  1591.       if (IsReadableStream(this) === false) {
  1592.         return Promise.reject(streamBrandCheckException('pipeTo'));
  1593.       }
  1594.       if (IsWritableStream(dest) === false) {
  1595.         return Promise.reject(new TypeError('ReadableStream.prototype.pipeTo\'s first argument must be a WritableStream'));
  1596.       }
  1597.  
  1598.       preventClose = Boolean(preventClose);
  1599.       preventAbort = Boolean(preventAbort);
  1600.       preventCancel = Boolean(preventCancel);
  1601.  
  1602.       if (IsReadableStreamLocked(this) === true) {
  1603.         return Promise.reject(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream'));
  1604.       }
  1605.       if (IsWritableStreamLocked(dest) === true) {
  1606.         return Promise.reject(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream'));
  1607.       }
  1608.  
  1609.       var reader = AcquireReadableStreamDefaultReader(this);
  1610.       var writer = AcquireWritableStreamDefaultWriter(dest);
  1611.  
  1612.       var shuttingDown = false;
  1613.  
  1614.       // This is used to keep track of the spec's requirement that we wait for ongoing writes during shutdown.
  1615.       var currentWrite = Promise.resolve();
  1616.  
  1617.       return new Promise(function (resolve, reject) {
  1618.         // Using reader and writer, read all chunks from this and write them to dest
  1619.         // - Backpressure must be enforced
  1620.         // - Shutdown must stop all activity
  1621.         function pipeLoop() {
  1622.           currentWrite = Promise.resolve();
  1623.  
  1624.           if (shuttingDown === true) {
  1625.             return Promise.resolve();
  1626.           }
  1627.  
  1628.           return writer._readyPromise.then(function () {
  1629.             return ReadableStreamDefaultReaderRead(reader).then(function (_ref5) {
  1630.               var value = _ref5.value,
  1631.                   done = _ref5.done;
  1632.  
  1633.               if (done === true) {
  1634.                 return undefined;
  1635.               }
  1636.  
  1637.               currentWrite = WritableStreamDefaultWriterWrite(writer, value);
  1638.               return currentWrite;
  1639.             });
  1640.           }).then(pipeLoop);
  1641.         }
  1642.  
  1643.         // Errors must be propagated forward
  1644.         isOrBecomesErrored(_this, reader._closedPromise, function (storedError) {
  1645.           if (preventAbort === false) {
  1646.             shutdownWithAction(function () {
  1647.               return WritableStreamAbort(dest, storedError);
  1648.             }, true, storedError);
  1649.           } else {
  1650.             shutdown(true, storedError);
  1651.           }
  1652.         });
  1653.  
  1654.         // Errors must be propagated backward
  1655.         isOrBecomesErrored(dest, writer._closedPromise, function (storedError) {
  1656.           if (preventCancel === false) {
  1657.             shutdownWithAction(function () {
  1658.               return ReadableStreamCancel(_this, storedError);
  1659.             }, true, storedError);
  1660.           } else {
  1661.             shutdown(true, storedError);
  1662.           }
  1663.         });
  1664.  
  1665.         // Closing must be propagated forward
  1666.         isOrBecomesClosed(_this, reader._closedPromise, function () {
  1667.           if (preventClose === false) {
  1668.             shutdownWithAction(function () {
  1669.               return WritableStreamDefaultWriterCloseWithErrorPropagation(writer);
  1670.             });
  1671.           } else {
  1672.             shutdown();
  1673.           }
  1674.         });
  1675.  
  1676.         // Closing must be propagated backward
  1677.         if (dest._state === 'closing' || dest._state === 'closed') {
  1678.           (function () {
  1679.             var destClosed = new TypeError('the destination writable stream closed before all data could be piped to it');
  1680.  
  1681.             if (preventCancel === false) {
  1682.               shutdownWithAction(function () {
  1683.                 return ReadableStreamCancel(_this, destClosed);
  1684.               }, true, destClosed);
  1685.             } else {
  1686.               shutdown(true, destClosed);
  1687.             }
  1688.           })();
  1689.         }
  1690.  
  1691.         pipeLoop().catch(function (err) {
  1692.           currentWrite = Promise.resolve();
  1693.           rethrowAssertionErrorRejection(err);
  1694.         });
  1695.  
  1696.         function isOrBecomesErrored(stream, promise, action) {
  1697.           if (stream._state === 'errored') {
  1698.             action(stream._storedError);
  1699.           } else {
  1700.             promise.catch(action).catch(rethrowAssertionErrorRejection);
  1701.           }
  1702.         }
  1703.  
  1704.         function isOrBecomesClosed(stream, promise, action) {
  1705.           if (stream._state === 'closed') {
  1706.             action();
  1707.           } else {
  1708.             promise.then(action).catch(rethrowAssertionErrorRejection);
  1709.           }
  1710.         }
  1711.  
  1712.         function waitForCurrentWrite() {
  1713.           return currentWrite.catch(function () {});
  1714.         }
  1715.  
  1716.         function shutdownWithAction(action, originalIsError, originalError) {
  1717.           if (shuttingDown === true) {
  1718.             return;
  1719.           }
  1720.           shuttingDown = true;
  1721.  
  1722.           waitForCurrentWrite().then(function () {
  1723.             return action().then(function () {
  1724.               return finalize(originalIsError, originalError);
  1725.             }, function (newError) {
  1726.               return finalize(true, newError);
  1727.             });
  1728.           }).catch(rethrowAssertionErrorRejection);
  1729.         }
  1730.  
  1731.         function shutdown(isError, error) {
  1732.           if (shuttingDown === true) {
  1733.             return;
  1734.           }
  1735.           shuttingDown = true;
  1736.  
  1737.           waitForCurrentWrite().then(function () {
  1738.             finalize(isError, error);
  1739.           }).catch(rethrowAssertionErrorRejection);
  1740.         }
  1741.  
  1742.         function finalize(isError, error) {
  1743.           WritableStreamDefaultWriterRelease(writer);
  1744.           ReadableStreamReaderGenericRelease(reader);
  1745.  
  1746.           if (isError) {
  1747.             reject(error);
  1748.           } else {
  1749.             resolve(undefined);
  1750.           }
  1751.         }
  1752.       });
  1753.     }
  1754.   }, {
  1755.     key: 'tee',
  1756.     value: function tee() {
  1757.       if (IsReadableStream(this) === false) {
  1758.         throw streamBrandCheckException('tee');
  1759.       }
  1760.  
  1761.       var branches = ReadableStreamTee(this, false);
  1762.       return createArrayFromList(branches);
  1763.     }
  1764.   }, {
  1765.     key: 'locked',
  1766.     get: function get() {
  1767.       if (IsReadableStream(this) === false) {
  1768.         throw streamBrandCheckException('locked');
  1769.       }
  1770.  
  1771.       return IsReadableStreamLocked(this);
  1772.     }
  1773.   }]);
  1774.  
  1775.   return ReadableStream;
  1776. }();
  1777.  
  1778. module.exports = {
  1779.   ReadableStream: ReadableStream,
  1780.   IsReadableStreamDisturbed: IsReadableStreamDisturbed,
  1781.   ReadableStreamDefaultControllerClose: ReadableStreamDefaultControllerClose,
  1782.   ReadableStreamDefaultControllerEnqueue: ReadableStreamDefaultControllerEnqueue,
  1783.   ReadableStreamDefaultControllerError: ReadableStreamDefaultControllerError,
  1784.   ReadableStreamDefaultControllerGetDesiredSize: ReadableStreamDefaultControllerGetDesiredSize
  1785. };
  1786.  
  1787. // Abstract operations for the ReadableStream.
  1788.  
  1789. function AcquireReadableStreamBYOBReader(stream) {
  1790.   return new ReadableStreamBYOBReader(stream);
  1791. }
  1792.  
  1793. function AcquireReadableStreamDefaultReader(stream) {
  1794.   return new ReadableStreamDefaultReader(stream);
  1795. }
  1796.  
  1797. function IsReadableStream(x) {
  1798.   if (!typeIsObject(x)) {
  1799.     return false;
  1800.   }
  1801.  
  1802.   if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {
  1803.     return false;
  1804.   }
  1805.  
  1806.   return true;
  1807. }
  1808.  
  1809. function IsReadableStreamDisturbed(stream) {
  1810.   assert(IsReadableStream(stream) === true, 'IsReadableStreamDisturbed should only be used on known readable streams');
  1811.  
  1812.   return stream._disturbed;
  1813. }
  1814.  
  1815. function IsReadableStreamLocked(stream) {
  1816.   assert(IsReadableStream(stream) === true, 'IsReadableStreamLocked should only be used on known readable streams');
  1817.  
  1818.   if (stream._reader === undefined) {
  1819.     return false;
  1820.   }
  1821.  
  1822.   return true;
  1823. }
  1824.  
  1825. function ReadableStreamTee(stream, cloneForBranch2) {
  1826.   assert(IsReadableStream(stream) === true);
  1827.   assert(typeof cloneForBranch2 === 'boolean');
  1828.  
  1829.   var reader = AcquireReadableStreamDefaultReader(stream);
  1830.  
  1831.   var teeState = {
  1832.     closedOrErrored: false,
  1833.     canceled1: false,
  1834.     canceled2: false,
  1835.     reason1: undefined,
  1836.     reason2: undefined
  1837.   };
  1838.   teeState.promise = new Promise(function (resolve) {
  1839.     teeState._resolve = resolve;
  1840.   });
  1841.  
  1842.   var pull = create_ReadableStreamTeePullFunction();
  1843.   pull._reader = reader;
  1844.   pull._teeState = teeState;
  1845.   pull._cloneForBranch2 = cloneForBranch2;
  1846.  
  1847.   var cancel1 = create_ReadableStreamTeeBranch1CancelFunction();
  1848.   cancel1._stream = stream;
  1849.   cancel1._teeState = teeState;
  1850.  
  1851.   var cancel2 = create_ReadableStreamTeeBranch2CancelFunction();
  1852.   cancel2._stream = stream;
  1853.   cancel2._teeState = teeState;
  1854.  
  1855.   var underlyingSource1 = Object.create(Object.prototype);
  1856.   createDataProperty(underlyingSource1, 'pull', pull);
  1857.   createDataProperty(underlyingSource1, 'cancel', cancel1);
  1858.   var branch1Stream = new ReadableStream(underlyingSource1);
  1859.  
  1860.   var underlyingSource2 = Object.create(Object.prototype);
  1861.   createDataProperty(underlyingSource2, 'pull', pull);
  1862.   createDataProperty(underlyingSource2, 'cancel', cancel2);
  1863.   var branch2Stream = new ReadableStream(underlyingSource2);
  1864.  
  1865.   pull._branch1 = branch1Stream._readableStreamController;
  1866.   pull._branch2 = branch2Stream._readableStreamController;
  1867.  
  1868.   reader._closedPromise.catch(function (r) {
  1869.     if (teeState.closedOrErrored === true) {
  1870.       return;
  1871.     }
  1872.  
  1873.     ReadableStreamDefaultControllerError(pull._branch1, r);
  1874.     ReadableStreamDefaultControllerError(pull._branch2, r);
  1875.     teeState.closedOrErrored = true;
  1876.   });
  1877.  
  1878.   return [branch1Stream, branch2Stream];
  1879. }
  1880.  
  1881. function create_ReadableStreamTeePullFunction() {
  1882.   function f() {
  1883.     var reader = f._reader,
  1884.         branch1 = f._branch1,
  1885.         branch2 = f._branch2,
  1886.         teeState = f._teeState;
  1887.  
  1888.  
  1889.     return ReadableStreamDefaultReaderRead(reader).then(function (result) {
  1890.       assert(typeIsObject(result));
  1891.       var value = result.value;
  1892.       var done = result.done;
  1893.       assert(typeof done === 'boolean');
  1894.  
  1895.       if (done === true && teeState.closedOrErrored === false) {
  1896.         if (teeState.canceled1 === false) {
  1897.           ReadableStreamDefaultControllerClose(branch1);
  1898.         }
  1899.         if (teeState.canceled2 === false) {
  1900.           ReadableStreamDefaultControllerClose(branch2);
  1901.         }
  1902.         teeState.closedOrErrored = true;
  1903.       }
  1904.  
  1905.       if (teeState.closedOrErrored === true) {
  1906.         return;
  1907.       }
  1908.  
  1909.       var value1 = value;
  1910.       var value2 = value;
  1911.  
  1912.       // There is no way to access the cloning code right now in the reference implementation.
  1913.       // If we add one then we'll need an implementation for StructuredClone.
  1914.       // if (teeState.canceled2 === false && cloneForBranch2 === true) {
  1915.       //   value2 = StructuredClone(value2);
  1916.       // }
  1917.  
  1918.       if (teeState.canceled1 === false) {
  1919.         ReadableStreamDefaultControllerEnqueue(branch1, value1);
  1920.       }
  1921.  
  1922.       if (teeState.canceled2 === false) {
  1923.         ReadableStreamDefaultControllerEnqueue(branch2, value2);
  1924.       }
  1925.     });
  1926.   }
  1927.   return f;
  1928. }
  1929.  
  1930. function create_ReadableStreamTeeBranch1CancelFunction() {
  1931.   function f(reason) {
  1932.     var stream = f._stream,
  1933.         teeState = f._teeState;
  1934.  
  1935.  
  1936.     teeState.canceled1 = true;
  1937.     teeState.reason1 = reason;
  1938.     if (teeState.canceled2 === true) {
  1939.       var compositeReason = createArrayFromList([teeState.reason1, teeState.reason2]);
  1940.       var cancelResult = ReadableStreamCancel(stream, compositeReason);
  1941.       teeState._resolve(cancelResult);
  1942.     }
  1943.     return teeState.promise;
  1944.   }
  1945.   return f;
  1946. }
  1947.  
  1948. function create_ReadableStreamTeeBranch2CancelFunction() {
  1949.   function f(reason) {
  1950.     var stream = f._stream,
  1951.         teeState = f._teeState;
  1952.  
  1953.  
  1954.     teeState.canceled2 = true;
  1955.     teeState.reason2 = reason;
  1956.     if (teeState.canceled1 === true) {
  1957.       var compositeReason = createArrayFromList([teeState.reason1, teeState.reason2]);
  1958.       var cancelResult = ReadableStreamCancel(stream, compositeReason);
  1959.       teeState._resolve(cancelResult);
  1960.     }
  1961.     return teeState.promise;
  1962.   }
  1963.   return f;
  1964. }
  1965.  
  1966. // ReadableStream API exposed for controllers.
  1967.  
  1968. function ReadableStreamAddReadIntoRequest(stream) {
  1969.   assert(IsReadableStreamBYOBReader(stream._reader) === true);
  1970.   assert(stream._state === 'readable' || stream._state === 'closed');
  1971.  
  1972.   var promise = new Promise(function (resolve, reject) {
  1973.     var readIntoRequest = {
  1974.       _resolve: resolve,
  1975.       _reject: reject
  1976.     };
  1977.  
  1978.     stream._reader._readIntoRequests.push(readIntoRequest);
  1979.   });
  1980.  
  1981.   return promise;
  1982. }
  1983.  
  1984. function ReadableStreamAddReadRequest(stream) {
  1985.   assert(IsReadableStreamDefaultReader(stream._reader) === true);
  1986.   assert(stream._state === 'readable');
  1987.  
  1988.   var promise = new Promise(function (resolve, reject) {
  1989.     var readRequest = {
  1990.       _resolve: resolve,
  1991.       _reject: reject
  1992.     };
  1993.  
  1994.     stream._reader._readRequests.push(readRequest);
  1995.   });
  1996.  
  1997.   return promise;
  1998. }
  1999.  
  2000. function ReadableStreamCancel(stream, reason) {
  2001.   stream._disturbed = true;
  2002.  
  2003.   if (stream._state === 'closed') {
  2004.     return Promise.resolve(undefined);
  2005.   }
  2006.   if (stream._state === 'errored') {
  2007.     return Promise.reject(stream._storedError);
  2008.   }
  2009.  
  2010.   ReadableStreamClose(stream);
  2011.  
  2012.   var sourceCancelPromise = stream._readableStreamController[InternalCancel](reason);
  2013.   return sourceCancelPromise.then(function () {
  2014.     return undefined;
  2015.   });
  2016. }
  2017.  
  2018. function ReadableStreamClose(stream) {
  2019.   assert(stream._state === 'readable');
  2020.  
  2021.   stream._state = 'closed';
  2022.  
  2023.   var reader = stream._reader;
  2024.  
  2025.   if (reader === undefined) {
  2026.     return undefined;
  2027.   }
  2028.  
  2029.   if (IsReadableStreamDefaultReader(reader) === true) {
  2030.     var _iteratorNormalCompletion = true;
  2031.     var _didIteratorError = false;
  2032.     var _iteratorError = undefined;
  2033.  
  2034.     try {
  2035.       for (var _iterator = reader._readRequests[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
  2036.         var _resolve = _step.value._resolve;
  2037.  
  2038.         _resolve(CreateIterResultObject(undefined, true));
  2039.       }
  2040.     } catch (err) {
  2041.       _didIteratorError = true;
  2042.       _iteratorError = err;
  2043.     } finally {
  2044.       try {
  2045.         if (!_iteratorNormalCompletion && _iterator.return) {
  2046.           _iterator.return();
  2047.         }
  2048.       } finally {
  2049.         if (_didIteratorError) {
  2050.           throw _iteratorError;
  2051.         }
  2052.       }
  2053.     }
  2054.  
  2055.     reader._readRequests = [];
  2056.   }
  2057.  
  2058.   defaultReaderClosedPromiseResolve(reader);
  2059.  
  2060.   return undefined;
  2061. }
  2062.  
  2063. function ReadableStreamError(stream, e) {
  2064.   assert(IsReadableStream(stream) === true, 'stream must be ReadableStream');
  2065.   assert(stream._state === 'readable', 'state must be readable');
  2066.  
  2067.   stream._state = 'errored';
  2068.   stream._storedError = e;
  2069.  
  2070.   var reader = stream._reader;
  2071.  
  2072.   if (reader === undefined) {
  2073.     return undefined;
  2074.   }
  2075.  
  2076.   if (IsReadableStreamDefaultReader(reader) === true) {
  2077.     var _iteratorNormalCompletion2 = true;
  2078.     var _didIteratorError2 = false;
  2079.     var _iteratorError2 = undefined;
  2080.  
  2081.     try {
  2082.       for (var _iterator2 = reader._readRequests[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
  2083.         var readRequest = _step2.value;
  2084.  
  2085.         readRequest._reject(e);
  2086.       }
  2087.     } catch (err) {
  2088.       _didIteratorError2 = true;
  2089.       _iteratorError2 = err;
  2090.     } finally {
  2091.       try {
  2092.         if (!_iteratorNormalCompletion2 && _iterator2.return) {
  2093.           _iterator2.return();
  2094.         }
  2095.       } finally {
  2096.         if (_didIteratorError2) {
  2097.           throw _iteratorError2;
  2098.         }
  2099.       }
  2100.     }
  2101.  
  2102.     reader._readRequests = [];
  2103.   } else {
  2104.     assert(IsReadableStreamBYOBReader(reader), 'reader must be ReadableStreamBYOBReader');
  2105.  
  2106.     var _iteratorNormalCompletion3 = true;
  2107.     var _didIteratorError3 = false;
  2108.     var _iteratorError3 = undefined;
  2109.  
  2110.     try {
  2111.       for (var _iterator3 = reader._readIntoRequests[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
  2112.         var readIntoRequest = _step3.value;
  2113.  
  2114.         readIntoRequest._reject(e);
  2115.       }
  2116.     } catch (err) {
  2117.       _didIteratorError3 = true;
  2118.       _iteratorError3 = err;
  2119.     } finally {
  2120.       try {
  2121.         if (!_iteratorNormalCompletion3 && _iterator3.return) {
  2122.           _iterator3.return();
  2123.         }
  2124.       } finally {
  2125.         if (_didIteratorError3) {
  2126.           throw _iteratorError3;
  2127.         }
  2128.       }
  2129.     }
  2130.  
  2131.     reader._readIntoRequests = [];
  2132.   }
  2133.  
  2134.   defaultReaderClosedPromiseReject(reader, e);
  2135.   reader._closedPromise.catch(function () {});
  2136. }
  2137.  
  2138. function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {
  2139.   var reader = stream._reader;
  2140.  
  2141.   assert(reader._readIntoRequests.length > 0);
  2142.  
  2143.   var readIntoRequest = reader._readIntoRequests.shift();
  2144.   readIntoRequest._resolve(CreateIterResultObject(chunk, done));
  2145. }
  2146.  
  2147. function ReadableStreamFulfillReadRequest(stream, chunk, done) {
  2148.   var reader = stream._reader;
  2149.  
  2150.   assert(reader._readRequests.length > 0);
  2151.  
  2152.   var readRequest = reader._readRequests.shift();
  2153.   readRequest._resolve(CreateIterResultObject(chunk, done));
  2154. }
  2155.  
  2156. function ReadableStreamGetNumReadIntoRequests(stream) {
  2157.   return stream._reader._readIntoRequests.length;
  2158. }
  2159.  
  2160. function ReadableStreamGetNumReadRequests(stream) {
  2161.   return stream._reader._readRequests.length;
  2162. }
  2163.  
  2164. function ReadableStreamHasBYOBReader(stream) {
  2165.   var reader = stream._reader;
  2166.  
  2167.   if (reader === undefined) {
  2168.     return false;
  2169.   }
  2170.  
  2171.   if (IsReadableStreamBYOBReader(reader) === false) {
  2172.     return false;
  2173.   }
  2174.  
  2175.   return true;
  2176. }
  2177.  
  2178. function ReadableStreamHasDefaultReader(stream) {
  2179.   var reader = stream._reader;
  2180.  
  2181.   if (reader === undefined) {
  2182.     return false;
  2183.   }
  2184.  
  2185.   if (IsReadableStreamDefaultReader(reader) === false) {
  2186.     return false;
  2187.   }
  2188.  
  2189.   return true;
  2190. }
  2191.  
  2192. // Readers
  2193.  
  2194. var ReadableStreamDefaultReader = function () {
  2195.   function ReadableStreamDefaultReader(stream) {
  2196.     _classCallCheck(this, ReadableStreamDefaultReader);
  2197.  
  2198.     if (IsReadableStream(stream) === false) {
  2199.       throw new TypeError('ReadableStreamDefaultReader can only be constructed with a ReadableStream instance');
  2200.     }
  2201.     if (IsReadableStreamLocked(stream) === true) {
  2202.       throw new TypeError('This stream has already been locked for exclusive reading by another reader');
  2203.     }
  2204.  
  2205.     ReadableStreamReaderGenericInitialize(this, stream);
  2206.  
  2207.     this._readRequests = [];
  2208.   }
  2209.  
  2210.   _createClass(ReadableStreamDefaultReader, [{
  2211.     key: 'cancel',
  2212.     value: function cancel(reason) {
  2213.       if (IsReadableStreamDefaultReader(this) === false) {
  2214.         return Promise.reject(defaultReaderBrandCheckException('cancel'));
  2215.       }
  2216.  
  2217.       if (this._ownerReadableStream === undefined) {
  2218.         return Promise.reject(readerLockException('cancel'));
  2219.       }
  2220.  
  2221.       return ReadableStreamReaderGenericCancel(this, reason);
  2222.     }
  2223.   }, {
  2224.     key: 'read',
  2225.     value: function read() {
  2226.       if (IsReadableStreamDefaultReader(this) === false) {
  2227.         return Promise.reject(defaultReaderBrandCheckException('read'));
  2228.       }
  2229.  
  2230.       if (this._ownerReadableStream === undefined) {
  2231.         return Promise.reject(readerLockException('read from'));
  2232.       }
  2233.  
  2234.       return ReadableStreamDefaultReaderRead(this);
  2235.     }
  2236.   }, {
  2237.     key: 'releaseLock',
  2238.     value: function releaseLock() {
  2239.       if (IsReadableStreamDefaultReader(this) === false) {
  2240.         throw defaultReaderBrandCheckException('releaseLock');
  2241.       }
  2242.  
  2243.       if (this._ownerReadableStream === undefined) {
  2244.         return;
  2245.       }
  2246.  
  2247.       if (this._readRequests.length > 0) {
  2248.         throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');
  2249.       }
  2250.  
  2251.       ReadableStreamReaderGenericRelease(this);
  2252.     }
  2253.   }, {
  2254.     key: 'closed',
  2255.     get: function get() {
  2256.       if (IsReadableStreamDefaultReader(this) === false) {
  2257.         return Promise.reject(defaultReaderBrandCheckException('closed'));
  2258.       }
  2259.  
  2260.       return this._closedPromise;
  2261.     }
  2262.   }]);
  2263.  
  2264.   return ReadableStreamDefaultReader;
  2265. }();
  2266.  
  2267. var ReadableStreamBYOBReader = function () {
  2268.   function ReadableStreamBYOBReader(stream) {
  2269.     _classCallCheck(this, ReadableStreamBYOBReader);
  2270.  
  2271.     if (!IsReadableStream(stream)) {
  2272.       throw new TypeError('ReadableStreamBYOBReader can only be constructed with a ReadableStream instance given a ' + 'byte source');
  2273.     }
  2274.     if (IsReadableStreamLocked(stream)) {
  2275.       throw new TypeError('This stream has already been locked for exclusive reading by another reader');
  2276.     }
  2277.  
  2278.     ReadableStreamReaderGenericInitialize(this, stream);
  2279.  
  2280.     this._readIntoRequests = [];
  2281.   }
  2282.  
  2283.   _createClass(ReadableStreamBYOBReader, [{
  2284.     key: 'cancel',
  2285.     value: function cancel(reason) {
  2286.       if (!IsReadableStreamBYOBReader(this)) {
  2287.         return Promise.reject(byobReaderBrandCheckException('cancel'));
  2288.       }
  2289.  
  2290.       if (this._ownerReadableStream === undefined) {
  2291.         return Promise.reject(readerLockException('cancel'));
  2292.       }
  2293.  
  2294.       return ReadableStreamReaderGenericCancel(this, reason);
  2295.     }
  2296.   }, {
  2297.     key: 'read',
  2298.     value: function read(view) {
  2299.       if (!IsReadableStreamBYOBReader(this)) {
  2300.         return Promise.reject(byobReaderBrandCheckException('read'));
  2301.       }
  2302.  
  2303.       if (this._ownerReadableStream === undefined) {
  2304.         return Promise.reject(readerLockException('read from'));
  2305.       }
  2306.  
  2307.       if (!ArrayBuffer.isView(view)) {
  2308.         return Promise.reject(new TypeError('view must be an array buffer view'));
  2309.       }
  2310.  
  2311.       if (view.byteLength === 0) {
  2312.         return Promise.reject(new TypeError('view must have non-zero byteLength'));
  2313.       }
  2314.  
  2315.       return ReadableStreamBYOBReaderRead(this, view);
  2316.     }
  2317.   }, {
  2318.     key: 'releaseLock',
  2319.     value: function releaseLock() {
  2320.       if (!IsReadableStreamBYOBReader(this)) {
  2321.         throw byobReaderBrandCheckException('releaseLock');
  2322.       }
  2323.  
  2324.       if (this._ownerReadableStream === undefined) {
  2325.         return;
  2326.       }
  2327.  
  2328.       if (this._readIntoRequests.length > 0) {
  2329.         throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');
  2330.       }
  2331.  
  2332.       ReadableStreamReaderGenericRelease(this);
  2333.     }
  2334.   }, {
  2335.     key: 'closed',
  2336.     get: function get() {
  2337.       if (!IsReadableStreamBYOBReader(this)) {
  2338.         return Promise.reject(byobReaderBrandCheckException('closed'));
  2339.       }
  2340.  
  2341.       return this._closedPromise;
  2342.     }
  2343.   }]);
  2344.  
  2345.   return ReadableStreamBYOBReader;
  2346. }();
  2347.  
  2348. // Abstract operations for the readers.
  2349.  
  2350. function IsReadableStreamBYOBReader(x) {
  2351.   if (!typeIsObject(x)) {
  2352.     return false;
  2353.   }
  2354.  
  2355.   if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {
  2356.     return false;
  2357.   }
  2358.  
  2359.   return true;
  2360. }
  2361.  
  2362. function IsReadableStreamDefaultReader(x) {
  2363.   if (!typeIsObject(x)) {
  2364.     return false;
  2365.   }
  2366.  
  2367.   if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {
  2368.     return false;
  2369.   }
  2370.  
  2371.   return true;
  2372. }
  2373.  
  2374. function ReadableStreamReaderGenericInitialize(reader, stream) {
  2375.   reader._ownerReadableStream = stream;
  2376.   stream._reader = reader;
  2377.  
  2378.   if (stream._state === 'readable') {
  2379.     defaultReaderClosedPromiseInitialize(reader);
  2380.   } else if (stream._state === 'closed') {
  2381.     defaultReaderClosedPromiseInitializeAsResolved(reader);
  2382.   } else {
  2383.     assert(stream._state === 'errored', 'state must be errored');
  2384.  
  2385.     defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
  2386.     reader._closedPromise.catch(function () {});
  2387.   }
  2388. }
  2389.  
  2390. // A client of ReadableStreamDefaultReader and ReadableStreamBYOBReader may use these functions directly to bypass state
  2391. // check.
  2392.  
  2393. function ReadableStreamReaderGenericCancel(reader, reason) {
  2394.   var stream = reader._ownerReadableStream;
  2395.   assert(stream !== undefined);
  2396.   return ReadableStreamCancel(stream, reason);
  2397. }
  2398.  
  2399. function ReadableStreamReaderGenericRelease(reader) {
  2400.   assert(reader._ownerReadableStream !== undefined);
  2401.   assert(reader._ownerReadableStream._reader === reader);
  2402.  
  2403.   if (reader._ownerReadableStream._state === 'readable') {
  2404.     defaultReaderClosedPromiseReject(reader, new TypeError('Reader was released and can no longer be used to monitor the stream\'s closedness'));
  2405.   } else {
  2406.     defaultReaderClosedPromiseResetToRejected(reader, new TypeError('Reader was released and can no longer be used to monitor the stream\'s closedness'));
  2407.   }
  2408.   reader._closedPromise.catch(function () {});
  2409.  
  2410.   reader._ownerReadableStream._reader = undefined;
  2411.   reader._ownerReadableStream = undefined;
  2412. }
  2413.  
  2414. function ReadableStreamBYOBReaderRead(reader, view) {
  2415.   var stream = reader._ownerReadableStream;
  2416.  
  2417.   assert(stream !== undefined);
  2418.  
  2419.   stream._disturbed = true;
  2420.  
  2421.   if (stream._state === 'errored') {
  2422.     return Promise.reject(stream._storedError);
  2423.   }
  2424.  
  2425.   // Controllers must implement this.
  2426.   return ReadableByteStreamControllerPullInto(stream._readableStreamController, view);
  2427. }
  2428.  
  2429. function ReadableStreamDefaultReaderRead(reader) {
  2430.   var stream = reader._ownerReadableStream;
  2431.  
  2432.   assert(stream !== undefined);
  2433.  
  2434.   stream._disturbed = true;
  2435.  
  2436.   if (stream._state === 'closed') {
  2437.     return Promise.resolve(CreateIterResultObject(undefined, true));
  2438.   }
  2439.  
  2440.   if (stream._state === 'errored') {
  2441.     return Promise.reject(stream._storedError);
  2442.   }
  2443.  
  2444.   assert(stream._state === 'readable');
  2445.  
  2446.   return stream._readableStreamController[InternalPull]();
  2447. }
  2448.  
  2449. // Controllers
  2450.  
  2451. var ReadableStreamDefaultController = function () {
  2452.   function ReadableStreamDefaultController(stream, underlyingSource, size, highWaterMark) {
  2453.     _classCallCheck(this, ReadableStreamDefaultController);
  2454.  
  2455.     if (IsReadableStream(stream) === false) {
  2456.       throw new TypeError('ReadableStreamDefaultController can only be constructed with a ReadableStream instance');
  2457.     }
  2458.  
  2459.     if (stream._readableStreamController !== undefined) {
  2460.       throw new TypeError('ReadableStreamDefaultController instances can only be created by the ReadableStream constructor');
  2461.     }
  2462.  
  2463.     this._controlledReadableStream = stream;
  2464.  
  2465.     this._underlyingSource = underlyingSource;
  2466.  
  2467.     this._queue = [];
  2468.     this._started = false;
  2469.     this._closeRequested = false;
  2470.     this._pullAgain = false;
  2471.     this._pulling = false;
  2472.  
  2473.     var normalizedStrategy = ValidateAndNormalizeQueuingStrategy(size, highWaterMark);
  2474.     this._strategySize = normalizedStrategy.size;
  2475.     this._strategyHWM = normalizedStrategy.highWaterMark;
  2476.  
  2477.     var controller = this;
  2478.  
  2479.     var startResult = InvokeOrNoop(underlyingSource, 'start', [this]);
  2480.     Promise.resolve(startResult).then(function () {
  2481.       controller._started = true;
  2482.  
  2483.       assert(controller._pulling === false);
  2484.       assert(controller._pullAgain === false);
  2485.  
  2486.       ReadableStreamDefaultControllerCallPullIfNeeded(controller);
  2487.     }, function (r) {
  2488.       ReadableStreamDefaultControllerErrorIfNeeded(controller, r);
  2489.     }).catch(rethrowAssertionErrorRejection);
  2490.   }
  2491.  
  2492.   _createClass(ReadableStreamDefaultController, [{
  2493.     key: 'close',
  2494.     value: function close() {
  2495.       if (IsReadableStreamDefaultController(this) === false) {
  2496.         throw defaultControllerBrandCheckException('close');
  2497.       }
  2498.  
  2499.       if (this._closeRequested === true) {
  2500.         throw new TypeError('The stream has already been closed; do not close it again!');
  2501.       }
  2502.  
  2503.       var state = this._controlledReadableStream._state;
  2504.       if (state !== 'readable') {
  2505.         throw new TypeError('The stream (in ' + state + ' state) is not in the readable state and cannot be closed');
  2506.       }
  2507.  
  2508.       ReadableStreamDefaultControllerClose(this);
  2509.     }
  2510.   }, {
  2511.     key: 'enqueue',
  2512.     value: function enqueue(chunk) {
  2513.       if (IsReadableStreamDefaultController(this) === false) {
  2514.         throw defaultControllerBrandCheckException('enqueue');
  2515.       }
  2516.  
  2517.       if (this._closeRequested === true) {
  2518.         throw new TypeError('stream is closed or draining');
  2519.       }
  2520.  
  2521.       var state = this._controlledReadableStream._state;
  2522.       if (state !== 'readable') {
  2523.         throw new TypeError('The stream (in ' + state + ' state) is not in the readable state and cannot be enqueued to');
  2524.       }
  2525.  
  2526.       return ReadableStreamDefaultControllerEnqueue(this, chunk);
  2527.     }
  2528.   }, {
  2529.     key: 'error',
  2530.     value: function error(e) {
  2531.       if (IsReadableStreamDefaultController(this) === false) {
  2532.         throw defaultControllerBrandCheckException('error');
  2533.       }
  2534.  
  2535.       var stream = this._controlledReadableStream;
  2536.       if (stream._state !== 'readable') {
  2537.         throw new TypeError('The stream is ' + stream._state + ' and so cannot be errored');
  2538.       }
  2539.  
  2540.       ReadableStreamDefaultControllerError(this, e);
  2541.     }
  2542.   }, {
  2543.     key: InternalCancel,
  2544.     value: function value(reason) {
  2545.       this._queue = [];
  2546.  
  2547.       return PromiseInvokeOrNoop(this._underlyingSource, 'cancel', [reason]);
  2548.     }
  2549.   }, {
  2550.     key: InternalPull,
  2551.     value: function value() {
  2552.       var stream = this._controlledReadableStream;
  2553.  
  2554.       if (this._queue.length > 0) {
  2555.         var chunk = DequeueValue(this._queue);
  2556.  
  2557.         if (this._closeRequested === true && this._queue.length === 0) {
  2558.           ReadableStreamClose(stream);
  2559.         } else {
  2560.           ReadableStreamDefaultControllerCallPullIfNeeded(this);
  2561.         }
  2562.  
  2563.         return Promise.resolve(CreateIterResultObject(chunk, false));
  2564.       }
  2565.  
  2566.       var pendingPromise = ReadableStreamAddReadRequest(stream);
  2567.       ReadableStreamDefaultControllerCallPullIfNeeded(this);
  2568.       return pendingPromise;
  2569.     }
  2570.   }, {
  2571.     key: 'desiredSize',
  2572.     get: function get() {
  2573.       if (IsReadableStreamDefaultController(this) === false) {
  2574.         throw defaultControllerBrandCheckException('desiredSize');
  2575.       }
  2576.  
  2577.       return ReadableStreamDefaultControllerGetDesiredSize(this);
  2578.     }
  2579.   }]);
  2580.  
  2581.   return ReadableStreamDefaultController;
  2582. }();
  2583.  
  2584. // Abstract operations for the ReadableStreamDefaultController.
  2585.  
  2586. function IsReadableStreamDefaultController(x) {
  2587.   if (!typeIsObject(x)) {
  2588.     return false;
  2589.   }
  2590.  
  2591.   if (!Object.prototype.hasOwnProperty.call(x, '_underlyingSource')) {
  2592.     return false;
  2593.   }
  2594.  
  2595.   return true;
  2596. }
  2597.  
  2598. function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
  2599.   var shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
  2600.   if (shouldPull === false) {
  2601.     return undefined;
  2602.   }
  2603.  
  2604.   if (controller._pulling === true) {
  2605.     controller._pullAgain = true;
  2606.     return undefined;
  2607.   }
  2608.  
  2609.   assert(controller._pullAgain === false);
  2610.  
  2611.   controller._pulling = true;
  2612.  
  2613.   var pullPromise = PromiseInvokeOrNoop(controller._underlyingSource, 'pull', [controller]);
  2614.   pullPromise.then(function () {
  2615.     controller._pulling = false;
  2616.  
  2617.     if (controller._pullAgain === true) {
  2618.       controller._pullAgain = false;
  2619.       return ReadableStreamDefaultControllerCallPullIfNeeded(controller);
  2620.     }
  2621.     return undefined;
  2622.   }, function (e) {
  2623.     ReadableStreamDefaultControllerErrorIfNeeded(controller, e);
  2624.   }).catch(rethrowAssertionErrorRejection);
  2625.  
  2626.   return undefined;
  2627. }
  2628.  
  2629. function ReadableStreamDefaultControllerShouldCallPull(controller) {
  2630.   var stream = controller._controlledReadableStream;
  2631.  
  2632.   if (stream._state === 'closed' || stream._state === 'errored') {
  2633.     return false;
  2634.   }
  2635.  
  2636.   if (controller._closeRequested === true) {
  2637.     return false;
  2638.   }
  2639.  
  2640.   if (controller._started === false) {
  2641.     return false;
  2642.   }
  2643.  
  2644.   if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
  2645.     return true;
  2646.   }
  2647.  
  2648.   var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
  2649.   if (desiredSize > 0) {
  2650.     return true;
  2651.   }
  2652.  
  2653.   return false;
  2654. }
  2655.  
  2656. // A client of ReadableStreamDefaultController may use these functions directly to bypass state check.
  2657.  
  2658. function ReadableStreamDefaultControllerClose(controller) {
  2659.   var stream = controller._controlledReadableStream;
  2660.  
  2661.   assert(controller._closeRequested === false);
  2662.   assert(stream._state === 'readable');
  2663.  
  2664.   controller._closeRequested = true;
  2665.  
  2666.   if (controller._queue.length === 0) {
  2667.     ReadableStreamClose(stream);
  2668.   }
  2669. }
  2670.  
  2671. function ReadableStreamDefaultControllerEnqueue(controller, chunk) {
  2672.   var stream = controller._controlledReadableStream;
  2673.  
  2674.   assert(controller._closeRequested === false);
  2675.   assert(stream._state === 'readable');
  2676.  
  2677.   if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
  2678.     ReadableStreamFulfillReadRequest(stream, chunk, false);
  2679.   } else {
  2680.     var chunkSize = 1;
  2681.  
  2682.     if (controller._strategySize !== undefined) {
  2683.       try {
  2684.         chunkSize = controller._strategySize(chunk);
  2685.       } catch (chunkSizeE) {
  2686.         ReadableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
  2687.         throw chunkSizeE;
  2688.       }
  2689.     }
  2690.  
  2691.     try {
  2692.       EnqueueValueWithSize(controller._queue, chunk, chunkSize);
  2693.     } catch (enqueueE) {
  2694.       ReadableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
  2695.       throw enqueueE;
  2696.     }
  2697.   }
  2698.  
  2699.   ReadableStreamDefaultControllerCallPullIfNeeded(controller);
  2700.  
  2701.   return undefined;
  2702. }
  2703.  
  2704. function ReadableStreamDefaultControllerError(controller, e) {
  2705.   var stream = controller._controlledReadableStream;
  2706.  
  2707.   assert(stream._state === 'readable');
  2708.  
  2709.   controller._queue = [];
  2710.  
  2711.   ReadableStreamError(stream, e);
  2712. }
  2713.  
  2714. function ReadableStreamDefaultControllerErrorIfNeeded(controller, e) {
  2715.   if (controller._controlledReadableStream._state === 'readable') {
  2716.     ReadableStreamDefaultControllerError(controller, e);
  2717.   }
  2718. }
  2719.  
  2720. function ReadableStreamDefaultControllerGetDesiredSize(controller) {
  2721.   var queueSize = GetTotalQueueSize(controller._queue);
  2722.   return controller._strategyHWM - queueSize;
  2723. }
  2724.  
  2725. var ReadableStreamBYOBRequest = function () {
  2726.   function ReadableStreamBYOBRequest(controller, view) {
  2727.     _classCallCheck(this, ReadableStreamBYOBRequest);
  2728.  
  2729.     this._associatedReadableByteStreamController = controller;
  2730.     this._view = view;
  2731.   }
  2732.  
  2733.   _createClass(ReadableStreamBYOBRequest, [{
  2734.     key: 'respond',
  2735.     value: function respond(bytesWritten) {
  2736.       if (IsReadableStreamBYOBRequest(this) === false) {
  2737.         throw byobRequestBrandCheckException('respond');
  2738.       }
  2739.  
  2740.       if (this._associatedReadableByteStreamController === undefined) {
  2741.         throw new TypeError('This BYOB request has been invalidated');
  2742.       }
  2743.  
  2744.       ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);
  2745.     }
  2746.   }, {
  2747.     key: 'respondWithNewView',
  2748.     value: function respondWithNewView(view) {
  2749.       if (IsReadableStreamBYOBRequest(this) === false) {
  2750.         throw byobRequestBrandCheckException('respond');
  2751.       }
  2752.  
  2753.       if (this._associatedReadableByteStreamController === undefined) {
  2754.         throw new TypeError('This BYOB request has been invalidated');
  2755.       }
  2756.  
  2757.       if (!ArrayBuffer.isView(view)) {
  2758.         throw new TypeError('You can only respond with array buffer views');
  2759.       }
  2760.  
  2761.       ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
  2762.     }
  2763.   }, {
  2764.     key: 'view',
  2765.     get: function get() {
  2766.       return this._view;
  2767.     }
  2768.   }]);
  2769.  
  2770.   return ReadableStreamBYOBRequest;
  2771. }();
  2772.  
  2773. var ReadableByteStreamController = function () {
  2774.   function ReadableByteStreamController(stream, underlyingByteSource, highWaterMark) {
  2775.     _classCallCheck(this, ReadableByteStreamController);
  2776.  
  2777.     if (IsReadableStream(stream) === false) {
  2778.       throw new TypeError('ReadableByteStreamController can only be constructed with a ReadableStream instance given ' + 'a byte source');
  2779.     }
  2780.  
  2781.     if (stream._readableStreamController !== undefined) {
  2782.       throw new TypeError('ReadableByteStreamController instances can only be created by the ReadableStream constructor given a byte ' + 'source');
  2783.     }
  2784.  
  2785.     this._controlledReadableStream = stream;
  2786.  
  2787.     this._underlyingByteSource = underlyingByteSource;
  2788.  
  2789.     this._pullAgain = false;
  2790.     this._pulling = false;
  2791.  
  2792.     ReadableByteStreamControllerClearPendingPullIntos(this);
  2793.  
  2794.     this._queue = [];
  2795.     this._totalQueuedBytes = 0;
  2796.  
  2797.     this._closeRequested = false;
  2798.  
  2799.     this._started = false;
  2800.  
  2801.     this._strategyHWM = ValidateAndNormalizeHighWaterMark(highWaterMark);
  2802.  
  2803.     var autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
  2804.     if (autoAllocateChunkSize !== undefined) {
  2805.       if (Number.isInteger(autoAllocateChunkSize) === false || autoAllocateChunkSize <= 0) {
  2806.         throw new RangeError('autoAllocateChunkSize must be a positive integer');
  2807.       }
  2808.     }
  2809.     this._autoAllocateChunkSize = autoAllocateChunkSize;
  2810.  
  2811.     this._pendingPullIntos = [];
  2812.  
  2813.     var controller = this;
  2814.  
  2815.     var startResult = InvokeOrNoop(underlyingByteSource, 'start', [this]);
  2816.     Promise.resolve(startResult).then(function () {
  2817.       controller._started = true;
  2818.  
  2819.       assert(controller._pulling === false);
  2820.       assert(controller._pullAgain === false);
  2821.  
  2822.       ReadableByteStreamControllerCallPullIfNeeded(controller);
  2823.     }, function (r) {
  2824.       if (stream._state === 'readable') {
  2825.         ReadableByteStreamControllerError(controller, r);
  2826.       }
  2827.     }).catch(rethrowAssertionErrorRejection);
  2828.   }
  2829.  
  2830.   _createClass(ReadableByteStreamController, [{
  2831.     key: 'close',
  2832.     value: function close() {
  2833.       if (IsReadableByteStreamController(this) === false) {
  2834.         throw byteStreamControllerBrandCheckException('close');
  2835.       }
  2836.  
  2837.       if (this._closeRequested === true) {
  2838.         throw new TypeError('The stream has already been closed; do not close it again!');
  2839.       }
  2840.  
  2841.       var state = this._controlledReadableStream._state;
  2842.       if (state !== 'readable') {
  2843.         throw new TypeError('The stream (in ' + state + ' state) is not in the readable state and cannot be closed');
  2844.       }
  2845.  
  2846.       ReadableByteStreamControllerClose(this);
  2847.     }
  2848.   }, {
  2849.     key: 'enqueue',
  2850.     value: function enqueue(chunk) {
  2851.       if (IsReadableByteStreamController(this) === false) {
  2852.         throw byteStreamControllerBrandCheckException('enqueue');
  2853.       }
  2854.  
  2855.       if (this._closeRequested === true) {
  2856.         throw new TypeError('stream is closed or draining');
  2857.       }
  2858.  
  2859.       var state = this._controlledReadableStream._state;
  2860.       if (state !== 'readable') {
  2861.         throw new TypeError('The stream (in ' + state + ' state) is not in the readable state and cannot be enqueued to');
  2862.       }
  2863.  
  2864.       if (!ArrayBuffer.isView(chunk)) {
  2865.         throw new TypeError('You can only enqueue array buffer views when using a ReadableByteStreamController');
  2866.       }
  2867.  
  2868.       ReadableByteStreamControllerEnqueue(this, chunk);
  2869.     }
  2870.   }, {
  2871.     key: 'error',
  2872.     value: function error(e) {
  2873.       if (IsReadableByteStreamController(this) === false) {
  2874.         throw byteStreamControllerBrandCheckException('error');
  2875.       }
  2876.  
  2877.       var stream = this._controlledReadableStream;
  2878.       if (stream._state !== 'readable') {
  2879.         throw new TypeError('The stream is ' + stream._state + ' and so cannot be errored');
  2880.       }
  2881.  
  2882.       ReadableByteStreamControllerError(this, e);
  2883.     }
  2884.   }, {
  2885.     key: InternalCancel,
  2886.     value: function value(reason) {
  2887.       if (this._pendingPullIntos.length > 0) {
  2888.         var firstDescriptor = this._pendingPullIntos[0];
  2889.         firstDescriptor.bytesFilled = 0;
  2890.       }
  2891.  
  2892.       this._queue = [];
  2893.       this._totalQueuedBytes = 0;
  2894.  
  2895.       return PromiseInvokeOrNoop(this._underlyingByteSource, 'cancel', [reason]);
  2896.     }
  2897.   }, {
  2898.     key: InternalPull,
  2899.     value: function value() {
  2900.       var stream = this._controlledReadableStream;
  2901.  
  2902.       if (ReadableStreamGetNumReadRequests(stream) === 0) {
  2903.         if (this._totalQueuedBytes > 0) {
  2904.           var entry = this._queue.shift();
  2905.           this._totalQueuedBytes -= entry.byteLength;
  2906.  
  2907.           ReadableByteStreamControllerHandleQueueDrain(this);
  2908.  
  2909.           var view = void 0;
  2910.           try {
  2911.             view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
  2912.           } catch (viewE) {
  2913.             return Promise.reject(viewE);
  2914.           }
  2915.  
  2916.           return Promise.resolve(CreateIterResultObject(view, false));
  2917.         }
  2918.  
  2919.         var autoAllocateChunkSize = this._autoAllocateChunkSize;
  2920.         if (autoAllocateChunkSize !== undefined) {
  2921.           var buffer = void 0;
  2922.           try {
  2923.             buffer = new ArrayBuffer(autoAllocateChunkSize);
  2924.           } catch (bufferE) {
  2925.             return Promise.reject(bufferE);
  2926.           }
  2927.  
  2928.           var pullIntoDescriptor = {
  2929.             buffer: buffer,
  2930.             byteOffset: 0,
  2931.             byteLength: autoAllocateChunkSize,
  2932.             bytesFilled: 0,
  2933.             elementSize: 1,
  2934.             ctor: Uint8Array,
  2935.             readerType: 'default'
  2936.           };
  2937.  
  2938.           this._pendingPullIntos.push(pullIntoDescriptor);
  2939.         }
  2940.       } else {
  2941.         assert(this._autoAllocateChunkSize === undefined);
  2942.       }
  2943.  
  2944.       var promise = ReadableStreamAddReadRequest(stream);
  2945.  
  2946.       ReadableByteStreamControllerCallPullIfNeeded(this);
  2947.  
  2948.       return promise;
  2949.     }
  2950.   }, {
  2951.     key: 'byobRequest',
  2952.     get: function get() {
  2953.       if (IsReadableByteStreamController(this) === false) {
  2954.         throw byteStreamControllerBrandCheckException('byobRequest');
  2955.       }
  2956.  
  2957.       if (this._byobRequest === undefined && this._pendingPullIntos.length > 0) {
  2958.         var firstDescriptor = this._pendingPullIntos[0];
  2959.         var view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
  2960.  
  2961.         this._byobRequest = new ReadableStreamBYOBRequest(this, view);
  2962.       }
  2963.  
  2964.       return this._byobRequest;
  2965.     }
  2966.   }, {
  2967.     key: 'desiredSize',
  2968.     get: function get() {
  2969.       if (IsReadableByteStreamController(this) === false) {
  2970.         throw byteStreamControllerBrandCheckException('desiredSize');
  2971.       }
  2972.  
  2973.       return ReadableByteStreamControllerGetDesiredSize(this);
  2974.     }
  2975.   }]);
  2976.  
  2977.   return ReadableByteStreamController;
  2978. }();
  2979.  
  2980. // Abstract operations for the ReadableByteStreamController.
  2981.  
  2982. function IsReadableByteStreamController(x) {
  2983.   if (!typeIsObject(x)) {
  2984.     return false;
  2985.   }
  2986.  
  2987.   if (!Object.prototype.hasOwnProperty.call(x, '_underlyingByteSource')) {
  2988.     return false;
  2989.   }
  2990.  
  2991.   return true;
  2992. }
  2993.  
  2994. function IsReadableStreamBYOBRequest(x) {
  2995.   if (!typeIsObject(x)) {
  2996.     return false;
  2997.   }
  2998.  
  2999.   if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {
  3000.     return false;
  3001.   }
  3002.  
  3003.   return true;
  3004. }
  3005.  
  3006. function ReadableByteStreamControllerCallPullIfNeeded(controller) {
  3007.   var shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
  3008.   if (shouldPull === false) {
  3009.     return undefined;
  3010.   }
  3011.  
  3012.   if (controller._pulling === true) {
  3013.     controller._pullAgain = true;
  3014.     return undefined;
  3015.   }
  3016.  
  3017.   assert(controller._pullAgain === false);
  3018.  
  3019.   controller._pulling = true;
  3020.  
  3021.   // TODO: Test controller argument
  3022.   var pullPromise = PromiseInvokeOrNoop(controller._underlyingByteSource, 'pull', [controller]);
  3023.   pullPromise.then(function () {
  3024.     controller._pulling = false;
  3025.  
  3026.     if (controller._pullAgain === true) {
  3027.       controller._pullAgain = false;
  3028.       ReadableByteStreamControllerCallPullIfNeeded(controller);
  3029.     }
  3030.   }, function (e) {
  3031.     if (controller._controlledReadableStream._state === 'readable') {
  3032.       ReadableByteStreamControllerError(controller, e);
  3033.     }
  3034.   }).catch(rethrowAssertionErrorRejection);
  3035.  
  3036.   return undefined;
  3037. }
  3038.  
  3039. function ReadableByteStreamControllerClearPendingPullIntos(controller) {
  3040.   ReadableByteStreamControllerInvalidateBYOBRequest(controller);
  3041.   controller._pendingPullIntos = [];
  3042. }
  3043.  
  3044. function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {
  3045.   assert(stream._state !== 'errored', 'state must not be errored');
  3046.  
  3047.   var done = false;
  3048.   if (stream._state === 'closed') {
  3049.     assert(pullIntoDescriptor.bytesFilled === 0);
  3050.     done = true;
  3051.   }
  3052.  
  3053.   var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
  3054.   if (pullIntoDescriptor.readerType === 'default') {
  3055.     ReadableStreamFulfillReadRequest(stream, filledView, done);
  3056.   } else {
  3057.     assert(pullIntoDescriptor.readerType === 'byob');
  3058.     ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
  3059.   }
  3060. }
  3061.  
  3062. function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {
  3063.   var bytesFilled = pullIntoDescriptor.bytesFilled;
  3064.   var elementSize = pullIntoDescriptor.elementSize;
  3065.  
  3066.   assert(bytesFilled <= pullIntoDescriptor.byteLength);
  3067.   assert(bytesFilled % elementSize === 0);
  3068.  
  3069.   return new pullIntoDescriptor.ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize);
  3070. }
  3071.  
  3072. function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) {
  3073.   controller._queue.push({ buffer: buffer, byteOffset: byteOffset, byteLength: byteLength });
  3074.   controller._totalQueuedBytes += byteLength;
  3075. }
  3076.  
  3077. function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {
  3078.   var elementSize = pullIntoDescriptor.elementSize;
  3079.  
  3080.   var currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize;
  3081.  
  3082.   var maxBytesToCopy = Math.min(controller._totalQueuedBytes, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
  3083.   var maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
  3084.   var maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize;
  3085.  
  3086.   var totalBytesToCopyRemaining = maxBytesToCopy;
  3087.   var ready = false;
  3088.   if (maxAlignedBytes > currentAlignedBytes) {
  3089.     totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
  3090.     ready = true;
  3091.   }
  3092.  
  3093.   var queue = controller._queue;
  3094.  
  3095.   while (totalBytesToCopyRemaining > 0) {
  3096.     var headOfQueue = queue[0];
  3097.  
  3098.     var bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength);
  3099.  
  3100.     var destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
  3101.     ArrayBufferCopy(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy);
  3102.  
  3103.     if (headOfQueue.byteLength === bytesToCopy) {
  3104.       queue.shift();
  3105.     } else {
  3106.       headOfQueue.byteOffset += bytesToCopy;
  3107.       headOfQueue.byteLength -= bytesToCopy;
  3108.     }
  3109.     controller._totalQueuedBytes -= bytesToCopy;
  3110.  
  3111.     ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor);
  3112.  
  3113.     totalBytesToCopyRemaining -= bytesToCopy;
  3114.   }
  3115.  
  3116.   if (ready === false) {
  3117.     assert(controller._totalQueuedBytes === 0, 'queue must be empty');
  3118.     assert(pullIntoDescriptor.bytesFilled > 0);
  3119.     assert(pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize);
  3120.   }
  3121.  
  3122.   return ready;
  3123. }
  3124.  
  3125. function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
  3126.   assert(controller._pendingPullIntos.length === 0 || controller._pendingPullIntos[0] === pullIntoDescriptor);
  3127.  
  3128.   ReadableByteStreamControllerInvalidateBYOBRequest(controller);
  3129.   pullIntoDescriptor.bytesFilled += size;
  3130. }
  3131.  
  3132. function ReadableByteStreamControllerHandleQueueDrain(controller) {
  3133.   assert(controller._controlledReadableStream._state === 'readable');
  3134.  
  3135.   if (controller._totalQueuedBytes === 0 && controller._closeRequested === true) {
  3136.     ReadableStreamClose(controller._controlledReadableStream);
  3137.   } else {
  3138.     ReadableByteStreamControllerCallPullIfNeeded(controller);
  3139.   }
  3140. }
  3141.  
  3142. function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {
  3143.   if (controller._byobRequest === undefined) {
  3144.     return;
  3145.   }
  3146.  
  3147.   controller._byobRequest._associatedReadableByteStreamController = undefined;
  3148.   controller._byobRequest._view = undefined;
  3149.   controller._byobRequest = undefined;
  3150. }
  3151.  
  3152. function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {
  3153.   assert(controller._closeRequested === false);
  3154.  
  3155.   while (controller._pendingPullIntos.length > 0) {
  3156.     if (controller._totalQueuedBytes === 0) {
  3157.       return;
  3158.     }
  3159.  
  3160.     var pullIntoDescriptor = controller._pendingPullIntos[0];
  3161.  
  3162.     if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {
  3163.       ReadableByteStreamControllerShiftPendingPullInto(controller);
  3164.  
  3165.       ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableStream, pullIntoDescriptor);
  3166.     }
  3167.   }
  3168. }
  3169.  
  3170. function ReadableByteStreamControllerPullInto(controller, view) {
  3171.   var stream = controller._controlledReadableStream;
  3172.  
  3173.   var elementSize = 1;
  3174.   if (view.constructor !== DataView) {
  3175.     elementSize = view.constructor.BYTES_PER_ELEMENT;
  3176.   }
  3177.  
  3178.   var ctor = view.constructor;
  3179.  
  3180.   var pullIntoDescriptor = {
  3181.     buffer: view.buffer,
  3182.     byteOffset: view.byteOffset,
  3183.     byteLength: view.byteLength,
  3184.     bytesFilled: 0,
  3185.     elementSize: elementSize,
  3186.     ctor: ctor,
  3187.     readerType: 'byob'
  3188.   };
  3189.  
  3190.   if (controller._pendingPullIntos.length > 0) {
  3191.     pullIntoDescriptor.buffer = SameRealmTransfer(pullIntoDescriptor.buffer);
  3192.     controller._pendingPullIntos.push(pullIntoDescriptor);
  3193.  
  3194.     // No ReadableByteStreamControllerCallPullIfNeeded() call since:
  3195.     // - No change happens on desiredSize
  3196.     // - The source has already been notified of that there's at least 1 pending read(view)
  3197.  
  3198.     return ReadableStreamAddReadIntoRequest(stream);
  3199.   }
  3200.  
  3201.   if (stream._state === 'closed') {
  3202.     var emptyView = new view.constructor(view.buffer, view.byteOffset, 0);
  3203.     return Promise.resolve(CreateIterResultObject(emptyView, true));
  3204.   }
  3205.  
  3206.   if (controller._totalQueuedBytes > 0) {
  3207.     if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {
  3208.       var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
  3209.  
  3210.       ReadableByteStreamControllerHandleQueueDrain(controller);
  3211.  
  3212.       return Promise.resolve(CreateIterResultObject(filledView, false));
  3213.     }
  3214.  
  3215.     if (controller._closeRequested === true) {
  3216.       var e = new TypeError('Insufficient bytes to fill elements in the given buffer');
  3217.       ReadableByteStreamControllerError(controller, e);
  3218.  
  3219.       return Promise.reject(e);
  3220.     }
  3221.   }
  3222.  
  3223.   pullIntoDescriptor.buffer = SameRealmTransfer(pullIntoDescriptor.buffer);
  3224.   controller._pendingPullIntos.push(pullIntoDescriptor);
  3225.  
  3226.   var promise = ReadableStreamAddReadIntoRequest(stream);
  3227.  
  3228.   ReadableByteStreamControllerCallPullIfNeeded(controller);
  3229.  
  3230.   return promise;
  3231. }
  3232.  
  3233. function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
  3234.   firstDescriptor.buffer = SameRealmTransfer(firstDescriptor.buffer);
  3235.  
  3236.   assert(firstDescriptor.bytesFilled === 0, 'bytesFilled must be 0');
  3237.  
  3238.   var stream = controller._controlledReadableStream;
  3239.  
  3240.   while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
  3241.     var pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);
  3242.  
  3243.     ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);
  3244.   }
  3245. }
  3246.  
  3247. function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
  3248.   if (pullIntoDescriptor.bytesFilled + bytesWritten > pullIntoDescriptor.byteLength) {
  3249.     throw new RangeError('bytesWritten out of range');
  3250.   }
  3251.  
  3252.   ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
  3253.  
  3254.   if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {
  3255.     // TODO: Figure out whether we should detach the buffer or not here.
  3256.     return;
  3257.   }
  3258.  
  3259.   ReadableByteStreamControllerShiftPendingPullInto(controller);
  3260.  
  3261.   var remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
  3262.   if (remainderSize > 0) {
  3263.     var end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
  3264.     var remainder = pullIntoDescriptor.buffer.slice(end - remainderSize, end);
  3265.     ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);
  3266.   }
  3267.  
  3268.   pullIntoDescriptor.buffer = SameRealmTransfer(pullIntoDescriptor.buffer);
  3269.   pullIntoDescriptor.bytesFilled -= remainderSize;
  3270.   ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableStream, pullIntoDescriptor);
  3271.  
  3272.   ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
  3273. }
  3274.  
  3275. function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
  3276.   var firstDescriptor = controller._pendingPullIntos[0];
  3277.  
  3278.   var stream = controller._controlledReadableStream;
  3279.  
  3280.   if (stream._state === 'closed') {
  3281.     if (bytesWritten !== 0) {
  3282.       throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream');
  3283.     }
  3284.  
  3285.     ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
  3286.   } else {
  3287.     assert(stream._state === 'readable');
  3288.  
  3289.     ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
  3290.   }
  3291. }
  3292.  
  3293. function ReadableByteStreamControllerShiftPendingPullInto(controller) {
  3294.   var descriptor = controller._pendingPullIntos.shift();
  3295.   ReadableByteStreamControllerInvalidateBYOBRequest(controller);
  3296.   return descriptor;
  3297. }
  3298.  
  3299. function ReadableByteStreamControllerShouldCallPull(controller) {
  3300.   var stream = controller._controlledReadableStream;
  3301.  
  3302.   if (stream._state !== 'readable') {
  3303.     return false;
  3304.   }
  3305.  
  3306.   if (controller._closeRequested === true) {
  3307.     return false;
  3308.   }
  3309.  
  3310.   if (controller._started === false) {
  3311.     return false;
  3312.   }
  3313.  
  3314.   if (ReadableStreamHasDefaultReader(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {
  3315.     return true;
  3316.   }
  3317.  
  3318.   if (ReadableStreamHasBYOBReader(stream) && ReadableStreamGetNumReadIntoRequests(stream) > 0) {
  3319.     return true;
  3320.   }
  3321.  
  3322.   if (ReadableByteStreamControllerGetDesiredSize(controller) > 0) {
  3323.     return true;
  3324.   }
  3325.  
  3326.   return false;
  3327. }
  3328.  
  3329. // A client of ReadableByteStreamController may use these functions directly to bypass state check.
  3330.  
  3331. function ReadableByteStreamControllerClose(controller) {
  3332.   var stream = controller._controlledReadableStream;
  3333.  
  3334.   assert(controller._closeRequested === false);
  3335.   assert(stream._state === 'readable');
  3336.  
  3337.   if (controller._totalQueuedBytes > 0) {
  3338.     controller._closeRequested = true;
  3339.  
  3340.     return;
  3341.   }
  3342.  
  3343.   if (controller._pendingPullIntos.length > 0) {
  3344.     var firstPendingPullInto = controller._pendingPullIntos[0];
  3345.     if (firstPendingPullInto.bytesFilled > 0) {
  3346.       var e = new TypeError('Insufficient bytes to fill elements in the given buffer');
  3347.       ReadableByteStreamControllerError(controller, e);
  3348.  
  3349.       throw e;
  3350.     }
  3351.   }
  3352.  
  3353.   ReadableStreamClose(stream);
  3354. }
  3355.  
  3356. function ReadableByteStreamControllerEnqueue(controller, chunk) {
  3357.   var stream = controller._controlledReadableStream;
  3358.  
  3359.   assert(controller._closeRequested === false);
  3360.   assert(stream._state === 'readable');
  3361.  
  3362.   var buffer = chunk.buffer;
  3363.   var byteOffset = chunk.byteOffset;
  3364.   var byteLength = chunk.byteLength;
  3365.   var transferredBuffer = SameRealmTransfer(buffer);
  3366.  
  3367.   if (ReadableStreamHasDefaultReader(stream) === true) {
  3368.     if (ReadableStreamGetNumReadRequests(stream) === 0) {
  3369.       ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
  3370.     } else {
  3371.       assert(controller._queue.length === 0);
  3372.  
  3373.       var transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);
  3374.       ReadableStreamFulfillReadRequest(stream, transferredView, false);
  3375.     }
  3376.   } else if (ReadableStreamHasBYOBReader(stream) === true) {
  3377.     // TODO: Ideally in this branch detaching should happen only if the buffer is not consumed fully.
  3378.     ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
  3379.     ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
  3380.   } else {
  3381.     assert(IsReadableStreamLocked(stream) === false, 'stream must not be locked');
  3382.     ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
  3383.   }
  3384. }
  3385.  
  3386. function ReadableByteStreamControllerError(controller, e) {
  3387.   var stream = controller._controlledReadableStream;
  3388.  
  3389.   assert(stream._state === 'readable');
  3390.  
  3391.   ReadableByteStreamControllerClearPendingPullIntos(controller);
  3392.  
  3393.   controller._queue = [];
  3394.  
  3395.   ReadableStreamError(stream, e);
  3396. }
  3397.  
  3398. function ReadableByteStreamControllerGetDesiredSize(controller) {
  3399.   return controller._strategyHWM - controller._totalQueuedBytes;
  3400. }
  3401.  
  3402. function ReadableByteStreamControllerRespond(controller, bytesWritten) {
  3403.   bytesWritten = Number(bytesWritten);
  3404.   if (IsFiniteNonNegativeNumber(bytesWritten) === false) {
  3405.     throw new RangeError('bytesWritten must be a finite');
  3406.   }
  3407.  
  3408.   assert(controller._pendingPullIntos.length > 0);
  3409.  
  3410.   ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
  3411. }
  3412.  
  3413. function ReadableByteStreamControllerRespondWithNewView(controller, view) {
  3414.   assert(controller._pendingPullIntos.length > 0);
  3415.  
  3416.   var firstDescriptor = controller._pendingPullIntos[0];
  3417.  
  3418.   if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) {
  3419.     throw new RangeError('The region specified by view does not match byobRequest');
  3420.   }
  3421.   if (firstDescriptor.byteLength !== view.byteLength) {
  3422.     throw new RangeError('The buffer of view has different capacity than byobRequest');
  3423.   }
  3424.  
  3425.   firstDescriptor.buffer = view.buffer;
  3426.  
  3427.   ReadableByteStreamControllerRespondInternal(controller, view.byteLength);
  3428. }
  3429.  
  3430. // Helper functions for the ReadableStream.
  3431.  
  3432. function streamBrandCheckException(name) {
  3433.   return new TypeError('ReadableStream.prototype.' + name + ' can only be used on a ReadableStream');
  3434. }
  3435.  
  3436. // Helper functions for the readers.
  3437.  
  3438. function readerLockException(name) {
  3439.   return new TypeError('Cannot ' + name + ' a stream using a released reader');
  3440. }
  3441.  
  3442. // Helper functions for the ReadableStreamDefaultReader.
  3443.  
  3444. function defaultReaderBrandCheckException(name) {
  3445.   return new TypeError('ReadableStreamDefaultReader.prototype.' + name + ' can only be used on a ReadableStreamDefaultReader');
  3446. }
  3447.  
  3448. function defaultReaderClosedPromiseInitialize(reader) {
  3449.   reader._closedPromise = new Promise(function (resolve, reject) {
  3450.     reader._closedPromise_resolve = resolve;
  3451.     reader._closedPromise_reject = reject;
  3452.   });
  3453. }
  3454.  
  3455. function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
  3456.   reader._closedPromise = Promise.reject(reason);
  3457.   reader._closedPromise_resolve = undefined;
  3458.   reader._closedPromise_reject = undefined;
  3459. }
  3460.  
  3461. function defaultReaderClosedPromiseInitializeAsResolved(reader) {
  3462.   reader._closedPromise = Promise.resolve(undefined);
  3463.   reader._closedPromise_resolve = undefined;
  3464.   reader._closedPromise_reject = undefined;
  3465. }
  3466.  
  3467. function defaultReaderClosedPromiseReject(reader, reason) {
  3468.   assert(reader._closedPromise_resolve !== undefined);
  3469.   assert(reader._closedPromise_reject !== undefined);
  3470.  
  3471.   reader._closedPromise_reject(reason);
  3472.   reader._closedPromise_resolve = undefined;
  3473.   reader._closedPromise_reject = undefined;
  3474. }
  3475.  
  3476. function defaultReaderClosedPromiseResetToRejected(reader, reason) {
  3477.   assert(reader._closedPromise_resolve === undefined);
  3478.   assert(reader._closedPromise_reject === undefined);
  3479.  
  3480.   reader._closedPromise = Promise.reject(reason);
  3481. }
  3482.  
  3483. function defaultReaderClosedPromiseResolve(reader) {
  3484.   assert(reader._closedPromise_resolve !== undefined);
  3485.   assert(reader._closedPromise_reject !== undefined);
  3486.  
  3487.   reader._closedPromise_resolve(undefined);
  3488.   reader._closedPromise_resolve = undefined;
  3489.   reader._closedPromise_reject = undefined;
  3490. }
  3491.  
  3492. // Helper functions for the ReadableStreamDefaultReader.
  3493.  
  3494. function byobReaderBrandCheckException(name) {
  3495.   return new TypeError('ReadableStreamBYOBReader.prototype.' + name + ' can only be used on a ReadableStreamBYOBReader');
  3496. }
  3497.  
  3498. // Helper functions for the ReadableStreamDefaultController.
  3499.  
  3500. function defaultControllerBrandCheckException(name) {
  3501.   return new TypeError('ReadableStreamDefaultController.prototype.' + name + ' can only be used on a ReadableStreamDefaultController');
  3502. }
  3503.  
  3504. // Helper functions for the ReadableStreamBYOBRequest.
  3505.  
  3506. function byobRequestBrandCheckException(name) {
  3507.   return new TypeError('ReadableStreamBYOBRequest.prototype.' + name + ' can only be used on a ReadableStreamBYOBRequest');
  3508. }
  3509.  
  3510. // Helper functions for the ReadableByteStreamController.
  3511.  
  3512. function byteStreamControllerBrandCheckException(name) {
  3513.   return new TypeError('ReadableByteStreamController.prototype.' + name + ' can only be used on a ReadableByteStreamController');
  3514. }
  3515.  
  3516. },{"./helpers.js":9,"./queue-with-sizes.js":10,"./utils.js":13,"./writable-stream.js":14,"assert":2}],12:[function(_dereq_,module,exports){
  3517. 'use strict';
  3518.  
  3519. 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; }; }();
  3520.  
  3521. function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  3522.  
  3523. var assert = _dereq_('assert');
  3524.  
  3525. var _require = _dereq_('./helpers.js'),
  3526.     InvokeOrNoop = _require.InvokeOrNoop,
  3527.     PromiseInvokeOrPerformFallback = _require.PromiseInvokeOrPerformFallback,
  3528.     PromiseInvokeOrNoop = _require.PromiseInvokeOrNoop,
  3529.     typeIsObject = _require.typeIsObject;
  3530.  
  3531. var _require2 = _dereq_('./readable-stream.js'),
  3532.     ReadableStream = _require2.ReadableStream,
  3533.     ReadableStreamDefaultControllerClose = _require2.ReadableStreamDefaultControllerClose,
  3534.     ReadableStreamDefaultControllerEnqueue = _require2.ReadableStreamDefaultControllerEnqueue,
  3535.     ReadableStreamDefaultControllerError = _require2.ReadableStreamDefaultControllerError,
  3536.     ReadableStreamDefaultControllerGetDesiredSize = _require2.ReadableStreamDefaultControllerGetDesiredSize;
  3537.  
  3538. var _require3 = _dereq_('./writable-stream.js'),
  3539.     WritableStream = _require3.WritableStream,
  3540.     WritableStreamDefaultControllerError = _require3.WritableStreamDefaultControllerError;
  3541.  
  3542. // Methods on the transform stream controller object
  3543.  
  3544. function TransformStreamCloseReadable(transformStream) {
  3545.   // console.log('TransformStreamCloseReadable()');
  3546.  
  3547.   if (transformStream._errored === true) {
  3548.     throw new TypeError('TransformStream is already errored');
  3549.   }
  3550.  
  3551.   if (transformStream._readableClosed === true) {
  3552.     throw new TypeError('Readable side is already closed');
  3553.   }
  3554.  
  3555.   TransformStreamCloseReadableInternal(transformStream);
  3556. }
  3557.  
  3558. function TransformStreamEnqueueToReadable(transformStream, chunk) {
  3559.   // console.log('TransformStreamEnqueueToReadable()');
  3560.  
  3561.   if (transformStream._errored === true) {
  3562.     throw new TypeError('TransformStream is already errored');
  3563.   }
  3564.  
  3565.   if (transformStream._readableClosed === true) {
  3566.     throw new TypeError('Readable side is already closed');
  3567.   }
  3568.  
  3569.   // We throttle transformer.transform invocation based on the backpressure of the ReadableStream, but we still
  3570.   // accept TransformStreamEnqueueToReadable() calls.
  3571.  
  3572.   var controller = transformStream._readableController;
  3573.  
  3574.   try {
  3575.     ReadableStreamDefaultControllerEnqueue(controller, chunk);
  3576.   } catch (e) {
  3577.     // This happens when readableStrategy.size() throws.
  3578.     // The ReadableStream has already errored itself.
  3579.     transformStream._readableClosed = true;
  3580.     TransformStreamErrorIfNeeded(transformStream, e);
  3581.  
  3582.     throw transformStream._storedError;
  3583.   }
  3584.  
  3585.   var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
  3586.   var maybeBackpressure = desiredSize <= 0;
  3587.  
  3588.   if (maybeBackpressure === true && transformStream._backpressure === false) {
  3589.     // This allows pull() again. When desiredSize is 0, it's possible that a pull() will happen immediately (but
  3590.     // asynchronously) after this because of pending read()s and set _backpressure back to false.
  3591.     //
  3592.     // If pull() could be called from inside enqueue(), then this logic would be wrong. This cannot happen
  3593.     // because there is always a promise pending from start() or pull() when _backpressure is false.
  3594.     TransformStreamSetBackpressure(transformStream, true);
  3595.   }
  3596. }
  3597.  
  3598. function TransformStreamError(transformStream, e) {
  3599.   if (transformStream._errored === true) {
  3600.     throw new TypeError('TransformStream is already errored');
  3601.   }
  3602.  
  3603.   TransformStreamErrorInternal(transformStream, e);
  3604. }
  3605.  
  3606. // Abstract operations.
  3607.  
  3608. function TransformStreamCloseReadableInternal(transformStream) {
  3609.   assert(transformStream._errored === false);
  3610.   assert(transformStream._readableClosed === false);
  3611.  
  3612.   try {
  3613.     ReadableStreamDefaultControllerClose(transformStream._readableController);
  3614.   } catch (e) {
  3615.     assert(false);
  3616.   }
  3617.  
  3618.   transformStream._readableClosed = true;
  3619. }
  3620.  
  3621. function TransformStreamErrorIfNeeded(transformStream, e) {
  3622.   if (transformStream._errored === false) {
  3623.     TransformStreamErrorInternal(transformStream, e);
  3624.   }
  3625. }
  3626.  
  3627. function TransformStreamErrorInternal(transformStream, e) {
  3628.   // console.log('TransformStreamErrorInternal()');
  3629.  
  3630.   assert(transformStream._errored === false);
  3631.  
  3632.   transformStream._errored = true;
  3633.   transformStream._storedError = e;
  3634.  
  3635.   if (transformStream._writableDone === false) {
  3636.     WritableStreamDefaultControllerError(transformStream._writableController, e);
  3637.   }
  3638.   if (transformStream._readableClosed === false) {
  3639.     ReadableStreamDefaultControllerError(transformStream._readableController, e);
  3640.   }
  3641. }
  3642.  
  3643. // Used for preventing the next write() call on TransformStreamSink until there
  3644. // is no longer backpressure.
  3645. function TransformStreamReadableReadyPromise(transformStream) {
  3646.   assert(transformStream._backpressureChangePromise !== undefined, '_backpressureChangePromise should have been initialized');
  3647.  
  3648.   if (transformStream._backpressure === false) {
  3649.     return Promise.resolve();
  3650.   }
  3651.  
  3652.   assert(transformStream._backpressure === true, '_backpressure should have been initialized');
  3653.  
  3654.   return transformStream._backpressureChangePromise;
  3655. }
  3656.  
  3657. function TransformStreamSetBackpressure(transformStream, backpressure) {
  3658.   // console.log(`TransformStreamSetBackpressure(${backpressure})`);
  3659.  
  3660.   // Passes also when called during construction.
  3661.   assert(transformStream._backpressure !== backpressure, 'TransformStreamSetBackpressure() should be called only when backpressure is changed');
  3662.  
  3663.   if (transformStream._backpressureChangePromise !== undefined) {
  3664.     // The fulfillment value is just for a sanity check.
  3665.     transformStream._backpressureChangePromise_resolve(backpressure);
  3666.   }
  3667.  
  3668.   transformStream._backpressureChangePromise = new Promise(function (resolve) {
  3669.     transformStream._backpressureChangePromise_resolve = resolve;
  3670.   });
  3671.  
  3672.   transformStream._backpressureChangePromise.then(function (resolution) {
  3673.     assert(resolution !== backpressure, '_backpressureChangePromise should be fulfilled only when backpressure is changed');
  3674.   });
  3675.  
  3676.   transformStream._backpressure = backpressure;
  3677. }
  3678.  
  3679. function TransformStreamDefaultTransform(chunk, transformStreamController) {
  3680.   var transformStream = transformStreamController._controlledTransformStream;
  3681.   TransformStreamEnqueueToReadable(transformStream, chunk);
  3682.   return Promise.resolve();
  3683. }
  3684.  
  3685. function TransformStreamTransform(transformStream, chunk) {
  3686.   // console.log('TransformStreamTransform()');
  3687.  
  3688.   assert(transformStream._errored === false);
  3689.   assert(transformStream._transforming === false);
  3690.   assert(transformStream._backpressure === false);
  3691.  
  3692.   transformStream._transforming = true;
  3693.  
  3694.   var transformer = transformStream._transformer;
  3695.   var controller = transformStream._transformStreamController;
  3696.  
  3697.   var transformPromise = PromiseInvokeOrPerformFallback(transformer, 'transform', [chunk, controller], TransformStreamDefaultTransform, [chunk, controller]);
  3698.  
  3699.   return transformPromise.then(function () {
  3700.     transformStream._transforming = false;
  3701.  
  3702.     return TransformStreamReadableReadyPromise(transformStream);
  3703.   }, function (e) {
  3704.     TransformStreamErrorIfNeeded(transformStream, e);
  3705.     return Promise.reject(e);
  3706.   });
  3707. }
  3708.  
  3709. function IsTransformStreamDefaultController(x) {
  3710.   if (!typeIsObject(x)) {
  3711.     return false;
  3712.   }
  3713.  
  3714.   if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) {
  3715.     return false;
  3716.   }
  3717.  
  3718.   return true;
  3719. }
  3720.  
  3721. function IsTransformStream(x) {
  3722.   if (!typeIsObject(x)) {
  3723.     return false;
  3724.   }
  3725.  
  3726.   if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) {
  3727.     return false;
  3728.   }
  3729.  
  3730.   return true;
  3731. }
  3732.  
  3733. var TransformStreamSink = function () {
  3734.   function TransformStreamSink(transformStream, startPromise) {
  3735.     _classCallCheck(this, TransformStreamSink);
  3736.  
  3737.     this._transformStream = transformStream;
  3738.     this._startPromise = startPromise;
  3739.   }
  3740.  
  3741.   _createClass(TransformStreamSink, [{
  3742.     key: 'start',
  3743.     value: function start(c) {
  3744.       var transformStream = this._transformStream;
  3745.  
  3746.       transformStream._writableController = c;
  3747.  
  3748.       return this._startPromise.then(function () {
  3749.         return TransformStreamReadableReadyPromise(transformStream);
  3750.       });
  3751.     }
  3752.   }, {
  3753.     key: 'write',
  3754.     value: function write(chunk) {
  3755.       // console.log('TransformStreamSink.write()');
  3756.  
  3757.       var transformStream = this._transformStream;
  3758.  
  3759.       return TransformStreamTransform(transformStream, chunk);
  3760.     }
  3761.   }, {
  3762.     key: 'abort',
  3763.     value: function abort() {
  3764.       var transformStream = this._transformStream;
  3765.       transformStream._writableDone = true;
  3766.       TransformStreamErrorInternal(transformStream, new TypeError('Writable side aborted'));
  3767.     }
  3768.   }, {
  3769.     key: 'close',
  3770.     value: function close() {
  3771.       // console.log('TransformStreamSink.close()');
  3772.  
  3773.       var transformStream = this._transformStream;
  3774.  
  3775.       assert(transformStream._transforming === false);
  3776.  
  3777.       transformStream._writableDone = true;
  3778.  
  3779.       var flushPromise = PromiseInvokeOrNoop(transformStream._transformer, 'flush', [transformStream._transformStreamController]);
  3780.       // Return a promise that is fulfilled with undefined on success.
  3781.       return flushPromise.then(function () {
  3782.         if (transformStream._errored === true) {
  3783.           return Promise.reject(transformStream._storedError);
  3784.         }
  3785.         if (transformStream._readableClosed === false) {
  3786.           TransformStreamCloseReadableInternal(transformStream);
  3787.         }
  3788.         return Promise.resolve();
  3789.       }).catch(function (r) {
  3790.         TransformStreamErrorIfNeeded(transformStream, r);
  3791.         return Promise.reject(transformStream._storedError);
  3792.       });
  3793.     }
  3794.   }]);
  3795.  
  3796.   return TransformStreamSink;
  3797. }();
  3798.  
  3799. var TransformStreamSource = function () {
  3800.   function TransformStreamSource(transformStream, startPromise) {
  3801.     _classCallCheck(this, TransformStreamSource);
  3802.  
  3803.     this._transformStream = transformStream;
  3804.     this._startPromise = startPromise;
  3805.   }
  3806.  
  3807.   _createClass(TransformStreamSource, [{
  3808.     key: 'start',
  3809.     value: function start(c) {
  3810.       var transformStream = this._transformStream;
  3811.  
  3812.       transformStream._readableController = c;
  3813.  
  3814.       return this._startPromise.then(function () {
  3815.         // Prevent the first pull() call until there is backpressure.
  3816.  
  3817.         assert(transformStream._backpressureChangePromise !== undefined, '_backpressureChangePromise should have been initialized');
  3818.  
  3819.         if (transformStream._backpressure === true) {
  3820.           return Promise.resolve();
  3821.         }
  3822.  
  3823.         assert(transformStream._backpressure === false, '_backpressure should have been initialized');
  3824.  
  3825.         return transformStream._backpressureChangePromise;
  3826.       });
  3827.     }
  3828.   }, {
  3829.     key: 'pull',
  3830.     value: function pull() {
  3831.       // console.log('TransformStreamSource.pull()');
  3832.  
  3833.       var transformStream = this._transformStream;
  3834.  
  3835.       // Invariant. Enforced by the promises returned by start() and pull().
  3836.       assert(transformStream._backpressure === true, 'pull() should be never called while _backpressure is false');
  3837.  
  3838.       assert(transformStream._backpressureChangePromise !== undefined, '_backpressureChangePromise should have been initialized');
  3839.  
  3840.       TransformStreamSetBackpressure(transformStream, false);
  3841.  
  3842.       // Prevent the next pull() call until there is backpressure.
  3843.       return transformStream._backpressureChangePromise;
  3844.     }
  3845.   }, {
  3846.     key: 'cancel',
  3847.     value: function cancel() {
  3848.       var transformStream = this._transformStream;
  3849.       transformStream._readableClosed = true;
  3850.       TransformStreamErrorInternal(transformStream, new TypeError('Readable side canceled'));
  3851.     }
  3852.   }]);
  3853.  
  3854.   return TransformStreamSource;
  3855. }();
  3856.  
  3857. var TransformStreamDefaultController = function () {
  3858.   function TransformStreamDefaultController(transformStream) {
  3859.     _classCallCheck(this, TransformStreamDefaultController);
  3860.  
  3861.     if (IsTransformStream(transformStream) === false) {
  3862.       throw new TypeError('TransformStreamDefaultController can only be ' + 'constructed with a TransformStream instance');
  3863.     }
  3864.  
  3865.     if (transformStream._transformStreamController !== undefined) {
  3866.       throw new TypeError('TransformStreamDefaultController instances can ' + 'only be created by the TransformStream constructor');
  3867.     }
  3868.  
  3869.     this._controlledTransformStream = transformStream;
  3870.   }
  3871.  
  3872.   _createClass(TransformStreamDefaultController, [{
  3873.     key: 'enqueue',
  3874.     value: function enqueue(chunk) {
  3875.       if (IsTransformStreamDefaultController(this) === false) {
  3876.         throw defaultControllerBrandCheckException('enqueue');
  3877.       }
  3878.  
  3879.       TransformStreamEnqueueToReadable(this._controlledTransformStream, chunk);
  3880.     }
  3881.   }, {
  3882.     key: 'close',
  3883.     value: function close() {
  3884.       if (IsTransformStreamDefaultController(this) === false) {
  3885.         throw defaultControllerBrandCheckException('close');
  3886.       }
  3887.  
  3888.       TransformStreamCloseReadable(this._controlledTransformStream);
  3889.     }
  3890.   }, {
  3891.     key: 'error',
  3892.     value: function error(reason) {
  3893.       if (IsTransformStreamDefaultController(this) === false) {
  3894.         throw defaultControllerBrandCheckException('error');
  3895.       }
  3896.  
  3897.       TransformStreamError(this._controlledTransformStream, reason);
  3898.     }
  3899.   }, {
  3900.     key: 'desiredSize',
  3901.     get: function get() {
  3902.       if (IsTransformStreamDefaultController(this) === false) {
  3903.         throw defaultControllerBrandCheckException('desiredSize');
  3904.       }
  3905.  
  3906.       var transformStream = this._controlledTransformStream;
  3907.       var readableController = transformStream._readableController;
  3908.  
  3909.       return ReadableStreamDefaultControllerGetDesiredSize(readableController);
  3910.     }
  3911.   }]);
  3912.  
  3913.   return TransformStreamDefaultController;
  3914. }();
  3915.  
  3916. var TransformStream = function () {
  3917.   function TransformStream() {
  3918.     var transformer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  3919.  
  3920.     _classCallCheck(this, TransformStream);
  3921.  
  3922.     this._transformer = transformer;
  3923.     var readableStrategy = transformer.readableStrategy,
  3924.         writableStrategy = transformer.writableStrategy;
  3925.  
  3926.  
  3927.     this._transforming = false;
  3928.     this._errored = false;
  3929.     this._storedError = undefined;
  3930.  
  3931.     this._writableController = undefined;
  3932.     this._readableController = undefined;
  3933.     this._transformStreamController = undefined;
  3934.  
  3935.     this._writableDone = false;
  3936.     this._readableClosed = false;
  3937.  
  3938.     this._backpressure = undefined;
  3939.     this._backpressureChangePromise = undefined;
  3940.     this._backpressureChangePromise_resolve = undefined;
  3941.  
  3942.     this._transformStreamController = new TransformStreamDefaultController(this);
  3943.  
  3944.     var startPromise_resolve = void 0;
  3945.     var startPromise = new Promise(function (resolve) {
  3946.       startPromise_resolve = resolve;
  3947.     });
  3948.  
  3949.     var source = new TransformStreamSource(this, startPromise);
  3950.  
  3951.     this._readable = new ReadableStream(source, readableStrategy);
  3952.  
  3953.     var sink = new TransformStreamSink(this, startPromise);
  3954.  
  3955.     this._writable = new WritableStream(sink, writableStrategy);
  3956.  
  3957.     assert(this._writableController !== undefined);
  3958.     assert(this._readableController !== undefined);
  3959.  
  3960.     var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(this._readableController);
  3961.     // Set _backpressure based on desiredSize. As there is no read() at this point, we can just interpret
  3962.     // desiredSize being non-positive as backpressure.
  3963.     TransformStreamSetBackpressure(this, desiredSize <= 0);
  3964.  
  3965.     var transformStream = this;
  3966.     var startResult = InvokeOrNoop(transformer, 'start', [transformStream._transformStreamController]);
  3967.     startPromise_resolve(startResult);
  3968.     startPromise.catch(function (e) {
  3969.       // The underlyingSink and underlyingSource will error the readable and writable ends on their own.
  3970.       if (transformStream._errored === false) {
  3971.         transformStream._errored = true;
  3972.         transformStream._storedError = e;
  3973.       }
  3974.     });
  3975.   }
  3976.  
  3977.   _createClass(TransformStream, [{
  3978.     key: 'readable',
  3979.     get: function get() {
  3980.       if (IsTransformStream(this) === false) {
  3981.         throw streamBrandCheckException('readable');
  3982.       }
  3983.  
  3984.       return this._readable;
  3985.     }
  3986.   }, {
  3987.     key: 'writable',
  3988.     get: function get() {
  3989.       if (IsTransformStream(this) === false) {
  3990.         throw streamBrandCheckException('writable');
  3991.       }
  3992.  
  3993.       return this._writable;
  3994.     }
  3995.   }]);
  3996.  
  3997.   return TransformStream;
  3998. }();
  3999.  
  4000. module.exports = { TransformStream: TransformStream };
  4001.  
  4002. // Helper functions for the TransformStreamDefaultController.
  4003.  
  4004. function defaultControllerBrandCheckException(name) {
  4005.   return new TypeError('TransformStreamDefaultController.prototype.' + name + ' can only be used on a TransformStreamDefaultController');
  4006. }
  4007.  
  4008. // Helper functions for the TransformStream.
  4009.  
  4010. function streamBrandCheckException(name) {
  4011.   return new TypeError('TransformStream.prototype.' + name + ' can only be used on a TransformStream');
  4012. }
  4013.  
  4014. },{"./helpers.js":9,"./readable-stream.js":11,"./writable-stream.js":14,"assert":2}],13:[function(_dereq_,module,exports){
  4015. 'use strict';
  4016.  
  4017. var assert = _dereq_('assert');
  4018.  
  4019. exports.rethrowAssertionErrorRejection = function (e) {
  4020.   // Used throughout the reference implementation, as `.catch(rethrowAssertionErrorRejection)`, to ensure any errors
  4021.   // get shown. There are places in the spec where we do promise transformations and purposefully ignore or don't
  4022.   // expect any errors, but assertion errors are always problematic.
  4023.   if (e && e.constructor === assert.AssertionError) {
  4024.     setTimeout(function () {
  4025.       throw e;
  4026.     }, 0);
  4027.   }
  4028. };
  4029.  
  4030. },{"assert":2}],14:[function(_dereq_,module,exports){
  4031. 'use strict';
  4032.  
  4033. 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; }; }();
  4034.  
  4035. function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  4036.  
  4037. var assert = _dereq_('assert');
  4038.  
  4039. var _require = _dereq_('./helpers.js'),
  4040.     InvokeOrNoop = _require.InvokeOrNoop,
  4041.     PromiseInvokeOrNoop = _require.PromiseInvokeOrNoop,
  4042.     PromiseInvokeOrFallbackOrNoop = _require.PromiseInvokeOrFallbackOrNoop,
  4043.     ValidateAndNormalizeQueuingStrategy = _require.ValidateAndNormalizeQueuingStrategy,
  4044.     typeIsObject = _require.typeIsObject;
  4045.  
  4046. var _require2 = _dereq_('./utils.js'),
  4047.     rethrowAssertionErrorRejection = _require2.rethrowAssertionErrorRejection;
  4048.  
  4049. var _require3 = _dereq_('./queue-with-sizes.js'),
  4050.     DequeueValue = _require3.DequeueValue,
  4051.     EnqueueValueWithSize = _require3.EnqueueValueWithSize,
  4052.     GetTotalQueueSize = _require3.GetTotalQueueSize,
  4053.     PeekQueueValue = _require3.PeekQueueValue;
  4054.  
  4055. var WritableStream = function () {
  4056.   function WritableStream() {
  4057.     var underlyingSink = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  4058.  
  4059.     var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
  4060.         size = _ref.size,
  4061.         _ref$highWaterMark = _ref.highWaterMark,
  4062.         highWaterMark = _ref$highWaterMark === undefined ? 1 : _ref$highWaterMark;
  4063.  
  4064.     _classCallCheck(this, WritableStream);
  4065.  
  4066.     this._state = 'writable';
  4067.     this._storedError = undefined;
  4068.  
  4069.     this._writer = undefined;
  4070.  
  4071.     // Initialize to undefined first because the constructor of the controller checks this
  4072.     // variable to validate the caller.
  4073.     this._writableStreamController = undefined;
  4074.  
  4075.     // This queue is placed here instead of the writer class in order to allow for passing a writer to the next data
  4076.     // producer without waiting for the queued writes to finish.
  4077.     this._writeRequests = [];
  4078.  
  4079.     // Write requests are removed from _writeRequests when write() is called on the underlying sink. This prevents
  4080.     // them from being erroneously rejected on error. If a write() call is pending, the request is stored here.
  4081.     this._pendingWriteRequest = undefined;
  4082.  
  4083.     // The promise that was returned from writer.close(). Stored here because it may be fulfilled after the writer
  4084.     // has been detached.
  4085.     this._pendingCloseRequest = undefined;
  4086.  
  4087.     // The promise that was returned from writer.abort(). This may also be fulfilled after the writer has detached.
  4088.     this._pendingAbortRequest = undefined;
  4089.  
  4090.     var type = underlyingSink.type;
  4091.  
  4092.     if (type !== undefined) {
  4093.       throw new RangeError('Invalid type is specified');
  4094.     }
  4095.  
  4096.     this._writableStreamController = new WritableStreamDefaultController(this, underlyingSink, size, highWaterMark);
  4097.   }
  4098.  
  4099.   _createClass(WritableStream, [{
  4100.     key: 'abort',
  4101.     value: function abort(reason) {
  4102.       if (IsWritableStream(this) === false) {
  4103.         return Promise.reject(streamBrandCheckException('abort'));
  4104.       }
  4105.  
  4106.       if (IsWritableStreamLocked(this) === true) {
  4107.         return Promise.reject(new TypeError('Cannot abort a stream that already has a writer'));
  4108.       }
  4109.  
  4110.       return WritableStreamAbort(this, reason);
  4111.     }
  4112.   }, {
  4113.     key: 'getWriter',
  4114.     value: function getWriter() {
  4115.       if (IsWritableStream(this) === false) {
  4116.         throw streamBrandCheckException('getWriter');
  4117.       }
  4118.  
  4119.       return AcquireWritableStreamDefaultWriter(this);
  4120.     }
  4121.   }, {
  4122.     key: 'locked',
  4123.     get: function get() {
  4124.       if (IsWritableStream(this) === false) {
  4125.         throw streamBrandCheckException('locked');
  4126.       }
  4127.  
  4128.       return IsWritableStreamLocked(this);
  4129.     }
  4130.   }]);
  4131.  
  4132.   return WritableStream;
  4133. }();
  4134.  
  4135. module.exports = {
  4136.   AcquireWritableStreamDefaultWriter: AcquireWritableStreamDefaultWriter,
  4137.   IsWritableStream: IsWritableStream,
  4138.   IsWritableStreamLocked: IsWritableStreamLocked,
  4139.   WritableStream: WritableStream,
  4140.   WritableStreamAbort: WritableStreamAbort,
  4141.   WritableStreamDefaultControllerError: WritableStreamDefaultControllerError,
  4142.   WritableStreamDefaultWriterCloseWithErrorPropagation: WritableStreamDefaultWriterCloseWithErrorPropagation,
  4143.   WritableStreamDefaultWriterRelease: WritableStreamDefaultWriterRelease,
  4144.   WritableStreamDefaultWriterWrite: WritableStreamDefaultWriterWrite
  4145. };
  4146.  
  4147. // Abstract operations for the WritableStream.
  4148.  
  4149. function AcquireWritableStreamDefaultWriter(stream) {
  4150.   return new WritableStreamDefaultWriter(stream);
  4151. }
  4152.  
  4153. function IsWritableStream(x) {
  4154.   if (!typeIsObject(x)) {
  4155.     return false;
  4156.   }
  4157.  
  4158.   if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) {
  4159.     return false;
  4160.   }
  4161.  
  4162.   return true;
  4163. }
  4164.  
  4165. function IsWritableStreamLocked(stream) {
  4166.   assert(IsWritableStream(stream) === true, 'IsWritableStreamLocked should only be used on known writable streams');
  4167.  
  4168.   if (stream._writer === undefined) {
  4169.     return false;
  4170.   }
  4171.  
  4172.   return true;
  4173. }
  4174.  
  4175. function WritableStreamAbort(stream, reason) {
  4176.   var state = stream._state;
  4177.   if (state === 'closed') {
  4178.     return Promise.resolve(undefined);
  4179.   }
  4180.   if (state === 'errored') {
  4181.     return Promise.reject(stream._storedError);
  4182.   }
  4183.  
  4184.   assert(state === 'writable' || state === 'closing');
  4185.  
  4186.   var error = new TypeError('Aborted');
  4187.  
  4188.   WritableStreamError(stream, error);
  4189.  
  4190.   var controller = stream._writableStreamController;
  4191.   assert(controller !== undefined);
  4192.   if (controller._writing === true || controller._inClose === true) {
  4193.     var promise = new Promise(function (resolve, reject) {
  4194.       var abortRequest = {
  4195.         _resolve: resolve,
  4196.         _reject: reject
  4197.       };
  4198.  
  4199.       stream._pendingAbortRequest = abortRequest;
  4200.     });
  4201.     if (controller._writing === true) {
  4202.       return promise.then(function () {
  4203.         return WritableStreamDefaultControllerAbort(stream._writableStreamController, reason);
  4204.       });
  4205.     }
  4206.     return promise;
  4207.   }
  4208.  
  4209.   return WritableStreamDefaultControllerAbort(stream._writableStreamController, reason);
  4210. }
  4211.  
  4212. // WritableStream API exposed for controllers.
  4213.  
  4214. function WritableStreamAddWriteRequest(stream) {
  4215.   assert(IsWritableStreamLocked(stream) === true);
  4216.   assert(stream._state === 'writable');
  4217.  
  4218.   var promise = new Promise(function (resolve, reject) {
  4219.     var writeRequest = {
  4220.       _resolve: resolve,
  4221.       _reject: reject
  4222.     };
  4223.  
  4224.     stream._writeRequests.push(writeRequest);
  4225.   });
  4226.  
  4227.   return promise;
  4228. }
  4229.  
  4230. function WritableStreamError(stream, e) {
  4231.   var oldState = stream._state;
  4232.   assert(oldState === 'writable' || oldState === 'closing');
  4233.   stream._state = 'errored';
  4234.   stream._storedError = e;
  4235.  
  4236.   var controller = stream._writableStreamController;
  4237.   // This method can be called during the construction of the controller, in which case "controller" will be undefined
  4238.   // but the flags are guaranteed to be false anyway.
  4239.   if (controller === undefined || controller._writing === false && controller._inClose === false) {
  4240.     WritableStreamRejectPromisesInReactionToError(stream);
  4241.   }
  4242.  
  4243.   var writer = stream._writer;
  4244.   if (writer !== undefined) {
  4245.     if (oldState === 'writable' && WritableStreamDefaultControllerGetBackpressure(stream._writableStreamController) === true) {
  4246.       defaultWriterReadyPromiseReject(writer, e);
  4247.     } else {
  4248.       defaultWriterReadyPromiseResetToRejected(writer, e);
  4249.     }
  4250.     writer._readyPromise.catch(function () {});
  4251.   }
  4252. }
  4253.  
  4254. function WritableStreamFinishClose(stream) {
  4255.   assert(stream._state === 'closing' || stream._state === 'errored');
  4256.  
  4257.   if (stream._state === 'closing') {
  4258.     defaultWriterClosedPromiseResolve(stream._writer);
  4259.     stream._state = 'closed';
  4260.   } else {
  4261.     assert(stream._state === 'errored');
  4262.     defaultWriterClosedPromiseReject(stream._writer, stream._storedError);
  4263.     stream._writer._closedPromise.catch(function () {});
  4264.   }
  4265.  
  4266.   if (stream._pendingAbortRequest !== undefined) {
  4267.     stream._pendingAbortRequest._resolve();
  4268.     stream._pendingAbortRequest = undefined;
  4269.   }
  4270. }
  4271.  
  4272. function WritableStreamRejectPromisesInReactionToError(stream) {
  4273.   assert(stream._state === 'errored');
  4274.   assert(stream._pendingWriteRequest === undefined);
  4275.  
  4276.   var storedError = stream._storedError;
  4277.   var _iteratorNormalCompletion = true;
  4278.   var _didIteratorError = false;
  4279.   var _iteratorError = undefined;
  4280.  
  4281.   try {
  4282.     for (var _iterator = stream._writeRequests[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
  4283.       var writeRequest = _step.value;
  4284.  
  4285.       writeRequest._reject(storedError);
  4286.     }
  4287.   } catch (err) {
  4288.     _didIteratorError = true;
  4289.     _iteratorError = err;
  4290.   } finally {
  4291.     try {
  4292.       if (!_iteratorNormalCompletion && _iterator.return) {
  4293.         _iterator.return();
  4294.       }
  4295.     } finally {
  4296.       if (_didIteratorError) {
  4297.         throw _iteratorError;
  4298.       }
  4299.     }
  4300.   }
  4301.  
  4302.   stream._writeRequests = [];
  4303.  
  4304.   if (stream._pendingCloseRequest !== undefined) {
  4305.     assert(stream._writableStreamController._inClose === false);
  4306.     stream._pendingCloseRequest._reject(storedError);
  4307.     stream._pendingCloseRequest = undefined;
  4308.   }
  4309.  
  4310.   var writer = stream._writer;
  4311.   if (writer !== undefined) {
  4312.     defaultWriterClosedPromiseReject(writer, storedError);
  4313.     writer._closedPromise.catch(function () {});
  4314.   }
  4315. }
  4316.  
  4317. function WritableStreamUpdateBackpressure(stream, backpressure) {
  4318.   assert(stream._state === 'writable');
  4319.  
  4320.   var writer = stream._writer;
  4321.   if (writer === undefined) {
  4322.     return;
  4323.   }
  4324.  
  4325.   if (backpressure === true) {
  4326.     defaultWriterReadyPromiseReset(writer);
  4327.   } else {
  4328.     assert(backpressure === false);
  4329.     defaultWriterReadyPromiseResolve(writer);
  4330.   }
  4331. }
  4332.  
  4333. var WritableStreamDefaultWriter = function () {
  4334.   function WritableStreamDefaultWriter(stream) {
  4335.     _classCallCheck(this, WritableStreamDefaultWriter);
  4336.  
  4337.     if (IsWritableStream(stream) === false) {
  4338.       throw new TypeError('WritableStreamDefaultWriter can only be constructed with a WritableStream instance');
  4339.     }
  4340.     if (IsWritableStreamLocked(stream) === true) {
  4341.       throw new TypeError('This stream has already been locked for exclusive writing by another writer');
  4342.     }
  4343.  
  4344.     this._ownerWritableStream = stream;
  4345.     stream._writer = this;
  4346.  
  4347.     var state = stream._state;
  4348.  
  4349.     if (state === 'writable' || state === 'closing') {
  4350.       defaultWriterClosedPromiseInitialize(this);
  4351.     } else if (state === 'closed') {
  4352.       defaultWriterClosedPromiseInitializeAsResolved(this);
  4353.     } else {
  4354.       assert(state === 'errored', 'state must be errored');
  4355.  
  4356.       defaultWriterClosedPromiseInitializeAsRejected(this, stream._storedError);
  4357.       this._closedPromise.catch(function () {});
  4358.     }
  4359.  
  4360.     if (state === 'writable' && WritableStreamDefaultControllerGetBackpressure(stream._writableStreamController) === true) {
  4361.       defaultWriterReadyPromiseInitialize(this);
  4362.     } else {
  4363.       defaultWriterReadyPromiseInitializeAsResolved(this, undefined);
  4364.     }
  4365.   }
  4366.  
  4367.   _createClass(WritableStreamDefaultWriter, [{
  4368.     key: 'abort',
  4369.     value: function abort(reason) {
  4370.       if (IsWritableStreamDefaultWriter(this) === false) {
  4371.         return Promise.reject(defaultWriterBrandCheckException('abort'));
  4372.       }
  4373.  
  4374.       if (this._ownerWritableStream === undefined) {
  4375.         return Promise.reject(defaultWriterLockException('abort'));
  4376.       }
  4377.  
  4378.       return WritableStreamDefaultWriterAbort(this, reason);
  4379.     }
  4380.   }, {
  4381.     key: 'close',
  4382.     value: function close() {
  4383.       if (IsWritableStreamDefaultWriter(this) === false) {
  4384.         return Promise.reject(defaultWriterBrandCheckException('close'));
  4385.       }
  4386.  
  4387.       var stream = this._ownerWritableStream;
  4388.  
  4389.       if (stream === undefined) {
  4390.         return Promise.reject(defaultWriterLockException('close'));
  4391.       }
  4392.  
  4393.       if (stream._state === 'closing') {
  4394.         return Promise.reject(new TypeError('cannot close an already-closing stream'));
  4395.       }
  4396.  
  4397.       return WritableStreamDefaultWriterClose(this);
  4398.     }
  4399.   }, {
  4400.     key: 'releaseLock',
  4401.     value: function releaseLock() {
  4402.       if (IsWritableStreamDefaultWriter(this) === false) {
  4403.         throw defaultWriterBrandCheckException('releaseLock');
  4404.       }
  4405.  
  4406.       var stream = this._ownerWritableStream;
  4407.  
  4408.       if (stream === undefined) {
  4409.         return;
  4410.       }
  4411.  
  4412.       assert(stream._writer !== undefined);
  4413.  
  4414.       WritableStreamDefaultWriterRelease(this);
  4415.     }
  4416.   }, {
  4417.     key: 'write',
  4418.     value: function write(chunk) {
  4419.       if (IsWritableStreamDefaultWriter(this) === false) {
  4420.         return Promise.reject(defaultWriterBrandCheckException('write'));
  4421.       }
  4422.  
  4423.       var stream = this._ownerWritableStream;
  4424.  
  4425.       if (stream === undefined) {
  4426.         return Promise.reject(defaultWriterLockException('write to'));
  4427.       }
  4428.  
  4429.       if (stream._state === 'closing') {
  4430.         return Promise.reject(new TypeError('Cannot write to an already-closed stream'));
  4431.       }
  4432.  
  4433.       return WritableStreamDefaultWriterWrite(this, chunk);
  4434.     }
  4435.   }, {
  4436.     key: 'closed',
  4437.     get: function get() {
  4438.       if (IsWritableStreamDefaultWriter(this) === false) {
  4439.         return Promise.reject(defaultWriterBrandCheckException('closed'));
  4440.       }
  4441.  
  4442.       return this._closedPromise;
  4443.     }
  4444.   }, {
  4445.     key: 'desiredSize',
  4446.     get: function get() {
  4447.       if (IsWritableStreamDefaultWriter(this) === false) {
  4448.         throw defaultWriterBrandCheckException('desiredSize');
  4449.       }
  4450.  
  4451.       if (this._ownerWritableStream === undefined) {
  4452.         throw defaultWriterLockException('desiredSize');
  4453.       }
  4454.  
  4455.       return WritableStreamDefaultWriterGetDesiredSize(this);
  4456.     }
  4457.   }, {
  4458.     key: 'ready',
  4459.     get: function get() {
  4460.       if (IsWritableStreamDefaultWriter(this) === false) {
  4461.         return Promise.reject(defaultWriterBrandCheckException('ready'));
  4462.       }
  4463.  
  4464.       return this._readyPromise;
  4465.     }
  4466.   }]);
  4467.  
  4468.   return WritableStreamDefaultWriter;
  4469. }();
  4470.  
  4471. // Abstract operations for the WritableStreamDefaultWriter.
  4472.  
  4473. function IsWritableStreamDefaultWriter(x) {
  4474.   if (!typeIsObject(x)) {
  4475.     return false;
  4476.   }
  4477.  
  4478.   if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) {
  4479.     return false;
  4480.   }
  4481.  
  4482.   return true;
  4483. }
  4484.  
  4485. // A client of WritableStreamDefaultWriter may use these functions directly to bypass state check.
  4486.  
  4487. function WritableStreamDefaultWriterAbort(writer, reason) {
  4488.   var stream = writer._ownerWritableStream;
  4489.  
  4490.   assert(stream !== undefined);
  4491.  
  4492.   return WritableStreamAbort(stream, reason);
  4493. }
  4494.  
  4495. function WritableStreamDefaultWriterClose(writer) {
  4496.   var stream = writer._ownerWritableStream;
  4497.  
  4498.   assert(stream !== undefined);
  4499.  
  4500.   var state = stream._state;
  4501.   if (state === 'closed' || state === 'errored') {
  4502.     return Promise.reject(new TypeError('The stream (in ' + state + ' state) is not in the writable state and cannot be closed'));
  4503.   }
  4504.  
  4505.   assert(state === 'writable');
  4506.  
  4507.   var promise = new Promise(function (resolve, reject) {
  4508.     var closeRequest = {
  4509.       _resolve: resolve,
  4510.       _reject: reject
  4511.     };
  4512.  
  4513.     stream._pendingCloseRequest = closeRequest;
  4514.   });
  4515.  
  4516.   if (WritableStreamDefaultControllerGetBackpressure(stream._writableStreamController) === true) {
  4517.     defaultWriterReadyPromiseResolve(writer);
  4518.   }
  4519.  
  4520.   stream._state = 'closing';
  4521.  
  4522.   WritableStreamDefaultControllerClose(stream._writableStreamController);
  4523.  
  4524.   return promise;
  4525. }
  4526.  
  4527. function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {
  4528.   var stream = writer._ownerWritableStream;
  4529.  
  4530.   assert(stream !== undefined);
  4531.  
  4532.   var state = stream._state;
  4533.   if (state === 'closing' || state === 'closed') {
  4534.     return Promise.resolve();
  4535.   }
  4536.  
  4537.   if (state === 'errored') {
  4538.     return Promise.reject(stream._storedError);
  4539.   }
  4540.  
  4541.   assert(state === 'writable');
  4542.  
  4543.   return WritableStreamDefaultWriterClose(writer);
  4544. }
  4545.  
  4546. function WritableStreamDefaultWriterGetDesiredSize(writer) {
  4547.   var stream = writer._ownerWritableStream;
  4548.   var state = stream._state;
  4549.  
  4550.   if (state === 'errored') {
  4551.     return null;
  4552.   }
  4553.  
  4554.   if (state === 'closed') {
  4555.     return 0;
  4556.   }
  4557.  
  4558.   return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);
  4559. }
  4560.  
  4561. function WritableStreamDefaultWriterRelease(writer) {
  4562.   var stream = writer._ownerWritableStream;
  4563.   assert(stream !== undefined);
  4564.   assert(stream._writer === writer);
  4565.  
  4566.   var releasedError = new TypeError('Writer was released and can no longer be used to monitor the stream\'s closedness');
  4567.   var state = stream._state;
  4568.  
  4569.   if (state === 'writable' || state === 'closing' || stream._pendingAbortRequest !== undefined) {
  4570.     defaultWriterClosedPromiseReject(writer, releasedError);
  4571.   } else {
  4572.     defaultWriterClosedPromiseResetToRejected(writer, releasedError);
  4573.   }
  4574.   writer._closedPromise.catch(function () {});
  4575.  
  4576.   if (state === 'writable' && WritableStreamDefaultControllerGetBackpressure(stream._writableStreamController) === true) {
  4577.     defaultWriterReadyPromiseReject(writer, releasedError);
  4578.   } else {
  4579.     defaultWriterReadyPromiseResetToRejected(writer, releasedError);
  4580.   }
  4581.   writer._readyPromise.catch(function () {});
  4582.  
  4583.   stream._writer = undefined;
  4584.   writer._ownerWritableStream = undefined;
  4585. }
  4586.  
  4587. function WritableStreamDefaultWriterWrite(writer, chunk) {
  4588.   var stream = writer._ownerWritableStream;
  4589.  
  4590.   assert(stream !== undefined);
  4591.  
  4592.   var state = stream._state;
  4593.   if (state === 'closed' || state === 'errored') {
  4594.     return Promise.reject(new TypeError('The stream (in ' + state + ' state) is not in the writable state and cannot be written to'));
  4595.   }
  4596.  
  4597.   assert(state === 'writable');
  4598.  
  4599.   var promise = WritableStreamAddWriteRequest(stream);
  4600.  
  4601.   WritableStreamDefaultControllerWrite(stream._writableStreamController, chunk);
  4602.  
  4603.   return promise;
  4604. }
  4605.  
  4606. var WritableStreamDefaultController = function () {
  4607.   function WritableStreamDefaultController(stream, underlyingSink, size, highWaterMark) {
  4608.     _classCallCheck(this, WritableStreamDefaultController);
  4609.  
  4610.     if (IsWritableStream(stream) === false) {
  4611.       throw new TypeError('WritableStreamDefaultController can only be constructed with a WritableStream instance');
  4612.     }
  4613.  
  4614.     if (stream._writableStreamController !== undefined) {
  4615.       throw new TypeError('WritableStreamDefaultController instances can only be created by the WritableStream constructor');
  4616.     }
  4617.  
  4618.     this._controlledWritableStream = stream;
  4619.  
  4620.     this._underlyingSink = underlyingSink;
  4621.  
  4622.     this._queue = [];
  4623.     this._started = false;
  4624.     this._writing = false;
  4625.     this._inClose = false;
  4626.  
  4627.     var normalizedStrategy = ValidateAndNormalizeQueuingStrategy(size, highWaterMark);
  4628.     this._strategySize = normalizedStrategy.size;
  4629.     this._strategyHWM = normalizedStrategy.highWaterMark;
  4630.  
  4631.     var backpressure = WritableStreamDefaultControllerGetBackpressure(this);
  4632.     if (backpressure === true) {
  4633.       WritableStreamUpdateBackpressure(stream, backpressure);
  4634.     }
  4635.  
  4636.     var controller = this;
  4637.  
  4638.     var startResult = InvokeOrNoop(underlyingSink, 'start', [this]);
  4639.     Promise.resolve(startResult).then(function () {
  4640.       controller._started = true;
  4641.       WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
  4642.     }, function (r) {
  4643.       WritableStreamDefaultControllerErrorIfNeeded(controller, r);
  4644.     }).catch(rethrowAssertionErrorRejection);
  4645.   }
  4646.  
  4647.   _createClass(WritableStreamDefaultController, [{
  4648.     key: 'error',
  4649.     value: function error(e) {
  4650.       if (IsWritableStreamDefaultController(this) === false) {
  4651.         throw new TypeError('WritableStreamDefaultController.prototype.error can only be used on a WritableStreamDefaultController');
  4652.       }
  4653.  
  4654.       var state = this._controlledWritableStream._state;
  4655.       if (state === 'closed' || state === 'errored') {
  4656.         throw new TypeError('The stream is ' + state + ' and so cannot be errored');
  4657.       }
  4658.  
  4659.       WritableStreamDefaultControllerError(this, e);
  4660.     }
  4661.   }]);
  4662.  
  4663.   return WritableStreamDefaultController;
  4664. }();
  4665.  
  4666. // Abstract operations implementing interface required by the WritableStream.
  4667.  
  4668. function WritableStreamDefaultControllerAbort(controller, reason) {
  4669.   controller._queue = [];
  4670.  
  4671.   var sinkAbortPromise = PromiseInvokeOrFallbackOrNoop(controller._underlyingSink, 'abort', [reason], 'close', [controller]);
  4672.   return sinkAbortPromise.then(function () {
  4673.     return undefined;
  4674.   });
  4675. }
  4676.  
  4677. function WritableStreamDefaultControllerClose(controller) {
  4678.   EnqueueValueWithSize(controller._queue, 'close', 0);
  4679.   WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
  4680. }
  4681.  
  4682. function WritableStreamDefaultControllerGetDesiredSize(controller) {
  4683.   var queueSize = GetTotalQueueSize(controller._queue);
  4684.   return controller._strategyHWM - queueSize;
  4685. }
  4686.  
  4687. function WritableStreamDefaultControllerWrite(controller, chunk) {
  4688.   var stream = controller._controlledWritableStream;
  4689.  
  4690.   assert(stream._state === 'writable');
  4691.  
  4692.   var chunkSize = 1;
  4693.  
  4694.   if (controller._strategySize !== undefined) {
  4695.     try {
  4696.       chunkSize = controller._strategySize(chunk);
  4697.     } catch (chunkSizeE) {
  4698.       // TODO: Should we notify the sink of this error?
  4699.       WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
  4700.       return;
  4701.     }
  4702.   }
  4703.  
  4704.   var writeRecord = { chunk: chunk };
  4705.  
  4706.   var lastBackpressure = WritableStreamDefaultControllerGetBackpressure(controller);
  4707.  
  4708.   try {
  4709.     EnqueueValueWithSize(controller._queue, writeRecord, chunkSize);
  4710.   } catch (enqueueE) {
  4711.     WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
  4712.     return;
  4713.   }
  4714.  
  4715.   if (stream._state === 'writable') {
  4716.     var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
  4717.     if (lastBackpressure !== backpressure) {
  4718.       WritableStreamUpdateBackpressure(stream, backpressure);
  4719.     }
  4720.   }
  4721.  
  4722.   WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
  4723. }
  4724.  
  4725. // Abstract operations for the WritableStreamDefaultController.
  4726.  
  4727. function IsWritableStreamDefaultController(x) {
  4728.   if (!typeIsObject(x)) {
  4729.     return false;
  4730.   }
  4731.  
  4732.   if (!Object.prototype.hasOwnProperty.call(x, '_underlyingSink')) {
  4733.     return false;
  4734.   }
  4735.  
  4736.   return true;
  4737. }
  4738.  
  4739. function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
  4740.   if (controller._controlledWritableStream._state === 'closed' || controller._controlledWritableStream._state === 'errored') {
  4741.     return;
  4742.   }
  4743.  
  4744.   if (controller._started === false) {
  4745.     return;
  4746.   }
  4747.  
  4748.   if (controller._writing === true) {
  4749.     return;
  4750.   }
  4751.  
  4752.   if (controller._queue.length === 0) {
  4753.     return;
  4754.   }
  4755.  
  4756.   var writeRecord = PeekQueueValue(controller._queue);
  4757.   if (writeRecord === 'close') {
  4758.     WritableStreamDefaultControllerProcessClose(controller);
  4759.   } else {
  4760.     WritableStreamDefaultControllerProcessWrite(controller, writeRecord.chunk);
  4761.   }
  4762. }
  4763.  
  4764. function WritableStreamDefaultControllerErrorIfNeeded(controller, e) {
  4765.   if (controller._controlledWritableStream._state === 'writable' || controller._controlledWritableStream._state === 'closing') {
  4766.     WritableStreamDefaultControllerError(controller, e);
  4767.   }
  4768. }
  4769.  
  4770. function WritableStreamDefaultControllerProcessClose(controller) {
  4771.   var stream = controller._controlledWritableStream;
  4772.  
  4773.   assert(stream._state === 'closing', 'can\'t process final write record unless already closed');
  4774.  
  4775.   DequeueValue(controller._queue);
  4776.   assert(controller._queue.length === 0, 'queue must be empty once the final write record is dequeued');
  4777.  
  4778.   controller._inClose = true;
  4779.   var sinkClosePromise = PromiseInvokeOrNoop(controller._underlyingSink, 'close', [controller]);
  4780.   sinkClosePromise.then(function () {
  4781.     assert(controller._inClose === true);
  4782.     controller._inClose = false;
  4783.     if (stream._state !== 'closing' && stream._state !== 'errored') {
  4784.       return;
  4785.     }
  4786.  
  4787.     assert(stream._pendingCloseRequest !== undefined);
  4788.     stream._pendingCloseRequest._resolve(undefined);
  4789.     stream._pendingCloseRequest = undefined;
  4790.  
  4791.     WritableStreamFinishClose(stream);
  4792.   }, function (r) {
  4793.     assert(controller._inClose === true);
  4794.     controller._inClose = false;
  4795.     assert(stream._pendingCloseRequest !== undefined);
  4796.     stream._pendingCloseRequest._reject(r);
  4797.     stream._pendingCloseRequest = undefined;
  4798.     if (stream._pendingAbortRequest !== undefined) {
  4799.       stream._pendingAbortRequest._reject(r);
  4800.       stream._pendingAbortRequest = undefined;
  4801.     }
  4802.     WritableStreamDefaultControllerErrorIfNeeded(controller, r);
  4803.   }).catch(rethrowAssertionErrorRejection);
  4804. }
  4805.  
  4806. function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
  4807.   controller._writing = true;
  4808.  
  4809.   var stream = controller._controlledWritableStream;
  4810.  
  4811.   assert(stream._pendingWriteRequest === undefined);
  4812.   assert(stream._writeRequests.length !== 0);
  4813.   stream._pendingWriteRequest = stream._writeRequests.shift();
  4814.   var sinkWritePromise = PromiseInvokeOrNoop(controller._underlyingSink, 'write', [chunk, controller]);
  4815.   sinkWritePromise.then(function () {
  4816.     var state = stream._state;
  4817.  
  4818.     assert(controller._writing === true);
  4819.     controller._writing = false;
  4820.  
  4821.     assert(stream._pendingWriteRequest !== undefined);
  4822.     stream._pendingWriteRequest._resolve(undefined);
  4823.     stream._pendingWriteRequest = undefined;
  4824.  
  4825.     if (state === 'errored') {
  4826.       WritableStreamRejectPromisesInReactionToError(stream);
  4827.  
  4828.       if (stream._pendingAbortRequest !== undefined) {
  4829.         stream._pendingAbortRequest._resolve();
  4830.         stream._pendingAbortRequest = undefined;
  4831.       }
  4832.       return;
  4833.     }
  4834.     var lastBackpressure = WritableStreamDefaultControllerGetBackpressure(controller);
  4835.     DequeueValue(controller._queue);
  4836.     if (state !== 'closing') {
  4837.       var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
  4838.       if (lastBackpressure !== backpressure) {
  4839.         WritableStreamUpdateBackpressure(controller._controlledWritableStream, backpressure);
  4840.       }
  4841.     }
  4842.  
  4843.     WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
  4844.   }, function (r) {
  4845.     assert(controller._writing === true);
  4846.     controller._writing = false;
  4847.  
  4848.     assert(stream._pendingWriteRequest !== undefined);
  4849.     stream._pendingWriteRequest._reject(r);
  4850.     stream._pendingWriteRequest = undefined;
  4851.     if (stream._state === 'errored') {
  4852.       stream._storedError = r;
  4853.       WritableStreamRejectPromisesInReactionToError(stream);
  4854.     }
  4855.     if (stream._pendingAbortRequest !== undefined) {
  4856.       stream._pendingAbortRequest._reject(r);
  4857.       stream._pendingAbortRequest = undefined;
  4858.     }
  4859.     WritableStreamDefaultControllerErrorIfNeeded(controller, r);
  4860.   }).catch(rethrowAssertionErrorRejection);
  4861. }
  4862.  
  4863. function WritableStreamDefaultControllerGetBackpressure(controller) {
  4864.   var desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);
  4865.   return desiredSize <= 0;
  4866. }
  4867.  
  4868. // A client of WritableStreamDefaultController may use these functions directly to bypass state check.
  4869.  
  4870. function WritableStreamDefaultControllerError(controller, e) {
  4871.   var stream = controller._controlledWritableStream;
  4872.  
  4873.   assert(stream._state === 'writable' || stream._state === 'closing');
  4874.  
  4875.   WritableStreamError(stream, e);
  4876.  
  4877.   controller._queue = [];
  4878. }
  4879.  
  4880. // Helper functions for the WritableStream.
  4881.  
  4882. function streamBrandCheckException(name) {
  4883.   return new TypeError('WritableStream.prototype.' + name + ' can only be used on a WritableStream');
  4884. }
  4885.  
  4886. // Helper functions for the WritableStreamDefaultWriter.
  4887.  
  4888. function defaultWriterBrandCheckException(name) {
  4889.   return new TypeError('WritableStreamDefaultWriter.prototype.' + name + ' can only be used on a WritableStreamDefaultWriter');
  4890. }
  4891.  
  4892. function defaultWriterLockException(name) {
  4893.   return new TypeError('Cannot ' + name + ' a stream using a released writer');
  4894. }
  4895.  
  4896. function defaultWriterClosedPromiseInitialize(writer) {
  4897.   writer._closedPromise = new Promise(function (resolve, reject) {
  4898.     writer._closedPromise_resolve = resolve;
  4899.     writer._closedPromise_reject = reject;
  4900.   });
  4901. }
  4902.  
  4903. function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) {
  4904.   writer._closedPromise = Promise.reject(reason);
  4905.   writer._closedPromise_resolve = undefined;
  4906.   writer._closedPromise_reject = undefined;
  4907. }
  4908.  
  4909. function defaultWriterClosedPromiseInitializeAsResolved(writer) {
  4910.   writer._closedPromise = Promise.resolve(undefined);
  4911.   writer._closedPromise_resolve = undefined;
  4912.   writer._closedPromise_reject = undefined;
  4913. }
  4914.  
  4915. function defaultWriterClosedPromiseReject(writer, reason) {
  4916.   assert(writer._closedPromise_resolve !== undefined);
  4917.   assert(writer._closedPromise_reject !== undefined);
  4918.  
  4919.   writer._closedPromise_reject(reason);
  4920.   writer._closedPromise_resolve = undefined;
  4921.   writer._closedPromise_reject = undefined;
  4922. }
  4923.  
  4924. function defaultWriterClosedPromiseResetToRejected(writer, reason) {
  4925.   assert(writer._closedPromise_resolve === undefined);
  4926.   assert(writer._closedPromise_reject === undefined);
  4927.  
  4928.   writer._closedPromise = Promise.reject(reason);
  4929. }
  4930.  
  4931. function defaultWriterClosedPromiseResolve(writer) {
  4932.   assert(writer._closedPromise_resolve !== undefined);
  4933.   assert(writer._closedPromise_reject !== undefined);
  4934.  
  4935.   writer._closedPromise_resolve(undefined);
  4936.   writer._closedPromise_resolve = undefined;
  4937.   writer._closedPromise_reject = undefined;
  4938. }
  4939.  
  4940. function defaultWriterReadyPromiseInitialize(writer) {
  4941.   writer._readyPromise = new Promise(function (resolve, reject) {
  4942.     writer._readyPromise_resolve = resolve;
  4943.     writer._readyPromise_reject = reject;
  4944.   });
  4945. }
  4946.  
  4947. function defaultWriterReadyPromiseInitializeAsResolved(writer) {
  4948.   writer._readyPromise = Promise.resolve(undefined);
  4949.   writer._readyPromise_resolve = undefined;
  4950.   writer._readyPromise_reject = undefined;
  4951. }
  4952.  
  4953. function defaultWriterReadyPromiseReject(writer, reason) {
  4954.   assert(writer._readyPromise_resolve !== undefined);
  4955.   assert(writer._readyPromise_reject !== undefined);
  4956.  
  4957.   writer._readyPromise_reject(reason);
  4958.   writer._readyPromise_resolve = undefined;
  4959.   writer._readyPromise_reject = undefined;
  4960. }
  4961.  
  4962. function defaultWriterReadyPromiseReset(writer) {
  4963.   assert(writer._readyPromise_resolve === undefined);
  4964.   assert(writer._readyPromise_reject === undefined);
  4965.  
  4966.   writer._readyPromise = new Promise(function (resolve, reject) {
  4967.     writer._readyPromise_resolve = resolve;
  4968.     writer._readyPromise_reject = reject;
  4969.   });
  4970. }
  4971.  
  4972. function defaultWriterReadyPromiseResetToRejected(writer, reason) {
  4973.   assert(writer._readyPromise_resolve === undefined);
  4974.   assert(writer._readyPromise_reject === undefined);
  4975.  
  4976.   writer._readyPromise = Promise.reject(reason);
  4977. }
  4978.  
  4979. function defaultWriterReadyPromiseResolve(writer) {
  4980.   assert(writer._readyPromise_resolve !== undefined);
  4981.   assert(writer._readyPromise_reject !== undefined);
  4982.  
  4983.   writer._readyPromise_resolve(undefined);
  4984.   writer._readyPromise_resolve = undefined;
  4985.   writer._readyPromise_reject = undefined;
  4986. }
  4987.  
  4988. },{"./helpers.js":9,"./queue-with-sizes.js":10,"./utils.js":13,"assert":2}]},{},[1])(1)
  4989. });
  4990. //# sourceMappingURL=polyfill.js.map