pdfjs-dist/web/compatibility.js

/* Copyright 2017 Mozilla Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define("pdfjs-dist/web/compatibility", [], factory);
	else if(typeof exports === 'object')
		exports["pdfjs-dist/web/compatibility"] = factory();
	else
		root["pdfjs-dist/web/compatibility"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.l = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}


/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

/******/ 	// identity function for calling harmony imports with the correct context
/******/ 	__webpack_require__.i = function(value) { return value; };

/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};

/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};

/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 2);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(global) {
if (typeof PDFJS === 'undefined' || !PDFJS.compatibilityChecked) {
 var globalScope = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : this;
 var userAgent = typeof navigator !== 'undefined' && navigator.userAgent || '';
 var isAndroid = /Android/.test(userAgent);
 var isAndroidPre3 = /Android\s[0-2][^\d]/.test(userAgent);
 var isAndroidPre5 = /Android\s[0-4][^\d]/.test(userAgent);
 var isChrome = userAgent.indexOf('Chrom') >= 0;
 var isChromeWithRangeBug = /Chrome\/(39|40)\./.test(userAgent);
 var isIOSChrome = userAgent.indexOf('CriOS') >= 0;
 var isIE = userAgent.indexOf('Trident') >= 0;
 var isIOS = /\b(iPad|iPhone|iPod)(?=;)/.test(userAgent);
 var isOpera = userAgent.indexOf('Opera') >= 0;
 var isSafari = /Safari\//.test(userAgent) && !/(Chrome\/|Android\s)/.test(userAgent);
 var hasDOM = typeof window === 'object' && typeof document === 'object';
 if (typeof PDFJS === 'undefined') {
  globalScope.PDFJS = {};
 }
 PDFJS.compatibilityChecked = true;
 (function checkTypedArrayCompatibility() {
  if (typeof Uint8Array !== 'undefined') {
   if (typeof Uint8Array.prototype.subarray === 'undefined') {
    Uint8Array.prototype.subarray = function subarray(start, end) {
     return new Uint8Array(this.slice(start, end));
    };
    Float32Array.prototype.subarray = function subarray(start, end) {
     return new Float32Array(this.slice(start, end));
    };
   }
   if (typeof Float64Array === 'undefined') {
    globalScope.Float64Array = Float32Array;
   }
   return;
  }
  function subarray(start, end) {
   return new TypedArray(this.slice(start, end));
  }
  function setArrayOffset(array, offset) {
   if (arguments.length < 2) {
    offset = 0;
   }
   for (var i = 0, n = array.length; i < n; ++i, ++offset) {
    this[offset] = array[i] & 0xFF;
   }
  }
  function TypedArray(arg1) {
   var result, i, n;
   if (typeof arg1 === 'number') {
    result = [];
    for (i = 0; i < arg1; ++i) {
     result[i] = 0;
    }
   } else if ('slice' in arg1) {
    result = arg1.slice(0);
   } else {
    result = [];
    for (i = 0, n = arg1.length; i < n; ++i) {
     result[i] = arg1[i];
    }
   }
   result.subarray = subarray;
   result.buffer = result;
   result.byteLength = result.length;
   result.set = setArrayOffset;
   if (typeof arg1 === 'object' && arg1.buffer) {
    result.buffer = arg1.buffer;
   }
   return result;
  }
  globalScope.Uint8Array = TypedArray;
  globalScope.Int8Array = TypedArray;
  globalScope.Uint32Array = TypedArray;
  globalScope.Int32Array = TypedArray;
  globalScope.Uint16Array = TypedArray;
  globalScope.Float32Array = TypedArray;
  globalScope.Float64Array = TypedArray;
 }());
 (function normalizeURLObject() {
  if (!globalScope.URL) {
   globalScope.URL = globalScope.webkitURL;
  }
 }());
 (function checkObjectDefinePropertyCompatibility() {
  if (typeof Object.defineProperty !== 'undefined') {
   var definePropertyPossible = true;
   try {
    if (hasDOM) {
     Object.defineProperty(new Image(), 'id', { value: 'test' });
    }
    var Test = function Test() {
    };
    Test.prototype = {
     get id() {
     }
    };
    Object.defineProperty(new Test(), 'id', {
     value: '',
     configurable: true,
     enumerable: true,
     writable: false
    });
   } catch (e) {
    definePropertyPossible = false;
   }
   if (definePropertyPossible) {
    return;
   }
  }
  Object.defineProperty = function objectDefineProperty(obj, name, def) {
   delete obj[name];
   if ('get' in def) {
    obj.__defineGetter__(name, def['get']);
   }
   if ('set' in def) {
    obj.__defineSetter__(name, def['set']);
   }
   if ('value' in def) {
    obj.__defineSetter__(name, function objectDefinePropertySetter(value) {
     this.__defineGetter__(name, function objectDefinePropertyGetter() {
      return value;
     });
     return value;
    });
    obj[name] = def.value;
   }
  };
 }());
 (function checkXMLHttpRequestResponseCompatibility() {
  if (typeof XMLHttpRequest === 'undefined') {
   return;
  }
  var xhrPrototype = XMLHttpRequest.prototype;
  var xhr = new XMLHttpRequest();
  if (!('overrideMimeType' in xhr)) {
   Object.defineProperty(xhrPrototype, 'overrideMimeType', {
    value: function xmlHttpRequestOverrideMimeType(mimeType) {
    }
   });
  }
  if ('responseType' in xhr) {
   return;
  }
  Object.defineProperty(xhrPrototype, 'responseType', {
   get: function xmlHttpRequestGetResponseType() {
    return this._responseType || 'text';
   },
   set: function xmlHttpRequestSetResponseType(value) {
    if (value === 'text' || value === 'arraybuffer') {
     this._responseType = value;
     if (value === 'arraybuffer' && typeof this.overrideMimeType === 'function') {
      this.overrideMimeType('text/plain; charset=x-user-defined');
     }
    }
   }
  });
  if (typeof VBArray !== 'undefined') {
   Object.defineProperty(xhrPrototype, 'response', {
    get: function xmlHttpRequestResponseGet() {
     if (this.responseType === 'arraybuffer') {
      return new Uint8Array(new VBArray(this.responseBody).toArray());
     }
     return this.responseText;
    }
   });
   return;
  }
  Object.defineProperty(xhrPrototype, 'response', {
   get: function xmlHttpRequestResponseGet() {
    if (this.responseType !== 'arraybuffer') {
     return this.responseText;
    }
    var text = this.responseText;
    var i, n = text.length;
    var result = new Uint8Array(n);
    for (i = 0; i < n; ++i) {
     result[i] = text.charCodeAt(i) & 0xFF;
    }
    return result.buffer;
   }
  });
 }());
 (function checkWindowBtoaCompatibility() {
  if ('btoa' in globalScope) {
   return;
  }
  var digits = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
  globalScope.btoa = function (chars) {
   var buffer = '';
   var i, n;
   for (i = 0, n = chars.length; i < n; i += 3) {
    var b1 = chars.charCodeAt(i) & 0xFF;
    var b2 = chars.charCodeAt(i + 1) & 0xFF;
    var b3 = chars.charCodeAt(i + 2) & 0xFF;
    var d1 = b1 >> 2, d2 = (b1 & 3) << 4 | b2 >> 4;
    var d3 = i + 1 < n ? (b2 & 0xF) << 2 | b3 >> 6 : 64;
    var d4 = i + 2 < n ? b3 & 0x3F : 64;
    buffer += digits.charAt(d1) + digits.charAt(d2) + digits.charAt(d3) + digits.charAt(d4);
   }
   return buffer;
  };
 }());
 (function checkWindowAtobCompatibility() {
  if ('atob' in globalScope) {
   return;
  }
  var digits = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
  globalScope.atob = function (input) {
   input = input.replace(/=+$/, '');
   if (input.length % 4 === 1) {
    throw new Error('bad atob input');
   }
   for (var bc = 0, bs, buffer, idx = 0, output = ''; buffer = input.charAt(idx++); ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer, bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0) {
    buffer = digits.indexOf(buffer);
   }
   return output;
  };
 }());
 (function checkFunctionPrototypeBindCompatibility() {
  if (typeof Function.prototype.bind !== 'undefined') {
   return;
  }
  Function.prototype.bind = function functionPrototypeBind(obj) {
   var fn = this, headArgs = Array.prototype.slice.call(arguments, 1);
   var bound = function functionPrototypeBindBound() {
    var args = headArgs.concat(Array.prototype.slice.call(arguments));
    return fn.apply(obj, args);
   };
   return bound;
  };
 }());
 (function checkDatasetProperty() {
  if (!hasDOM) {
   return;
  }
  var div = document.createElement('div');
  if ('dataset' in div) {
   return;
  }
  Object.defineProperty(HTMLElement.prototype, 'dataset', {
   get: function () {
    if (this._dataset) {
     return this._dataset;
    }
    var dataset = {};
    for (var j = 0, jj = this.attributes.length; j < jj; j++) {
     var attribute = this.attributes[j];
     if (attribute.name.substring(0, 5) !== 'data-') {
      continue;
     }
     var key = attribute.name.substring(5).replace(/\-([a-z])/g, function (all, ch) {
      return ch.toUpperCase();
     });
     dataset[key] = attribute.value;
    }
    Object.defineProperty(this, '_dataset', {
     value: dataset,
     writable: false,
     enumerable: false
    });
    return dataset;
   },
   enumerable: true
  });
 }());
 (function checkClassListProperty() {
  function changeList(element, itemName, add, remove) {
   var s = element.className || '';
   var list = s.split(/\s+/g);
   if (list[0] === '') {
    list.shift();
   }
   var index = list.indexOf(itemName);
   if (index < 0 && add) {
    list.push(itemName);
   }
   if (index >= 0 && remove) {
    list.splice(index, 1);
   }
   element.className = list.join(' ');
   return index >= 0;
  }
  if (!hasDOM) {
   return;
  }
  var div = document.createElement('div');
  if ('classList' in div) {
   return;
  }
  var classListPrototype = {
   add: function (name) {
    changeList(this.element, name, true, false);
   },
   contains: function (name) {
    return changeList(this.element, name, false, false);
   },
   remove: function (name) {
    changeList(this.element, name, false, true);
   },
   toggle: function (name) {
    changeList(this.element, name, true, true);
   }
  };
  Object.defineProperty(HTMLElement.prototype, 'classList', {
   get: function () {
    if (this._classList) {
     return this._classList;
    }
    var classList = Object.create(classListPrototype, {
     element: {
      value: this,
      writable: false,
      enumerable: true
     }
    });
    Object.defineProperty(this, '_classList', {
     value: classList,
     writable: false,
     enumerable: false
    });
    return classList;
   },
   enumerable: true
  });
 }());
 (function checkWorkerConsoleCompatibility() {
  if (typeof importScripts === 'undefined' || 'console' in globalScope) {
   return;
  }
  var consoleTimer = {};
  var workerConsole = {
   log: function log() {
    var args = Array.prototype.slice.call(arguments);
    globalScope.postMessage({
     targetName: 'main',
     action: 'console_log',
     data: args
    });
   },
   error: function error() {
    var args = Array.prototype.slice.call(arguments);
    globalScope.postMessage({
     targetName: 'main',
     action: 'console_error',
     data: args
    });
   },
   time: function time(name) {
    consoleTimer[name] = Date.now();
   },
   timeEnd: function timeEnd(name) {
    var time = consoleTimer[name];
    if (!time) {
     throw new Error('Unknown timer name ' + name);
    }
    this.log('Timer:', name, Date.now() - time);
   }
  };
  globalScope.console = workerConsole;
 }());
 (function checkConsoleCompatibility() {
  if (!hasDOM) {
   return;
  }
  if (!('console' in window)) {
   window.console = {
    log: function () {
    },
    error: function () {
    },
    warn: function () {
    }
   };
   return;
  }
  if (!('bind' in console.log)) {
   console.log = function (fn) {
    return function (msg) {
     return fn(msg);
    };
   }(console.log);
   console.error = function (fn) {
    return function (msg) {
     return fn(msg);
    };
   }(console.error);
   console.warn = function (fn) {
    return function (msg) {
     return fn(msg);
    };
   }(console.warn);
   return;
  }
 }());
 (function checkOnClickCompatibility() {
  function ignoreIfTargetDisabled(event) {
   if (isDisabled(event.target)) {
    event.stopPropagation();
   }
  }
  function isDisabled(node) {
   return node.disabled || node.parentNode && isDisabled(node.parentNode);
  }
  if (isOpera) {
   document.addEventListener('click', ignoreIfTargetDisabled, true);
  }
 }());
 (function checkOnBlobSupport() {
  if (isIE || isIOSChrome) {
   PDFJS.disableCreateObjectURL = true;
  }
 }());
 (function checkNavigatorLanguage() {
  if (typeof navigator === 'undefined') {
   return;
  }
  if ('language' in navigator) {
   return;
  }
  PDFJS.locale = navigator.userLanguage || 'en-US';
 }());
 (function checkRangeRequests() {
  if (isSafari || isAndroidPre3 || isChromeWithRangeBug || isIOS) {
   PDFJS.disableRange = true;
   PDFJS.disableStream = true;
  }
 }());
 (function checkHistoryManipulation() {
  if (!hasDOM) {
   return;
  }
  if (!history.pushState || isAndroidPre3) {
   PDFJS.disableHistory = true;
  }
 }());
 (function checkSetPresenceInImageData() {
  if (!hasDOM) {
   return;
  }
  if (window.CanvasPixelArray) {
   if (typeof window.CanvasPixelArray.prototype.set !== 'function') {
    window.CanvasPixelArray.prototype.set = function (arr) {
     for (var i = 0, ii = this.length; i < ii; i++) {
      this[i] = arr[i];
     }
    };
   }
  } else {
   var polyfill = false, versionMatch;
   if (isChrome) {
    versionMatch = userAgent.match(/Chrom(e|ium)\/([0-9]+)\./);
    polyfill = versionMatch && parseInt(versionMatch[2]) < 21;
   } else if (isAndroid) {
    polyfill = isAndroidPre5;
   } else if (isSafari) {
    versionMatch = userAgent.match(/Version\/([0-9]+)\.([0-9]+)\.([0-9]+) Safari\//);
    polyfill = versionMatch && parseInt(versionMatch[1]) < 6;
   }
   if (polyfill) {
    var contextPrototype = window.CanvasRenderingContext2D.prototype;
    var createImageData = contextPrototype.createImageData;
    contextPrototype.createImageData = function (w, h) {
     var imageData = createImageData.call(this, w, h);
     imageData.data.set = function (arr) {
      for (var i = 0, ii = this.length; i < ii; i++) {
       this[i] = arr[i];
      }
     };
     return imageData;
    };
    contextPrototype = null;
   }
  }
 }());
 (function checkRequestAnimationFrame() {
  function fakeRequestAnimationFrame(callback) {
   window.setTimeout(callback, 20);
  }
  if (!hasDOM) {
   return;
  }
  if (isIOS) {
   window.requestAnimationFrame = fakeRequestAnimationFrame;
   return;
  }
  if ('requestAnimationFrame' in window) {
   return;
  }
  window.requestAnimationFrame = window.mozRequestAnimationFrame || window.webkitRequestAnimationFrame || fakeRequestAnimationFrame;
 }());
 (function checkCanvasSizeLimitation() {
  if (isIOS || isAndroid) {
   PDFJS.maxCanvasPixels = 5242880;
  }
 }());
 (function checkFullscreenSupport() {
  if (!hasDOM) {
   return;
  }
  if (isIE && window.parent !== window) {
   PDFJS.disableFullscreen = true;
  }
 }());
 (function checkCurrentScript() {
  if (!hasDOM) {
   return;
  }
  if ('currentScript' in document) {
   return;
  }
  Object.defineProperty(document, 'currentScript', {
   get: function () {
    var scripts = document.getElementsByTagName('script');
    return scripts[scripts.length - 1];
   },
   enumerable: true,
   configurable: true
  });
 }());
 (function checkInputTypeNumberAssign() {
  if (!hasDOM) {
   return;
  }
  var el = document.createElement('input');
  try {
   el.type = 'number';
  } catch (ex) {
   var inputProto = el.constructor.prototype;
   var typeProperty = Object.getOwnPropertyDescriptor(inputProto, 'type');
   Object.defineProperty(inputProto, 'type', {
    get: function () {
     return typeProperty.get.call(this);
    },
    set: function (value) {
     typeProperty.set.call(this, value === 'number' ? 'text' : value);
    },
    enumerable: true,
    configurable: true
   });
  }
 }());
 (function checkDocumentReadyState() {
  if (!hasDOM) {
   return;
  }
  if (!document.attachEvent) {
   return;
  }
  var documentProto = document.constructor.prototype;
  var readyStateProto = Object.getOwnPropertyDescriptor(documentProto, 'readyState');
  Object.defineProperty(documentProto, 'readyState', {
   get: function () {
    var value = readyStateProto.get.call(this);
    return value === 'interactive' ? 'loading' : value;
   },
   set: function (value) {
    readyStateProto.set.call(this, value);
   },
   enumerable: true,
   configurable: true
  });
 }());
 (function checkChildNodeRemove() {
  if (!hasDOM) {
   return;
  }
  if (typeof Element.prototype.remove !== 'undefined') {
   return;
  }
  Element.prototype.remove = function () {
   if (this.parentNode) {
    this.parentNode.removeChild(this);
   }
  };
 }());
 (function checkPromise() {
  if (globalScope.Promise) {
   if (typeof globalScope.Promise.all !== 'function') {
    globalScope.Promise.all = function (iterable) {
     var count = 0, results = [], resolve, reject;
     var promise = new globalScope.Promise(function (resolve_, reject_) {
      resolve = resolve_;
      reject = reject_;
     });
     iterable.forEach(function (p, i) {
      count++;
      p.then(function (result) {
       results[i] = result;
       count--;
       if (count === 0) {
        resolve(results);
       }
      }, reject);
     });
     if (count === 0) {
      resolve(results);
     }
     return promise;
    };
   }
   if (typeof globalScope.Promise.resolve !== 'function') {
    globalScope.Promise.resolve = function (value) {
     return new globalScope.Promise(function (resolve) {
      resolve(value);
     });
    };
   }
   if (typeof globalScope.Promise.reject !== 'function') {
    globalScope.Promise.reject = function (reason) {
     return new globalScope.Promise(function (resolve, reject) {
      reject(reason);
     });
    };
   }
   if (typeof globalScope.Promise.prototype.catch !== 'function') {
    globalScope.Promise.prototype.catch = function (onReject) {
     return globalScope.Promise.prototype.then(undefined, onReject);
    };
   }
   return;
  }
  var STATUS_PENDING = 0;
  var STATUS_RESOLVED = 1;
  var STATUS_REJECTED = 2;
  var REJECTION_TIMEOUT = 500;
  var HandlerManager = {
   handlers: [],
   running: false,
   unhandledRejections: [],
   pendingRejectionCheck: false,
   scheduleHandlers: function scheduleHandlers(promise) {
    if (promise._status === STATUS_PENDING) {
     return;
    }
    this.handlers = this.handlers.concat(promise._handlers);
    promise._handlers = [];
    if (this.running) {
     return;
    }
    this.running = true;
    setTimeout(this.runHandlers.bind(this), 0);
   },
   runHandlers: function runHandlers() {
    var RUN_TIMEOUT = 1;
    var timeoutAt = Date.now() + RUN_TIMEOUT;
    while (this.handlers.length > 0) {
     var handler = this.handlers.shift();
     var nextStatus = handler.thisPromise._status;
     var nextValue = handler.thisPromise._value;
     try {
      if (nextStatus === STATUS_RESOLVED) {
       if (typeof handler.onResolve === 'function') {
        nextValue = handler.onResolve(nextValue);
       }
      } else if (typeof handler.onReject === 'function') {
       nextValue = handler.onReject(nextValue);
       nextStatus = STATUS_RESOLVED;
       if (handler.thisPromise._unhandledRejection) {
        this.removeUnhandeledRejection(handler.thisPromise);
       }
      }
     } catch (ex) {
      nextStatus = STATUS_REJECTED;
      nextValue = ex;
     }
     handler.nextPromise._updateStatus(nextStatus, nextValue);
     if (Date.now() >= timeoutAt) {
      break;
     }
    }
    if (this.handlers.length > 0) {
     setTimeout(this.runHandlers.bind(this), 0);
     return;
    }
    this.running = false;
   },
   addUnhandledRejection: function addUnhandledRejection(promise) {
    this.unhandledRejections.push({
     promise: promise,
     time: Date.now()
    });
    this.scheduleRejectionCheck();
   },
   removeUnhandeledRejection: function removeUnhandeledRejection(promise) {
    promise._unhandledRejection = false;
    for (var i = 0; i < this.unhandledRejections.length; i++) {
     if (this.unhandledRejections[i].promise === promise) {
      this.unhandledRejections.splice(i);
      i--;
     }
    }
   },
   scheduleRejectionCheck: function scheduleRejectionCheck() {
    if (this.pendingRejectionCheck) {
     return;
    }
    this.pendingRejectionCheck = true;
    setTimeout(function rejectionCheck() {
     this.pendingRejectionCheck = false;
     var now = Date.now();
     for (var i = 0; i < this.unhandledRejections.length; i++) {
      if (now - this.unhandledRejections[i].time > REJECTION_TIMEOUT) {
       var unhandled = this.unhandledRejections[i].promise._value;
       var msg = 'Unhandled rejection: ' + unhandled;
       if (unhandled.stack) {
        msg += '\n' + unhandled.stack;
       }
       try {
        throw new Error(msg);
       } catch (_) {
        console.warn(msg);
       }
       this.unhandledRejections.splice(i);
       i--;
      }
     }
     if (this.unhandledRejections.length) {
      this.scheduleRejectionCheck();
     }
    }.bind(this), REJECTION_TIMEOUT);
   }
  };
  var Promise = function Promise(resolver) {
   this._status = STATUS_PENDING;
   this._handlers = [];
   try {
    resolver.call(this, this._resolve.bind(this), this._reject.bind(this));
   } catch (e) {
    this._reject(e);
   }
  };
  Promise.all = function Promise_all(promises) {
   var resolveAll, rejectAll;
   var deferred = new Promise(function (resolve, reject) {
    resolveAll = resolve;
    rejectAll = reject;
   });
   var unresolved = promises.length;
   var results = [];
   if (unresolved === 0) {
    resolveAll(results);
    return deferred;
   }
   function reject(reason) {
    if (deferred._status === STATUS_REJECTED) {
     return;
    }
    results = [];
    rejectAll(reason);
   }
   for (var i = 0, ii = promises.length; i < ii; ++i) {
    var promise = promises[i];
    var resolve = function (i) {
     return function (value) {
      if (deferred._status === STATUS_REJECTED) {
       return;
      }
      results[i] = value;
      unresolved--;
      if (unresolved === 0) {
       resolveAll(results);
      }
     };
    }(i);
    if (Promise.isPromise(promise)) {
     promise.then(resolve, reject);
    } else {
     resolve(promise);
    }
   }
   return deferred;
  };
  Promise.isPromise = function Promise_isPromise(value) {
   return value && typeof value.then === 'function';
  };
  Promise.resolve = function Promise_resolve(value) {
   return new Promise(function (resolve) {
    resolve(value);
   });
  };
  Promise.reject = function Promise_reject(reason) {
   return new Promise(function (resolve, reject) {
    reject(reason);
   });
  };
  Promise.prototype = {
   _status: null,
   _value: null,
   _handlers: null,
   _unhandledRejection: null,
   _updateStatus: function Promise__updateStatus(status, value) {
    if (this._status === STATUS_RESOLVED || this._status === STATUS_REJECTED) {
     return;
    }
    if (status === STATUS_RESOLVED && Promise.isPromise(value)) {
     value.then(this._updateStatus.bind(this, STATUS_RESOLVED), this._updateStatus.bind(this, STATUS_REJECTED));
     return;
    }
    this._status = status;
    this._value = value;
    if (status === STATUS_REJECTED && this._handlers.length === 0) {
     this._unhandledRejection = true;
     HandlerManager.addUnhandledRejection(this);
    }
    HandlerManager.scheduleHandlers(this);
   },
   _resolve: function Promise_resolve(value) {
    this._updateStatus(STATUS_RESOLVED, value);
   },
   _reject: function Promise_reject(reason) {
    this._updateStatus(STATUS_REJECTED, reason);
   },
   then: function Promise_then(onResolve, onReject) {
    var nextPromise = new Promise(function (resolve, reject) {
     this.resolve = resolve;
     this.reject = reject;
    });
    this._handlers.push({
     thisPromise: this,
     onResolve: onResolve,
     onReject: onReject,
     nextPromise: nextPromise
    });
    HandlerManager.scheduleHandlers(this);
    return nextPromise;
   },
   catch: function Promise_catch(onReject) {
    return this.then(undefined, onReject);
   }
  };
  globalScope.Promise = Promise;
 }());
 (function checkWeakMap() {
  if (globalScope.WeakMap) {
   return;
  }
  var id = 0;
  function WeakMap() {
   this.id = '$weakmap' + id++;
  }
  WeakMap.prototype = {
   has: function (obj) {
    return !!Object.getOwnPropertyDescriptor(obj, this.id);
   },
   get: function (obj, defaultValue) {
    return this.has(obj) ? obj[this.id] : defaultValue;
   },
   set: function (obj, value) {
    Object.defineProperty(obj, this.id, {
     value: value,
     enumerable: false,
     configurable: true
    });
   },
   delete: function (obj) {
    delete obj[this.id];
   }
  };
  globalScope.WeakMap = WeakMap;
 }());
 (function checkURLConstructor() {
  var hasWorkingUrl = false;
  try {
   if (typeof URL === 'function' && typeof URL.prototype === 'object' && 'origin' in URL.prototype) {
    var u = new URL('b', 'http://a');
    u.pathname = 'c%20d';
    hasWorkingUrl = u.href === 'http://a/c%20d';
   }
  } catch (e) {
  }
  if (hasWorkingUrl) {
   return;
  }
  var relative = Object.create(null);
  relative['ftp'] = 21;
  relative['file'] = 0;
  relative['gopher'] = 70;
  relative['http'] = 80;
  relative['https'] = 443;
  relative['ws'] = 80;
  relative['wss'] = 443;
  var relativePathDotMapping = Object.create(null);
  relativePathDotMapping['%2e'] = '.';
  relativePathDotMapping['.%2e'] = '..';
  relativePathDotMapping['%2e.'] = '..';
  relativePathDotMapping['%2e%2e'] = '..';
  function isRelativeScheme(scheme) {
   return relative[scheme] !== undefined;
  }
  function invalid() {
   clear.call(this);
   this._isInvalid = true;
  }
  function IDNAToASCII(h) {
   if (h === '') {
    invalid.call(this);
   }
   return h.toLowerCase();
  }
  function percentEscape(c) {
   var unicode = c.charCodeAt(0);
   if (unicode > 0x20 && unicode < 0x7F && [
     0x22,
     0x23,
     0x3C,
     0x3E,
     0x3F,
     0x60
    ].indexOf(unicode) === -1) {
    return c;
   }
   return encodeURIComponent(c);
  }
  function percentEscapeQuery(c) {
   var unicode = c.charCodeAt(0);
   if (unicode > 0x20 && unicode < 0x7F && [
     0x22,
     0x23,
     0x3C,
     0x3E,
     0x60
    ].indexOf(unicode) === -1) {
    return c;
   }
   return encodeURIComponent(c);
  }
  var EOF, ALPHA = /[a-zA-Z]/, ALPHANUMERIC = /[a-zA-Z0-9\+\-\.]/;
  function parse(input, stateOverride, base) {
   function err(message) {
    errors.push(message);
   }
   var state = stateOverride || 'scheme start', cursor = 0, buffer = '', seenAt = false, seenBracket = false, errors = [];
   loop:
    while ((input[cursor - 1] !== EOF || cursor === 0) && !this._isInvalid) {
     var c = input[cursor];
     switch (state) {
     case 'scheme start':
      if (c && ALPHA.test(c)) {
       buffer += c.toLowerCase();
       state = 'scheme';
      } else if (!stateOverride) {
       buffer = '';
       state = 'no scheme';
       continue;
      } else {
       err('Invalid scheme.');
       break loop;
      }
      break;
     case 'scheme':
      if (c && ALPHANUMERIC.test(c)) {
       buffer += c.toLowerCase();
      } else if (c === ':') {
       this._scheme = buffer;
       buffer = '';
       if (stateOverride) {
        break loop;
       }
       if (isRelativeScheme(this._scheme)) {
        this._isRelative = true;
       }
       if (this._scheme === 'file') {
        state = 'relative';
       } else if (this._isRelative && base && base._scheme === this._scheme) {
        state = 'relative or authority';
       } else if (this._isRelative) {
        state = 'authority first slash';
       } else {
        state = 'scheme data';
       }
      } else if (!stateOverride) {
       buffer = '';
       cursor = 0;
       state = 'no scheme';
       continue;
      } else if (EOF === c) {
       break loop;
      } else {
       err('Code point not allowed in scheme: ' + c);
       break loop;
      }
      break;
     case 'scheme data':
      if (c === '?') {
       this._query = '?';
       state = 'query';
      } else if (c === '#') {
       this._fragment = '#';
       state = 'fragment';
      } else {
       if (EOF !== c && '\t' !== c && '\n' !== c && '\r' !== c) {
        this._schemeData += percentEscape(c);
       }
      }
      break;
     case 'no scheme':
      if (!base || !isRelativeScheme(base._scheme)) {
       err('Missing scheme.');
       invalid.call(this);
      } else {
       state = 'relative';
       continue;
      }
      break;
     case 'relative or authority':
      if (c === '/' && input[cursor + 1] === '/') {
       state = 'authority ignore slashes';
      } else {
       err('Expected /, got: ' + c);
       state = 'relative';
       continue;
      }
      break;
     case 'relative':
      this._isRelative = true;
      if ('file' !== this._scheme) {
       this._scheme = base._scheme;
      }
      if (EOF === c) {
       this._host = base._host;
       this._port = base._port;
       this._path = base._path.slice();
       this._query = base._query;
       this._username = base._username;
       this._password = base._password;
       break loop;
      } else if (c === '/' || c === '\\') {
       if (c === '\\') {
        err('\\ is an invalid code point.');
       }
       state = 'relative slash';
      } else if (c === '?') {
       this._host = base._host;
       this._port = base._port;
       this._path = base._path.slice();
       this._query = '?';
       this._username = base._username;
       this._password = base._password;
       state = 'query';
      } else if (c === '#') {
       this._host = base._host;
       this._port = base._port;
       this._path = base._path.slice();
       this._query = base._query;
       this._fragment = '#';
       this._username = base._username;
       this._password = base._password;
       state = 'fragment';
      } else {
       var nextC = input[cursor + 1];
       var nextNextC = input[cursor + 2];
       if ('file' !== this._scheme || !ALPHA.test(c) || nextC !== ':' && nextC !== '|' || EOF !== nextNextC && '/' !== nextNextC && '\\' !== nextNextC && '?' !== nextNextC && '#' !== nextNextC) {
        this._host = base._host;
        this._port = base._port;
        this._username = base._username;
        this._password = base._password;
        this._path = base._path.slice();
        this._path.pop();
       }
       state = 'relative path';
       continue;
      }
      break;
     case 'relative slash':
      if (c === '/' || c === '\\') {
       if (c === '\\') {
        err('\\ is an invalid code point.');
       }
       if (this._scheme === 'file') {
        state = 'file host';
       } else {
        state = 'authority ignore slashes';
       }
      } else {
       if ('file' !== this._scheme) {
        this._host = base._host;
        this._port = base._port;
        this._username = base._username;
        this._password = base._password;
       }
       state = 'relative path';
       continue;
      }
      break;
     case 'authority first slash':
      if (c === '/') {
       state = 'authority second slash';
      } else {
       err('Expected \'/\', got: ' + c);
       state = 'authority ignore slashes';
       continue;
      }
      break;
     case 'authority second slash':
      state = 'authority ignore slashes';
      if ('/' !== c) {
       err('Expected \'/\', got: ' + c);
       continue;
      }
      break;
     case 'authority ignore slashes':
      if ('/' !== c && '\\' !== c) {
       state = 'authority';
       continue;
      } else {
       err('Expected authority, got: ' + c);
      }
      break;
     case 'authority':
      if (c === '@') {
       if (seenAt) {
        err('@ already seen.');
        buffer += '%40';
       }
       seenAt = true;
       for (var i = 0; i < buffer.length; i++) {
        var cp = buffer[i];
        if (cp === '\t' || cp === '\n' || cp === '\r') {
         err('Invalid whitespace in authority.');
         continue;
        }
        if (cp === ':' && this._password === null) {
         this._password = '';
         continue;
        }
        var tempC = percentEscape(cp);
        if (null !== this._password) {
         this._password += tempC;
        } else {
         this._username += tempC;
        }
       }
       buffer = '';
      } else if (c === EOF || c === '/' || c === '\\' || c === '?' || c === '#') {
       cursor -= buffer.length;
       buffer = '';
       state = 'host';
       continue;
      } else {
       buffer += c;
      }
      break;
     case 'file host':
      if (c === EOF || c === '/' || c === '\\' || c === '?' || c === '#') {
       if (buffer.length === 2 && ALPHA.test(buffer[0]) && (buffer[1] === ':' || buffer[1] === '|')) {
        state = 'relative path';
       } else if (buffer.length === 0) {
        state = 'relative path start';
       } else {
        this._host = IDNAToASCII.call(this, buffer);
        buffer = '';
        state = 'relative path start';
       }
       continue;
      } else if (c === '\t' || c === '\n' || c === '\r') {
       err('Invalid whitespace in file host.');
      } else {
       buffer += c;
      }
      break;
     case 'host':
     case 'hostname':
      if (c === ':' && !seenBracket) {
       this._host = IDNAToASCII.call(this, buffer);
       buffer = '';
       state = 'port';
       if (stateOverride === 'hostname') {
        break loop;
       }
      } else if (c === EOF || c === '/' || c === '\\' || c === '?' || c === '#') {
       this._host = IDNAToASCII.call(this, buffer);
       buffer = '';
       state = 'relative path start';
       if (stateOverride) {
        break loop;
       }
       continue;
      } else if ('\t' !== c && '\n' !== c && '\r' !== c) {
       if (c === '[') {
        seenBracket = true;
       } else if (c === ']') {
        seenBracket = false;
       }
       buffer += c;
      } else {
       err('Invalid code point in host/hostname: ' + c);
      }
      break;
     case 'port':
      if (/[0-9]/.test(c)) {
       buffer += c;
      } else if (c === EOF || c === '/' || c === '\\' || c === '?' || c === '#' || stateOverride) {
       if ('' !== buffer) {
        var temp = parseInt(buffer, 10);
        if (temp !== relative[this._scheme]) {
         this._port = temp + '';
        }
        buffer = '';
       }
       if (stateOverride) {
        break loop;
       }
       state = 'relative path start';
       continue;
      } else if (c === '\t' || c === '\n' || c === '\r') {
       err('Invalid code point in port: ' + c);
      } else {
       invalid.call(this);
      }
      break;
     case 'relative path start':
      if (c === '\\') {
       err('\'\\\' not allowed in path.');
      }
      state = 'relative path';
      if ('/' !== c && '\\' !== c) {
       continue;
      }
      break;
     case 'relative path':
      if (c === EOF || c === '/' || c === '\\' || !stateOverride && (c === '?' || c === '#')) {
       if (c === '\\') {
        err('\\ not allowed in relative path.');
       }
       var tmp;
       if (tmp = relativePathDotMapping[buffer.toLowerCase()]) {
        buffer = tmp;
       }
       if (buffer === '..') {
        this._path.pop();
        if ('/' !== c && '\\' !== c) {
         this._path.push('');
        }
       } else if (buffer === '.' && '/' !== c && '\\' !== c) {
        this._path.push('');
       } else if ('.' !== buffer) {
        if (this._scheme === 'file' && this._path.length === 0 && buffer.length === 2 && ALPHA.test(buffer[0]) && buffer[1] === '|') {
         buffer = buffer[0] + ':';
        }
        this._path.push(buffer);
       }
       buffer = '';
       if (c === '?') {
        this._query = '?';
        state = 'query';
       } else if (c === '#') {
        this._fragment = '#';
        state = 'fragment';
       }
      } else if ('\t' !== c && '\n' !== c && '\r' !== c) {
       buffer += percentEscape(c);
      }
      break;
     case 'query':
      if (!stateOverride && c === '#') {
       this._fragment = '#';
       state = 'fragment';
      } else if (EOF !== c && '\t' !== c && '\n' !== c && '\r' !== c) {
       this._query += percentEscapeQuery(c);
      }
      break;
     case 'fragment':
      if (EOF !== c && '\t' !== c && '\n' !== c && '\r' !== c) {
       this._fragment += c;
      }
      break;
     }
     cursor++;
    }
  }
  function clear() {
   this._scheme = '';
   this._schemeData = '';
   this._username = '';
   this._password = null;
   this._host = '';
   this._port = '';
   this._path = [];
   this._query = '';
   this._fragment = '';
   this._isInvalid = false;
   this._isRelative = false;
  }
  function JURL(url, base) {
   if (base !== undefined && !(base instanceof JURL)) {
    base = new JURL(String(base));
   }
   this._url = url;
   clear.call(this);
   var input = url.replace(/^[ \t\r\n\f]+|[ \t\r\n\f]+$/g, '');
   parse.call(this, input, null, base);
  }
  JURL.prototype = {
   toString: function () {
    return this.href;
   },
   get href() {
    if (this._isInvalid) {
     return this._url;
    }
    var authority = '';
    if ('' !== this._username || null !== this._password) {
     authority = this._username + (null !== this._password ? ':' + this._password : '') + '@';
    }
    return this.protocol + (this._isRelative ? '//' + authority + this.host : '') + this.pathname + this._query + this._fragment;
   },
   set href(href) {
    clear.call(this);
    parse.call(this, href);
   },
   get protocol() {
    return this._scheme + ':';
   },
   set protocol(protocol) {
    if (this._isInvalid) {
     return;
    }
    parse.call(this, protocol + ':', 'scheme start');
   },
   get host() {
    return this._isInvalid ? '' : this._port ? this._host + ':' + this._port : this._host;
   },
   set host(host) {
    if (this._isInvalid || !this._isRelative) {
     return;
    }
    parse.call(this, host, 'host');
   },
   get hostname() {
    return this._host;
   },
   set hostname(hostname) {
    if (this._isInvalid || !this._isRelative) {
     return;
    }
    parse.call(this, hostname, 'hostname');
   },
   get port() {
    return this._port;
   },
   set port(port) {
    if (this._isInvalid || !this._isRelative) {
     return;
    }
    parse.call(this, port, 'port');
   },
   get pathname() {
    return this._isInvalid ? '' : this._isRelative ? '/' + this._path.join('/') : this._schemeData;
   },
   set pathname(pathname) {
    if (this._isInvalid || !this._isRelative) {
     return;
    }
    this._path = [];
    parse.call(this, pathname, 'relative path start');
   },
   get search() {
    return this._isInvalid || !this._query || this._query === '?' ? '' : this._query;
   },
   set search(search) {
    if (this._isInvalid || !this._isRelative) {
     return;
    }
    this._query = '?';
    if (search[0] === '?') {
     search = search.slice(1);
    }
    parse.call(this, search, 'query');
   },
   get hash() {
    return this._isInvalid || !this._fragment || this._fragment === '#' ? '' : this._fragment;
   },
   set hash(hash) {
    if (this._isInvalid) {
     return;
    }
    this._fragment = '#';
    if (hash[0] === '#') {
     hash = hash.slice(1);
    }
    parse.call(this, hash, 'fragment');
   },
   get origin() {
    var host;
    if (this._isInvalid || !this._scheme) {
     return '';
    }
    switch (this._scheme) {
    case 'data':
    case 'file':
    case 'javascript':
    case 'mailto':
     return 'null';
    }
    host = this.host;
    if (!host) {
     return '';
    }
    return this._scheme + '://' + host;
   }
  };
  var OriginalURL = globalScope.URL;
  if (OriginalURL) {
   JURL.createObjectURL = function (blob) {
    return OriginalURL.createObjectURL.apply(OriginalURL, arguments);
   };
   JURL.revokeObjectURL = function (url) {
    OriginalURL.revokeObjectURL(url);
   };
  }
  globalScope.URL = JURL;
 }());
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1 */
/***/ (function(module, exports) {

var g;
g = function () {
 return this;
}();
try {
 g = g || Function("return this")() || (1, eval)("this");
} catch (e) {
 if (typeof window === "object")
  g = window;
}
module.exports = g;

/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

__webpack_require__(0);

/***/ })
/******/ ]);
});