PDF.js version 1.7.316 - See mozilla/pdf.js@59392fd5442d819879dc7ec0a0a8ce9a2fbd2f71

bower.json

@@ -1,6 +1,6 @@
 {
   "name": "pdfjs-dist",
-  "version": "1.7.314",
+  "version": "1.7.316",
   "main": [
     "build/pdf.js",
     "build/pdf.worker.js"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdfjs-dist",
-  "version": "1.7.314",
+  "version": "1.7.316",
   "main": "build/pdf.js",
   "description": "Generic build of Mozilla's PDF.js library.",
   "keywords": [

web/compatibility.js

@@ -1,4 +1,4 @@
-/* Copyright 2012 Mozilla Foundation
+/* 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.
@@ -12,653 +12,1528 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/* eslint strict: ["error", "function"] */
-/* eslint-disable no-extend-native */
-/* globals VBArray, PDFJS */
 
-(function compatibilityWrapper() {
-  'use strict';
+(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 = {};
 
-var userAgent = navigator.userAgent;
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
 
-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);
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId])
+/******/ 			return installedModules[moduleId].exports;
 
-// Initializing PDFJS global object here, it case if we need to change/disable
-// some PDF.js features, e.g. range requests
-if (typeof PDFJS === 'undefined') {
-  (typeof window !== 'undefined' ? window : this).PDFJS = {};
-}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
 
-// Checking if the typed arrays are supported
-// Support: iOS<6.0 (subarray), IE<10, Android<4.0
-(function checkTypedArrayCompatibility() {
-  if (typeof Uint8Array !== 'undefined') {
-    // Support: iOS<6.0
-    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));
-      };
-    }
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
 
-    // Support: Android<4.1
-    if (typeof Float64Array === 'undefined') {
-      window.Float64Array = Float32Array;
-    }
-    return;
-  }
+/******/ 		// 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));
+   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;
-    }
+   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];
-      }
+   var result, i, n;
+   if (typeof arg1 === 'number') {
+    result = [];
+    for (i = 0; i < arg1; ++i) {
+     result[i] = 0;
     }
-
-    result.subarray = subarray;
-    result.buffer = result;
-    result.byteLength = result.length;
-    result.set = setArrayOffset;
-
-    if (typeof arg1 === 'object' && arg1.buffer) {
-      result.buffer = arg1.buffer;
+   } else if ('slice' in arg1) {
+    result = arg1.slice(0);
+   } else {
+    result = [];
+    for (i = 0, n = arg1.length; i < n; ++i) {
+     result[i] = arg1[i];
     }
-    return result;
+   }
+   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;
   }
-
-  window.Uint8Array = TypedArray;
-  window.Int8Array = TypedArray;
-
-  // we don't need support for set, byteLength for 32-bit array
-  // so we can use the TypedArray as well
-  window.Uint32Array = TypedArray;
-  window.Int32Array = TypedArray;
-  window.Uint16Array = TypedArray;
-  window.Float32Array = TypedArray;
-  window.Float64Array = TypedArray;
-})();
-
-// URL = URL || webkitURL
-// Support: Safari<7, Android 4.2+
-(function normalizeURLObject() {
-  if (!window.URL) {
-    window.URL = window.webkitURL;
+  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;
   }
-})();
-
-// Object.defineProperty()?
-// Support: Android<4.0, Safari<5.1
-(function checkObjectDefinePropertyCompatibility() {
+ }());
+ (function checkObjectDefinePropertyCompatibility() {
   if (typeof Object.defineProperty !== 'undefined') {
-    var definePropertyPossible = true;
-    try {
-      // some browsers (e.g. safari) cannot use defineProperty() on DOM objects
-      // and thus the native version is not sufficient
-      Object.defineProperty(new Image(), 'id', { value: 'test' });
-      // ... another test for android gb browser for non-DOM objects
-      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;
+   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;
-    }
+   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;
+   }
   };
-})();
-
-
-// No XMLHttpRequest#response?
-// Support: IE<11, Android <4.0
-(function checkXMLHttpRequestResponseCompatibility() {
+ }());
+ (function checkXMLHttpRequestResponseCompatibility() {
+  if (typeof XMLHttpRequest === 'undefined') {
+   return;
+  }
   var xhrPrototype = XMLHttpRequest.prototype;
   var xhr = new XMLHttpRequest();
   if (!('overrideMimeType' in xhr)) {
-    // IE10 might have response, but not overrideMimeType
-    // Support: IE10
-    Object.defineProperty(xhrPrototype, 'overrideMimeType', {
-      value: function xmlHttpRequestOverrideMimeType(mimeType) {}
-    });
+   Object.defineProperty(xhrPrototype, 'overrideMimeType', {
+    value: function xmlHttpRequestOverrideMimeType(mimeType) {
+    }
+   });
   }
   if ('responseType' in xhr) {
-    return;
+   return;
   }
-
-  // The worker will be using XHR, so we can save time and disable worker.
-  PDFJS.disableWorker = true;
-
   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');
-        }
-      }
+   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');
+     }
     }
+   }
   });
-
-  // Support: IE9
   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 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;
+   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;
+   }
   });
-})();
-
-// window.btoa (base64 encode function) ?
-// Support: IE<10
-(function checkWindowBtoaCompatibility() {
-  if ('btoa' in window) {
-    return;
+ }());
+ (function checkWindowBtoaCompatibility() {
+  if ('btoa' in globalScope) {
+   return;
   }
-
-  var digits =
-    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-
-  window.btoa = function windowBtoa(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;
+  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;
   };
-})();
-
-// window.atob (base64 encode function)?
-// Support: IE<10
-(function checkWindowAtobCompatibility() {
-  if ('atob' in window) {
-    return;
+ }());
+ (function checkWindowAtobCompatibility() {
+  if ('atob' in globalScope) {
+   return;
   }
-
-  // https://github.com/davidchambers/Base64.js
-  var digits =
-    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-  window.atob = function (input) {
-    input = input.replace(/=+$/, '');
-    if (input.length % 4 === 1) {
-      throw new Error('bad atob input');
-    }
-    for (
-      // initialize result and counters
-      var bc = 0, bs, buffer, idx = 0, output = '';
-      // get next character
-      (buffer = input.charAt(idx++));
-      // character found in table?
-      // initialize bit storage and add its ascii value
-      ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer,
-        // and if not first of each 4 characters,
-        // convert the first 8 bits to one ascii character
-        bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0
-    ) {
-      // try to find character in table (0-63, not found => -1)
-      buffer = digits.indexOf(buffer);
-    }
-    return output;
+  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.prototype.bind?
-// Support: Android<4.0, iOS<6.0
-(function checkFunctionPrototypeBindCompatibility() {
+ }());
+ (function checkFunctionPrototypeBindCompatibility() {
   if (typeof Function.prototype.bind !== 'undefined') {
-    return;
+   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;
+   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;
   };
-})();
-
-// HTMLElement dataset property
-// Support: IE<11, Safari<5.1, Android<4.0
-(function checkDatasetProperty() {
+ }());
+ (function checkDatasetProperty() {
+  if (!hasDOM) {
+   return;
+  }
   var div = document.createElement('div');
   if ('dataset' in div) {
-    return; // dataset property exists
+   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
+   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
   });
-})();
-
-// HTMLElement classList property
-// Support: IE<10, Android<4.0, iOS<5.0
-(function checkClassListProperty() {
+ }());
+ (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; // classList property exists
+   return;
   }
-
-  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);
+  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;
     }
-    if (index >= 0 && remove) {
-      list.splice(index, 1);
+    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);
     }
-    element.className = list.join(' ');
-    return (index >= 0);
+    this.log('Timer:', name, Date.now() - time);
+   }
+  };
+  globalScope.console = workerConsole;
+ }());
+ (function checkConsoleCompatibility() {
+  if (!hasDOM) {
+   return;
   }
-
-  var classListPrototype = {
-    add: function(name) {
-      changeList(this.element, name, true, false);
-    },
-    contains: function(name) {
-      return changeList(this.element, name, false, false);
+  if (!('console' in window)) {
+   window.console = {
+    log: function () {
     },
-    remove: function(name) {
-      changeList(this.element, name, false, true);
+    error: function () {
     },
-    toggle: function(name) {
-      changeList(this.element, name, true, true);
+    warn: function () {
     }
-  };
-
-  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
-  });
-})();
-
-// Check console compatibility
-// In older IE versions the console object is not available
-// unless console is open.
-// Support: IE<10
-(function checkConsoleCompatibility() {
-  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);
     };
-  } else if (!('bind' in console.log)) {
-    // native functions in IE9 might not have bind
-    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);
-  }
-})();
-
-// Check onclick compatibility in Opera
-// Support: Opera<15
-(function checkOnClickCompatibility() {
-  // workaround for reported Opera bug DSK-354448:
-  // onclick fires on disabled buttons with opaque content
+   }(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();
-    }
+   if (isDisabled(event.target)) {
+    event.stopPropagation();
+   }
   }
   function isDisabled(node) {
-    return node.disabled || (node.parentNode && isDisabled(node.parentNode));
+   return node.disabled || node.parentNode && isDisabled(node.parentNode);
   }
   if (isOpera) {
-    // use browser detection since we cannot feature-check this bug
-    document.addEventListener('click', ignoreIfTargetDisabled, true);
+   document.addEventListener('click', ignoreIfTargetDisabled, true);
   }
-})();
-
-// Checks if possible to use URL.createObjectURL()
-// Support: IE, Chrome on iOS
-(function checkOnBlobSupport() {
-  // sometimes IE and Chrome on iOS loosing the data created with
-  // createObjectURL(), see #3977 and #8081
+ }());
+ (function checkOnBlobSupport() {
   if (isIE || isIOSChrome) {
-    PDFJS.disableCreateObjectURL = true;
+   PDFJS.disableCreateObjectURL = true;
+  }
+ }());
+ (function checkNavigatorLanguage() {
+  if (typeof navigator === 'undefined') {
+   return;
   }
-})();
-
-// Checks if navigator.language is supported
-(function checkNavigatorLanguage() {
   if ('language' in navigator) {
-    return;
+   return;
   }
   PDFJS.locale = navigator.userLanguage || 'en-US';
-})();
-
-// Support: Safari 6.0+, Android<3.0, Chrome 39/40, iOS
-(function checkRangeRequests() {
-  // Safari has issues with cached range requests see:
-  // https://github.com/mozilla/pdf.js/issues/3260
-  // Last tested with version 6.0.4.
-
-  // Older versions of Android (pre 3.0) has issues with range requests, see:
-  // https://github.com/mozilla/pdf.js/issues/3381.
-  // Make sure that we only match webkit-based Android browsers,
-  // since Firefox/Fennec works as expected.
-
-  // Range requests are broken in Chrome 39 and 40, https://crbug.com/442318
+ }());
+ (function checkRangeRequests() {
   if (isSafari || isAndroidPre3 || isChromeWithRangeBug || isIOS) {
-    PDFJS.disableRange = true;
-    PDFJS.disableStream = true;
+   PDFJS.disableRange = true;
+   PDFJS.disableStream = true;
+  }
+ }());
+ (function checkHistoryManipulation() {
+  if (!hasDOM) {
+   return;
   }
-})();
-
-// Check if the browser supports manipulation of the history.
-// Support: IE<10, Android<4.2
-(function checkHistoryManipulation() {
-  // Android 2.x has so buggy pushState support that it was removed in
-  // Android 3.0 and restored as late as in Android 4.2.
-  // Support: Android 2.x
   if (!history.pushState || isAndroidPre3) {
-    PDFJS.disableHistory = true;
+   PDFJS.disableHistory = true;
+  }
+ }());
+ (function checkSetPresenceInImageData() {
+  if (!hasDOM) {
+   return;
   }
-})();
-
-// Support: IE<11, Chrome<21, Android<4.4, Safari<6
-(function checkSetPresenceInImageData() {
-  // IE < 11 will use window.CanvasPixelArray which lacks set function.
   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];
-        }
-      };
-    }
+   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 {
-    // Old Chrome and Android use an inaccessible CanvasPixelArray prototype.
-    // Because we cannot feature detect it, we rely on user agent parsing.
-    var polyfill = false, versionMatch;
-    if (isChrome) {
-      versionMatch = userAgent.match(/Chrom(e|ium)\/([0-9]+)\./);
-      // Chrome < 21 lacks the set function.
-      polyfill = versionMatch && parseInt(versionMatch[2]) < 21;
-    } else if (isAndroid) {
-      // Android < 4.4 lacks the set function.
-      // Android >= 4.4 will contain Chrome in the user agent,
-      // thus pass the Chrome check above and not reach this block.
-      polyfill = isAndroidPre5;
-    } else if (isSafari) {
-      versionMatch = userAgent.
-        match(/Version\/([0-9]+)\.([0-9]+)\.([0-9]+) Safari\//);
-      // Safari < 6 lacks the set function.
-      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;
-      };
-      // this closure will be kept referenced, so clear its vars
-      contextPrototype = null;
-    }
-  }
-})();
-
-// Support: IE<10, Android<4.0, iOS
-(function checkRequestAnimationFrame() {
+   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);
+   window.setTimeout(callback, 20);
+  }
+  if (!hasDOM) {
+   return;
   }
-
   if (isIOS) {
-    // requestAnimationFrame on iOS is broken, replacing with fake one.
-    window.requestAnimationFrame = fakeRequestAnimationFrame;
-    return;
+   window.requestAnimationFrame = fakeRequestAnimationFrame;
+   return;
   }
   if ('requestAnimationFrame' in window) {
-    return;
+   return;
   }
-  window.requestAnimationFrame =
-    window.mozRequestAnimationFrame ||
-    window.webkitRequestAnimationFrame ||
-    fakeRequestAnimationFrame;
-})();
-
-// Support: Android, iOS
-(function checkCanvasSizeLimitation() {
+  window.requestAnimationFrame = window.mozRequestAnimationFrame || window.webkitRequestAnimationFrame || fakeRequestAnimationFrame;
+ }());
+ (function checkCanvasSizeLimitation() {
   if (isIOS || isAndroid) {
-    // 5MP
-    PDFJS.maxCanvasPixels = 5242880;
+   PDFJS.maxCanvasPixels = 5242880;
+  }
+ }());
+ (function checkFullscreenSupport() {
+  if (!hasDOM) {
+   return;
   }
-})();
-
-// Disable fullscreen support for certain problematic configurations.
-// Support: IE11+ (when embedded).
-(function checkFullscreenSupport() {
   if (isIE && window.parent !== window) {
-    PDFJS.disableFullscreen = true;
+   PDFJS.disableFullscreen = true;
+  }
+ }());
+ (function checkCurrentScript() {
+  if (!hasDOM) {
+   return;
   }
-})();
-
-// Provides document.currentScript support
-// Support: IE, Chrome<29.
-(function checkCurrentScript() {
   if ('currentScript' in document) {
-    return;
+   return;
   }
   Object.defineProperty(document, 'currentScript', {
-    get: function () {
-      var scripts = document.getElementsByTagName('script');
-      return scripts[scripts.length - 1];
-    },
-    enumerable: true,
-    configurable: true
+   get: function () {
+    var scripts = document.getElementsByTagName('script');
+    return scripts[scripts.length - 1];
+   },
+   enumerable: true,
+   configurable: true
   });
-})();
-
-// Provides `input.type = 'type'` runtime failure protection.
-// Support: IE9,10.
-(function checkInputTypeNumberAssign() {
+ }());
+ (function checkInputTypeNumberAssign() {
+  if (!hasDOM) {
+   return;
+  }
   var el = document.createElement('input');
   try {
-    el.type = 'number';
+   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
-    });
-  }
-})();
-
-// Provides correct document.readyState value for legacy browsers.
-// Support: IE9,10.
-(function checkDocumentReadyState() {
-  if (!document.attachEvent) {
-    return;
-  }
-  var documentProto = document.constructor.prototype;
-  var readyStateProto = Object.getOwnPropertyDescriptor(documentProto,
-                                                        'readyState');
-  Object.defineProperty(documentProto, 'readyState', {
+   var inputProto = el.constructor.prototype;
+   var typeProperty = Object.getOwnPropertyDescriptor(inputProto, 'type');
+   Object.defineProperty(inputProto, 'type', {
     get: function () {
-      var value = readyStateProto.get.call(this);
-      return value === 'interactive' ? 'loading' : value;
+     return typeProperty.get.call(this);
     },
     set: function (value) {
-      readyStateProto.set.call(this, 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
   });
-})();
-
-// Provides support for ChildNode.remove in legacy browsers.
-// Support: IE.
-(function checkChildNodeRemove() {
+ }());
+ (function checkChildNodeRemove() {
+  if (!hasDOM) {
+   return;
+  }
   if (typeof Element.prototype.remove !== 'undefined') {
-    return;
+   return;
   }
   Element.prototype.remove = function () {
-    if (this.parentNode) {
-      this.parentNode.removeChild(this);
+   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);
 
-}).call((typeof window === 'undefined') ? this : window);
+/***/ })
+/******/ ]);
+});