Merge pull request #67 from jimmywarting/master

Compatibility overhaul

Blob.js

@@ -1,6 +1,6 @@
 /* Blob.js
  * A Blob, File, FileReader & URL implementation.
- * 2018-08-09
+ * 2019-04-19
  *
  * By Eli Grey, http://eligrey.com
  * By Jimmy Wärting, https://github.com/jimmywarting
@@ -8,8 +8,7 @@
  *   See https://github.com/eligrey/Blob.js/blob/master/LICENSE.md
  */
 
-;(function(){
+;(function () {
-
   var global = typeof window === 'object'
       ? window : typeof self === 'object'
       ? self : this
@@ -17,9 +16,9 @@
   var BlobBuilder = global.BlobBuilder
     || global.WebKitBlobBuilder
     || global.MSBlobBuilder
-    || global.MozBlobBuilder;
+    || global.MozBlobBuilder
 
-  global.URL = global.URL || global.webkitURL || function(href, a) {
+  global.URL = global.URL || global.webkitURL || function (href, a) {
   	a = document.createElement('a')
   	a.href = href
   	return a
@@ -34,7 +33,7 @@
   var arrayBufferSupported = !!global.ArrayBuffer
   var blobBuilderSupported = BlobBuilder
     && BlobBuilder.prototype.append
-    && BlobBuilder.prototype.getBlob;
+    && BlobBuilder.prototype.getBlob
 
   try {
     // Check if Blob constructor is supported
@@ -42,168 +41,266 @@
 
     // Check if Blob constructor supports ArrayBufferViews
     // Fails in Safari 6, so we need to map to ArrayBuffers there.
-    blobSupportsArrayBufferView = new Blob([new Uint8Array([1,2])]).size === 2
+    blobSupportsArrayBufferView = new Blob([new Uint8Array([1, 2])]).size === 2
-  } catch(e) {}
+  } catch (e) {}
 
   /**
    * Helper function that maps ArrayBufferViews to ArrayBuffers
    * Used by BlobBuilder constructor and old browsers that didn't
    * support it in the Blob constructor.
    */
-  function mapArrayBufferViews(ary) {
+  function mapArrayBufferViews (ary) {
-    return ary.map(function(chunk) {
+    return ary.map(function (chunk) {
       if (chunk.buffer instanceof ArrayBuffer) {
-        var buf = chunk.buffer;
+        var buf = chunk.buffer
 
         // if this is a subarray, make a copy so we only
         // include the subarray region from the underlying buffer
         if (chunk.byteLength !== buf.byteLength) {
-          var copy = new Uint8Array(chunk.byteLength);
+          var copy = new Uint8Array(chunk.byteLength)
-          copy.set(new Uint8Array(buf, chunk.byteOffset, chunk.byteLength));
+          copy.set(new Uint8Array(buf, chunk.byteOffset, chunk.byteLength))
-          buf = copy.buffer;
+          buf = copy.buffer
         }
 
-        return buf;
+        return buf
       }
 
-      return chunk;
+      return chunk
-    });
+    })
   }
 
-  function BlobBuilderConstructor(ary, options) {
+  function BlobBuilderConstructor (ary, options) {
-    options = options || {};
+    options = options || {}
 
-    var bb = new BlobBuilder();
+    var bb = new BlobBuilder()
-    mapArrayBufferViews(ary).forEach(function(part) {
+    mapArrayBufferViews(ary).forEach(function (part) {
-      bb.append(part);
+      bb.append(part)
-    });
+    })
 
-    return options.type ? bb.getBlob(options.type) : bb.getBlob();
+    return options.type ? bb.getBlob(options.type) : bb.getBlob()
-  };
+  }
 
-  function BlobConstructor(ary, options) {
+  function BlobConstructor (ary, options) {
-    return new origBlob(mapArrayBufferViews(ary), options || {});
+    return new origBlob(mapArrayBufferViews(ary), options || {})
-  };
+  }
 
   if (global.Blob) {
-    BlobBuilderConstructor.prototype = Blob.prototype;
+    BlobBuilderConstructor.prototype = Blob.prototype
-    BlobConstructor.prototype = Blob.prototype;
+    BlobConstructor.prototype = Blob.prototype
   }
 
-  function FakeBlobBuilder() {
+
-    function toUTF8Array(str) {
+
-      var utf8 = [];
+  /********************************************************/
-      for (var i=0; i < str.length; i++) {
+  /*               String Encoder fallback                */
-        var charcode = str.charCodeAt(i);
+  /********************************************************/
-        if (charcode < 0x80) utf8.push(charcode);
+  function stringEncode (string) {
-        else if (charcode < 0x800) {
+    var pos = 0
-          utf8.push(0xc0 | (charcode >> 6), 
+    var len = string.length
-          0x80 | (charcode & 0x3f));
+    var out = []
+    var Arr = global.Uint8Array || Array // Use byte array when possible
+
+    var at = 0  // output position
+    var tlen = Math.max(32, len + (len >> 1) + 7)  // 1.5x size
+    var target = new Arr((tlen >> 3) << 3)  // ... but at 8 byte offset
+
+    while (pos < len) {
+      var value = string.charCodeAt(pos++)
+      if (value >= 0xd800 && value <= 0xdbff) {
+        // high surrogate
+        if (pos < len) {
+          var extra = string.charCodeAt(pos)
+          if ((extra & 0xfc00) === 0xdc00) {
+            ++pos
+            value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000
+          }
         }
-        else if (charcode < 0xd800 || charcode >= 0xe000) {
+        if (value >= 0xd800 && value <= 0xdbff) {
-          utf8.push(0xe0 | (charcode >> 12), 
+          continue  // drop lone surrogate
-          0x80 | ((charcode>>6) & 0x3f), 
-          0x80 | (charcode & 0x3f));
-        }
-        // surrogate pair
-        else {
-          i++;
-          // UTF-16 encodes 0x10000-0x10FFFF by
-          // subtracting 0x10000 and splitting the
-          // 20 bits of 0x0-0xFFFFF into two halves
-          charcode = 0x10000 + (((charcode & 0x3ff)<<10)
-          | (str.charCodeAt(i) & 0x3ff));
-          utf8.push(0xf0 | (charcode >>18), 
-          0x80 | ((charcode>>12) & 0x3f), 
-          0x80 | ((charcode>>6) & 0x3f), 
-          0x80 | (charcode & 0x3f));
         }
       }
-      return utf8;
+
+      // expand the buffer if we couldn't write 4 bytes
+      if (at + 4 > target.length) {
+        tlen += 8  // minimum extra
+        tlen *= (1.0 + (pos / string.length) * 2)  // take 2x the remaining
+        tlen = (tlen >> 3) << 3  // 8 byte offset
+
+        const update = new Uint8Array(tlen)
+        update.set(target)
+        target = update
+      }
+
+      if ((value & 0xffffff80) === 0) {  // 1-byte
+        target[at++] = value  // ASCII
+        continue
+      } else if ((value & 0xfffff800) === 0) {  // 2-byte
+        target[at++] = ((value >> 6) & 0x1f) | 0xc0
+      } else if ((value & 0xffff0000) === 0) {  // 3-byte
+        target[at++] = ((value >> 12) & 0x0f) | 0xe0
+        target[at++] = ((value >> 6) & 0x3f) | 0x80
+      } else if ((value & 0xffe00000) === 0) {  // 4-byte
+        target[at++] = ((value >> 18) & 0x07) | 0xf0
+        target[at++] = ((value >> 12) & 0x3f) | 0x80
+        target[at++] = ((value >> 6) & 0x3f) | 0x80
+      } else {
+        // FIXME: do we care
+        continue
+      }
+
+      target[at++] = (value & 0x3f) | 0x80
     }
-    function fromUtf8Array(array) {
+
-      var out, i, len, c;
+    return target.slice(0, at)
-      var char2, char3;
+  }
-      
+
-      out = "";
+  /********************************************************/
-      len = array.length;
+  /*               String Decoder fallback                */
-      i = 0;
+  /********************************************************/
-      while (i < len) {
+  function stringDecode (buf) {
-        c = array[i++];
+    var end = buf.length
-        switch (c >> 4)
+    var res = []
-        { 
+
-          case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
+    var i = 0
-          // 0xxxxxxx
+    while (i < end) {
-          out += String.fromCharCode(c);
+      var firstByte = buf[i]
-          break;
+      var codePoint = null
-          case 12: case 13:
+      var bytesPerSequence = (firstByte > 0xEF) ? 4
-          // 110x xxxx   10xx xxxx
+        : (firstByte > 0xDF) ? 3
-          char2 = array[i++];
+          : (firstByte > 0xBF) ? 2
-          out += String.fromCharCode(((c & 0x1F) << 6) | (char2 & 0x3F));
+            : 1
-          break;
+
-          case 14:
+      if (i + bytesPerSequence <= end) {
-          // 1110 xxxx  10xx xxxx  10xx xxxx
+        var secondByte, thirdByte, fourthByte, tempCodePoint
-          char2 = array[i++];
+
-          char3 = array[i++];
+        switch (bytesPerSequence) {
-          out += String.fromCharCode(((c & 0x0F) << 12) |
+          case 1:
-          ((char2 & 0x3F) << 6) |
+            if (firstByte < 0x80) {
-          ((char3 & 0x3F) << 0));
+              codePoint = firstByte
-          break;
+            }
+            break
+          case 2:
+            secondByte = buf[i + 1]
+            if ((secondByte & 0xC0) === 0x80) {
+              tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
+              if (tempCodePoint > 0x7F) {
+                codePoint = tempCodePoint
+              }
+            }
+            break
+          case 3:
+            secondByte = buf[i + 1]
+            thirdByte = buf[i + 2]
+            if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
+              tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
+              if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
+                codePoint = tempCodePoint
+              }
+            }
+            break
+          case 4:
+            secondByte = buf[i + 1]
+            thirdByte = buf[i + 2]
+            fourthByte = buf[i + 3]
+            if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
+              tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
+              if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
+                codePoint = tempCodePoint
+              }
+            }
         }
-      }    
+      }
-      return out;
+
+      if (codePoint === null) {
+        // we did not generate a valid codePoint so insert a
+        // replacement char (U+FFFD) and advance only 1 byte
+        codePoint = 0xFFFD
+        bytesPerSequence = 1
+      } else if (codePoint > 0xFFFF) {
+        // encode to utf16 (surrogate pair dance)
+        codePoint -= 0x10000
+        res.push(codePoint >>> 10 & 0x3FF | 0xD800)
+        codePoint = 0xDC00 | codePoint & 0x3FF
+      }
+
+      res.push(codePoint)
+      i += bytesPerSequence
     }
-    function isDataView(obj) {
+
+    var len = res.length
+    var str = ''
+    var i = 0
+
+    while (i < len) {
+      str += String.fromCharCode.apply(String, res.slice(i, i += 0x1000))
+    }
+
+    return str
+  }
+
+  // string -> buffer
+  var textEncode = typeof TextEncoder === 'function'
+    ? TextEncoder.prototype.encode.bind(new TextEncoder())
+    : stringEncode
+
+  // buffer -> string
+  var textDecode = typeof TextDecoder === 'function'
+    ? TextDecoder.prototype.decode.bind(new TextDecoder())
+    : stringDecode
+
+  function FakeBlobBuilder () {
+    function isDataView (obj) {
       return obj && DataView.prototype.isPrototypeOf(obj)
     }
-    function bufferClone(buf) {
+    function bufferClone (buf) {
       var view = new Array(buf.byteLength)
       var array = new Uint8Array(buf)
       var i = view.length
-      while(i--) {
+      while (i--) {
         view[i] = array[i]
       }
       return view
     }
-    function encodeByteArray(input) {
+    function array2base64 (input) {
-      var byteToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+      var byteToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
 
-      var output = [];
+      var output = []
 
       for (var i = 0; i < input.length; i += 3) {
-        var byte1 = input[i];
+        var byte1 = input[i]
-        var haveByte2 = i + 1 < input.length;
+        var haveByte2 = i + 1 < input.length
-        var byte2 = haveByte2 ? input[i + 1] : 0;
+        var byte2 = haveByte2 ? input[i + 1] : 0
-        var haveByte3 = i + 2 < input.length;
+        var haveByte3 = i + 2 < input.length
-        var byte3 = haveByte3 ? input[i + 2] : 0;
+        var byte3 = haveByte3 ? input[i + 2] : 0
 
-        var outByte1 = byte1 >> 2;
+        var outByte1 = byte1 >> 2
-        var outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
+        var outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4)
-        var outByte3 = ((byte2 & 0x0F) << 2) | (byte3 >> 6);
+        var outByte3 = ((byte2 & 0x0F) << 2) | (byte3 >> 6)
-        var outByte4 = byte3 & 0x3F;
+        var outByte4 = byte3 & 0x3F
 
         if (!haveByte3) {
-          outByte4 = 64;
+          outByte4 = 64
 
           if (!haveByte2) {
-            outByte3 = 64;
+            outByte3 = 64
           }
         }
 
         output.push(
-            byteToCharMap[outByte1], byteToCharMap[outByte2],
+          byteToCharMap[outByte1], byteToCharMap[outByte2],
-            byteToCharMap[outByte3], byteToCharMap[outByte4])
+          byteToCharMap[outByte3], byteToCharMap[outByte4]
+        )
       }
 
       return output.join('')
     }
 
     var create = Object.create || function (a) {
-      function c() {}
+      function c () {}
-      c.prototype = a;
+      c.prototype = a
-      return new c
+      return new c()
     }
-    
+
     if (arrayBufferSupported) {
       var viewClasses = [
         '[object Int8Array]',
@@ -217,86 +314,114 @@
         '[object Float64Array]'
       ]
 
-      var isArrayBufferView = ArrayBuffer.isView || function(obj) {
+      var isArrayBufferView = ArrayBuffer.isView || function (obj) {
         return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
       }
     }
 
-    
+    function concatTypedarrays (chunks) {
-    
+      var size = 0
+      var i = chunks.length
+      while (i--) { size += chunks[i].length }
+      var b = new Uint8Array(size)
+      var offset = 0
+      for (i = 0, l = chunks.length; i < l; i++) {
+        var chunk = chunks[i]
+        b.set(chunk, offset)
+        offset += chunk.byteLength || chunk.length
+      }
+
+      return b
+    }
+
     /********************************************************/
     /*                   Blob constructor                   */
     /********************************************************/
-    function Blob(chunks, opts) {
+    function Blob (chunks, opts) {
       chunks = chunks || []
+      opts = opts == null ? {} : opts
       for (var i = 0, len = chunks.length; i < len; i++) {
         var chunk = chunks[i]
         if (chunk instanceof Blob) {
           chunks[i] = chunk._buffer
         } else if (typeof chunk === 'string') {
-          chunks[i] = toUTF8Array(chunk)
+          chunks[i] = textEncode(chunk)
         } else if (arrayBufferSupported && (ArrayBuffer.prototype.isPrototypeOf(chunk) || isArrayBufferView(chunk))) {
           chunks[i] = bufferClone(chunk)
         } else if (arrayBufferSupported && isDataView(chunk)) {
           chunks[i] = bufferClone(chunk.buffer)
         } else {
-          chunks[i] = toUTF8Array(String(chunk))
+          chunks[i] = textEncode(String(chunk))
         }
       }
 
-      this._buffer = [].concat.apply([], chunks)
+      this._buffer = global.Uint8Array
+        ? concatTypedarrays(chunks)
+        : [].concat.apply([], chunks)
       this.size = this._buffer.length
-      this.type = opts ? opts.type || '' : ''
+
+      this.type = opts.type || ''
+      if (/[^\u0020-\u007E]/.test(this.type)) {
+        this.type = ''
+      } else {
+        this.type = this.type.toLowerCase()
+      }
     }
 
-    Blob.prototype.slice = function(start, end, type) {
+    Blob.prototype.arrayBuffer = function () {
+      return Promise.resolve(this._buffer)
+    }
+
+    Blob.prototype.text = function () {
+      return Promise.resolve(textDecode(this._buffer))
+    }
+
+    Blob.prototype.slice = function (start, end, type) {
       var slice = this._buffer.slice(start || 0, end || this._buffer.length)
       return new Blob([slice], {type: type})
     }
 
-    Blob.prototype.toString = function() {
+    Blob.prototype.toString = function () {
       return '[object Blob]'
     }
 
-    
-
     /********************************************************/
     /*                   File constructor                   */
     /********************************************************/
-    function File(chunks, name, opts) {
+    function File (chunks, name, opts) {
       opts = opts || {}
       var a = Blob.call(this, chunks, opts) || this
-      a.name = name
+      a.name = name.replace(/\//g, ':')
-      a.lastModifiedDate = opts.lastModified ? new Date(opts.lastModified) : new Date
+      a.lastModifiedDate = opts.lastModified ? new Date(opts.lastModified) : new Date()
       a.lastModified = +a.lastModifiedDate
-      
+
       return a
     }
 
-    File.prototype = create(Blob.prototype);
+    File.prototype = create(Blob.prototype)
-    File.prototype.constructor = File;
+    File.prototype.constructor = File
 
-    if (Object.setPrototypeOf) 
+    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(File, Blob);
+      Object.setPrototypeOf(File, Blob)
-    else {
+    } else {
-      try {File.__proto__ = Blob} catch (e) {}
+      try { File.__proto__ = Blob } catch (e) {}
     }
 
-    File.prototype.toString = function() {
+    File.prototype.toString = function () {
       return '[object File]'
     }
 
-    
     /********************************************************/
     /*                FileReader constructor                */
     /********************************************************/
-    function FileReader() {
+    function FileReader () {
-    	if (!(this instanceof FileReader))
+    	if (!(this instanceof FileReader)) {
-    		throw new TypeError("Failed to construct 'FileReader': Please use the 'new' operator, this DOM object constructor cannot be called as a function.")
+        throw new TypeError("Failed to construct 'FileReader': Please use the 'new' operator, this DOM object constructor cannot be called as a function.")
+      }
 
     	var delegate = document.createDocumentFragment()
     	this.addEventListener = delegate.addEventListener
-    	this.dispatchEvent = function(evt) {
+    	this.dispatchEvent = function (evt) {
     		var local = this['on' + evt.type]
     		if (typeof local === 'function') local(evt)
     		delegate.dispatchEvent(evt)
@@ -304,13 +429,14 @@
     	this.removeEventListener = delegate.removeEventListener
     }
 
-    function _read(fr, blob, kind) {
+    function _read (fr, blob, kind) {
-    	if (!(blob instanceof Blob))
+    	if (!(blob instanceof Blob)) {
-    		throw new TypeError("Failed to execute '" + kind + "' on 'FileReader': parameter 1 is not of type 'Blob'.")
+        throw new TypeError("Failed to execute '" + kind + "' on 'FileReader': parameter 1 is not of type 'Blob'.")
-    	
+      }
+
     	fr.result = ''
 
-    	setTimeout(function(){
+    	setTimeout(function () {
     		this.readyState = FileReader.LOADING
     		fr.dispatchEvent(new Event('load'))
     		fr.dispatchEvent(new Event('loadend'))
@@ -328,34 +454,34 @@
     FileReader.prototype.onloadstart = null
     FileReader.prototype.onprogress = null
 
-    FileReader.prototype.readAsDataURL = function(blob) {
+    FileReader.prototype.readAsDataURL = function (blob) {
     	_read(this, blob, 'readAsDataURL')
-    	this.result = 'data:' + blob.type + ';base64,' + encodeByteArray(blob._buffer)
+    	this.result = 'data:' + blob.type + ';base64,' + array2base64(blob._buffer)
     }
 
-    FileReader.prototype.readAsText = function(blob) {
+    FileReader.prototype.readAsText = function (blob) {
     	_read(this, blob, 'readAsText')
-    	this.result = fromUtf8Array(blob._buffer)
+    	this.result = textDecode(blob._buffer)
     }
 
-    FileReader.prototype.readAsArrayBuffer = function(blob) {
+    FileReader.prototype.readAsArrayBuffer = function (blob) {
-    	_read(this, blob, 'readAsText')
+      _read(this, blob, 'readAsText')
-    	this.result = blob._buffer.slice()
+       // return ArrayBuffer when possible
+      this.result = (blob._buffer.buffer || blob._buffer).slice()
     }
 
-    FileReader.prototype.abort = function() {}
+    FileReader.prototype.abort = function () {}
 
-    
     /********************************************************/
     /*                         URL                          */
     /********************************************************/
-    URL.createObjectURL = function(blob) {
+    URL.createObjectURL = function (blob) {
-      return blob instanceof Blob 
+      return blob instanceof Blob
-        ? 'data:' + blob.type + ';base64,' + encodeByteArray(blob._buffer)
+        ? 'data:' + blob.type + ';base64,' + array2base64(blob._buffer)
         : createObjectURL.call(URL, blob)
     }
-    
+
-    URL.revokeObjectURL = function(url) {
+    URL.revokeObjectURL = function (url) {
       revokeObjectURL && revokeObjectURL.call(URL, url)
     }
 
@@ -364,39 +490,33 @@
     /********************************************************/
     var _send = global.XMLHttpRequest && global.XMLHttpRequest.prototype.send
     if (_send) {
-      XMLHttpRequest.prototype.send = function(data) {
+      XMLHttpRequest.prototype.send = function (data) {
         if (data instanceof Blob) {
           this.setRequestHeader('Content-Type', data.type)
-          _send.call(this, fromUtf8Array(data._buffer))
+          _send.call(this, textDecode(data._buffer))
         } else {
           _send.call(this, data)
         }
       }
     }
-    
+
     global.FileReader = FileReader
     global.File = File
     global.Blob = Blob
   }
 
-  if (strTag) {
+  function fixFileAndXHR () {
-    File.prototype[strTag] = 'File'
-    Blob.prototype[strTag] = 'Blob'
-    FileReader.prototype[strTag] = 'FileReader'
-  }
-
-  function fixFileAndXHR() {
     var isIE = !!global.ActiveXObject || (
-      '-ms-scroll-limit' in document.documentElement.style && 
+      '-ms-scroll-limit' in document.documentElement.style &&
       '-ms-ime-align' in document.documentElement.style
     )
 
-    // Monkey patched 
+    // Monkey patched
     // IE don't set Content-Type header on XHR whose body is a typed Blob
     // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/6047383
     var _send = global.XMLHttpRequest && global.XMLHttpRequest.prototype.send
     if (isIE && _send) {
-      XMLHttpRequest.prototype.send = function(data) {
+      XMLHttpRequest.prototype.send = function (data) {
         if (data instanceof Blob) {
           this.setRequestHeader('Content-Type', data.type)
           _send.call(this, data)
@@ -408,34 +528,35 @@
 
     try {
       new File([], '')
-    } catch(e) {
+    } catch (e) {
       try {
-        var klass = new Function('class File extends Blob {' + 
+        var klass = new Function('class File extends Blob {' +
           'constructor(chunks, name, opts) {' +
             'opts = opts || {};' +
             'super(chunks, opts || {});' +
-            'this.name = name;' +
+            'this.name = name.replace(/\//g, ":");' +
-            'this.lastModifiedDate = opts.lastModified ? new Date(opts.lastModified) : new Date;' +
+            'this.lastModifiedDate = opts.lastModified ? new Date(opts.lastModified) : new Date();' +
             'this.lastModified = +this.lastModifiedDate;' +
           '}};' +
           'return new File([], ""), File'
         )()
         global.File = klass
-      } catch(e) {
+      } catch (e) {
-        var klass = function(b, d, c) {
+        var klass = function (b, d, c) {
           var blob = new Blob(b, c)
-          var t = c && void 0 !== c.lastModified ? new Date(c.lastModified) : new Date
+          var t = c && void 0 !== c.lastModified ? new Date(c.lastModified) : new Date()
-          
+
-          blob.name = d
+          blob.name = d.replace(/\//g, ':')
           blob.lastModifiedDate = t
           blob.lastModified = +t
-          blob.toString = function() {
+          blob.toString = function () {
             return '[object File]'
           }
-          
+
-          if (strTag)
+          if (strTag) {
             blob[strTag] = 'File'
-          
+          }
+
           return blob
         }
         global.File = klass
@@ -448,9 +569,117 @@
     global.Blob = blobSupportsArrayBufferView ? global.Blob : BlobConstructor
   } else if (blobBuilderSupported) {
     fixFileAndXHR()
-    global.Blob = BlobBuilderConstructor;
+    global.Blob = BlobBuilderConstructor
   } else {
     FakeBlobBuilder()
   }
 
-})();
+  if (strTag) {
+    File.prototype[strTag] = 'File'
+    Blob.prototype[strTag] = 'Blob'
+    FileReader.prototype[strTag] = 'FileReader'
+  }
+
+  var blob = global.Blob.prototype
+  var stream
+
+  function promisify(obj) {
+    return new Promise(function(resolve, reject) {
+      obj.onload =
+      obj.onerror = function(evt) {
+        obj.onload =
+        obj.onerror = null
+
+        evt.type === 'load'
+          ? resolve(obj.result || obj)
+          : reject(new Error('Failed to read the blob/file'))
+      }
+    })
+  }
+
+
+  try {
+    new ReadableStream({ type: 'bytes' })
+    stream = function stream() {
+      var position = 0
+      var blob = this
+
+      return new ReadableStream({
+        type: 'bytes',
+        autoAllocateChunkSize: 524288,
+
+        pull: function (controller) {
+          var v = controller.byobRequest.view
+          var chunk = blob.slice(position, position + v.byteLength)
+          return chunk.arrayBuffer()
+          .then(function (buffer) {
+            var uint8array = new Uint8Array(buffer)
+            var bytesRead = uint8array.byteLength
+
+            position += bytesRead
+            v.set(uint8array)
+              controller.byobRequest.respond(bytesRead)
+
+            if(position >= blob.size)
+              controller.close()
+          })
+        }
+      })
+    }
+  } catch (e) {
+    try {
+      new ReadableStream({})
+      stream = function stream(blob){
+        var position = 0
+        var blob = this
+
+        return new ReadableStream({
+          pull: function (controller) {
+            var chunk = blob.slice(position, position + 524288)
+
+            return chunk.arrayBuffer().then(function (buffer) {
+              position += buffer.byteLength
+              var uint8array = new Uint8Array(buffer)
+              controller.enqueue(uint8array)
+
+              if (position == blob.size)
+                controller.close()
+            })
+          }
+        })
+      }
+    } catch (e) {
+      try {
+        new Response('').body.getReader().read()
+        stream = function stream() {
+          return (new Response(this)).body
+        }
+      } catch (e) {
+        stream = function stream() {
+          throw new Error('Include https://github.com/MattiasBuelens/web-streams-polyfill')
+        }
+      }
+    }
+  }
+
+
+  if (!blob.arrayBuffer) {
+    blob.arrayBuffer = function arrayBuffer() {
+      var fr = new FileReader()
+      fr.readAsArrayBuffer(this)
+      return promisify(fr)
+    }
+  }
+
+  if (!blob.text) {
+    blob.text = function text() {
+      var fr = new FileReader()
+      fr.readAsText(this)
+      return promisify(fr)
+    }
+  }
+
+  if (!blob.stream) {
+    blob.stream = stream
+  }
+})()