libs/Blob.js

  1. /**
  2.  * @license
  3.  * Blob.js
  4.  * A Blob, File, FileReader & URL implementation.
  5.  * 2018-08-09
  6.  *
  7.  * By Eli Grey, http://eligrey.com
  8.  * By Jimmy Wärting, https://github.com/jimmywarting
  9.  * License: MIT
  10.  *   See https://github.com/eligrey/Blob.js/blob/master/LICENSE.md
  11.  */
  13. import { globalObject as global } from "./globalObject.js";
  15. var BlobBuilder =
  16.   global.BlobBuilder ||
  17.   global.WebKitBlobBuilder ||
  18.   global.MSBlobBuilder ||
  19.   global.MozBlobBuilder;
  21. global.URL =
  22.   global.URL ||
  23.   global.webkitURL ||
  24.   function(href, a) {
  25.     a = document.createElement("a");
  26.     a.href = href;
  27.     return a;
  28.   };
  30. var origBlob = global.Blob;
  31. var createObjectURL = URL.createObjectURL;
  32. var revokeObjectURL = URL.revokeObjectURL;
  33. var strTag = global.Symbol && global.Symbol.toStringTag;
  34. var blobSupported = false;
  35. var blobSupportsArrayBufferView = false;
  36. var arrayBufferSupported = !!global.ArrayBuffer;
  37. var blobBuilderSupported =
  38.   BlobBuilder && BlobBuilder.prototype.append && BlobBuilder.prototype.getBlob;
  40. try {
  41.   // Check if Blob constructor is supported
  42.   blobSupported = new Blob(["ä"]).size === 2;
  44.   // Check if Blob constructor supports ArrayBufferViews
  45.   // Fails in Safari 6, so we need to map to ArrayBuffers there.
  46.   blobSupportsArrayBufferView = new Blob([new Uint8Array([1, 2])]).size === 2;
  47. } catch (e) {}
  49. /**
  50.  * Helper function that maps ArrayBufferViews to ArrayBuffers
  51.  * Used by BlobBuilder constructor and old browsers that didn't
  52.  * support it in the Blob constructor.
  53.  */
  54. function mapArrayBufferViews(ary) {
  55.   return ary.map(function(chunk) {
  56.     if (chunk.buffer instanceof ArrayBuffer) {
  57.       var buf = chunk.buffer;
  59.       // if this is a subarray, make a copy so we only
  60.       // include the subarray region from the underlying buffer
  61.       if (chunk.byteLength !== buf.byteLength) {
  62.         var copy = new Uint8Array(chunk.byteLength);
  63.         copy.set(new Uint8Array(buf, chunk.byteOffset, chunk.byteLength));
  64.         buf = copy.buffer;
  65.       }
  67.       return buf;
  68.     }
  70.     return chunk;
  71.   });
  72. }
  74. function BlobBuilderConstructor(ary, options) {
  75.   options = options || {};
  77.   var bb = new BlobBuilder();
  78.   mapArrayBufferViews(ary).forEach(function(part) {
  79.     bb.append(part);
  80.   });
  82.   return options.type ? bb.getBlob(options.type) : bb.getBlob();
  83. }
  85. function BlobConstructor(ary, options) {
  86.   return new origBlob(mapArrayBufferViews(ary), options || {});
  87. }
  89. if (global.Blob) {
  90.   BlobBuilderConstructor.prototype = Blob.prototype;
  91.   BlobConstructor.prototype = Blob.prototype;
  92. }
  94. function FakeBlobBuilder() {
  95.   function toUTF8Array(str) {
  96.     var utf8 = [];
  97.     for (var i = 0; i < str.length; i++) {
  98.       var charcode = str.charCodeAt(i);
  99.       if (charcode < 0x80) utf8.push(charcode);
  100.       else if (charcode < 0x800) {
  101.         utf8.push(0xc0 | (charcode >> 6), 0x80 | (charcode & 0x3f));
  102.       } else if (charcode < 0xd800 || charcode >= 0xe000) {
  103.         utf8.push(
  104.           0xe0 | (charcode >> 12),
  105.           0x80 | ((charcode >> 6) & 0x3f),
  106.           0x80 | (charcode & 0x3f)
  107.         );
  108.       }
  109.       // surrogate pair
  110.       else {
  111.         i++;
  112.         // UTF-16 encodes 0x10000-0x10FFFF by
  113.         // subtracting 0x10000 and splitting the
  114.         // 20 bits of 0x0-0xFFFFF into two halves
  115.         charcode =
  116.           0x10000 + (((charcode & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
  117.         utf8.push(
  118.           0xf0 | (charcode >> 18),
  119.           0x80 | ((charcode >> 12) & 0x3f),
  120.           0x80 | ((charcode >> 6) & 0x3f),
  121.           0x80 | (charcode & 0x3f)
  122.         );
  123.       }
  124.     }
  125.     return utf8;
  126.   }
  127.   function fromUtf8Array(array) {
  128.     var out, i, len, c;
  129.     var char2, char3;
  131.     out = "";
  132.     len = array.length;
  133.     i = 0;
  134.     while (i < len) {
  135.       c = array[i++];
  136.       switch (c >> 4) {
  137.         case 0:
  138.         case 1:
  139.         case 2:
  140.         case 3:
  141.         case 4:
  142.         case 5:
  143.         case 6:
  144.         case 7:
  145.           // 0xxxxxxx
  146.           out += String.fromCharCode(c);
  147.           break;
  148.         case 12:
  149.         case 13:
  150.           // 110x xxxx   10xx xxxx
  151.           char2 = array[i++];
  152.           out += String.fromCharCode(((c & 0x1f) << 6) | (char2 & 0x3f));
  153.           break;
  154.         case 14:
  155.           // 1110 xxxx  10xx xxxx  10xx xxxx
  156.           char2 = array[i++];
  157.           char3 = array[i++];
  158.           out += String.fromCharCode(
  159.             ((c & 0x0f) << 12) | ((char2 & 0x3f) << 6) | ((char3 & 0x3f) << 0)
  160.           );
  161.           break;
  162.       }
  163.     }
  164.     return out;
  165.   }
  166.   function isDataView(obj) {
  167.     return obj && DataView.prototype.isPrototypeOf(obj);
  168.   }
  169.   function bufferClone(buf) {
  170.     var view = new Array(buf.byteLength);
  171.     var array = new Uint8Array(buf);
  172.     var i = view.length;
  173.     while (i--) {
  174.       view[i] = array[i];
  175.     }
  176.     return view;
  177.   }
  178.   function encodeByteArray(input) {
  179.     var byteToCharMap =
  180.       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
  182.     var output = [];
  184.     for (var i = 0; i < input.length; i += 3) {
  185.       var byte1 = input[i];
  186.       var haveByte2 = i + 1 < input.length;
  187.       var byte2 = haveByte2 ? input[i + 1] : 0;
  188.       var haveByte3 = i + 2 < input.length;
  189.       var byte3 = haveByte3 ? input[i + 2] : 0;
  191.       var outByte1 = byte1 >> 2;
  192.       var outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
  193.       var outByte3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6);
  194.       var outByte4 = byte3 & 0x3f;
  196.       if (!haveByte3) {
  197.         outByte4 = 64;
  199.         if (!haveByte2) {
  200.           outByte3 = 64;
  201.         }
  202.       }
  204.       output.push(
  205.         byteToCharMap[outByte1],
  206.         byteToCharMap[outByte2],
  207.         byteToCharMap[outByte3],
  208.         byteToCharMap[outByte4]
  209.       );
  210.     }
  212.     return output.join("");
  213.   }
  215.   var create =
  216.     Object.create ||
  217.     function(a) {
  218.       function c() {}
  219.       c.prototype = a;
  220.       return new c();
  221.     };
  223.   if (arrayBufferSupported) {
  224.     var viewClasses = [
  225.       "[object Int8Array]",
  226.       "[object Uint8Array]",
  227.       "[object Uint8ClampedArray]",
  228.       "[object Int16Array]",
  229.       "[object Uint16Array]",
  230.       "[object Int32Array]",
  231.       "[object Uint32Array]",
  232.       "[object Float32Array]",
  233.       "[object Float64Array]"
  234.     ];
  236.     var isArrayBufferView =
  237.       ArrayBuffer.isView ||
  238.       function(obj) {
  239.         return (
  240.           obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
  241.         );
  242.       };
  243.   }
  245.   /********************************************************/
  246.   /*                   Blob constructor                   */
  247.   /********************************************************/
  248.   function Blob(chunks, opts) {
  249.     chunks = chunks || [];
  250.     for (var i = 0, len = chunks.length; i < len; i++) {
  251.       var chunk = chunks[i];
  252.       if (chunk instanceof Blob) {
  253.         chunks[i] = chunk._buffer;
  254.       } else if (typeof chunk === "string") {
  255.         chunks[i] = toUTF8Array(chunk);
  256.       } else if (
  257.         arrayBufferSupported &&
  258.         (ArrayBuffer.prototype.isPrototypeOf(chunk) || isArrayBufferView(chunk))
  259.       ) {
  260.         chunks[i] = bufferClone(chunk);
  261.       } else if (arrayBufferSupported && isDataView(chunk)) {
  262.         chunks[i] = bufferClone(chunk.buffer);
  263.       } else {
  264.         chunks[i] = toUTF8Array(String(chunk));
  265.       }
  266.     }
  268.     this._buffer = [].concat.apply([], chunks);
  269.     this.size = this._buffer.length;
  270.     this.type = opts ? opts.type || "" : "";
  271.   }
  273.   Blob.prototype.slice = function(start, end, type) {
  274.     var slice = this._buffer.slice(start || 0, end || this._buffer.length);
  275.     return new Blob([slice], { type: type });
  276.   };
  278.   Blob.prototype.toString = function() {
  279.     return "[object Blob]";
  280.   };
  282.   /********************************************************/
  283.   /*                   File constructor                   */
  284.   /********************************************************/
  285.   function File(chunks, name, opts) {
  286.     opts = opts || {};
  287.     var a = Blob.call(this, chunks, opts) || this;
  288.     a.name = name;
  289.     a.lastModifiedDate = opts.lastModified
  290.       ? new Date(opts.lastModified)
  291.       : new Date();
  292.     a.lastModified = +a.lastModifiedDate;
  294.     return a;
  295.   }
  297.   File.prototype = create(Blob.prototype);
  298.   File.prototype.constructor = File;
  300.   if (Object.setPrototypeOf) Object.setPrototypeOf(File, Blob);
  301.   else {
  302.     try {
  303.       File.__proto__ = Blob;
  304.     } catch (e) {}
  305.   }
  307.   File.prototype.toString = function() {
  308.     return "[object File]";
  309.   };
  311.   /********************************************************/
  312.   /*                FileReader constructor                */
  313.   /********************************************************/
  314.   function FileReader() {
  315.     if (!(this instanceof FileReader))
  316.       throw new TypeError(
  317.         "Failed to construct 'FileReader': Please use the 'new' operator, this DOM object constructor cannot be called as a function."
  318.       );
  320.     var delegate = document.createDocumentFragment();
  321.     this.addEventListener = delegate.addEventListener;
  322.     this.dispatchEvent = function(evt) {
  323.       var local = this["on" + evt.type];
  324.       if (typeof local === "function") local(evt);
  325.       delegate.dispatchEvent(evt);
  326.     };
  327.     this.removeEventListener = delegate.removeEventListener;
  328.   }
  330.   function _read(fr, blob, kind) {
  331.     if (!(blob instanceof Blob))
  332.       throw new TypeError(
  333.         "Failed to execute '" +
  334.           kind +
  335.           "' on 'FileReader': parameter 1 is not of type 'Blob'."
  336.       );
  338.     fr.result = "";
  340.     setTimeout(function() {
  341.       this.readyState = FileReader.LOADING;
  342.       fr.dispatchEvent(new Event("load"));
  343.       fr.dispatchEvent(new Event("loadend"));
  344.     });
  345.   }
  347.   FileReader.EMPTY = 0;
  348.   FileReader.LOADING = 1;
  349.   FileReader.DONE = 2;
  350.   FileReader.prototype.error = null;
  351.   FileReader.prototype.onabort = null;
  352.   FileReader.prototype.onerror = null;
  353.   FileReader.prototype.onload = null;
  354.   FileReader.prototype.onloadend = null;
  355.   FileReader.prototype.onloadstart = null;
  356.   FileReader.prototype.onprogress = null;
  358.   FileReader.prototype.readAsDataURL = function(blob) {
  359.     _read(this, blob, "readAsDataURL");
  360.     this.result =
  361.       "data:" + blob.type + ";base64," + encodeByteArray(blob._buffer);
  362.   };
  364.   FileReader.prototype.readAsText = function(blob) {
  365.     _read(this, blob, "readAsText");
  366.     this.result = fromUtf8Array(blob._buffer);
  367.   };
  369.   FileReader.prototype.readAsArrayBuffer = function(blob) {
  370.     _read(this, blob, "readAsText");
  371.     this.result = blob._buffer.slice();
  372.   };
  374.   FileReader.prototype.abort = function() {};
  376.   /********************************************************/
  377.   /*                         URL                          */
  378.   /********************************************************/
  379.   URL.createObjectURL = function(blob) {
  380.     return blob instanceof Blob
  381.       ? "data:" + blob.type + ";base64," + encodeByteArray(blob._buffer)
  382.       : createObjectURL.call(URL, blob);
  383.   };
  385.   URL.revokeObjectURL = function(url) {
  386.     revokeObjectURL && revokeObjectURL.call(URL, url);
  387.   };
  389.   /********************************************************/
  390.   /*                         XHR                          */
  391.   /********************************************************/
  392.   var _send = global.XMLHttpRequest && global.XMLHttpRequest.prototype.send;
  393.   if (_send) {
  394.     XMLHttpRequest.prototype.send = function(data) {
  395.       if (data instanceof Blob) {
  396.         this.setRequestHeader("Content-Type", data.type);
  397.         _send.call(this, fromUtf8Array(data._buffer));
  398.       } else {
  399.         _send.call(this, data);
  400.       }
  401.     };
  402.   }
  404.   global.FileReader = FileReader;
  405.   global.File = File;
  406.   global.Blob = Blob;
  407. }
  409. if (strTag) {
  410.   try {
  411.     File.prototype[strTag] = "File";
  412.     Blob.prototype[strTag] = "Blob";
  413.     FileReader.prototype[strTag] = "FileReader";
  414.   } catch (e) {}
  415. }
  417. function fixFileAndXHR() {
  418.   try {
  419.     new File([], "");
  420.   } catch (e) {
  421.     try {
  422.       var klass = new Function(
  423.         "class File extends Blob {" +
  424.           "constructor(chunks, name, opts) {" +
  425.           "opts = opts || {};" +
  426.           "super(chunks, opts || {});" +
  427.           "this.name = name;" +
  428.           "this.lastModifiedDate = opts.lastModified ? new Date(opts.lastModified) : new Date;" +
  429.           "this.lastModified = +this.lastModifiedDate;" +
  430.           "}};" +
  431.           'return new File([], ""), File'
  432.       )();
  433.       global.File = klass;
  434.     } catch (e) {
  435.       var klass = function(b, d, c) {
  436.         var blob = new Blob(b, c);
  437.         var t =
  438.           c && void 0 !== c.lastModified
  439.             ? new Date(c.lastModified)
  440.             : new Date();
  442.         blob.name = d;
  443.         blob.lastModifiedDate = t;
  444.         blob.lastModified = +t;
  445.         blob.toString = function() {
  446.           return "[object File]";
  447.         };
  449.         if (strTag) blob[strTag] = "File";
  451.         return blob;
  452.       };
  453.       global.File = klass;
  454.     }
  455.   }
  456. }
  458. if (blobSupported) {
  459.   fixFileAndXHR();
  460.   global.Blob = blobSupportsArrayBufferView ? global.Blob : BlobConstructor;
  461. } else if (blobBuilderSupported) {
  462.   fixFileAndXHR();
  463.   global.Blob = BlobBuilderConstructor;
  464. } else {
  465.   FakeBlobBuilder();
  466. }