☰

web-streams-polyfill

Web Streams, based on the WHATWG spec reference implementation

Dieses Skript sollte nicht direkt installiert werden. Es handelt sich hier um eine Bibliothek für andere Skripte, welche über folgenden Befehl in den Metadaten eines Skriptes eingebunden wird // @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