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
@@ -9,7 +9,6 @@
  */
 
 ;(function () {
-
   var global = typeof window === 'object'
       ? window : typeof self === 'object'
       ? self : this
@@ -17,7 +16,7 @@
   var BlobBuilder = global.BlobBuilder
     || global.WebKitBlobBuilder
     || global.MSBlobBuilder
-    || global.MozBlobBuilder;
+    || global.MozBlobBuilder
 
   global.URL = global.URL || global.webkitURL || function (href, a) {
   	a = document.createElement('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
@@ -53,106 +52,203 @@
   function mapArrayBufferViews (ary) {
     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) {
-    options = options || {};
+    options = options || {}
 
-    var bb = new BlobBuilder();
+    var bb = new BlobBuilder()
     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) {
-    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
   }
 
+
+
+  /********************************************************/
+  /*               String Encoder fallback                */
+  /********************************************************/
+  function stringEncode (string) {
+    var pos = 0
+    var len = string.length
+    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
+          }
+        }
+        if (value >= 0xd800 && value <= 0xdbff) {
+          continue  // drop lone surrogate
+        }
+      }
+
+      // 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
+    }
+
+    return target.slice(0, at)
+  }
+
+  /********************************************************/
+  /*               String Decoder fallback                */
+  /********************************************************/
+  function stringDecode (buf) {
+    var end = buf.length
+    var res = []
+
+    var i = 0
+    while (i < end) {
+      var firstByte = buf[i]
+      var codePoint = null
+      var bytesPerSequence = (firstByte > 0xEF) ? 4
+        : (firstByte > 0xDF) ? 3
+          : (firstByte > 0xBF) ? 2
+            : 1
+
+      if (i + bytesPerSequence <= end) {
+        var secondByte, thirdByte, fourthByte, tempCodePoint
+
+        switch (bytesPerSequence) {
+          case 1:
+            if (firstByte < 0x80) {
+              codePoint = firstByte
+            }
+            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
+              }
+            }
+        }
+      }
+
+      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
+    }
+
+    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 toUTF8Array(str) {
-      var utf8 = [];
-      for (var i=0; i < str.length; i++) {
-        var charcode = str.charCodeAt(i);
-        if (charcode < 0x80) utf8.push(charcode);
-        else if (charcode < 0x800) {
-          utf8.push(0xc0 | (charcode >> 6), 
-          0x80 | (charcode & 0x3f));
-        }
-        else if (charcode < 0xd800 || charcode >= 0xe000) {
-          utf8.push(0xe0 | (charcode >> 12), 
-          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;
-    }
-    function fromUtf8Array(array) {
-      var out, i, len, c;
-      var char2, char3;
-      
-      out = "";
-      len = array.length;
-      i = 0;
-      while (i < len) {
-        c = array[i++];
-        switch (c >> 4)
-        { 
-          case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
-          // 0xxxxxxx
-          out += String.fromCharCode(c);
-          break;
-          case 12: case 13:
-          // 110x xxxx   10xx xxxx
-          char2 = array[i++];
-          out += String.fromCharCode(((c & 0x1F) << 6) | (char2 & 0x3F));
-          break;
-          case 14:
-          // 1110 xxxx  10xx xxxx  10xx xxxx
-          char2 = array[i++];
-          char3 = array[i++];
-          out += String.fromCharCode(((c & 0x0F) << 12) |
-          ((char2 & 0x3F) << 6) |
-          ((char3 & 0x3F) << 0));
-          break;
-        }
-      }    
-      return out;
-    }
     function isDataView (obj) {
       return obj && DataView.prototype.isPrototypeOf(obj)
     }
@@ -165,34 +261,35 @@
       }
       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[outByte3], byteToCharMap[outByte4])
+          byteToCharMap[outByte3], byteToCharMap[outByte4]
+        )
       }
 
       return output.join('')
@@ -200,8 +297,8 @@
 
     var create = Object.create || function (a) {
       function c () {}
-      c.prototype = a;
+      c.prototype = a
-      return new c
+      return new c()
     }
 
     if (arrayBufferSupported) {
@@ -222,31 +319,61 @@
       }
     }
 
+    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) {
       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.arrayBuffer = function () {
+      return Promise.resolve(this._buffer)
+    }
+
+    Blob.prototype.text = function () {
+      return Promise.resolve(textDecode(this._buffer))
     }
 
     Blob.prototype.slice = function (start, end, type) {
@@ -258,27 +385,25 @@
       return '[object Blob]'
     }
 
-    
-
     /********************************************************/
     /*                   File constructor                   */
     /********************************************************/
     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) {}
     }
 
@@ -286,13 +411,13 @@
       return '[object File]'
     }
 
-    
     /********************************************************/
     /*                FileReader constructor                */
     /********************************************************/
     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.")
+      }
 
     	var delegate = document.createDocumentFragment()
     	this.addEventListener = delegate.addEventListener
@@ -305,8 +430,9 @@
     }
 
     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'.")
+      }
 
     	fr.result = ''
 
@@ -330,28 +456,28 @@
 
     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) {
     	_read(this, blob, 'readAsText')
-    	this.result = fromUtf8Array(blob._buffer)
+    	this.result = textDecode(blob._buffer)
     }
 
     FileReader.prototype.readAsArrayBuffer = function (blob) {
       _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 () {}
 
-    
     /********************************************************/
     /*                         URL                          */
     /********************************************************/
     URL.createObjectURL = function (blob) {
       return blob instanceof Blob
-        ? 'data:' + blob.type + ';base64,' + encodeByteArray(blob._buffer)
+        ? 'data:' + blob.type + ';base64,' + array2base64(blob._buffer)
         : createObjectURL.call(URL, blob)
     }
 
@@ -367,7 +493,7 @@
       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)
         }
@@ -379,12 +505,6 @@
     global.Blob = Blob
   }
 
-  if (strTag) {
-    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 &&
@@ -414,8 +534,8 @@
           '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'
@@ -424,17 +544,18 @@
       } catch (e) {
         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 () {
             return '[object File]'
           }
 
-          if (strTag)
+          if (strTag) {
             blob[strTag] = 'File'
+          }
 
           return blob
         }
@@ -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
+  }
+})()