# libs/Blob.js

    /**
     * @license
     * Blob.js
     * A Blob, File, FileReader & URL implementation.
     * 2018-08-09
     *
     * By Eli Grey, http://eligrey.com
     * By Jimmy Wärting, https://github.com/jimmywarting
     * License: MIT
     *   See https://github.com/eligrey/Blob.js/blob/master/LICENSE.md
     */

    import { globalObject as global } from "./globalObject.js";

    var BlobBuilder =
      global.BlobBuilder ||
      global.WebKitBlobBuilder ||
      global.MSBlobBuilder ||
      global.MozBlobBuilder;

    global.URL =
      global.URL ||
      global.webkitURL ||
      function(href, a) {
        a = document.createElement("a");
        a.href = href;
        return a;
      };

    var origBlob = global.Blob;
    var createObjectURL = URL.createObjectURL;
    var revokeObjectURL = URL.revokeObjectURL;
    var strTag = global.Symbol && global.Symbol.toStringTag;
    var blobSupported = false;
    var blobSupportsArrayBufferView = false;
    var arrayBufferSupported = !!global.ArrayBuffer;
    var blobBuilderSupported =
      BlobBuilder && BlobBuilder.prototype.append && BlobBuilder.prototype.getBlob;

    try {
      // Check if Blob constructor is supported
      blobSupported = new Blob(["ä"]).size === 2;

      // 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;
    } 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) {
      return ary.map(function(chunk) {
        if (chunk.buffer instanceof ArrayBuffer) {
          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);
            copy.set(new Uint8Array(buf, chunk.byteOffset, chunk.byteLength));
            buf = copy.buffer;
          }

          return buf;
        }

        return chunk;
      });
    }

    function BlobBuilderConstructor(ary, options) {
      options = options || {};

      var bb = new BlobBuilder();
      mapArrayBufferViews(ary).forEach(function(part) {
        bb.append(part);
      });

      return options.type ? bb.getBlob(options.type) : bb.getBlob();
    }

    function BlobConstructor(ary, options) {
      return new origBlob(mapArrayBufferViews(ary), options || {});
    }

    if (global.Blob) {
      BlobBuilderConstructor.prototype = Blob.prototype;
      BlobConstructor.prototype = Blob.prototype;
    }

    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);
      }
      function bufferClone(buf) {
        var view = new Array(buf.byteLength);
        var array = new Uint8Array(buf);
        var i = view.length;
        while (i--) {
          view[i] = array[i];
        }
        return view;
      }
      function encodeByteArray(input) {
        var byteToCharMap =
          "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

        var output = [];

        for (var i = 0; i < input.length; i += 3) {
          var byte1 = input[i];
          var haveByte2 = i + 1 < input.length;
          var byte2 = haveByte2 ? input[i + 1] : 0;
          var haveByte3 = i + 2 < input.length;
          var byte3 = haveByte3 ? input[i + 2] : 0;

          var outByte1 = byte1 >> 2;
          var outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
          var outByte3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6);
          var outByte4 = byte3 & 0x3f;

          if (!haveByte3) {
            outByte4 = 64;

            if (!haveByte2) {
              outByte3 = 64;
            }
          }

          output.push(
            byteToCharMap[outByte1],
            byteToCharMap[outByte2],
            byteToCharMap[outByte3],
            byteToCharMap[outByte4]
          );
        }

        return output.join("");
      }

      var create =
        Object.create ||
        function(a) {
          function c() {}
          c.prototype = a;
          return new c();
        };

      if (arrayBufferSupported) {
        var viewClasses = [
          "[object Int8Array]",
          "[object Uint8Array]",
          "[object Uint8ClampedArray]",
          "[object Int16Array]",
          "[object Uint16Array]",
          "[object Int32Array]",
          "[object Uint32Array]",
          "[object Float32Array]",
          "[object Float64Array]"
        ];

        var isArrayBufferView =
          ArrayBuffer.isView ||
          function(obj) {
            return (
              obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
            );
          };
      }

      /********************************************************/
      /*                   Blob constructor                   */
      /********************************************************/
      function Blob(chunks, opts) {
        chunks = chunks || [];
        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);
          } 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));
          }
        }

        this._buffer = [].concat.apply([], chunks);
        this.size = this._buffer.length;
        this.type = opts ? opts.type || "" : "";
      }

      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() {
        return "[object Blob]";
      };

      /********************************************************/
      /*                   File constructor                   */
      /********************************************************/
      function File(chunks, name, opts) {
        opts = opts || {};
        var a = Blob.call(this, chunks, opts) || this;
        a.name = name;
        a.lastModifiedDate = opts.lastModified
          ? new Date(opts.lastModified)
          : new Date();
        a.lastModified = +a.lastModifiedDate;

        return a;
      }

      File.prototype = create(Blob.prototype);
      File.prototype.constructor = File;

      if (Object.setPrototypeOf) Object.setPrototypeOf(File, Blob);
      else {
        try {
          File.__proto__ = Blob;
        } catch (e) {}
      }

      File.prototype.toString = function() {
        return "[object File]";
      };

      /********************************************************/
      /*                FileReader constructor                */
      /********************************************************/
      function 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;
        this.dispatchEvent = function(evt) {
          var local = this["on" + evt.type];
          if (typeof local === "function") local(evt);
          delegate.dispatchEvent(evt);
        };
        this.removeEventListener = delegate.removeEventListener;
      }

      function _read(fr, blob, kind) {
        if (!(blob instanceof Blob))
          throw new TypeError(
            "Failed to execute '" +
              kind +
              "' on 'FileReader': parameter 1 is not of type 'Blob'."
          );

        fr.result = "";

        setTimeout(function() {
          this.readyState = FileReader.LOADING;
          fr.dispatchEvent(new Event("load"));
          fr.dispatchEvent(new Event("loadend"));
        });
      }

      FileReader.EMPTY = 0;
      FileReader.LOADING = 1;
      FileReader.DONE = 2;
      FileReader.prototype.error = null;
      FileReader.prototype.onabort = null;
      FileReader.prototype.onerror = null;
      FileReader.prototype.onload = null;
      FileReader.prototype.onloadend = null;
      FileReader.prototype.onloadstart = null;
      FileReader.prototype.onprogress = null;

      FileReader.prototype.readAsDataURL = function(blob) {
        _read(this, blob, "readAsDataURL");
        this.result =
          "data:" + blob.type + ";base64," + encodeByteArray(blob._buffer);
      };

      FileReader.prototype.readAsText = function(blob) {
        _read(this, blob, "readAsText");
        this.result = fromUtf8Array(blob._buffer);
      };

      FileReader.prototype.readAsArrayBuffer = function(blob) {
        _read(this, blob, "readAsText");
        this.result = blob._buffer.slice();
      };

      FileReader.prototype.abort = function() {};

      /********************************************************/
      /*                         URL                          */
      /********************************************************/
      URL.createObjectURL = function(blob) {
        return blob instanceof Blob
          ? "data:" + blob.type + ";base64," + encodeByteArray(blob._buffer)
          : createObjectURL.call(URL, blob);
      };

      URL.revokeObjectURL = function(url) {
        revokeObjectURL && revokeObjectURL.call(URL, url);
      };

      /********************************************************/
      /*                         XHR                          */
      /********************************************************/
      var _send = global.XMLHttpRequest && global.XMLHttpRequest.prototype.send;
      if (_send) {
        XMLHttpRequest.prototype.send = function(data) {
          if (data instanceof Blob) {
            this.setRequestHeader("Content-Type", data.type);
            _send.call(this, fromUtf8Array(data._buffer));
          } else {
            _send.call(this, data);
          }
        };
      }

      global.FileReader = FileReader;
      global.File = File;
      global.Blob = Blob;
    }

    if (strTag) {
      try {
        File.prototype[strTag] = "File";
        Blob.prototype[strTag] = "Blob";
        FileReader.prototype[strTag] = "FileReader";
      } catch (e) {}
    }

    function fixFileAndXHR() {
      var isIE =
        !!global.ActiveXObject ||
        ("-ms-scroll-limit" in document.documentElement.style &&
          "-ms-ime-align" in document.documentElement.style);

      // 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) {
          if (data instanceof Blob) {
            this.setRequestHeader("Content-Type", data.type);
            _send.call(this, data);
          } else {
            _send.call(this, data);
          }
        };
      }

      try {
        new File([], "");
      } catch (e) {
        try {
          var klass = new Function(
            "class File extends Blob {" +
              "constructor(chunks, name, opts) {" +
              "opts = opts || {};" +
              "super(chunks, opts || {});" +
              "this.name = name;" +
              "this.lastModifiedDate = opts.lastModified ? new Date(opts.lastModified) : new Date;" +
              "this.lastModified = +this.lastModifiedDate;" +
              "}};" +
              'return new File([], ""), File'
          )();
          global.File = klass;
        } 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();

            blob.name = d;
            blob.lastModifiedDate = t;
            blob.lastModified = +t;
            blob.toString = function() {
              return "[object File]";
            };

            if (strTag) blob[strTag] = "File";

            return blob;
          };
          global.File = klass;
        }
      }
    }

    if (blobSupported) {
      fixFileAndXHR();
      global.Blob = blobSupportsArrayBufferView ? global.Blob : BlobConstructor;
    } else if (blobBuilderSupported) {
      fixFileAndXHR();
      global.Blob = BlobBuilderConstructor;
    } else {
      FakeBlobBuilder();
    }